claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/services/mcp_gateway/config/config_schema.py

@@ -7,22 +7,22 @@ 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
+from typing import Any, Dict, List, Optional
 
 
 @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": {
@@ -43,21 +43,21 @@ class MCPConfigSchema:
                                 "type": {
                                     "type": "string",
                                     "required": True,
-                                    "enum": ["stdio", "websocket", "http"]
+                                    "enum": ["stdio", "websocket", "http"],
                                 },
                                 "timeout": {
                                     "type": "number",
                                     "required": False,
                                     "min": 1,
-                                    "max": 3600
+                                    "max": 3600,
                                 },
                                 "buffer_size": {
                                     "type": "integer",
                                     "required": False,
                                     "min": 1024,
-                                    "max": 1048576
+                                    "max": 1048576,
                                 },
-                            }
+                            },
                         },
                         "capabilities": {
                             "type": "object",
@@ -66,9 +66,9 @@ class MCPConfigSchema:
                                 "tools": {"type": "boolean", "required": False},
                                 "resources": {"type": "boolean", "required": False},
                                 "prompts": {"type": "boolean", "required": False},
-                            }
+                            },
                         },
-                    }
+                    },
                 },
                 "tools": {
                     "type": "object",
@@ -79,21 +79,21 @@ class MCPConfigSchema:
                         "discovery_paths": {
                             "type": "array",
                             "required": False,
-                            "items": {"type": "string"}
+                            "items": {"type": "string"},
                         },
                         "timeout_default": {
                             "type": "number",
                             "required": False,
                             "min": 1,
-                            "max": 300
+                            "max": 300,
                         },
                         "max_concurrent": {
                             "type": "integer",
                             "required": False,
                             "min": 1,
-                            "max": 100
+                            "max": 100,
                         },
-                    }
+                    },
                 },
                 "logging": {
                     "type": "object",
@@ -102,7 +102,7 @@ class MCPConfigSchema:
                         "level": {
                             "type": "string",
                             "required": False,
-                            "enum": ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+                            "enum": ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
                         },
                         "file": {"type": "string", "required": False},
                         "max_size": {"type": "string", "required": False},
@@ -110,14 +110,14 @@ class MCPConfigSchema:
                             "type": "integer",
                             "required": False,
                             "min": 1,
-                            "max": 100
+                            "max": 100,
                         },
                         "format": {
                             "type": "string",
                             "required": False,
-                            "enum": ["json", "text"]
+                            "enum": ["json", "text"],
                         },
-                    }
+                    },
                 },
                 "security": {
                     "type": "object",
@@ -129,44 +129,46 @@ class MCPConfigSchema:
                             "type": "integer",
                             "required": False,
                             "min": 1024,
-                            "max": 104857600  # 100MB max
+                            "max": 104857600,  # 100MB max
                         },
                         "allowed_tools": {
                             "type": "array",
                             "required": False,
-                            "items": {"type": "string"}
+                            "items": {"type": "string"},
                         },
                         "blocked_tools": {
                             "type": "array",
                             "required": False,
-                            "items": {"type": "string"}
+                            "items": {"type": "string"},
                         },
-                    }
+                    },
                 },
-            }
+            },
         }
     }
 
 
-def validate_config(config: Dict[str, Any], schema: Optional[Dict[str, Any]] = None) -> List[str]:
+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:
@@ -188,47 +190,54 @@ def validate_config(config: Dict[str, Any], schema: Optional[Dict[str, Any]] = N
             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']}")
-        
+            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']}")
+                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']}")
-        
+                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
+
+    return MCPConfiguration.DEFAULT_CONFIG

claude_mpm/services/mcp_gateway/config/configuration.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 MCP Gateway Configuration Implementation
 ========================================
@@ -9,27 +11,27 @@ 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
+from claude_mpm.services.mcp_gateway.core.interfaces import IMCPConfiguration
 
 
 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": {
@@ -44,7 +46,7 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
                 "capabilities": {
                     "tools": True,
                     "resources": False,  # Not yet implemented
-                    "prompts": False,    # Not yet implemented
+                    "prompts": False,  # Not yet implemented
                 },
             },
             "tools": {
@@ -73,11 +75,11 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
             },
         }
     }
-    
+
     def __init__(self, config_path: Optional[Path] = None):
         """
         Initialize MCP configuration service.
-        
+
         Args:
             config_path: Optional path to configuration file
         """
@@ -85,76 +87,76 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
         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']:
+
+            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
@@ -164,30 +166,32 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
                 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('_')
-            
+            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])}")
+                    self.log_warning(
+                        f"Cannot override non-dict config at {'.'.join(config_path[:i+1])}"
+                    )
                     break
                 current = current[part]
             else:
@@ -196,46 +200,47 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
                 # 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('.')
+        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('.')
+        parts = key.split(".")
         current = self._config_data
-        
+
         # Navigate to parent
         for part in parts[:-1]:
             if part not in current:
@@ -245,15 +250,15 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
                     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
         """
@@ -264,66 +269,66 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
                 "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
+                        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"
+                    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"
+                    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
         """
@@ -331,41 +336,43 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
         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)
-            
+
+            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()
+        return self.validate()