mcp-proxy-adapter 3.1.6__py3-none-any.whl → 4.1.0__py3-none-any.whl

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
+        } 

mcp_proxy_adapter/commands/settings_command.py

@@ -0,0 +1,189 @@
+"""
+Settings command for demonstrating configuration management.
+"""
+
+from typing import Dict, Any, Optional
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.core.settings import Settings, get_setting, set_setting, reload_settings
+
+
+class SettingsResult:
+    """Result class for settings command."""
+    
+    def __init__(
+        self,
+        success: bool,
+        operation: str,
+        key: Optional[str] = None,
+        value: Any = None,
+        all_settings: Optional[Dict[str, Any]] = None,
+        error_message: Optional[str] = None
+    ):
+        self.success = success
+        self.operation = operation
+        self.key = key
+        self.value = value
+        self.all_settings = all_settings
+        self.error_message = error_message
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert result to dictionary."""
+        result = {
+            "success": self.success,
+            "operation": self.operation
+        }
+        
+        if self.key is not None:
+            result["key"] = self.key
+        if self.value is not None:
+            result["value"] = self.value
+        if self.all_settings is not None:
+            result["all_settings"] = self.all_settings
+        if self.error_message is not None:
+            result["error_message"] = self.error_message
+            
+        return result
+    
+    def get_schema(self) -> Dict[str, Any]:
+        """Get schema for the result."""
+        return {
+            "type": "object",
+            "properties": {
+                "success": {
+                    "type": "boolean",
+                    "description": "Whether the operation was successful"
+                },
+                "operation": {
+                    "type": "string",
+                    "description": "Type of operation performed",
+                    "enum": ["get", "set", "get_all", "reload"]
+                },
+                "key": {
+                    "type": "string",
+                    "description": "Configuration key (for get/set operations)"
+                },
+                "value": {
+                    "description": "Configuration value (for get/set operations)"
+                },
+                "all_settings": {
+                    "type": "object",
+                    "description": "All configuration settings (for get_all operation)"
+                },
+                "error_message": {
+                    "type": "string",
+                    "description": "Error message if operation failed"
+                }
+            },
+            "required": ["success", "operation"]
+        }
+
+
+class SettingsCommand(Command):
+    """Command for managing framework settings."""
+    
+    name = "settings"
+    description = "Manage framework settings and configuration"
+    
+    async def execute(self, **params) -> SettingsResult:
+        """
+        Execute settings command.
+        
+        Args:
+            operation: Operation to perform (get, set, get_all, reload)
+            key: Configuration key (for get/set operations)
+            value: Configuration value (for set operation)
+            
+        Returns:
+            SettingsResult with operation result
+        """
+        try:
+            operation = params.get("operation", "get_all")
+            
+            if operation == "get":
+                key = params.get("key")
+                if not key:
+                    return SettingsResult(
+                        success=False,
+                        operation=operation,
+                        error_message="Key is required for 'get' operation"
+                    )
+                
+                value = get_setting(key)
+                return SettingsResult(
+                    success=True,
+                    operation=operation,
+                    key=key,
+                    value=value
+                )
+            
+            elif operation == "set":
+                key = params.get("key")
+                value = params.get("value")
+                
+                if not key:
+                    return SettingsResult(
+                        success=False,
+                        operation=operation,
+                        error_message="Key is required for 'set' operation"
+                    )
+                
+                set_setting(key, value)
+                return SettingsResult(
+                    success=True,
+                    operation=operation,
+                    key=key,
+                    value=value
+                )
+            
+            elif operation == "get_all":
+                all_settings = Settings.get_all_settings()
+                return SettingsResult(
+                    success=True,
+                    operation=operation,
+                    all_settings=all_settings
+                )
+            
+            elif operation == "reload":
+                reload_settings()
+                return SettingsResult(
+                    success=True,
+                    operation=operation
+                )
+            
+            else:
+                return SettingsResult(
+                    success=False,
+                    operation=operation,
+                    error_message=f"Unknown operation: {operation}. Supported operations: get, set, get_all, reload"
+                )
+                
+        except Exception as e:
+            return SettingsResult(
+                success=False,
+                operation=params.get("operation", "unknown"),
+                error_message=str(e)
+            )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get schema for the command."""
+        return {
+            "type": "object",
+            "properties": {
+                "operation": {
+                    "type": "string",
+                    "description": "Operation to perform",
+                    "enum": ["get", "set", "get_all", "reload"],
+                    "default": "get_all"
+                },
+                "key": {
+                    "type": "string",
+                    "description": "Configuration key in dot notation (e.g., 'server.host', 'custom.feature_enabled')"
+                },
+                "value": {
+                    "description": "Configuration value to set (for 'set' operation)"
+                }
+            },
+            "required": ["operation"],
+            "additionalProperties": False
+        } 

mcp_proxy_adapter/config.py

@@ -39,7 +39,22 @@ class Config:
             },
             "logging": {
                 "level": "INFO",
-                "file": None
+                "file": None,
+                "log_dir": "./logs",
+                "log_file": "mcp_proxy_adapter.log",
+                "error_log_file": "mcp_proxy_adapter_error.log",
+                "access_log_file": "mcp_proxy_adapter_access.log",
+                "max_file_size": "10MB",
+                "backup_count": 5,
+                "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+                "date_format": "%Y-%m-%d %H:%M:%S",
+                "console_output": True,
+                "file_output": True
+            },
+            "commands": {
+                "auto_discovery": True,
+                "discovery_path": "mcp_proxy_adapter.commands",
+                "custom_commands_path": None
             }
         }
         

mcp_proxy_adapter/core/__init__.py

@@ -0,0 +1,44 @@
+"""
+Core functionality for MCP Proxy Adapter.
+"""
+
+from .errors import *
+from .logging import *
+from .settings import *
+
+__all__ = [
+    # Errors
+    "NotFoundError",
+    "InvalidParamsError",
+    "CommandExecutionError",
+    "ConfigurationError",
+    
+    # Logging
+    "setup_logging",
+    "get_logger",
+    "logger",
+    "RequestLogger",
+    "CustomFormatter",
+    "RequestContextFilter",
+    
+    # Settings
+"Settings",
+"ServerSettings",
+"LoggingSettings",
+"CommandsSettings",
+"get_server_host",
+"get_server_port",
+"get_server_debug",
+"get_logging_level",
+"get_logging_dir",
+"get_auto_discovery",
+"get_discovery_path",
+"get_setting",
+"set_setting",
+"reload_settings",
+"add_custom_settings",
+"get_custom_settings",
+"get_custom_setting_value",
+"set_custom_setting_value",
+"clear_custom_settings"
+]