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

mcp_proxy_adapter/commands/registry/command_registry.py

@@ -0,0 +1,217 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Main command registry for MCP Proxy Adapter.
+"""
+
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.core.logging import get_global_logger
+from .command_loader import CommandLoader
+from .command_manager import CommandManager
+from .command_info import CommandInfo
+
+
+class CommandRegistry:
+    """
+    Registry for registering and finding commands.
+
+    Supports three types of commands:
+    - Builtin: Core commands that come with the framework
+    - Custom: User-defined commands
+    - Loaded: Commands loaded from external sources
+    """
+
+    def __init__(self):
+        """Initialize command registry."""
+        self.logger = get_global_logger()
+        
+        # Command storage
+        self._commands: Dict[str, Type[Command]] = {}
+        self._instances: Dict[str, Command] = {}
+        self._command_types: Dict[str, str] = {}  # "builtin", "custom", "loaded"
+        
+        # Initialize components
+        self._loader = CommandLoader()
+        self._manager = CommandManager()
+        self._info = CommandInfo()
+
+
+
+    def register_loaded(self, command: Union[Type[Command], Command]) -> None:
+        """
+        Register a loaded command.
+
+        Args:
+            command: Command class or instance to register
+        """
+        self._register_command(command, "loaded")
+
+    def _register_command(self, command: Union[Type[Command], Command], cmd_type: str) -> None:
+        """
+        Register a command.
+
+        Args:
+            command: Command class or instance to register
+            cmd_type: Type of command ("builtin", "custom", "loaded")
+        """
+        if isinstance(command, Command):
+            # Register instance
+            command_name = self._manager._get_command_name(command.__class__)
+            self._instances[command_name] = command
+            self._commands[command_name] = command.__class__
+        else:
+            # Register class
+            command_name = self._manager._get_command_name(command)
+            self._commands[command_name] = command
+        
+        self._command_types[command_name] = cmd_type
+        self.logger.info(f"Registered {cmd_type} command: {command_name}")
+
+    def load_command_from_source(self, source: str) -> Dict[str, Any]:
+        """
+        Load command from source.
+
+        Args:
+            source: Source string - local path, URL, or command name from registry
+
+        Returns:
+            Dictionary with loading result information
+        """
+        result = self._loader.load_command_from_source(source)
+        
+        if result["success"]:
+            # Register loaded commands
+            for command_class in result["commands"]:
+                self.register_loaded(command_class)
+        
+        return result
+
+
+    def command_exists(self, command_name: str) -> bool:
+        """
+        Check if command exists.
+
+        Args:
+            command_name: Name of the command
+
+        Returns:
+            True if command exists, False otherwise
+        """
+        return self._manager.command_exists(command_name, self._commands)
+
+    def get_command(self, command_name: str) -> Type[Command]:
+        """
+        Get command class by name.
+
+        Args:
+            command_name: Name of the command
+
+        Returns:
+            Command class
+
+        Raises:
+            NotFoundError: If command not found
+        """
+        return self._manager.get_command(command_name, self._commands)
+
+    def get_command_instance(self, command_name: str) -> Command:
+        """
+        Get command instance by name.
+
+        Args:
+            command_name: Name of the command
+
+        Returns:
+            Command instance
+
+        Raises:
+            NotFoundError: If command not found
+        """
+        return self._manager.get_command_instance(command_name, self._commands, self._instances)
+
+    def has_instance(self, command_name: str) -> bool:
+        """
+        Check if command has instance.
+
+        Args:
+            command_name: Name of the command
+
+        Returns:
+            True if command has instance, False otherwise
+        """
+        return self._manager.has_instance(command_name, self._instances)
+
+    def get_all_commands(self) -> Dict[str, Type[Command]]:
+        """
+        Get all registered commands.
+
+        Returns:
+            Dictionary of all commands
+        """
+        return self._manager.get_all_commands(self._commands)
+
+    def get_commands_by_type(self) -> Dict[str, Dict[str, Type[Command]]]:
+        """
+        Get commands grouped by type.
+
+        Returns:
+            Dictionary of commands grouped by type
+        """
+        return self._manager.get_commands_by_type(self._commands, self._command_types)
+
+    def get_all_metadata(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Get metadata for all commands.
+
+        Returns:
+            Dictionary of command metadata
+        """
+        return self._manager.get_all_metadata(self._commands, self._command_types)
+
+    def clear(self) -> None:
+        """Clear all commands and instances."""
+        self._manager.clear(self._commands, self._instances, self._command_types)
+        self.logger.info("Cleared all commands")
+
+    def get_all_commands_info(self) -> Dict[str, Any]:
+        """
+        Get comprehensive information about all commands.
+
+        Returns:
+            Dictionary with command information
+        """
+        return self._info.get_all_commands_info(self._commands, self._command_types)
+
+    def get_command_info(self, command_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Get detailed information about a specific command.
+
+        Args:
+            command_name: Name of the command
+
+        Returns:
+            Dictionary with command information or None if not found
+        """
+        if command_name not in self._commands:
+            return None
+        
+        return self._info.get_command_info(
+            command_name, 
+            self._commands[command_name], 
+            self._command_types
+        )
+
+    def _load_all_commands(self) -> Dict[str, int]:
+        """
+        Load all commands from configured directories.
+
+        Returns:
+            Dictionary with loading statistics
+        """
+        return self._manager._load_all_commands(self._commands, self._command_types)
+
+
+# Global registry instance
+registry = CommandRegistry()

mcp_proxy_adapter/commands/reload_command.py

@@ -0,0 +1,136 @@
+"""
+Reload command for configuration and command discovery.
+
+This command allows reloading configuration and rediscovering commands
+without restarting the server.
+"""
+
+from typing import Any, Dict, Optional
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class ReloadResult:
+    """
+    Result of reload operation.
+    """
+
+    def __init__(
+        self,
+        config_reloaded: bool,
+        builtin_commands: int,
+        custom_commands: int,
+        loaded_commands: int,
+        remote_commands: int = 0,
+        total_commands: int = 0,
+        server_restart_required: bool = True,
+        success: bool = True,
+        error_message: Optional[str] = None,
+    ):
+        """
+        Initialize reload result.
+
+        Args:
+            config_reloaded: Whether configuration was reloaded successfully
+            builtin_commands: Number of built-in commands registered
+            custom_commands: Number of custom commands registered
+            loaded_commands: Number of commands loaded from directory
+            total_commands: Total number of commands after reload
+            server_restart_required: Whether server restart is required
+            success: Whether reload was successful
+            error_message: Error message if reload failed
+        """
+        self.config_reloaded = config_reloaded
+        self.builtin_commands = builtin_commands
+        self.custom_commands = custom_commands
+        self.loaded_commands = loaded_commands
+        self.remote_commands = remote_commands
+        self.total_commands = total_commands
+        self.server_restart_required = server_restart_required
+        self.success = success
+        self.error_message = error_message
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+
+        Returns:
+            Dictionary representation of the result.
+        """
+        return {
+            "success": self.success,
+            "config_reloaded": self.config_reloaded,
+            "builtin_commands": self.builtin_commands,
+            "custom_commands": self.custom_commands,
+            "loaded_commands": self.loaded_commands,
+            "remote_commands": self.remote_commands,
+            "total_commands": self.total_commands,
+            "server_restart_required": self.server_restart_required,
+            "message": "Server restart required to apply configuration changes",
+            "error_message": self.error_message,
+        }
+
+    @classmethod
+
+
+class ReloadCommand(Command):
+    """
+    Command for reloading configuration and rediscovering commands.
+    Uses the unified initialization logic.
+    """
+
+    name = "reload"
+
+    async def execute(self, **params) -> ReloadResult:
+        """
+        Execute reload command.
+
+        Args:
+            **params: Command parameters (config_path)
+
+        Returns:
+            ReloadResult with reload information
+        """
+        try:
+            get_global_logger().info("🔄 Starting configuration and commands reload...")
+
+            # Get config path from parameters
+            config_path = params.get("config_path")
+            if not config_path:
+                get_global_logger().warning("No config_path provided, using default configuration")
+
+            # Perform reload using unified initialization
+            reload_info = await registry.reload_system(config_path=config_path)
+
+            # Create result
+            result = ReloadResult(
+                config_reloaded=reload_info.get("config_reloaded", False),
+                builtin_commands=reload_info.get("builtin_commands", 0),
+                custom_commands=reload_info.get("custom_commands", 0),
+                loaded_commands=reload_info.get("loaded_commands", 0),
+                remote_commands=reload_info.get("remote_commands", 0),
+                total_commands=reload_info.get("total_commands", 0),
+                server_restart_required=True,  # Default to True as per tests
+                success=True,
+            )
+
+            get_global_logger().info(f"✅ Reload completed successfully: {result.to_dict()}")
+            return result
+
+        except Exception as e:
+            get_global_logger().error(f"❌ Reload failed: {str(e)}")
+            return ReloadResult(
+                config_reloaded=False,
+                builtin_commands=0,
+                custom_commands=0,
+                loaded_commands=0,
+                remote_commands=0,
+                total_commands=0,
+                server_restart_required=False,
+                success=False,
+                error_message=str(e),
+            )
+
+    @classmethod

mcp_proxy_adapter/commands/result.py

@@ -0,0 +1,157 @@
+"""
+Module with base classes for command results.
+"""
+
+import json
+from abc import ABC, abstractmethod
+from typing import TypeVar, Dict, Any, Optional
+
+T = TypeVar("T", bound="CommandResult")
+
+
+class CommandResult(ABC):
+    """
+    Base abstract class for command execution results.
+    """
+
+    @abstractmethod
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts result to dictionary for serialization.
+
+        Returns:
+            Dictionary with result data.
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get JSON schema for the result."""
+        pass
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "CommandResult":
+        """Create result from dictionary."""
+        pass
+
+
+class SuccessResult(CommandResult):
+    """
+    Base class for successful command results.
+    """
+
+    def __init__(
+        self, data: Optional[Dict[str, Any]] = None, message: Optional[str] = None
+    ):
+        """
+        Initialize successful result.
+
+        Args:
+            data: Result data.
+            message: Result message.
+        """
+        self.data = data or {}
+        self.message = message
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts result to dictionary for serialization.
+
+        Returns:
+            Dictionary with result data.
+        """
+        result = {"success": True}
+        if self.data:
+            result["data"] = self.data
+        if self.message:
+            result["message"] = self.message
+        return result
+
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get JSON schema for success result."""
+        return {
+            "type": "object",
+            "properties": {
+                "success": {"type": "boolean", "const": True},
+                "data": {"type": "object"},
+                "message": {"type": "string"}
+            }
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SuccessResult":
+        """Create success result from dictionary."""
+        return cls(
+            data=data.get("data"),
+            message=data.get("message")
+        )
+
+
+class ErrorResult(CommandResult):
+    """
+    Base class for command results with error.
+
+    This class follows the JSON-RPC 2.0 error object format:
+    https://www.jsonrpc.org/specification#error_object
+    """
+
+    def __init__(
+        self, message: str, code: int = -32000, details: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Initialize error result.
+
+        Args:
+            message: Error message.
+            code: Error code (following JSON-RPC 2.0 spec).
+            details: Additional error details.
+        """
+        self.message = message
+        self.error = message  # For backward compatibility with tests
+        self.code = code
+        self.details = details or {}
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Converts result to dictionary for serialization.
+
+        Returns:
+            Dictionary with result data in JSON-RPC 2.0 error format.
+        """
+        result = {
+            "success": False,
+            "error": {"code": self.code, "message": self.message},
+        }
+        if self.details:
+            result["error"]["data"] = self.details
+        return result
+
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get JSON schema for error result."""
+        return {
+            "type": "object",
+            "properties": {
+                "success": {"type": "boolean", "const": False},
+                "error": {
+                    "type": "object",
+                    "properties": {
+                        "code": {"type": "integer"},
+                        "message": {"type": "string"},
+                        "data": {"type": "object"}
+                    }
+                }
+            }
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ErrorResult":
+        """Create error result from dictionary."""
+        error_data = data.get("error", {})
+        return cls(
+            code=error_data.get("code", -32603),
+            message=error_data.get("message", "Internal error"),
+            details=error_data.get("data")
+        )

mcp_proxy_adapter/commands/role_test_command.py

@@ -0,0 +1,99 @@
+"""
+Role Test Command
+
+This command tests role-based access control by checking user permissions.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import logging
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import SuccessResult
+
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+logger = logging.getLogger(__name__)
+
+
+class RoleTestCommandResult(SuccessResult):
+    """Result for role test command."""
+
+    def __init__(self, user_role: str, permissions: list, action: str, allowed: bool):
+        """
+        Initialize role test result.
+
+        Args:
+            user_role: User's role
+            permissions: User's permissions
+            action: Action being tested
+            allowed: Whether action is allowed
+        """
+        super().__init__()
+        self.user_role = user_role
+        self.permissions = permissions
+        self.action = action
+        self.allowed = allowed
+
+
+    @classmethod
+
+
+class RoleTestCommand(Command):
+    """Test role-based access control."""
+
+    name = "roletest"
+    descr = "Test role-based access control"
+    category = "security"
+    author = "Vasiliy Zdanovskiy"
+    email = "vasilyvz@gmail.com"
+
+    async def execute(self, **kwargs) -> RoleTestCommandResult:
+        """
+        Execute role test command.
+
+        Args:
+            **kwargs: Command parameters including context
+
+        Returns:
+            RoleTestCommandResult
+        """
+        # Extract parameters
+        action = kwargs.get("action", "read")
+        context = kwargs.get("context", {})
+
+        # Get user info from context
+        user_role = "guest"  # Default
+        permissions = ["read"]  # Default
+
+        if context:
+            user_info = context.get("user", {})
+            user_role = user_info.get("role", "guest")
+            permissions = user_info.get("permissions", ["read"])
+
+        # Check if action is allowed
+        allowed = self._check_permission(action, permissions)
+
+        get_global_logger().info(f"Role test: user={user_role}, action={action}, allowed={allowed}")
+
+        return RoleTestCommandResult(user_role, permissions, action, allowed)
+
+    @classmethod
+
+    def _check_permission(self, action: str, permissions: list) -> bool:
+        """
+        Check if action is allowed for given permissions.
+
+        Args:
+            action: Action to check
+            permissions: User permissions
+
+        Returns:
+            True if allowed, False otherwise
+        """
+        # Admin has all permissions
+        if "*" in permissions:
+            return True
+
+        # Check specific permission
+        return action in permissions