Initial commit: MCP Hub Community Edition v3.0.0

Community edition generated from private repo via sync pipeline.
Includes 9 plugins (WordPress, WooCommerce, WP Advanced, Gitea, n8n,
Supabase, OpenPanel, Appwrite, Directus) with ~587 tools.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

plugins/appwrite/plugin.py

@@ -0,0 +1,166 @@
+"""
+Appwrite Plugin - Self-Hosted Backend-as-a-Service Management
+
+Complete Appwrite Self-Hosted management through REST APIs.
+Provides tools for Databases, Documents, Users, Teams, Storage,
+Functions, Messaging, and System operations.
+
+For Self-Hosted instances deployed on Coolify.
+"""
+
+from typing import Any
+
+from plugins.appwrite import handlers
+from plugins.appwrite.client import AppwriteClient
+from plugins.base import BasePlugin
+
+class AppwritePlugin(BasePlugin):
+    """
+    Appwrite Self-Hosted Plugin - Complete backend management.
+
+    Provides comprehensive Appwrite management capabilities including:
+    - Database operations (Databases, Collections, Attributes, Indexes)
+    - Document operations (CRUD, Bulk ops, Queries, Search)
+    - User management (CRUD, Labels, Sessions, Status)
+    - Team management (Teams, Memberships, Roles)
+    - Storage operations (Buckets, Files, Image transformation)
+    - Functions (Functions, Deployments, Executions)
+    - Messaging (Topics, Subscribers, Email/SMS/Push messages)
+    - System operations (Health checks, Avatars)
+
+    Phase I.1: Database (18) + Documents (12) + System (8) = 38 tools
+    Phase I.2: Users (12) + Teams (10) = 22 tools
+    Phase I.3: Storage (14) = 14 tools
+    Phase I.4: Functions (14) + Messaging (12) = 26 tools
+
+    Total: 100 tools - Complete!
+    """
+
+    @staticmethod
+    def get_plugin_name() -> str:
+        """Return plugin type identifier"""
+        return "appwrite"
+
+    @staticmethod
+    def get_required_config_keys() -> list[str]:
+        """Return required configuration keys"""
+        return ["url", "project_id", "api_key"]
+
+    def __init__(self, config: dict[str, Any], project_id: str | None = None):
+        """
+        Initialize Appwrite plugin with client.
+
+        Args:
+            config: Configuration dictionary containing:
+                - url: Appwrite instance URL (e.g., https://appwrite.example.com/v1)
+                - project_id: Appwrite project ID
+                - api_key: API key with appropriate scopes
+            project_id: Optional MCP project ID (auto-generated if not provided)
+        """
+        super().__init__(config, project_id=project_id)
+
+        # Create Appwrite API client
+        self.client = AppwriteClient(
+            base_url=config["url"], project_id=config["project_id"], api_key=config["api_key"]
+        )
+
+    @staticmethod
+    def get_tool_specifications() -> list[dict[str, Any]]:
+        """
+        Return all tool specifications for ToolGenerator.
+
+        This method is called by ToolGenerator to create unified tools
+        with site parameter routing.
+
+        Returns:
+            List of tool specification dictionaries
+        """
+        specs = []
+
+        # Phase I.1: Core (38 tools)
+        specs.extend(handlers.databases.get_tool_specifications())  # 18 tools
+        specs.extend(handlers.documents.get_tool_specifications())  # 12 tools
+        specs.extend(handlers.system.get_tool_specifications())  # 8 tools
+
+        # Phase I.2: Auth & Teams (22 tools)
+        specs.extend(handlers.users.get_tool_specifications())  # 12 tools
+        specs.extend(handlers.teams.get_tool_specifications())  # 10 tools
+
+        # Phase I.3: Storage (14 tools)
+        specs.extend(handlers.storage.get_tool_specifications())  # 14 tools
+
+        # Phase I.4: Functions & Messaging (26 tools)
+        specs.extend(handlers.functions.get_tool_specifications())  # 14 tools
+        specs.extend(handlers.messaging.get_tool_specifications())  # 12 tools
+
+        return specs
+
+    def __getattr__(self, name: str):
+        """
+        Dynamically delegate method calls to appropriate handlers.
+
+        This allows ToolGenerator to call methods like plugin.list_databases()
+        without explicitly defining each method.
+
+        Args:
+            name: Method name being called
+
+        Returns:
+            Handler function from the appropriate handler module
+        """
+        # Try to find the method in handler modules
+        handler_modules = [
+            # Phase I.1: Core
+            handlers.databases,
+            handlers.documents,
+            handlers.system,
+            # Phase I.2: Auth & Teams
+            handlers.users,
+            handlers.teams,
+            # Phase I.3: Storage
+            handlers.storage,
+            # Phase I.4: Functions & Messaging
+            handlers.functions,
+            handlers.messaging,
+        ]
+
+        for handler_module in handler_modules:
+            if hasattr(handler_module, name):
+                func = getattr(handler_module, name)
+
+                # Create wrapper that passes self.client
+                async def wrapper(_func=func, **kwargs):
+                    return await _func(self.client, **kwargs)
+
+                return wrapper
+
+        # Method not found in any handler
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+    async def check_health(self) -> dict[str, Any]:
+        """
+        Check if Appwrite instance is accessible (internal use).
+
+        Note: This is named check_health to avoid shadowing the handler's
+        health_check function which is exposed as an MCP tool.
+
+        Returns:
+            Dict containing health check result
+        """
+        try:
+            result = await self.client.health_check()
+            is_healthy = result.get("status") == "pass"
+            return {
+                "healthy": is_healthy,
+                "message": f"Appwrite instance at {self.client.base_url} is {'accessible' if is_healthy else 'not accessible'}",
+            }
+        except Exception as e:
+            return {"healthy": False, "message": f"Appwrite health check failed: {str(e)}"}
+
+    async def health_check(self, **kwargs) -> str:
+        """
+        Override BasePlugin.health_check to use handler function.
+
+        This ensures the MCP tool returns a JSON string, not a Dict.
+        """
+        return await handlers.system.health_check(self.client)