mcp-proxy-adapter 3.0.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

mcp_proxy_adapter/commands/command_registry.py

@@ -0,0 +1,231 @@
+"""
+Module for registering and managing commands.
+"""
+
+import importlib
+import inspect
+import os
+import pkgutil
+from typing import Any, Dict, List, Optional, Type, TypeVar, cast
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.core.errors import NotFoundError
+from mcp_proxy_adapter.core.logging import logger
+
+T = TypeVar("T", bound=Command)
+
+
+class CommandRegistry:
+    """
+    Registry for registering and finding commands.
+    """
+    
+    def __init__(self):
+        """
+        Initialize command registry.
+        """
+        self._commands: Dict[str, Type[Command]] = {}
+    
+    def register(self, command_class: Type[Command]) -> None:
+        """
+        Registers command class in the registry.
+
+        Args:
+            command_class: Command class to register.
+
+        Raises:
+            ValueError: If command with the same name is already registered.
+        """
+        if not hasattr(command_class, "name") or not command_class.name:
+            # Use class name if name attribute is not set
+            command_name = command_class.__name__.lower()
+            if command_name.endswith("command"):
+                command_name = command_name[:-7]  # Remove "command" suffix
+        else:
+            command_name = command_class.name
+            
+        if command_name in self._commands:
+            logger.debug(f"Command '{command_name}' is already registered, skipping")
+            raise ValueError(f"Command '{command_name}' is already registered")
+            
+        logger.debug(f"Registering command: {command_name}")
+        self._commands[command_name] = command_class
+    
+    def unregister(self, command_name: str) -> None:
+        """
+        Removes command from registry.
+
+        Args:
+            command_name: Command name to remove.
+
+        Raises:
+            NotFoundError: If command is not found.
+        """
+        if command_name not in self._commands:
+            raise NotFoundError(f"Command '{command_name}' not found")
+            
+        logger.debug(f"Unregistering command: {command_name}")
+        del self._commands[command_name]
+    
+    def command_exists(self, command_name: str) -> bool:
+        """
+        Checks if command exists in registry.
+
+        Args:
+            command_name: Command name to check.
+
+        Returns:
+            True if command exists, False otherwise.
+        """
+        return command_name in self._commands
+    
+    def get_command(self, command_name: str) -> Type[Command]:
+        """
+        Gets command class by name.
+
+        Args:
+            command_name: Command name.
+
+        Returns:
+            Command class.
+
+        Raises:
+            NotFoundError: If command is not found.
+        """
+        if command_name not in self._commands:
+            raise NotFoundError(f"Command '{command_name}' not found")
+            
+        return self._commands[command_name]
+    
+    def get_all_commands(self) -> Dict[str, Type[Command]]:
+        """
+        Returns all registered commands.
+
+        Returns:
+            Dictionary with command names and their classes.
+        """
+        return dict(self._commands)
+    
+    def get_command_info(self, command_name: str) -> Dict[str, Any]:
+        """
+        Gets information about a command.
+
+        Args:
+            command_name: Command name.
+
+        Returns:
+            Dictionary with command information.
+
+        Raises:
+            NotFoundError: If command is not found.
+        """
+        command_class = self.get_command(command_name)
+        
+        return {
+            "name": command_name,
+            "description": command_class.__doc__ or "",
+            "params": command_class.get_param_info(),
+            "schema": command_class.get_schema(),
+            "result_schema": command_class.get_result_schema()
+        }
+    
+    def get_command_metadata(self, command_name: str) -> Dict[str, Any]:
+        """
+        Get complete metadata for a command.
+        
+        Args:
+            command_name: Command name
+            
+        Returns:
+            Dict with command metadata
+            
+        Raises:
+            NotFoundError: If command is not found
+        """
+        command_class = self.get_command(command_name)
+        return command_class.get_metadata()
+    
+    def get_all_metadata(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Get metadata for all registered commands.
+        
+        Returns:
+            Dict with command names as keys and metadata as values
+        """
+        metadata = {}
+        for name, command_class in self._commands.items():
+            metadata[name] = command_class.get_metadata()
+        return metadata
+    
+    def get_all_commands_info(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Gets information about all registered commands.
+
+        Returns:
+            Dictionary with information about all commands.
+        """
+        commands_info = {}
+        for name in self._commands:
+            commands_info[name] = self.get_command_info(name)
+        return commands_info
+    
+    def discover_commands(self, package_path: str = "mcp_proxy_adapter.commands") -> None:
+        """
+        Automatically discovers and registers commands in the specified package.
+
+        Args:
+            package_path: Path to package with commands.
+        """
+        logger.info(f"Discovering commands in package: {package_path}")
+        
+        try:
+            package = importlib.import_module(package_path)
+            package_dir = os.path.dirname(package.__file__ or "")
+            
+            for _, module_name, is_pkg in pkgutil.iter_modules([package_dir]):
+                if is_pkg:
+                    # Recursively traverse subpackages
+                    self.discover_commands(f"{package_path}.{module_name}")
+                elif module_name.endswith("_command"):
+                    # Import only command modules
+                    module_path = f"{package_path}.{module_name}"
+                    logger.debug(f"Found command module: {module_path}")
+                    
+                    try:
+                        module = importlib.import_module(module_path)
+                        
+                        # Find all command classes in the module
+                        for name, obj in inspect.getmembers(module):
+                            if (inspect.isclass(obj) and 
+                                issubclass(obj, Command) and 
+                                obj != Command and
+                                not inspect.isabstract(obj)):
+                                
+                                # Get command name before registration
+                                command_name = obj.name if hasattr(obj, "name") and obj.name else obj.__name__.lower()
+                                if command_name.endswith("command"):
+                                    command_name = command_name[:-7]  # Remove "command" suffix
+                                
+                                # Register the command only if it doesn't exist
+                                if not self.command_exists(command_name):
+                                    self.register(cast(Type[Command], obj))
+                                else:
+                                    logger.debug(f"Command '{command_name}' is already registered, skipping")
+                    except ValueError as e:
+                        # Skip already registered commands
+                        logger.debug(f"Skipping command registration: {str(e)}")
+                    except Exception as e:
+                        logger.error(f"Error loading command module {module_path}: {e}")
+        except Exception as e:
+            logger.error(f"Error discovering commands: {e}")
+            
+    def clear(self) -> None:
+        """
+        Clears command registry.
+        """
+        logger.debug("Clearing command registry")
+        self._commands.clear()
+
+
+# Global command registry instance
+registry = CommandRegistry()

mcp_proxy_adapter/commands/config_command.py

@@ -0,0 +1,113 @@
+"""
+Config command implementation for managing service configuration.
+"""
+
+from typing import Dict, Any, Optional
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import SuccessResult
+from mcp_proxy_adapter.config import config as config_instance
+
+
+class ConfigResult(SuccessResult):
+    """
+    Config operation result.
+    """
+    
+    def __init__(self, config: Dict[str, Any], operation: str, message: str = None):
+        """
+        Initialize config result.
+        
+        Args:
+            config: Configuration values
+            operation: Operation performed
+            message: Optional message
+        """
+        super().__init__(data={
+            "config": config,
+            "operation": operation
+        }, message=message)
+
+
+class ConfigCommand(Command):
+    """
+    Command for managing service configuration.
+    """
+    name = "config"
+    description = "Get or set configuration values"
+    result_class = ConfigResult
+    
+    async def execute(self, operation: str = "get", path: str = None, value: Any = None) -> ConfigResult:
+        """
+        Execute the command.
+        
+        Args:
+            operation: Operation to perform (get, set)
+            path: Configuration path (dot notation)
+            value: Value to set (for set operation)
+            
+        Returns:
+            Config operation result
+        """
+        message = None
+        result_config = {}
+        
+        if operation == "get":
+            if path:
+                # Get specific config value
+                result_config = {path: config_instance.get(path)}
+            else:
+                # Get all config
+                result_config = config_instance.get_all()
+            message = f"Configuration retrieved successfully"
+            
+        elif operation == "set":
+            if path and value is not None:
+                # Set config value
+                config_instance.set(path, value)
+                # Save config
+                config_instance.save()
+                result_config = {path: value}
+                message = f"Configuration updated successfully"
+            else:
+                # Error - missing required parameters
+                raise ValueError("Both 'path' and 'value' are required for 'set' operation")
+                
+        else:
+            # Invalid operation
+            raise ValueError(f"Invalid operation: {operation}. Valid operations: get, set")
+        
+        return ConfigResult(
+            config=result_config,
+            operation=operation,
+            message=message
+        )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Returns JSON schema for command parameters validation.
+        
+        Returns:
+            Dictionary with JSON schema.
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "operation": {
+                    "type": "string", 
+                    "enum": ["get", "set"],
+                    "default": "get",
+                    "description": "Operation to perform (get or set)"
+                },
+                "path": {
+                    "type": "string",
+                    "description": "Configuration path in dot notation (e.g. 'server.host')"
+                },
+                "value": {
+                    "description": "Value to set (required for 'set' operation)"
+                }
+            },
+            "required": ["operation"],
+            "additionalProperties": False
+        } 

mcp_proxy_adapter/commands/health_command.py

@@ -0,0 +1,136 @@
+"""
+Module with health command implementation.
+"""
+
+import os
+import platform
+import sys
+import psutil
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult
+from mcp_proxy_adapter.commands.command_registry import registry
+
+
+class HealthResult(SuccessResult):
+    """
+    Result of the health command execution.
+    """
+    
+    def __init__(self, status: str, version: str, uptime: float, components: Dict[str, Any]):
+        """
+        Initialize health command result.
+        
+        Args:
+            status: Server status ("ok" or "error")
+            version: Server version
+            uptime: Server uptime in seconds
+            components: Dictionary with components status
+        """
+        super().__init__(
+            data={
+                "status": status,
+                "version": version,
+                "uptime": uptime,
+                "components": components
+            }
+        )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result validation.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "data": {
+                    "type": "object",
+                    "properties": {
+                        "status": {"type": "string"},
+                        "version": {"type": "string"},
+                        "uptime": {"type": "number"},
+                        "components": {
+                            "type": "object",
+                            "properties": {
+                                "system": {"type": "object"},
+                                "process": {"type": "object"},
+                                "commands": {"type": "object"}
+                            }
+                        }
+                    },
+                    "required": ["status", "version", "uptime", "components"]
+                }
+            },
+            "required": ["data"]
+        }
+
+
+class HealthCommand(Command):
+    """
+    Command that returns information about server health and status.
+    """
+    
+    name = "health"
+    result_class = HealthResult
+    
+    async def execute(self) -> HealthResult:
+        """
+        Execute health command.
+        
+        Returns:
+            HealthResult: Health command result
+        """
+        # Get version from package
+        try:
+            from mcp_proxy_adapter.version import __version__ as version
+        except ImportError:
+            version = "unknown"
+        
+        # Get process start time
+        process = psutil.Process(os.getpid())
+        start_time = datetime.fromtimestamp(process.create_time())
+        uptime_seconds = (datetime.now() - start_time).total_seconds()
+        
+        # Get system information
+        memory_info = process.memory_info()
+        
+        return HealthResult(
+            status="ok",
+            version=version,
+            uptime=uptime_seconds,
+            components={
+                "system": {
+                    "python_version": sys.version,
+                    "platform": platform.platform(),
+                    "cpu_count": os.cpu_count()
+                },
+                "process": {
+                    "pid": os.getpid(),
+                    "memory_usage_mb": memory_info.rss / (1024 * 1024),
+                    "start_time": start_time.isoformat()
+                },
+                "commands": {
+                    "registered_count": len(registry.get_all_commands())
+                }
+            }
+        )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters validation.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "additionalProperties": False,
+            "description": "Command doesn't accept any parameters"
+        }

mcp_proxy_adapter/commands/help_command.py

@@ -0,0 +1,193 @@
+"""
+Module with help command implementation.
+"""
+
+from typing import Dict, Any, Optional
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.errors import NotFoundError
+
+
+class HelpResult(CommandResult):
+    """
+    Result of the help command execution.
+    """
+    
+    def __init__(self, commands_info: Optional[Dict[str, Any]] = None, command_info: Optional[Dict[str, Any]] = None):
+        """
+        Initialize help command result.
+        
+        Args:
+            commands_info: Information about all commands (for request without parameters)
+            command_info: Information about a specific command (for request with cmdname parameter)
+        """
+        self.commands_info = commands_info
+        self.command_info = command_info
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dict[str, Any]: Result as dictionary
+        """
+        if self.command_info:
+            return {
+                "cmdname": self.command_info["name"],
+                "info": {
+                    "description": self.command_info["description"],
+                    "summary": self.command_info["summary"],
+                    "params": self.command_info["params"],
+                    "examples": self.command_info["examples"]
+                }
+            }
+        
+        # For list of all commands, return as is (already formatted)
+        result = self.commands_info.copy()
+        
+        # Add total count and note about usage
+        result["total"] = len(result["commands"])
+        result["note"] = "To get detailed information about a specific command, call help with parameter: POST /cmd {\"command\": \"help\", \"params\": {\"cmdname\": \"<command_name>\"}}. Only 'cmdname' parameter is supported."
+        
+        return result
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result validation.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "oneOf": [
+                {
+                    "properties": {
+                        "commands": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "object",
+                                "properties": {
+                                    "description": {"type": "string"}
+                                }
+                            }
+                        },
+                        "tool_info": {
+                            "type": "object",
+                            "properties": {
+                                "name": {"type": "string"},
+                                "description": {"type": "string"},
+                                "version": {"type": "string"}
+                            }
+                        },
+                        "help_usage": {
+                            "type": "object"
+                        },
+                        "total": {"type": "integer"},
+                        "note": {"type": "string"}
+                    },
+                    "required": ["commands"]
+                },
+                {
+                    "properties": {
+                        "cmdname": {"type": "string"},
+                        "info": {
+                            "type": "object",
+                            "properties": {
+                                "description": {"type": "string"},
+                                "summary": {"type": "string"},
+                                "params": {"type": "object"},
+                                "examples": {"type": "array"}
+                            }
+                        }
+                    },
+                    "required": ["cmdname", "info"]
+                }
+            ]
+        }
+
+
+class HelpCommand(Command):
+    """
+    Command for getting help information about available commands.
+    """
+    
+    name = "help"
+    result_class = HelpResult
+    
+    async def execute(self, cmdname: Optional[str] = None) -> HelpResult:
+        """
+        Execute help command.
+        
+        Args:
+            cmdname: Name of the command to get information about (optional)
+            
+        Returns:
+            HelpResult: Help command result
+            
+        Raises:
+            NotFoundError: If specified command not found
+        """
+        # If cmdname is provided, return information about specific command
+        if cmdname:
+            try:
+                # Get command metadata from registry
+                command_metadata = registry.get_command_metadata(cmdname)
+                return HelpResult(command_info=command_metadata)
+            except NotFoundError:
+                # If command not found, raise error
+                raise NotFoundError(f"Command '{cmdname}' not found")
+        
+        # Otherwise, return information about all available commands
+        # and tool metadata
+        
+        # Get metadata for all commands
+        all_metadata = registry.get_all_metadata()
+        
+        # Prepare response format with tool metadata
+        result = {
+            "tool_info": {
+                "name": "MCP-Proxy API Service",
+                "description": "JSON-RPC API for microservice command execution",
+                "version": "1.0.0"
+            },
+            "help_usage": {
+                "description": "Get information about commands",
+                "examples": [
+                    {"command": "help", "description": "List of all available commands"},
+                    {"command": "help", "params": {"cmdname": "command_name"}, "description": "Get detailed information about a specific command"}
+                ]
+            },
+            "commands": {}
+        }
+        
+        # Add brief information about commands
+        for name, metadata in all_metadata.items():
+            result["commands"][name] = {
+                "summary": metadata["summary"],
+                "params_count": len(metadata["params"])
+            }
+        
+        return HelpResult(commands_info=result)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters validation.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "cmdname": {
+                    "type": "string",
+                    "description": "Name of command to get information about"
+                }
+            },
+            "additionalProperties": False
+        }