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

mcp_proxy_adapter/commands/command_registry.py

@@ -0,0 +1,298 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Main command registry for MCP Proxy Adapter.
+"""
+
+
+from typing import Dict, List, Type, Union, Any, Optional
+
+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._loader = None
+        # self._manager = CommandManager()
+        # self._info = CommandInfo()
+        self._manager = None
+        self._info = None
+        
+        # Register built-in echo command
+        self._register_echo_command()
+        self._register_long_task_commands()
+
+    def _register_echo_command(self) -> None:
+        """Register built-in echo command."""
+        from mcp_proxy_adapter.commands.base import Command, CommandResult
+        
+        class EchoCommand(Command):
+            name = "echo"
+            descr = "Echo command for testing"
+            
+            async def execute(self, message: str = "Hello", **kwargs) -> CommandResult:
+                return CommandResult(success=True, data={"message": message})
+            
+            @classmethod
+            def get_schema(cls) -> Dict[str, Any]:
+                return {
+                    "type": "object",
+                    "properties": {
+                        "message": {"type": "string", "default": "Hello"}
+                    }
+                }
+        
+        self._commands["echo"] = EchoCommand
+        self._command_types["echo"] = "builtin"
+
+    def _register_long_task_commands(self) -> None:
+        """Register demo long-running task commands (enqueue/status)."""
+        from mcp_proxy_adapter.commands.base import Command, CommandResult
+        from mcp_proxy_adapter.core.job_manager import enqueue_coroutine, get_job_status
+        import asyncio
+
+        class LongTaskCommand(Command):
+            name = "long_task"
+            descr = "Enqueue a long-running task that sleeps for given seconds"
+
+            async def execute(self, seconds: float = 5.0, **kwargs) -> CommandResult:
+                async def _work():
+                    await asyncio.sleep(max(0.0, float(seconds)))
+                    return {"slept": float(seconds)}
+
+                job_id = enqueue_coroutine(_work())
+                return CommandResult(success=True, data={"job_id": job_id, "status": "queued"})
+
+            @classmethod
+            def get_schema(cls) -> Dict[str, Any]:
+                return {
+                    "type": "object",
+                    "properties": {"seconds": {"type": "number", "default": 5.0}},
+                    "description": "Start a demo long-running job"
+                }
+
+        class JobStatusCommand(Command):
+            name = "job_status"
+            descr = "Get status of a previously enqueued job"
+
+            async def execute(self, job_id: str, **kwargs) -> CommandResult:
+                status = get_job_status(job_id)
+                return CommandResult(success=True, data=status)
+
+            @classmethod
+            def get_schema(cls) -> Dict[str, Any]:
+                return {
+                    "type": "object",
+                    "properties": {"job_id": {"type": "string"}},
+                    "required": ["job_id"],
+                    "description": "Check job status"
+                }
+
+        self._commands["long_task"] = LongTaskCommand
+        self._command_types["long_task"] = "builtin"
+        self._commands["job_status"] = JobStatusCommand
+        self._command_types["job_status"] = "builtin"
+
+
+    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
+        """
+        if command_name not in self._commands:
+            raise KeyError(f"Command '{command_name}' not found")
+        return self._commands[command_name]
+
+    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._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/config_command.py

@@ -0,0 +1,102 @@
+"""
+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 get_config
+
+
+class ConfigResult(SuccessResult):
+    """
+    Config operation result.
+    """
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        operation: str,
+        message: Optional[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: Optional[str] = None,
+        value: Any = None,
+        context: Optional[Dict] = None,
+        **kwargs,
+    ) -> ConfigResult:
+        """
+        Execute the command.
+
+        Args:
+            operation: Operation to perform (get, set)
+            path: Configuration path (dot notation)
+            value: Value to set (for set operation)
+            context: Optional context parameter passed by framework
+            **kwargs: Additional parameters
+
+        Returns:
+            Config operation result
+        """
+        message = None
+        result_config = {}
+
+        if operation == "get":
+            config_instance = get_config()
+            if path:
+                # Get specific config value
+                result_config = {path: config_instance.get(path)}
+            else:
+                # Get all config
+                result_config = config_instance.get_all()
+            message = "Configuration retrieved successfully"
+
+        elif operation == "set":
+            if path and value is not None:
+                # Set config value
+                config_instance = get_config()
+                config_instance.set(path, value)
+                # Save config
+                config_instance.save()
+                result_config = {path: value}
+                message = "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

mcp_proxy_adapter/commands/dependency_container.py

@@ -0,0 +1,40 @@
+"""
+Module for dependency injection container implementation.
+
+This module provides a container for registering and resolving dependencies
+for command instances in the microservice.
+"""
+
+from typing import TypeVar, Dict, Any, Callable, Optional
+
+T = TypeVar("T")
+
+
+class DependencyContainer:
+    """
+    Container for managing dependencies.
+
+    This class provides functionality to register, resolve, and manage
+    dependencies that can be injected into command instances.
+    """
+
+    def __init__(self):
+        """Initialize dependency container."""
+        self._dependencies: Dict[str, Any] = {}
+        self._factories: Dict[str, callable] = {}
+        self._singletons: Dict[str, Any] = {}
+
+
+
+
+
+    def clear(self) -> None:
+        """Clear all registered dependencies."""
+        self._dependencies.clear()
+        self._factories.clear()
+        self._singletons.clear()
+
+
+
+# Global dependency container instance
+container = DependencyContainer()

mcp_proxy_adapter/commands/dependency_manager.py

@@ -0,0 +1,143 @@
+"""
+Dependency management system for remote plugins.
+
+This module handles automatic installation and verification of plugin dependencies
+using pip and other package management tools.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import subprocess
+import sys
+import importlib
+from typing import List, Dict, Any, Tuple
+
+try:  # Python 3.8+
+    from importlib import metadata as importlib_metadata  # type: ignore
+except Exception:  # pragma: no cover - very old Python fallback
+    import importlib_metadata  # type: ignore
+
+from packaging.requirements import Requirement
+from packaging.version import Version, InvalidVersion
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class DependencyManager:
+    """
+    Manages plugin dependencies installation and verification.
+    """
+
+    def __init__(self):
+        """Initialize dependency manager."""
+        self._installed_packages: Dict[str, str] = {}
+        self._load_installed_packages()
+
+    def _load_installed_packages(self) -> None:
+        """Load list of currently installed packages."""
+        try:
+            self._installed_packages.clear()
+            for dist in importlib_metadata.distributions():
+                try:
+                    name = dist.metadata.get("Name") or dist.metadata.get("name")
+                    version = dist.version
+                    if name and version:
+                        self._installed_packages[name.lower()] = version
+                except Exception:
+                    continue
+        except Exception as e:
+            get_global_logger().warning(f"Failed to load installed packages: {e}")
+
+
+    def _is_dependency_satisfied(self, dependency: str) -> bool:
+        """
+        Check if a single dependency is satisfied.
+
+        Args:
+            dependency: Dependency name or spec
+
+        Returns:
+            True if dependency is satisfied, False otherwise
+        """
+        # Parse requirement (handles version specifiers)
+        try:
+            req = Requirement(dependency)
+        except Exception:
+            # Fallback: treat as importable module name
+            try:
+                importlib.import_module(dependency)
+                return True
+            except ImportError:
+                return False
+
+        # Check installation by distribution name
+        try:
+            installed_version = importlib_metadata.version(req.name)
+        except importlib_metadata.PackageNotFoundError:
+            return False
+
+        # If no specifier, any installed version satisfies
+        if not req.specifier:
+            return True
+
+        try:
+            return Version(installed_version) in req.specifier
+        except InvalidVersion:
+            # If version parsing fails, fallback to string comparison via specifier
+            return req.specifier.contains(installed_version, prereleases=True)
+
+
+    def _install_single_dependency(
+        self, dependency: str, user_install: bool = False
+    ) -> bool:
+        """
+        Install a single dependency using pip.
+
+        Args:
+            dependency: Dependency name or spec
+            user_install: Whether to install for current user only
+
+        Returns:
+            True if installation successful, False otherwise
+        """
+        try:
+            # Build pip command
+            cmd = [sys.executable, "-m", "pip", "install"]
+
+            if user_install:
+                cmd.append("--user")
+
+            # Add quiet flag to reduce output
+            cmd.append("--quiet")
+
+            # Add dependency
+            cmd.append(dependency)
+
+            get_global_logger().debug(f"Installing dependency: {' '.join(cmd)}")
+
+            # Run pip install
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, timeout=300  # 5 minutes timeout
+            )
+
+            if result.returncode == 0:
+                get_global_logger().debug(f"Successfully installed {dependency}")
+                return True
+            else:
+                get_global_logger().error(f"Failed to install {dependency}: {result.stderr}")
+                return False
+
+        except subprocess.TimeoutExpired:
+            get_global_logger().error(f"Timeout while installing {dependency}")
+            return False
+        except Exception as e:
+            get_global_logger().error(f"Error installing {dependency}: {e}")
+            return False
+
+
+
+
+
+# Global instance
+dependency_manager = DependencyManager()

mcp_proxy_adapter/commands/echo_command.py

@@ -0,0 +1,48 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Echo command for testing purposes.
+"""
+
+import asyncio
+from typing import Any, Dict, Optional
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import SuccessResult
+
+
+class EchoCommandResult(SuccessResult):
+    """Result for echo command."""
+
+    def __init__(self, message: str, timestamp: Optional[str] = None):
+        data = {"message": message}
+        if timestamp:
+            data["timestamp"] = timestamp
+        super().__init__(data=data, message=message)
+
+    @classmethod
+
+
+class EchoCommand(Command):
+    """Echo command for testing purposes."""
+
+    name = "echo"
+    version = "1.0.0"
+    descr = "Echo command for testing"
+    category = "testing"
+    author = "Vasiliy Zdanovskiy"
+    email = "vasilyvz@gmail.com"
+    result_class = EchoCommandResult
+
+    async def execute(self, **kwargs) -> EchoCommandResult:
+        """Execute echo command."""
+        message = kwargs.get("message", "Hello, World!")
+        timestamp = kwargs.get("timestamp")
+
+        # Simulate some processing time
+        await asyncio.sleep(0.001)
+
+        return EchoCommandResult(message=message, timestamp=timestamp)
+
+    @classmethod