mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.30__py3-none-any.whl

mcp_proxy_adapter/commands/registration_status_command.py

@@ -23,44 +23,8 @@ class RegistrationStatusCommandResult(SuccessResult):
     status: Dict[str, Any]
     message: str = "Registration status retrieved successfully"
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert result to dictionary."""
-        return {
-            "success": True,
-            "status": self.status,
-            "message": self.message,
-        }
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get JSON schema for result."""
-        return {
-            "type": "object",
-            "properties": {
-                "success": {
-                    "type": "boolean",
-                    "description": "Whether the command was successful",
-                },
-                "status": {
-                    "type": "object",
-                    "description": "Registration status information",
-                    "properties": {
-                        "state": {"type": "string", "description": "Current registration state"},
-                        "server_key": {"type": "string", "description": "Server key if registered"},
-                        "last_attempt": {"type": "number", "description": "Timestamp of last registration attempt"},
-                        "last_success": {"type": "number", "description": "Timestamp of last successful registration"},
-                        "last_error": {"type": "string", "description": "Last error message"},
-                        "attempt_count": {"type": "integer", "description": "Total registration attempts"},
-                        "success_count": {"type": "integer", "description": "Total successful registrations"},
-                        "heartbeat_enabled": {"type": "boolean", "description": "Whether heartbeat is enabled"},
-                        "heartbeat_interval": {"type": "integer", "description": "Heartbeat interval in seconds"},
-                        "thread_alive": {"type": "boolean", "description": "Whether registration thread is alive"},
-                    },
-                },
-                "message": {"type": "string", "description": "Result message"},
-            },
-            "required": ["success", "status", "message"],
-        }
 
 
 class RegistrationStatusCommand(Command):
@@ -110,10 +74,3 @@ class RegistrationStatusCommand(Command):
             )
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get JSON schema for command parameters."""
-        return {
-            "type": "object",
-            "properties": {},
-            "additionalProperties": False,
-        }

mcp_proxy_adapter/commands/registry/__init__.py

@@ -0,0 +1,18 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Command registry package for MCP Proxy Adapter.
+"""
+
+from .command_registry import CommandRegistry
+from .command_loader import CommandLoader
+from .command_manager import CommandManager
+from .command_info import CommandInfo
+
+__all__ = [
+    "CommandRegistry",
+    "CommandLoader",
+    "CommandManager", 
+    "CommandInfo",
+]

mcp_proxy_adapter/commands/registry/command_info.py

@@ -0,0 +1,103 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Command information utilities for MCP Proxy Adapter.
+"""
+
+from typing import Any, Dict, List, Optional, Type
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class CommandInfo:
+    """Utilities for getting command information."""
+
+    def __init__(self):
+        """Initialize command info utilities."""
+        self.logger = get_global_logger()
+
+
+    def get_command_info(self, command_name: str, command_class: Type[Command], command_types: Dict[str, str]) -> Optional[Dict[str, Any]]:
+        """
+        Get detailed information about a specific command.
+
+        Args:
+            command_name: Name of the command
+            command_class: Command class
+            command_types: Dictionary mapping command names to types
+
+        Returns:
+            Dictionary with command information or None if not found
+        """
+        try:
+            cmd_type = command_types.get(command_name, "unknown")
+            
+            info = {
+                "name": command_name,
+                "type": cmd_type,
+                "class": command_class.__name__,
+                "module": command_class.__module__,
+                "file": getattr(command_class, "__file__", None),
+                "description": getattr(command_class, "__doc__", None),
+                "methods": self._get_command_methods(command_class),
+                "attributes": self._get_command_attributes(command_class),
+            }
+
+            # Get command-specific information
+            if hasattr(command_class, "get_schema"):
+                try:
+                    info["schema"] = command_class.get_schema()
+                except Exception as e:
+                    self.logger.warning(f"Failed to get schema for {command_name}: {e}")
+
+            return info
+
+        except Exception as e:
+            self.logger.error(f"Failed to get info for command {command_name}: {e}")
+            return None
+
+    def _get_command_methods(self, command_class: Type[Command]) -> List[Dict[str, Any]]:
+        """
+        Get information about command methods.
+
+        Args:
+            command_class: Command class
+
+        Returns:
+            List of method information
+        """
+        methods = []
+        
+        for name, method in command_class.__dict__.items():
+            if callable(method) and not name.startswith("_"):
+                methods.append({
+                    "name": name,
+                    "description": getattr(method, "__doc__", None),
+                    "is_async": hasattr(method, "__code__") and method.__code__.co_flags & 0x80,  # CO_ITERABLE_COROUTINE
+                })
+        
+        return methods
+
+    def _get_command_attributes(self, command_class: Type[Command]) -> Dict[str, Any]:
+        """
+        Get information about command attributes.
+
+        Args:
+            command_class: Command class
+
+        Returns:
+            Dictionary of attribute information
+        """
+        attributes = {}
+        
+        for name, value in command_class.__dict__.items():
+            if not callable(value) and not name.startswith("_"):
+                attributes[name] = {
+                    "value": value,
+                    "type": type(value).__name__,
+                }
+        
+        return attributes
+

mcp_proxy_adapter/commands/registry/command_loader.py

@@ -0,0 +1,207 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Command loading utilities for MCP Proxy Adapter.
+"""
+
+import importlib
+import importlib.util
+import inspect
+import os
+import tempfile
+import urllib.parse
+from pathlib import Path
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+try:
+    import requests
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+    get_global_logger().warning("requests library not available, HTTP/HTTPS loading will not work")
+
+
+class CommandLoader:
+    """Loader for commands from various sources."""
+
+    def __init__(self):
+        """Initialize command loader."""
+        self.logger = get_global_logger()
+
+
+    def _load_command_with_registry_check(self, source: str) -> Dict[str, Any]:
+        """
+        Load command with remote registry check.
+
+        Args:
+            source: Local path or command name
+
+        Returns:
+            Dictionary with loading result information
+        """
+        try:
+            from mcp_proxy_adapter.commands.catalog_manager import CatalogManager
+            from mcp_proxy_adapter.config import get_config
+
+            # Get configuration
+            config_obj = get_config()
+
+            # Get remote registry
+            plugin_servers = config_obj.get("commands.plugin_servers", [])
+            catalog_dir = "./catalog"
+
+            if plugin_servers:
+                # Initialize catalog manager
+                catalog_manager = CatalogManager(catalog_dir)
+
+                # Check if source is a command name in registry
+                if not os.path.exists(source) and not source.endswith("_command.py"):
+                    # Try to find in remote registry
+                    for server_url in plugin_servers:
+                        try:
+                            server_catalog = catalog_manager.get_catalog_from_server(
+                                server_url
+                            )
+                            if source in server_catalog:
+                                server_cmd = server_catalog[source]
+                                # Download from registry
+                                if catalog_manager._download_command(
+                                    source, server_cmd
+                                ):
+                                    source = str(
+                                        catalog_manager.commands_dir
+                                        / f"{source}_command.py"
+                                    )
+                                    break
+                        except Exception as e:
+                            self.logger.warning(
+                                f"Failed to check registry {server_url}: {e}"
+                            )
+
+            # Load from local file
+            return self._load_command_from_file(source)
+
+        except Exception as e:
+            self.logger.error(f"Failed to load command with registry check: {e}")
+            return {"success": False, "commands_loaded": 0, "error": str(e)}
+
+    def _load_command_from_url(self, url: str) -> Dict[str, Any]:
+        """
+        Load command from HTTP/HTTPS URL.
+
+        Args:
+            url: URL to load command from
+
+        Returns:
+            Dictionary with loading result information
+        """
+        if not REQUESTS_AVAILABLE:
+            error_msg = "requests library not available, cannot load from URL"
+            self.logger.error(error_msg)
+            return {
+                "success": False,
+                "error": error_msg,
+                "commands_loaded": 0,
+                "source": url,
+            }
+
+        try:
+            # Download command file
+            response = requests.get(url, timeout=30)
+            response.raise_for_status()
+
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(
+                mode="w", suffix="_command.py", delete=False
+            ) as temp_file:
+                temp_file.write(response.text)
+                temp_file_path = temp_file.name
+
+            try:
+                # Load from temporary file
+                result = self._load_command_from_file(temp_file_path)
+                result["source"] = url
+                return result
+            finally:
+                # Clean up temporary file
+                os.unlink(temp_file_path)
+
+        except Exception as e:
+            self.logger.error(f"Failed to load command from URL {url}: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "commands_loaded": 0,
+                "source": url,
+            }
+
+    def _load_command_from_file(self, file_path: str) -> Dict[str, Any]:
+        """
+        Load command from local file.
+
+        Args:
+            file_path: Path to command file
+
+        Returns:
+            Dictionary with loading result information
+        """
+        try:
+            if not os.path.exists(file_path):
+                return {
+                    "success": False,
+                    "error": f"File not found: {file_path}",
+                    "commands_loaded": 0,
+                    "source": file_path,
+                }
+
+            # Load module from file
+            spec = importlib.util.spec_from_file_location(
+                f"command_{Path(file_path).stem}", file_path
+            )
+            if spec is None or spec.loader is None:
+                return {
+                    "success": False,
+                    "error": f"Could not load module from {file_path}",
+                    "commands_loaded": 0,
+                    "source": file_path,
+                }
+
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            # Find command classes in module
+            commands = []
+            for name, obj in inspect.getmembers(module):
+                if (
+                    inspect.isclass(obj)
+                    and issubclass(obj, Command)
+                    and obj != Command
+                ):
+                    commands.append(obj)
+
+            if not commands:
+                return {
+                    "success": False,
+                    "error": f"No command classes found in {file_path}",
+                    "commands_loaded": 0,
+                    "source": file_path,
+                }
+
+            return {
+                "success": True,
+                "commands": commands,
+                "commands_loaded": len(commands),
+                "source": file_path,
+            }
+
+        except Exception as e:
+            self.logger.error(f"Failed to load command from file {file_path}: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "commands_loaded": 0,
+                "source": file_path,
+            }

mcp_proxy_adapter/commands/registry/command_manager.py

@@ -0,0 +1,119 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Command management utilities for MCP Proxy Adapter.
+"""
+
+import os
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class CommandManager:
+    """Manager for command operations."""
+
+    def __init__(self):
+        """Initialize command manager."""
+        self.logger = get_global_logger()
+
+    def _get_command_name(self, command_class: Type[Command]) -> str:
+        """
+        Get command name from command class.
+
+        Args:
+            command_class: Command class
+
+        Returns:
+            Command name
+        """
+        # Try to get name from class attribute
+        if hasattr(command_class, "name") and command_class.name:
+            return command_class.name
+
+        # Fallback to class name
+        class_name = command_class.__name__
+        if class_name.endswith("Command"):
+            return class_name[:-7].lower()  # Remove "Command" suffix
+        return class_name.lower()
+
+
+    def get_command(self, command_name: str, commands: Dict[str, Type[Command]]) -> Type[Command]:
+        """
+        Get command class by name.
+
+        Args:
+            command_name: Name of the command
+            commands: Dictionary of registered commands
+
+        Returns:
+            Command class
+
+        Raises:
+            NotFoundError: If command not found
+        """
+        if command_name not in commands:
+            from mcp_proxy_adapter.core.errors import NotFoundError
+            raise NotFoundError(f"Command '{command_name}' not found")
+        return commands[command_name]
+
+
+
+
+
+
+    def clear(self, commands: Dict[str, Type[Command]], instances: Dict[str, Command], command_types: Dict[str, str]) -> None:
+        """
+        Clear all commands and instances.
+
+        Args:
+            commands: Dictionary of registered commands
+            instances: Dictionary of command instances
+            command_types: Dictionary mapping command names to types
+        """
+        commands.clear()
+        instances.clear()
+        command_types.clear()
+
+
+    def _load_commands_from_directory(self, directory: str, commands: Dict[str, Type[Command]], command_types: Dict[str, str], cmd_type: str) -> int:
+        """
+        Load commands from directory.
+
+        Args:
+            directory: Directory to load commands from
+            commands: Dictionary of registered commands
+            command_types: Dictionary mapping command names to types
+            cmd_type: Type of commands being loaded
+
+        Returns:
+            Number of commands loaded
+        """
+        loaded_count = 0
+        
+        try:
+            for root, dirs, files in os.walk(directory):
+                for file in files:
+                    if file.endswith("_command.py"):
+                        file_path = os.path.join(root, file)
+                        try:
+                            # Load command from file
+                            from .command_loader import CommandLoader
+                            loader = CommandLoader()
+                            result = loader._load_command_from_file(file_path)
+                            
+                            if result["success"]:
+                                for command_class in result["commands"]:
+                                    command_name = self._get_command_name(command_class)
+                                    commands[command_name] = command_class
+                                    command_types[command_name] = cmd_type
+                                    loaded_count += 1
+                                    
+                        except Exception as e:
+                            self.logger.warning(f"Failed to load command from {file_path}: {e}")
+                            
+        except Exception as e:
+            self.logger.error(f"Failed to load commands from directory {directory}: {e}")
+            
+        return loaded_count