claude-mpm 3.9.7__py3-none-any.whl → 3.9.8__py3-none-any.whl

claude_mpm/services/mcp_gateway/config/config_schema.py

@@ -0,0 +1,234 @@
+"""
+MCP Gateway Configuration Schema
+================================
+
+Defines and validates the configuration schema for MCP Gateway.
+
+Part of ISS-0034: Infrastructure Setup - MCP Gateway Project Foundation
+"""
+
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class MCPConfigSchema:
+    """
+    Configuration schema definition for MCP Gateway.
+    
+    This class defines the structure and validation rules for
+    MCP Gateway configuration.
+    """
+    
+    # Schema version for migration support
+    SCHEMA_VERSION = "1.0.0"
+    
+    # Configuration schema definition
+    SCHEMA = {
+        "mcp": {
+            "type": "object",
+            "required": True,
+            "properties": {
+                "server": {
+                    "type": "object",
+                    "required": True,
+                    "properties": {
+                        "name": {"type": "string", "required": True},
+                        "version": {"type": "string", "required": True},
+                        "description": {"type": "string", "required": False},
+                        "communication": {
+                            "type": "object",
+                            "required": True,
+                            "properties": {
+                                "type": {
+                                    "type": "string",
+                                    "required": True,
+                                    "enum": ["stdio", "websocket", "http"]
+                                },
+                                "timeout": {
+                                    "type": "number",
+                                    "required": False,
+                                    "min": 1,
+                                    "max": 3600
+                                },
+                                "buffer_size": {
+                                    "type": "integer",
+                                    "required": False,
+                                    "min": 1024,
+                                    "max": 1048576
+                                },
+                            }
+                        },
+                        "capabilities": {
+                            "type": "object",
+                            "required": False,
+                            "properties": {
+                                "tools": {"type": "boolean", "required": False},
+                                "resources": {"type": "boolean", "required": False},
+                                "prompts": {"type": "boolean", "required": False},
+                            }
+                        },
+                    }
+                },
+                "tools": {
+                    "type": "object",
+                    "required": False,
+                    "properties": {
+                        "enabled": {"type": "boolean", "required": False},
+                        "auto_discover": {"type": "boolean", "required": False},
+                        "discovery_paths": {
+                            "type": "array",
+                            "required": False,
+                            "items": {"type": "string"}
+                        },
+                        "timeout_default": {
+                            "type": "number",
+                            "required": False,
+                            "min": 1,
+                            "max": 300
+                        },
+                        "max_concurrent": {
+                            "type": "integer",
+                            "required": False,
+                            "min": 1,
+                            "max": 100
+                        },
+                    }
+                },
+                "logging": {
+                    "type": "object",
+                    "required": False,
+                    "properties": {
+                        "level": {
+                            "type": "string",
+                            "required": False,
+                            "enum": ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+                        },
+                        "file": {"type": "string", "required": False},
+                        "max_size": {"type": "string", "required": False},
+                        "max_files": {
+                            "type": "integer",
+                            "required": False,
+                            "min": 1,
+                            "max": 100
+                        },
+                        "format": {
+                            "type": "string",
+                            "required": False,
+                            "enum": ["json", "text"]
+                        },
+                    }
+                },
+                "security": {
+                    "type": "object",
+                    "required": False,
+                    "properties": {
+                        "validate_schemas": {"type": "boolean", "required": False},
+                        "sanitize_inputs": {"type": "boolean", "required": False},
+                        "max_request_size": {
+                            "type": "integer",
+                            "required": False,
+                            "min": 1024,
+                            "max": 104857600  # 100MB max
+                        },
+                        "allowed_tools": {
+                            "type": "array",
+                            "required": False,
+                            "items": {"type": "string"}
+                        },
+                        "blocked_tools": {
+                            "type": "array",
+                            "required": False,
+                            "items": {"type": "string"}
+                        },
+                    }
+                },
+            }
+        }
+    }
+
+
+def validate_config(config: Dict[str, Any], schema: Optional[Dict[str, Any]] = None) -> List[str]:
+    """
+    Validate configuration against schema.
+    
+    Args:
+        config: Configuration dictionary to validate
+        schema: Schema to validate against (uses default if not provided)
+        
+    Returns:
+        List of validation errors (empty if valid)
+    """
+    if schema is None:
+        schema = MCPConfigSchema.SCHEMA
+    
+    errors = []
+    
+    def validate_value(value: Any, spec: Dict[str, Any], path: str) -> None:
+        """Recursively validate a value against its specification."""
+        
+        # Check type
+        expected_type = spec.get("type")
+        if expected_type:
+            if expected_type == "object" and not isinstance(value, dict):
+                errors.append(f"{path}: Expected object, got {type(value).__name__}")
+                return
+            elif expected_type == "array" and not isinstance(value, list):
+                errors.append(f"{path}: Expected array, got {type(value).__name__}")
+                return
+            elif expected_type == "string" and not isinstance(value, str):
+                errors.append(f"{path}: Expected string, got {type(value).__name__}")
+                return
+            elif expected_type == "number" and not isinstance(value, (int, float)):
+                errors.append(f"{path}: Expected number, got {type(value).__name__}")
+                return
+            elif expected_type == "integer" and not isinstance(value, int):
+                errors.append(f"{path}: Expected integer, got {type(value).__name__}")
+                return
+            elif expected_type == "boolean" and not isinstance(value, bool):
+                errors.append(f"{path}: Expected boolean, got {type(value).__name__}")
+                return
+        
+        # Check enum values
+        if "enum" in spec and value not in spec["enum"]:
+            errors.append(f"{path}: Value '{value}' not in allowed values: {spec['enum']}")
+        
+        # Check numeric constraints
+        if isinstance(value, (int, float)):
+            if "min" in spec and value < spec["min"]:
+                errors.append(f"{path}: Value {value} is less than minimum {spec['min']}")
+            if "max" in spec and value > spec["max"]:
+                errors.append(f"{path}: Value {value} is greater than maximum {spec['max']}")
+        
+        # Validate object properties
+        if expected_type == "object" and isinstance(value, dict):
+            properties = spec.get("properties", {})
+            for prop_name, prop_spec in properties.items():
+                prop_path = f"{path}.{prop_name}"
+                
+                if prop_name in value:
+                    validate_value(value[prop_name], prop_spec, prop_path)
+                elif prop_spec.get("required", False):
+                    errors.append(f"{prop_path}: Required field missing")
+        
+        # Validate array items
+        if expected_type == "array" and isinstance(value, list):
+            item_spec = spec.get("items", {})
+            for i, item in enumerate(value):
+                validate_value(item, item_spec, f"{path}[{i}]")
+    
+    # Start validation from root
+    validate_value(config, {"type": "object", "properties": schema}, "config")
+    
+    return errors
+
+
+def generate_config_template() -> Dict[str, Any]:
+    """
+    Generate a configuration template with all possible options.
+    
+    Returns:
+        Configuration template dictionary
+    """
+    from ..config.configuration import MCPConfiguration
+    return MCPConfiguration.DEFAULT_CONFIG

claude_mpm/services/mcp_gateway/config/configuration.py

@@ -0,0 +1,371 @@
+"""
+MCP Gateway Configuration Implementation
+========================================
+
+Manages configuration for the MCP Gateway service.
+
+Part of ISS-0034: Infrastructure Setup - MCP Gateway Project Foundation
+"""
+
+import os
+from typing import Any, Dict, Optional
+from pathlib import Path
+import yaml
+
+from claude_mpm.services.mcp_gateway.core.interfaces import IMCPConfiguration
+from claude_mpm.services.mcp_gateway.core.base import BaseMCPService
+from claude_mpm.services.mcp_gateway.core.exceptions import MCPConfigurationError
+
+
+class MCPConfiguration(BaseMCPService, IMCPConfiguration):
+    """
+    MCP Gateway configuration management service.
+    
+    This service handles loading, validation, and access to MCP Gateway configuration.
+    It supports YAML-based configuration files and environment variable overrides.
+    
+    WHY: Configuration is centralized in a service to ensure consistent access
+    patterns, validation, and the ability to reload configuration at runtime.
+    The service pattern also allows for dependency injection of configuration
+    into other MCP services.
+    """
+    
+    DEFAULT_CONFIG = {
+        "mcp": {
+            "server": {
+                "name": "claude-mpm-gateway",
+                "version": "1.0.0",
+                "description": "Claude MPM MCP Gateway Server",
+                "communication": {
+                    "type": "stdio",  # stdio, websocket, or http
+                    "timeout": 30,  # seconds
+                    "buffer_size": 8192,
+                },
+                "capabilities": {
+                    "tools": True,
+                    "resources": False,  # Not yet implemented
+                    "prompts": False,    # Not yet implemented
+                },
+            },
+            "tools": {
+                "enabled": True,
+                "auto_discover": True,
+                "discovery_paths": [
+                    "~/.claude/mcp/tools",
+                    "./mcp_tools",
+                ],
+                "timeout_default": 30,  # seconds
+                "max_concurrent": 10,
+            },
+            "logging": {
+                "level": "INFO",
+                "file": "~/.claude/logs/mcp_gateway.log",
+                "max_size": "10MB",
+                "max_files": 5,
+                "format": "json",  # json or text
+            },
+            "security": {
+                "validate_schemas": True,
+                "sanitize_inputs": True,
+                "max_request_size": 1048576,  # 1MB
+                "allowed_tools": [],  # Empty means all tools allowed
+                "blocked_tools": [],
+            },
+        }
+    }
+    
+    def __init__(self, config_path: Optional[Path] = None):
+        """
+        Initialize MCP configuration service.
+        
+        Args:
+            config_path: Optional path to configuration file
+        """
+        super().__init__("MCPConfiguration")
+        self._config_path = config_path
+        self._config_data: Dict[str, Any] = {}
+        self._is_loaded = False
+    
+    async def _do_initialize(self) -> bool:
+        """
+        Initialize the configuration service.
+        
+        Returns:
+            True if initialization successful
+        """
+        # Start with default configuration
+        self._config_data = self.DEFAULT_CONFIG.copy()
+        
+        # Load from file if path provided
+        if self._config_path:
+            if not self.load_config(self._config_path):
+                return False
+        
+        # Apply environment variable overrides
+        self._apply_env_overrides()
+        
+        # Validate configuration
+        if not self.validate():
+            return False
+        
+        self._is_loaded = True
+        self.log_info("Configuration initialized successfully")
+        return True
+    
+    def load_config(self, config_path: Path) -> bool:
+        """
+        Load configuration from a file.
+        
+        Args:
+            config_path: Path to configuration file
+            
+        Returns:
+            True if configuration loaded successfully
+        """
+        try:
+            # Expand user path
+            config_path = Path(config_path).expanduser()
+            
+            if not config_path.exists():
+                self.log_warning(f"Configuration file not found: {config_path}")
+                return True  # Not an error, use defaults
+            
+            with open(config_path, 'r') as f:
+                if config_path.suffix in ['.yaml', '.yml']:
+                    loaded_config = yaml.safe_load(f) or {}
+                else:
+                    raise MCPConfigurationError(
+                        f"Unsupported configuration file format: {config_path.suffix}"
+                    )
+            
+            # Merge with existing configuration
+            self._merge_config(self._config_data, loaded_config)
+            self._config_path = config_path
+            
+            self.log_info(f"Configuration loaded from {config_path}")
+            return True
+            
+        except yaml.YAMLError as e:
+            raise MCPConfigurationError(f"Failed to parse YAML configuration: {e}")
+        except Exception as e:
+            self.log_error(f"Failed to load configuration: {e}")
+            return False
+    
+    def _merge_config(self, base: Dict[str, Any], overlay: Dict[str, Any]) -> None:
+        """
+        Recursively merge overlay configuration into base.
+        
+        Args:
+            base: Base configuration dictionary
+            overlay: Configuration to merge in
+        """
+        for key, value in overlay.items():
+            if key in base and isinstance(base[key], dict) and isinstance(value, dict):
+                self._merge_config(base[key], value)
+            else:
+                base[key] = value
+    
+    def _apply_env_overrides(self) -> None:
+        """
+        Apply environment variable overrides to configuration.
+        
+        Environment variables follow the pattern: MCP_GATEWAY_<SECTION>_<KEY>
+        For example: MCP_GATEWAY_SERVER_NAME=my-server
+        """
+        prefix = "MCP_GATEWAY_"
+        
+        for env_key, env_value in os.environ.items():
+            if not env_key.startswith(prefix):
+                continue
+            
+            # Parse environment variable into configuration path
+            config_path = env_key[len(prefix):].lower().split('_')
+            
+            # Navigate to the configuration location
+            current = self._config_data
+            for i, part in enumerate(config_path[:-1]):
+                if part not in current:
+                    current[part] = {}
+                elif not isinstance(current[part], dict):
+                    self.log_warning(f"Cannot override non-dict config at {'.'.join(config_path[:i+1])}")
+                    break
+                current = current[part]
+            else:
+                # Set the value
+                key = config_path[-1]
+                # Try to parse as JSON for complex types
+                try:
+                    import json
+                    current[key] = json.loads(env_value)
+                except:
+                    # Fall back to string value
+                    current[key] = env_value
+                
+                self.log_debug(f"Applied environment override: {env_key}")
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get configuration value by key.
+        
+        Args:
+            key: Configuration key (supports dot notation, e.g., "mcp.server.name")
+            default: Default value if key not found
+            
+        Returns:
+            Configuration value or default
+        """
+        parts = key.split('.')
+        current = self._config_data
+        
+        for part in parts:
+            if isinstance(current, dict) and part in current:
+                current = current[part]
+            else:
+                return default
+        
+        return current
+    
+    def set(self, key: str, value: Any) -> None:
+        """
+        Set configuration value.
+        
+        Args:
+            key: Configuration key (supports dot notation)
+            value: Configuration value
+        """
+        parts = key.split('.')
+        current = self._config_data
+        
+        # Navigate to parent
+        for part in parts[:-1]:
+            if part not in current:
+                current[part] = {}
+            elif not isinstance(current[part], dict):
+                raise MCPConfigurationError(
+                    f"Cannot set value at {key}: parent is not a dictionary"
+                )
+            current = current[part]
+        
+        # Set the value
+        current[parts[-1]] = value
+        self.log_debug(f"Configuration updated: {key} = {value}")
+    
+    def validate(self) -> bool:
+        """
+        Validate the current configuration.
+        
+        Returns:
+            True if configuration is valid
+        """
+        try:
+            # Check required fields
+            required_fields = [
+                "mcp.server.name",
+                "mcp.server.version",
+                "mcp.server.communication.type",
+            ]
+            
+            for field in required_fields:
+                if self.get(field) is None:
+                    raise MCPConfigurationError(
+                        f"Required configuration field missing: {field}",
+                        config_key=field
+                    )
+            
+            # Validate communication type
+            comm_type = self.get("mcp.server.communication.type")
+            if comm_type not in ["stdio", "websocket", "http"]:
+                raise MCPConfigurationError(
+                    f"Invalid communication type: {comm_type}",
+                    config_key="mcp.server.communication.type",
+                    expected_type="stdio|websocket|http"
+                )
+            
+            # Validate numeric fields
+            timeout = self.get("mcp.server.communication.timeout")
+            if not isinstance(timeout, (int, float)) or timeout <= 0:
+                raise MCPConfigurationError(
+                    "Invalid timeout value",
+                    config_key="mcp.server.communication.timeout",
+                    expected_type="positive number"
+                )
+            
+            self.log_debug("Configuration validation successful")
+            return True
+            
+        except MCPConfigurationError:
+            raise
+        except Exception as e:
+            self.log_error(f"Configuration validation failed: {e}")
+            return False
+    
+    def get_server_config(self) -> Dict[str, Any]:
+        """
+        Get MCP server configuration.
+        
+        Returns:
+            Server configuration dictionary
+        """
+        return self.get("mcp.server", {})
+    
+    def get_tools_config(self) -> Dict[str, Any]:
+        """
+        Get tools configuration.
+        
+        Returns:
+            Tools configuration dictionary
+        """
+        return self.get("mcp.tools", {})
+    
+    def save_config(self, path: Optional[Path] = None) -> bool:
+        """
+        Save current configuration to file.
+        
+        Args:
+            path: Path to save configuration (uses loaded path if not specified)
+            
+        Returns:
+            True if save successful
+        """
+        save_path = path or self._config_path
+        if not save_path:
+            self.log_error("No path specified for saving configuration")
+            return False
+        
+        try:
+            save_path = Path(save_path).expanduser()
+            save_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            with open(save_path, 'w') as f:
+                yaml.dump(self._config_data, f, default_flow_style=False, sort_keys=True)
+            
+            self.log_info(f"Configuration saved to {save_path}")
+            return True
+            
+        except Exception as e:
+            self.log_error(f"Failed to save configuration: {e}")
+            return False
+    
+    def reload(self) -> bool:
+        """
+        Reload configuration from file.
+        
+        Returns:
+            True if reload successful
+        """
+        if not self._config_path:
+            self.log_warning("No configuration file to reload")
+            return True
+        
+        # Reset to defaults
+        self._config_data = self.DEFAULT_CONFIG.copy()
+        
+        # Reload from file
+        if not self.load_config(self._config_path):
+            return False
+        
+        # Reapply environment overrides
+        self._apply_env_overrides()
+        
+        # Revalidate
+        return self.validate()

claude_mpm/services/mcp_gateway/core/__init__.py

@@ -0,0 +1,51 @@
+"""
+MCP Gateway Core Module
+=======================
+
+Core interfaces and base classes for the MCP Gateway service.
+"""
+
+from .interfaces import (
+    IMCPServer,
+    IMCPToolRegistry,
+    IMCPConfiguration,
+    IMCPToolAdapter,
+    IMCPLifecycle,
+    IMCPCommunication,
+)
+
+from .base import (
+    BaseMCPService,
+    MCPServiceState,
+)
+
+from .exceptions import (
+    MCPException,
+    MCPConfigurationError,
+    MCPToolNotFoundError,
+    MCPServerError,
+    MCPCommunicationError,
+    MCPValidationError,
+)
+
+__all__ = [
+    # Interfaces
+    "IMCPServer",
+    "IMCPToolRegistry",
+    "IMCPConfiguration",
+    "IMCPToolAdapter",
+    "IMCPLifecycle",
+    "IMCPCommunication",
+    
+    # Base classes
+    "BaseMCPService",
+    "MCPServiceState",
+    
+    # Exceptions
+    "MCPException",
+    "MCPConfigurationError",
+    "MCPToolNotFoundError",
+    "MCPServerError",
+    "MCPCommunicationError",
+    "MCPValidationError",
+]