mcp-proxy-adapter 2.0.1__py3-none-any.whl → 6.9.50__py3-none-any.whl

mcp_proxy_adapter/commands/base.py

@@ -0,0 +1,389 @@
+"""
+Base command classes for MCP Microservice.
+"""
+
+import inspect
+from abc import ABC, abstractmethod
+from typing import TypeVar, Type, ClassVar, Dict, Any, List
+
+from docstring_parser import parse
+
+from mcp_proxy_adapter.core.errors import (
+    CommandError,
+    InternalError,
+    InvalidParamsError,
+    NotFoundError,
+    ValidationError,
+)
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class CommandResult:
+    """Base class for command results."""
+    
+    def __init__(self, success: bool = True, data: dict = None, error: str = None):
+        self.success = success
+        self.data = data or {}
+        self.error = error
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        result = {"success": self.success}
+        if self.data:
+            result["data"] = self.data
+        if self.error:
+            result["error"] = self.error
+        return result
+
+
+T = TypeVar("T", bound=CommandResult)
+
+
+class Command(ABC):
+    """
+    Base abstract class for all commands.
+    """
+
+    # Command name for registration
+    name: ClassVar[str]
+    # Command version (default: 0.1)
+    version: ClassVar[str] = "0.1"
+    # Plugin filename
+    plugin: ClassVar[str] = ""
+    # Command description
+    descr: ClassVar[str] = ""
+    # Command category
+    category: ClassVar[str] = ""
+    # Command author
+    author: ClassVar[str] = ""
+    # Author email
+    email: ClassVar[str] = ""
+    # Source URL
+    source_url: ClassVar[str] = ""
+    # Result class
+    result_class: ClassVar[Type[CommandResult]]
+
+    @abstractmethod
+    async def execute(self, **kwargs) -> CommandResult:
+        """
+        Execute command with the specified parameters.
+
+        Args:
+            **kwargs: Command parameters including optional 'context' parameter.
+
+        Returns:
+            Command result.
+        """
+        pass
+
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+
+        Returns:
+            JSON schema.
+        """
+        return {"type": "object", "properties": {}, "additionalProperties": False}
+
+    @classmethod
+    def get_result_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command result.
+
+        Returns:
+            JSON schema.
+        """
+        if hasattr(cls, "result_class") and cls.result_class:
+            return cls.result_class.get_schema()
+        return {}
+
+    def validate_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate command parameters.
+
+        Args:
+            params: Parameters to validate.
+
+        Returns:
+            Validated parameters.
+
+        Raises:
+            ValidationError: If parameters are invalid.
+        """
+        # Ensure params is a dictionary, even if None was passed
+        if params is None:
+            params = {}
+
+        # Create a copy to avoid modifying the input dictionary during iteration
+        validated_params = params.copy()
+
+        # Handle None values and empty strings in parameters
+        for key, value in list(validated_params.items()):
+            # Process None values or empty strings - this helps with JavaScript null/undefined conversions
+            if value is None or (
+                isinstance(value, str) and value.lower() in ["null", "none", ""]
+            ):
+                # For commands that specifically handle None values, keep the parameter
+                # (like help), keep the parameter but ensure it's a proper Python None
+                if key in [
+                    "cmdname"
+                ]:  # список параметров, для которых None является допустимым значением
+                    validated_params[key] = None
+                else:
+                    # For most parameters, remove None values to avoid issues
+                    del validated_params[key]
+
+        # Get command schema to validate parameters
+        schema = self.get_schema()
+        if schema and "properties" in schema:
+            allowed_properties = schema["properties"].keys()
+
+            # Filter out parameters that are not in the schema
+            invalid_params = []
+            for param_name in list(validated_params.keys()):
+                if param_name not in allowed_properties:
+                    invalid_params.append(param_name)
+                    del validated_params[param_name]
+
+            # Log warning about invalid parameters
+            if invalid_params:
+                get_global_logger().warning(
+                    f"Command {self.__class__.__name__} received invalid parameters: {invalid_params}. "
+                    f"Allowed parameters: {list(allowed_properties)}"
+                )
+
+        # Validate required parameters based on command schema
+        if schema and "required" in schema:
+            required_params = schema["required"]
+            missing_params = []
+
+            for param in required_params:
+                if param not in validated_params:
+                    missing_params.append(param)
+
+            if missing_params:
+                raise ValidationError(
+                    f"Missing required parameters: {', '.join(missing_params)}",
+                    data={"missing_parameters": missing_params},
+                )
+
+        return validated_params
+
+    @classmethod
+    async def run(cls, **kwargs) -> CommandResult:
+        """
+        Runs the command with the specified arguments.
+
+        Args:
+            **kwargs: Command arguments including optional 'context' parameter.
+
+        Returns:
+            Command result.
+        """
+        # Extract context from kwargs
+        context = kwargs.pop("context", {}) if "context" in kwargs else {}
+
+        try:
+            get_global_logger().debug(f"Running command {cls.__name__} with params: {kwargs}")
+
+            # Import registry here to avoid circular imports
+            from mcp_proxy_adapter.commands.command_registry import registry
+
+            # Get command name
+            if not hasattr(cls, "name") or not cls.name:
+                command_name = cls.__name__.lower()
+                if command_name.endswith("command"):
+                    command_name = command_name[:-7]
+            else:
+                command_name = cls.name
+
+            # Ensure kwargs is never None
+            if kwargs is None:
+                kwargs = {}
+
+            # Get command with priority (custom commands first, then built-in)
+            command_class = registry.get_command(command_name)
+            if command_class is None:
+                raise NotFoundError(f"Command '{command_name}' not found")
+
+            # Create new instance and validate parameters
+            command = command_class()
+            validated_params = command.validate_params(kwargs)
+
+            # Execute command with validated parameters and context
+            result = await command.execute(**validated_params, context=context)
+
+            get_global_logger().debug(f"Command {cls.__name__} executed successfully")
+            return result
+        except ValidationError as e:
+            # Ошибка валидации параметров
+            get_global_logger().error(f"Validation error in command {cls.__name__}: {e}")
+            return ErrorResult(message=str(e), code=e.code, details=e.data)
+        except InvalidParamsError as e:
+            # Ошибка в параметрах команды
+            get_global_logger().error(f"Invalid parameters error in command {cls.__name__}: {e}")
+            return ErrorResult(message=str(e), code=e.code, details=e.data)
+        except NotFoundError as e:
+            # Ресурс не найден
+            get_global_logger().error(f"Resource not found error in command {cls.__name__}: {e}")
+            return ErrorResult(message=str(e), code=e.code, details=e.data)
+        except TimeoutError as e:
+            # Превышено время ожидания
+            get_global_logger().error(f"Timeout error in command {cls.__name__}: {e}")
+            return ErrorResult(message=str(e), code=e.code, details=e.data)
+        except CommandError as e:
+            # Ошибка выполнения команды
+            get_global_logger().error(f"Command error in {cls.__name__}: {e}")
+            return ErrorResult(message=str(e), code=e.code, details=e.data)
+        except Exception as e:
+            # Непредвиденная ошибка
+            get_global_logger().exception(f"Unexpected error executing command {cls.__name__}: {e}")
+            internal_error = InternalError(f"Command execution error: {str(e)}")
+            return ErrorResult(
+                message=internal_error.message,
+                code=internal_error.code,
+                details={"original_error": str(e)},
+            )
+
+    @classmethod
+    def get_param_info(cls) -> Dict[str, Dict[str, Any]]:
+        """
+        Gets information about execute method parameters.
+
+        Returns:
+            Dictionary with parameters information.
+        """
+        signature = inspect.signature(cls.execute)
+        params = {}
+
+        for name, param in signature.parameters.items():
+            if name == "self":
+                continue
+
+            param_info = {
+                "name": name,
+                "required": param.default == inspect.Parameter.empty,
+            }
+
+            if param.annotation != inspect.Parameter.empty:
+                param_info["type"] = str(param.annotation)
+
+            if param.default != inspect.Parameter.empty:
+                param_info["default"] = param.default
+
+            params[name] = param_info
+
+        return params
+
+    @classmethod
+
+    @classmethod
+    def _generate_examples(
+        cls, params: Dict[str, Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        """
+        Generates usage examples of the command based on its parameters.
+
+        Args:
+            params: Information about command parameters
+
+        Returns:
+            List of examples
+        """
+        examples = []
+
+        # Simple example without parameters, if all parameters are optional
+        if not any(param.get("required", False) for param in params.values()):
+            examples.append(
+                {
+                    "command": cls.name,
+                    "description": f"Call {cls.name} command without parameters",
+                }
+            )
+
+        # Example with all required parameters
+        required_params = {k: v for k, v in params.items() if v.get("required", False)}
+        if required_params:
+            sample_params = {}
+            for param_name, param_info in required_params.items():
+                # Try to generate sample value based on type
+                param_type = param_info.get("type", "")
+
+                if "str" in param_type:
+                    sample_params[param_name] = f"sample_{param_name}"
+                elif "int" in param_type:
+                    sample_params[param_name] = 1
+                elif "float" in param_type:
+                    sample_params[param_name] = 1.0
+                elif "bool" in param_type:
+                    sample_params[param_name] = True
+                elif "list" in param_type or "List" in param_type:
+                    sample_params[param_name] = []
+                elif "dict" in param_type or "Dict" in param_type:
+                    sample_params[param_name] = {}
+                else:
+                    sample_params[param_name] = "..."
+
+            examples.append(
+                {
+                    "command": cls.name,
+                    "params": sample_params,
+                    "description": f"Call {cls.name} command with required parameters",
+                }
+            )
+
+        # Example with all parameters (including optional ones)
+        if len(params) > len(required_params):
+            all_params = {}
+            for param_name, param_info in params.items():
+                # For required parameters, use the same values as above
+                if param_info.get("required", False):
+                    # Try to generate sample value based on type
+                    param_type = param_info.get("type", "")
+
+                    if "str" in param_type:
+                        all_params[param_name] = f"sample_{param_name}"
+                    elif "int" in param_type:
+                        all_params[param_name] = 1
+                    elif "float" in param_type:
+                        all_params[param_name] = 1.0
+                    elif "bool" in param_type:
+                        all_params[param_name] = True
+                    elif "list" in param_type or "List" in param_type:
+                        all_params[param_name] = []
+                    elif "dict" in param_type or "Dict" in param_type:
+                        all_params[param_name] = {}
+                    else:
+                        all_params[param_name] = "..."
+                # For optional parameters, use their default values or a sample value
+                else:
+                    if "default" in param_info:
+                        all_params[param_name] = param_info["default"]
+                    else:
+                        param_type = param_info.get("type", "")
+
+                        if "str" in param_type:
+                            all_params[param_name] = f"optional_{param_name}"
+                        elif "int" in param_type:
+                            all_params[param_name] = 0
+                        elif "float" in param_type:
+                            all_params[param_name] = 0.0
+                        elif "bool" in param_type:
+                            all_params[param_name] = False
+                        elif "list" in param_type or "List" in param_type:
+                            all_params[param_name] = []
+                        elif "dict" in param_type or "Dict" in param_type:
+                            all_params[param_name] = {}
+                        else:
+                            all_params[param_name] = None
+
+            examples.append(
+                {
+                    "command": cls.name,
+                    "params": all_params,
+                    "description": f"Call {cls.name} command with all parameters",
+                }
+            )
+
+        return examples

mcp_proxy_adapter/commands/builtin_commands.py

@@ -0,0 +1,30 @@
+"""
+Module for registering built-in framework commands.
+
+This module contains the procedure for adding predefined commands
+that are part of the framework.
+"""
+
+from typing import List
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.commands.help_command import HelpCommand
+from mcp_proxy_adapter.commands.health_command import HealthCommand
+from mcp_proxy_adapter.commands.config_command import ConfigCommand
+from mcp_proxy_adapter.commands.reload_command import ReloadCommand
+from mcp_proxy_adapter.commands.settings_command import SettingsCommand
+from mcp_proxy_adapter.commands.load_command import LoadCommand
+from mcp_proxy_adapter.commands.unload_command import UnloadCommand
+from mcp_proxy_adapter.commands.plugins_command import PluginsCommand
+from mcp_proxy_adapter.commands.transport_management_command import (
+    TransportManagementCommand,
+)
+from mcp_proxy_adapter.commands.proxy_registration_command import (
+    ProxyRegistrationCommand,
+)
+from mcp_proxy_adapter.commands.echo_command import EchoCommand
+from mcp_proxy_adapter.commands.role_test_command import RoleTestCommand
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+
+

mcp_proxy_adapter/commands/catalog/__init__.py

@@ -0,0 +1,20 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Command catalog management package for MCP Proxy Adapter.
+"""
+
+from .command_catalog import CommandCatalog
+from .catalog_manager import CatalogManager
+from .catalog_loader import CatalogLoader
+from .catalog_syncer import CatalogSyncer
+from .dependency_manager import DependencyManager
+
+__all__ = [
+    "CommandCatalog",
+    "CatalogManager",
+    "CatalogLoader",
+    "CatalogSyncer",
+    "DependencyManager",
+]

mcp_proxy_adapter/commands/catalog/catalog_loader.py

@@ -0,0 +1,34 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Catalog loading utilities for MCP Proxy Adapter.
+"""
+
+import json
+from pathlib import Path
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from .command_catalog import CommandCatalog
+
+# Try to import requests, but don't fail if not available
+try:
+    import requests
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+    get_global_logger().warning(
+        "requests library not available, HTTP/HTTPS functionality will be limited"
+    )
+
+
+class CatalogLoader:
+    """Loader for command catalogs from various sources."""
+
+    def __init__(self):
+        """Initialize catalog loader."""
+        self.logger = get_global_logger()
+
+
+
+

mcp_proxy_adapter/commands/catalog/catalog_manager.py

@@ -0,0 +1,122 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Main catalog manager for MCP Proxy Adapter.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from packaging import version as pkg_version
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from mcp_proxy_adapter.commands.dependency_manager import dependency_manager
+from mcp_proxy_adapter.config import config
+from .command_catalog import CommandCatalog
+from .catalog_loader import CatalogLoader
+from .catalog_syncer import CatalogSyncer
+from .dependency_manager import DependencyManager
+
+# Try to import requests, but don't fail if not available
+try:
+    import requests
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+    get_global_logger().warning(
+        "requests library not available, HTTP/HTTPS functionality will be limited"
+    )
+
+
+class CatalogManager:
+    """
+    Manager for command catalog operations.
+
+    Handles loading, syncing, and managing command catalogs from various sources.
+    """
+
+    def __init__(self, catalog_dir: str):
+        """
+        Initialize catalog manager.
+
+        Args:
+            catalog_dir: Directory for catalog storage
+        """
+        self.catalog_dir = Path(catalog_dir)
+        self.logger = get_global_logger()
+        
+        # Initialize components
+        self.loader = CatalogLoader()
+        self.syncer = CatalogSyncer(catalog_dir)
+        self.dependency_manager = DependencyManager()
+        
+        # Load existing catalog
+        self.catalog: Dict[str, CommandCatalog] = {}
+        self._load_catalog()
+
+    def _load_catalog(self) -> None:
+        """Load catalog from local storage."""
+        catalog_file = self.catalog_dir / "catalog.json"
+        self.catalog = self.loader.load_catalog_from_file(catalog_file)
+
+    def _save_catalog(self) -> None:
+        """Save catalog to local storage."""
+        catalog_file = self.catalog_dir / "catalog.json"
+        self.loader.save_catalog_to_file(self.catalog, catalog_file)
+
+
+    def sync_with_servers(self, server_urls: List[str]) -> Dict[str, Any]:
+        """
+        Synchronize catalog with remote servers.
+
+        Args:
+            server_urls: List of server URLs to sync with
+
+        Returns:
+            Dictionary with sync results
+        """
+        return self.syncer.sync_with_servers(server_urls)
+
+
+
+
+
+    def _extract_metadata_from_file(self, file_path: str) -> Dict[str, Any]:
+        """
+        Extract metadata from command file.
+
+        Args:
+            file_path: Path to command file
+
+        Returns:
+            Dictionary of extracted metadata
+        """
+        metadata = {}
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # Extract basic metadata
+            for line in content.split('\n'):
+                line = line.strip()
+                if line.startswith('__version__'):
+                    metadata['version'] = line.split('=')[1].strip().strip('"\'')
+                elif line.startswith('__author__'):
+                    metadata['author'] = line.split('=')[1].strip().strip('"\'')
+                elif line.startswith('__description__'):
+                    metadata['description'] = line.split('=')[1].strip().strip('"\'')
+                elif line.startswith('__category__'):
+                    metadata['category'] = line.split('=')[1].strip().strip('"\'')
+                elif line.startswith('__email__'):
+                    metadata['email'] = line.split('=')[1].strip().strip('"\'')
+                elif line.startswith('__depends__'):
+                    deps_str = line.split('=')[1].strip().strip('[]"\'')
+                    if deps_str:
+                        metadata['depends'] = [dep.strip().strip('"\'') for dep in deps_str.split(',')]
+
+        except Exception as e:
+            self.logger.error(f"Failed to extract metadata from {file_path}: {e}")
+
+        return metadata