mcp-proxy-adapter 3.1.5__py3-none-any.whl → 4.0.0__py3-none-any.whl

mcp_proxy_adapter/commands/hooks.py

@@ -0,0 +1,260 @@
+"""
+Module for command execution hooks.
+
+This module provides a hook system that allows intercepting command execution
+before and after the actual command runs.
+"""
+
+from typing import Any, Callable, Dict, List, Optional, Union
+from dataclasses import dataclass
+from enum import Enum
+
+from mcp_proxy_adapter.core.logging import logger
+
+
+class HookType(Enum):
+    """Types of hooks."""
+    BEFORE_EXECUTION = "before_execution"
+    AFTER_EXECUTION = "after_execution"
+
+
+@dataclass
+class HookContext:
+    """Context passed to hook functions."""
+    command_name: str
+    params: Dict[str, Any]
+    hook_type: HookType
+    standard_processing: bool = True
+    result: Optional[Any] = None
+
+
+class CommandHooks:
+    """
+    Manages command execution hooks.
+    """
+    
+    def __init__(self):
+        """Initialize hooks manager."""
+        self._before_hooks: Dict[str, List[Callable]] = {}
+        self._after_hooks: Dict[str, List[Callable]] = {}
+        self._global_before_hooks: List[Callable] = []
+        self._global_after_hooks: List[Callable] = []
+    
+    def register_before_hook(self, command_name: str, hook: Callable[[HookContext], None]) -> None:
+        """
+        Register a hook to be executed before command execution.
+        
+        Args:
+            command_name: Name of the command to hook into
+            hook: Hook function that takes HookContext as parameter
+        """
+        if command_name not in self._before_hooks:
+            self._before_hooks[command_name] = []
+        self._before_hooks[command_name].append(hook)
+        logger.debug(f"Registered before hook for command: {command_name}")
+    
+    def register_after_hook(self, command_name: str, hook: Callable[[HookContext], None]) -> None:
+        """
+        Register a hook to be executed after command execution.
+        
+        Args:
+            command_name: Name of the command to hook into
+            hook: Hook function that takes HookContext as parameter
+        """
+        if command_name not in self._after_hooks:
+            self._after_hooks[command_name] = []
+        self._after_hooks[command_name].append(hook)
+        logger.debug(f"Registered after hook for command: {command_name}")
+    
+    def register_global_before_hook(self, hook: Callable[[HookContext], None]) -> None:
+        """
+        Register a global hook to be executed before any command.
+        
+        Args:
+            hook: Hook function that takes HookContext as parameter
+        """
+        self._global_before_hooks.append(hook)
+        logger.debug("Registered global before hook")
+    
+    def register_global_after_hook(self, hook: Callable[[HookContext], None]) -> None:
+        """
+        Register a global hook to be executed after any command.
+        
+        Args:
+            hook: Hook function that takes HookContext as parameter
+        """
+        self._global_after_hooks.append(hook)
+        logger.debug("Registered global after hook")
+    
+    def unregister_before_hook(self, command_name: str, hook: Callable[[HookContext], None]) -> None:
+        """
+        Unregister a before hook for a specific command.
+        
+        Args:
+            command_name: Name of the command
+            hook: Hook function to unregister
+        """
+        if command_name in self._before_hooks:
+            try:
+                self._before_hooks[command_name].remove(hook)
+                logger.debug(f"Unregistered before hook for command: {command_name}")
+                # Remove the command key if no hooks remain
+                if not self._before_hooks[command_name]:
+                    del self._before_hooks[command_name]
+            except ValueError:
+                logger.warning(f"Hook not found for command: {command_name}")
+    
+    def unregister_after_hook(self, command_name: str, hook: Callable[[HookContext], None]) -> None:
+        """
+        Unregister an after hook for a specific command.
+        
+        Args:
+            command_name: Name of the command
+            hook: Hook function to unregister
+        """
+        if command_name in self._after_hooks:
+            try:
+                self._after_hooks[command_name].remove(hook)
+                logger.debug(f"Unregistered after hook for command: {command_name}")
+                # Remove the command key if no hooks remain
+                if not self._after_hooks[command_name]:
+                    del self._after_hooks[command_name]
+            except ValueError:
+                logger.warning(f"Hook not found for command: {command_name}")
+    
+    def unregister_global_before_hook(self, hook: Callable[[HookContext], None]) -> None:
+        """
+        Unregister a global before hook.
+        
+        Args:
+            hook: Hook function to unregister
+        """
+        try:
+            self._global_before_hooks.remove(hook)
+            logger.debug("Unregistered global before hook")
+        except ValueError:
+            logger.warning("Global before hook not found")
+    
+    def unregister_global_after_hook(self, hook: Callable[[HookContext], None]) -> None:
+        """
+        Unregister a global after hook.
+        
+        Args:
+            hook: Hook function to unregister
+        """
+        try:
+            self._global_after_hooks.remove(hook)
+            logger.debug("Unregistered global after hook")
+        except ValueError:
+            logger.warning("Global after hook not found")
+    
+    def execute_before_hooks(self, command_name: str, params: Dict[str, Any]) -> HookContext:
+        """
+        Execute all before hooks for a command.
+        
+        Args:
+            command_name: Name of the command
+            params: Command parameters
+            
+        Returns:
+            HookContext with execution results
+        """
+        context = HookContext(
+            command_name=command_name,
+            params=params,
+            hook_type=HookType.BEFORE_EXECUTION
+        )
+        
+        # Execute global before hooks
+        for hook in self._global_before_hooks:
+            try:
+                hook(context)
+            except Exception as e:
+                logger.error(f"Error in global before hook for command {command_name}: {e}")
+        
+        # Execute command-specific before hooks
+        if command_name in self._before_hooks:
+            for hook in self._before_hooks[command_name]:
+                try:
+                    hook(context)
+                except Exception as e:
+                    logger.error(f"Error in before hook for command {command_name}: {e}")
+        
+        return context
+    
+    def execute_after_hooks(self, command_name: str, params: Dict[str, Any], result: Any) -> HookContext:
+        """
+        Execute all after hooks for a command.
+        
+        Args:
+            command_name: Name of the command
+            params: Command parameters
+            result: Command execution result
+            
+        Returns:
+            HookContext with execution results
+        """
+        context = HookContext(
+            command_name=command_name,
+            params=params,
+            hook_type=HookType.AFTER_EXECUTION,
+            result=result
+        )
+        
+        # Execute command-specific after hooks
+        if command_name in self._after_hooks:
+            for hook in self._after_hooks[command_name]:
+                try:
+                    hook(context)
+                except Exception as e:
+                    logger.error(f"Error in after hook for command {command_name}: {e}")
+        
+        # Execute global after hooks
+        for hook in self._global_after_hooks:
+            try:
+                hook(context)
+            except Exception as e:
+                logger.error(f"Error in global after hook for command {command_name}: {e}")
+        
+        return context
+    
+    def clear_hooks(self, command_name: Optional[str] = None) -> None:
+        """
+        Clear all hooks or hooks for a specific command.
+        
+        Args:
+            command_name: If provided, clear hooks only for this command.
+                          If None, clear all hooks.
+        """
+        if command_name is None:
+            # Clear all hooks
+            self._before_hooks.clear()
+            self._after_hooks.clear()
+            self._global_before_hooks.clear()
+            self._global_after_hooks.clear()
+            logger.debug("Cleared all hooks")
+        else:
+            # Clear hooks for specific command
+            if command_name in self._before_hooks:
+                del self._before_hooks[command_name]
+            if command_name in self._after_hooks:
+                del self._after_hooks[command_name]
+            logger.debug(f"Cleared hooks for command: {command_name}")
+    
+    def get_hook_info(self) -> Dict[str, Any]:
+        """
+        Get information about registered hooks.
+        
+        Returns:
+            Dictionary with hook information
+        """
+        return {
+            "before_hooks": {cmd: len(hooks) for cmd, hooks in self._before_hooks.items()},
+            "after_hooks": {cmd: len(hooks) for cmd, hooks in self._after_hooks.items()},
+            "global_before_hooks": len(self._global_before_hooks),
+            "global_after_hooks": len(self._global_after_hooks)
+        }
+
+
+# Global hooks instance
+hooks = CommandHooks() 

mcp_proxy_adapter/commands/reload_command.py

@@ -0,0 +1,211 @@
+"""
+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 logger
+
+
+class ReloadResult:
+    """
+    Result of reload operation.
+    """
+    
+    def __init__(
+        self,
+        config_reloaded: bool,
+        commands_discovered: int,
+        custom_commands_preserved: int,
+        total_commands: int,
+        built_in_commands: int,
+        custom_commands: int,
+        server_restart_required: bool = True,
+        success: bool = True,
+        error_message: Optional[str] = None
+    ):
+        """
+        Initialize reload result.
+        
+        Args:
+            config_reloaded: Whether configuration was reloaded successfully
+            commands_discovered: Number of commands discovered
+            custom_commands_preserved: Number of custom commands preserved
+            total_commands: Total number of commands after reload
+            built_in_commands: Number of built-in commands
+            custom_commands: Number of custom commands
+            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.commands_discovered = commands_discovered
+        self.custom_commands_preserved = custom_commands_preserved
+        self.total_commands = total_commands
+        self.built_in_commands = built_in_commands
+        self.custom_commands = custom_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,
+            "commands_discovered": self.commands_discovered,
+            "custom_commands_preserved": self.custom_commands_preserved,
+            "total_commands": self.total_commands,
+            "built_in_commands": self.built_in_commands,
+            "custom_commands": self.custom_commands,
+            "server_restart_required": self.server_restart_required,
+            "message": "Server restart required to apply configuration changes",
+            "error_message": self.error_message
+        }
+    
+    def get_schema(self) -> 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"
+                },
+                "commands_discovered": {
+                    "type": "integer",
+                    "description": "Number of commands discovered"
+                },
+                "custom_commands_preserved": {
+                    "type": "integer",
+                    "description": "Number of custom commands preserved"
+                },
+                "total_commands": {
+                    "type": "integer",
+                    "description": "Total number of commands after reload"
+                },
+                "built_in_commands": {
+                    "type": "integer",
+                    "description": "Number of built-in commands"
+                },
+                "custom_commands": {
+                    "type": "integer",
+                    "description": "Number of custom commands"
+                },
+                "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", "commands_discovered",
+                "custom_commands_preserved", "total_commands",
+                "built_in_commands", "custom_commands", "server_restart_required"
+            ]
+        }
+
+
+class ReloadCommand(Command):
+    """
+    Command for reloading configuration and rediscovering commands.
+    Note: This command will trigger a server restart to apply configuration changes.
+    """
+    
+    name = "reload"
+    
+    async def execute(self, **params) -> ReloadResult:
+        """
+        Execute reload command.
+        
+        Args:
+            **params: Command parameters (currently unused)
+            
+        Returns:
+            ReloadResult with reload information
+        """
+        try:
+            logger.info("🔄 Starting configuration and commands reload...")
+            
+            # Perform reload
+            reload_info = registry.reload_config_and_commands()
+            
+            # Create result
+            result = ReloadResult(
+                config_reloaded=reload_info.get("config_reloaded", False),
+                commands_discovered=reload_info.get("commands_discovered", 0),
+                custom_commands_preserved=reload_info.get("custom_commands_preserved", 0),
+                total_commands=reload_info.get("total_commands", 0),
+                built_in_commands=reload_info.get("built_in_commands", 0),
+                custom_commands=reload_info.get("custom_commands", 0),
+                server_restart_required=True,
+                success=True
+            )
+            
+            logger.info(f"✅ Reload completed successfully: {result.to_dict()}")
+            return result
+            
+        except Exception as e:
+            logger.error(f"❌ Reload failed: {str(e)}")
+            return ReloadResult(
+                config_reloaded=False,
+                commands_discovered=0,
+                custom_commands_preserved=0,
+                total_commands=0,
+                built_in_commands=0,
+                custom_commands=0,
+                server_restart_required=False,
+                success=False,
+                error_message=str(e)
+            )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            JSON schema dictionary.
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "package_path": {
+                    "type": "string",
+                    "description": "Path to package with commands to discover",
+                    "default": "mcp_proxy_adapter.commands"
+                },
+                "force_restart": {
+                    "type": "boolean",
+                    "description": "Force server restart to apply configuration changes",
+                    "default": True
+                }
+            },
+            "additionalProperties": False
+        } 

mcp_proxy_adapter/commands/reload_settings_command.py

@@ -0,0 +1,125 @@
+"""
+Reload Settings Command
+
+This command allows reloading configuration settings from files and environment variables.
+"""
+
+from typing import Dict, Any
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.core.settings import reload_settings, get_custom_settings
+from mcp_proxy_adapter.core.logging import get_logger
+
+
+class ReloadSettingsResult:
+    """
+    Result class for reload settings command.
+    """
+    
+    def __init__(
+        self,
+        success: bool,
+        message: str,
+        custom_settings: Dict[str, Any] = None,
+        error_message: str = None
+    ):
+        self.success = success
+        self.message = message
+        self.custom_settings = custom_settings or {}
+        self.error_message = error_message
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert result to dictionary."""
+        result = {
+            "success": self.success,
+            "message": self.message,
+            "custom_settings": self.custom_settings
+        }
+        if self.error_message:
+            result["error_message"] = self.error_message
+        return result
+    
+    def get_schema(self) -> Dict[str, Any]:
+        """Get JSON schema for the result."""
+        return {
+            "type": "object",
+            "properties": {
+                "success": {
+                    "type": "boolean",
+                    "description": "Whether the operation was successful"
+                },
+                "message": {
+                    "type": "string",
+                    "description": "Operation result message"
+                },
+                "custom_settings": {
+                    "type": "object",
+                    "description": "Current custom settings after reload",
+                    "additionalProperties": True
+                },
+                "error_message": {
+                    "type": "string",
+                    "description": "Error message if operation failed"
+                }
+            },
+            "required": ["success", "message", "custom_settings"]
+        }
+
+
+class ReloadSettingsCommand(Command):
+    """
+    Command to reload configuration settings.
+    """
+    
+    name = "reload_settings"
+    description = "Reload configuration settings from files and environment variables"
+    
+    async def execute(self, **params) -> ReloadSettingsResult:
+        """
+        Execute the reload settings command.
+        
+        Args:
+            **params: Command parameters (not used)
+            
+        Returns:
+            ReloadSettingsResult with operation status
+        """
+        logger = get_logger("reload_settings_command")
+        
+        try:
+            logger.info("🔄 Starting settings reload...")
+            
+            # Reload configuration from files and environment variables
+            reload_settings()
+            
+            # Get current custom settings
+            custom_settings = get_custom_settings()
+            
+            logger.info("✅ Settings reloaded successfully")
+            logger.info(f"📋 Current custom settings: {custom_settings}")
+            
+            return ReloadSettingsResult(
+                success=True,
+                message="Settings reloaded successfully from configuration files and environment variables",
+                custom_settings=custom_settings
+            )
+            
+        except Exception as e:
+            error_msg = f"Failed to reload settings: {str(e)}"
+            logger.error(f"❌ {error_msg}")
+            
+            return ReloadSettingsResult(
+                success=False,
+                message="Failed to reload settings",
+                custom_settings=get_custom_settings(),
+                error_message=error_msg
+            )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get JSON schema for the command parameters."""
+        return {
+            "type": "object",
+            "description": "Reload configuration settings from files and environment variables",
+            "properties": {},
+            "additionalProperties": False
+        }