mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.29__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

@@ -73,68 +73,6 @@ class ReloadResult:
         }
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for the result.
-
-        Returns:
-            JSON schema dictionary.
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "success": {
-                    "type": "boolean",
-                    "description": "Whether reload was successful",
-                },
-                "config_reloaded": {
-                    "type": "boolean",
-                    "description": "Whether configuration was reloaded successfully",
-                },
-                "builtin_commands": {
-                    "type": "integer",
-                    "description": "Number of built-in commands registered",
-                },
-                "custom_commands": {
-                    "type": "integer",
-                    "description": "Number of custom commands registered",
-                },
-                "loaded_commands": {
-                    "type": "integer",
-                    "description": "Number of commands loaded from directory",
-                },
-                "remote_commands": {
-                    "type": "integer",
-                    "description": "Number of commands loaded from remote plugins",
-                },
-                "total_commands": {
-                    "type": "integer",
-                    "description": "Total number of commands after reload",
-                },
-                "server_restart_required": {
-                    "type": "boolean",
-                    "description": "Whether server restart is required to apply changes",
-                },
-                "message": {
-                    "type": "string",
-                    "description": "Information message about the reload operation",
-                },
-                "error_message": {
-                    "type": ["string", "null"],
-                    "description": "Error message if reload failed",
-                },
-            },
-            "required": [
-                "success",
-                "config_reloaded",
-                "builtin_commands",
-                "custom_commands",
-                "loaded_commands",
-                "remote_commands",
-                "total_commands",
-                "server_restart_required",
-            ],
-        }
 
 
 class ReloadCommand(Command):
@@ -196,21 +134,3 @@ class ReloadCommand(Command):
             )
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for command parameters.
-
-        Returns:
-            JSON schema dictionary.
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "config_path": {
-                    "type": "string",
-                    "description": "Path to configuration file to reload",
-                    "default": None,
-                }
-            },
-            "additionalProperties": False,
-        }

mcp_proxy_adapter/commands/result.py

@@ -4,7 +4,7 @@ Module with base classes for command results.
 
 import json
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Type, TypeVar, Union
+from typing import TypeVar, Dict, Any, Optional
 
 T = TypeVar("T", bound="CommandResult")
 
@@ -27,39 +27,13 @@ class CommandResult(ABC):
     @classmethod
     @abstractmethod
     def get_schema(cls) -> Dict[str, Any]:
-        """
-        Returns JSON schema for result validation.
-
-        Returns:
-            Dictionary with JSON schema.
-        """
+        """Get JSON schema for the result."""
         pass
 
-    def to_json(self, indent: Optional[int] = None) -> str:
-        """
-        Converts result to JSON string.
-
-        Args:
-            indent: Indentation for JSON formatting.
-
-        Returns:
-            JSON string with result.
-        """
-        return json.dumps(self.to_dict(), ensure_ascii=False, indent=indent)
-
     @classmethod
-    def from_dict(cls: Type[T], data: Dict[str, Any]) -> T:
-        """
-        Creates result instance from dictionary.
-        This method must be overridden in subclasses.
-
-        Args:
-            data: Dictionary with result data.
-
-        Returns:
-            Result instance.
-        """
-        raise NotImplementedError("Method from_dict must be implemented in subclasses")
+    def from_dict(cls, data: Dict[str, Any]) -> "CommandResult":
+        """Create result from dictionary."""
+        pass
 
 
 class SuccessResult(CommandResult):
@@ -96,34 +70,23 @@ class SuccessResult(CommandResult):
 
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
-        """
-        Returns JSON schema for result validation.
-
-        Returns:
-            Dictionary with JSON schema.
-        """
+        """Get JSON schema for success result."""
         return {
             "type": "object",
             "properties": {
-                "success": {"type": "boolean"},
+                "success": {"type": "boolean", "const": True},
                 "data": {"type": "object"},
-                "message": {"type": "string"},
-            },
-            "required": ["success"],
+                "message": {"type": "string"}
+            }
         }
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "SuccessResult":
-        """
-        Creates successful result instance from dictionary.
-
-        Args:
-            data: Dictionary with result data.
-
-        Returns:
-            Successful result instance.
-        """
-        return cls(data=data.get("data"), message=data.get("message"))
+        """Create success result from dictionary."""
+        return cls(
+            data=data.get("data"),
+            message=data.get("message")
+        )
 
 
 class ErrorResult(CommandResult):
@@ -167,43 +130,28 @@ class ErrorResult(CommandResult):
 
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
-        """
-        Returns JSON schema for result validation.
-
-        Returns:
-            Dictionary with JSON schema.
-        """
+        """Get JSON schema for error result."""
         return {
             "type": "object",
             "properties": {
-                "success": {"type": "boolean"},
+                "success": {"type": "boolean", "const": False},
                 "error": {
                     "type": "object",
                     "properties": {
                         "code": {"type": "integer"},
                         "message": {"type": "string"},
-                        "data": {"type": "object"},
-                    },
-                    "required": ["code", "message"],
-                },
-            },
-            "required": ["success", "error"],
+                        "data": {"type": "object"}
+                    }
+                }
+            }
         }
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "ErrorResult":
-        """
-        Creates error result instance from dictionary.
-
-        Args:
-            data: Dictionary with result data.
-
-        Returns:
-            Error result instance.
-        """
-        error = data.get("error", {})
+        """Create error result from dictionary."""
+        error_data = data.get("error", {})
         return cls(
-            message=error.get("message", "Unknown error"),
-            code=error.get("code", -32000),
-            details=error.get("data"),
+            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

@@ -8,7 +8,6 @@ email: vasilyvz@gmail.com
 """
 
 import logging
-from typing import Dict, Any, Optional
 from mcp_proxy_adapter.commands.base import Command
 from mcp_proxy_adapter.commands.result import SuccessResult
 
@@ -36,38 +35,8 @@ class RoleTestCommandResult(SuccessResult):
         self.action = action
         self.allowed = allowed
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary."""
-        return {
-            "success": True,
-            "data": {
-                "user_role": self.user_role,
-                "permissions": self.permissions,
-                "action": self.action,
-                "allowed": self.allowed,
-            },
-            "message": f"Action '{self.action}' {'allowed' if self.allowed else 'denied'} for role '{self.user_role}'",
-        }
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get JSON schema."""
-        return {
-            "type": "object",
-            "properties": {
-                "success": {"type": "boolean"},
-                "data": {
-                    "type": "object",
-                    "properties": {
-                        "user_role": {"type": "string"},
-                        "permissions": {"type": "array", "items": {"type": "string"}},
-                        "action": {"type": "string"},
-                        "allowed": {"type": "boolean"},
-                    },
-                },
-                "message": {"type": "string"},
-            },
-        }
 
 
 class RoleTestCommand(Command):
@@ -110,19 +79,6 @@ class RoleTestCommand(Command):
         return RoleTestCommandResult(user_role, permissions, action, allowed)
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get JSON schema for command parameters."""
-        return {
-            "type": "object",
-            "properties": {
-                "action": {
-                    "type": "string",
-                    "description": "Action to test",
-                    "default": "read",
-                }
-            },
-            "additionalProperties": False,
-        }
 
     def _check_permission(self, action: str, permissions: list) -> bool:
         """