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

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"
+]

mcp_proxy_adapter/core/logging.py

@@ -122,15 +122,28 @@ def setup_logging(
     # Get parameters from configuration if not explicitly specified
     level = level or config.get("logging.level", "INFO")
     log_file = log_file or config.get("logging.file")
-    rotation_type = rotation_type or config.get("logging.rotation.type", "size")
+    rotation_type = rotation_type or "size"  # Default to size-based rotation
     
-    # Size-based rotation parameters
-    max_bytes = max_bytes or config.get("logging.rotation.max_bytes", 10 * 1024 * 1024)  # 10 MB by default
-    backup_count = backup_count or config.get("logging.rotation.backup_count", 5)
+    # Get log directory and file settings from config
+    log_dir = config.get("logging.log_dir", "./logs")
+    log_file_name = config.get("logging.log_file", "mcp_proxy_adapter.log")
+    error_log_file = config.get("logging.error_log_file", "mcp_proxy_adapter_error.log")
+    access_log_file = config.get("logging.access_log_file", "mcp_proxy_adapter_access.log")
     
-    # Time-based rotation parameters
-    rotation_when = rotation_when or config.get("logging.rotation.when", "D")  # Daily by default
-    rotation_interval = rotation_interval or config.get("logging.rotation.interval", 1)
+    # Get rotation settings from config
+    max_file_size_str = config.get("logging.max_file_size", "10MB")
+    backup_count = backup_count or config.get("logging.backup_count", 5)
+    
+    # Parse max file size (e.g., "10MB" -> 10 * 1024 * 1024)
+    max_bytes = max_bytes or _parse_file_size(max_file_size_str)
+    
+    # Get format settings
+    log_format = config.get("logging.format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    date_format = config.get("logging.date_format", "%Y-%m-%d %H:%M:%S")
+    
+    # Get output settings
+    console_output = config.get("logging.console_output", True)
+    file_output = config.get("logging.file_output", True)
 
     # Convert string logging level to constant
     numeric_level = getattr(logging, level.upper(), None)
@@ -142,42 +155,60 @@ def setup_logging(
     logger.setLevel(numeric_level)
     logger.handlers = []  # Clear handlers in case of repeated call
 
-    # Create console handler
-    console_handler = logging.StreamHandler(sys.stdout)
-    console_handler.setLevel(numeric_level)
-    console_handler.setFormatter(CustomFormatter())
-    logger.addHandler(console_handler)
-
-    # Create file handler if file specified
-    if log_file:
-        # Create directory for log file if it doesn't exist
-        log_dir = os.path.dirname(log_file)
-        if log_dir and not os.path.exists(log_dir):
+    # Create formatter
+    formatter = logging.Formatter(log_format, date_format)
+
+    # Create console handler if enabled
+    if console_output:
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setLevel(numeric_level)
+        console_handler.setFormatter(CustomFormatter())
+        logger.addHandler(console_handler)
+
+    # Create file handlers if file output is enabled
+    if file_output and log_dir:
+        # Create directory for log files if it doesn't exist
+        if not os.path.exists(log_dir):
             os.makedirs(log_dir, exist_ok=True)
 
-        # Choose rotation type
-        if rotation_type.lower() == "time":
-            file_handler = TimedRotatingFileHandler(
-                log_file,
-                when=rotation_when,
-                interval=rotation_interval,
+        # Main log file
+        if log_file_name:
+            main_log_path = os.path.join(log_dir, log_file_name)
+            main_handler = RotatingFileHandler(
+                main_log_path,
+                maxBytes=max_bytes,
+                backupCount=backup_count,
+                encoding="utf-8"
+            )
+            main_handler.setLevel(numeric_level)
+            main_handler.setFormatter(formatter)
+            logger.addHandler(main_handler)
+
+        # Error log file
+        if error_log_file:
+            error_log_path = os.path.join(log_dir, error_log_file)
+            error_handler = RotatingFileHandler(
+                error_log_path,
+                maxBytes=max_bytes,
                 backupCount=backup_count,
                 encoding="utf-8"
             )
-        else:  # Default to size-based rotation
-            file_handler = RotatingFileHandler(
-                log_file,
+            error_handler.setLevel(logging.ERROR)
+            error_handler.setFormatter(formatter)
+            logger.addHandler(error_handler)
+
+        # Access log file (for HTTP requests)
+        if access_log_file:
+            access_log_path = os.path.join(log_dir, access_log_file)
+            access_handler = RotatingFileHandler(
+                access_log_path,
                 maxBytes=max_bytes,
                 backupCount=backup_count,
                 encoding="utf-8"
             )
-            
-        file_handler.setLevel(numeric_level)
-        file_formatter = logging.Formatter(
-            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        )
-        file_handler.setFormatter(file_formatter)
-        logger.addHandler(file_handler)
+            access_handler.setLevel(logging.INFO)
+            access_handler.setFormatter(formatter)
+            logger.addHandler(access_handler)
 
     # Configure loggers for external libraries
     log_levels = config.get("logging.levels", {})
@@ -188,6 +219,28 @@ def setup_logging(
     return logger
 
 
+def _parse_file_size(size_str: str) -> int:
+    """
+    Parse file size string to bytes.
+    
+    Args:
+        size_str: Size string (e.g., "10MB", "1GB", "100KB")
+        
+    Returns:
+        Size in bytes
+    """
+    size_str = size_str.upper()
+    if size_str.endswith("KB"):
+        return int(size_str[:-2]) * 1024
+    elif size_str.endswith("MB"):
+        return int(size_str[:-2]) * 1024 * 1024
+    elif size_str.endswith("GB"):
+        return int(size_str[:-2]) * 1024 * 1024 * 1024
+    else:
+        # Assume bytes if no unit specified
+        return int(size_str)
+
+
 def get_logger(name: str) -> logging.Logger:
     """
     Get a logger with the specified name.