mcp-proxy-adapter 6.8.2__tar.gz → 6.9.1__tar.gz

{mcp_proxy_adapter-6.8.2 → mcp_proxy_adapter-6.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.8.2
+Version: 6.9.1
 Summary: Powerful JSON-RPC microservices framework with built-in security, authentication, and proxy registration
 Home-page: https://github.com/maverikod/mcp-proxy-adapter
 Author: Vasiliy Zdanovskiy

{mcp_proxy_adapter-6.8.2 → mcp_proxy_adapter-6.9.1}/mcp_proxy_adapter/config.py

@@ -12,6 +12,17 @@ from typing import Any, Dict, Optional, List
 
 logger = logging.getLogger(__name__)
 
+# Import validation if available
+try:
+    from .core.config_validator import ConfigValidator, ValidationResult, ValidationLevel
+    VALIDATION_AVAILABLE = True
+except ImportError:
+    VALIDATION_AVAILABLE = False
+    logger.warning("Configuration validation not available. Install the package to enable validation.")
+
+# Import configuration errors
+from .core.errors import ConfigError, ValidationResult
+
 
 class Config:
     """
@@ -20,113 +31,64 @@ class Config:
     Supports optional features that can be enabled/disabled.
     """
 
-    def __init__(self, config_path: Optional[str] = None):
+    def __init__(self, config_path: Optional[str] = None, validate_on_load: bool = True):
         """
         Initialize configuration.
 
         Args:
             config_path: Path to configuration file. If not specified,
                         "./config.json" is used.
+            validate_on_load: Whether to validate configuration on load (default: True)
+        
+        Raises:
+            ConfigError: If configuration validation fails
         """
         self.config_path = config_path or "./config.json"
         self.config_data: Dict[str, Any] = {}
+        self.validate_on_load = validate_on_load
+        self.validation_results: List[ValidationResult] = []
+        self.validator = None
+        
+        if VALIDATION_AVAILABLE:
+            self.validator = ConfigValidator()
+        
         self.load_config()
 
     def load_config(self) -> None:
         """
         Load configuration from file and environment variables.
+        NO DEFAULT VALUES - configuration must be complete and valid.
         """
-        # Set default config values
-        self.config_data = {
-            "server": {
-                "host": "0.0.0.0",
-                "port": 8000,
-                "protocol": "http",
-                "debug": False,
-                "log_level": "INFO",
-            },
-            "logging": {
-                "level": "INFO",
-                "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,
-                "commands_directory": "./commands",
-                "catalog_directory": "./catalog",
-                "plugin_servers": [],
-                "auto_install_dependencies": True,
-                "enabled_commands": ["health", "echo", "list", "help"],
-                "disabled_commands": [],
-                "custom_commands_path": "./commands",
-            },
-            "roles": {
-                "enabled": False,
-                "config_file": None,
-                "default_policy": {
-                    "deny_by_default": False,
-                    "require_role_match": False,
-                    "case_sensitive": False,
-                    "allow_wildcard": False,
-                },
-                "auto_load": False,
-                "validation_enabled": False,
-            },
-            "transport": {
-                "type": "http",
-                "port": None,
-                    "verify_client": False,
-                "chk_hostname": False,  # Default to False for HTTP
-            },
-            "proxy_registration": {
-                "enabled": False,
-                "proxy_url": "http://localhost:3004",
-                "server_id": "mcp_proxy_adapter",
-                "server_name": "MCP Proxy Adapter",
-                "description": "JSON-RPC API for interacting with MCP Proxy",
-                "version": "6.2.33",
-                "registration_timeout": 30,
-                "retry_attempts": 3,
-                "retry_delay": 5,
-                "auto_register_on_startup": True,
-                "auto_unregister_on_shutdown": True,
-            },
-            "debug": {"enabled": False, "level": "WARNING"},
-            "security": {
-                "enabled": False,
-                "tokens": {
-                    "admin": "admin-secret-key",
-                    "user": "user-secret-key",
-                    "readonly": "readonly-secret-key"
-                },
-                "roles": {
-                    "admin": ["read", "write", "delete", "admin"],
-                    "user": ["read", "write"],
-                    "readonly": ["read"]
-                },
-                "roles_file": None
-            },
-        }
-
-        # Try to load configuration from file
-        if os.path.exists(self.config_path):
-            try:
+        # Load configuration from file - NO DEFAULTS
+        if not os.path.exists(self.config_path):
+            raise ConfigError(f"Configuration file '{self.config_path}' does not exist. Use the configuration generator to create a valid configuration.")
+        
+        try:
                 with open(self.config_path, "r", encoding="utf-8") as f:
-                    file_config = json.load(f)
-                    self._update_nested_dict(self.config_data, file_config)
-            except Exception as e:
-                print(f"Error loading config from {self.config_path}: {e}")
-
-        # Load configuration from environment variables
+                    self.config_data = json.load(f)
+        except json.JSONDecodeError as e:
+            raise ConfigError(f"Configuration file '{self.config_path}' contains invalid JSON: {e}")
+        except Exception as e:
+            raise ConfigError(f"Error loading configuration from '{self.config_path}': {e}")
+        
+        # Validate configuration BEFORE applying any logic
+        if self.validate_on_load:
+            if VALIDATION_AVAILABLE and self.validator:
+                self.validator.config_data = self.config_data
+                validation_results = self.validator.validate_config()
+                
+                # Check for critical errors
+                errors = [r for r in validation_results if r.level == "error"]
+                if errors:
+                    error_summary = "\n".join([f"[{r.section}.{r.key if r.key else 'root'}] {r.message}" for r in errors])
+                    raise ConfigError(f"Configuration validation failed with {len(errors)} error(s):\n{error_summary}", errors)
+                
+                # Store validation results for later access
+                self.validation_results = validation_results
+            else:
+                raise ConfigError("Configuration validation is not available. Install required dependencies.")
+        
+        # Load configuration from environment variables (overrides file values)
         self._load_env_variables()
         
         # Apply hostname check logic based on SSL configuration
@@ -257,23 +219,6 @@ class Config:
         with open(save_path, "w", encoding="utf-8") as f:
             json.dump(self.config_data, f, indent=2)
 
-    def _update_nested_dict(self, d: Dict, u: Dict) -> Dict:
-        """
-        Update nested dictionary recursively.
-
-        Args:
-            d: Dictionary to update
-            u: Dictionary with new values
-
-        Returns:
-            Updated dictionary
-        """
-        for k, v in u.items():
-            if isinstance(v, dict) and k in d and isinstance(d[k], dict):
-                self._update_nested_dict(d[k], v)
-            else:
-                d[k] = v
-        return d
 
     def enable_feature(self, feature: str) -> None:
         """
@@ -540,6 +485,159 @@ class Config:
             chk_hostname_value = self.get("transport.ssl.chk_hostname")
             logger.debug(f"Using explicitly set chk_hostname={chk_hostname_value} for protocol {protocol}")
 
+    def validate(self) -> List[ValidationResult]:
+        """
+        Validate current configuration.
+        
+        Returns:
+            List of validation results
+            
+        Raises:
+            ConfigError: If validation is not available or critical errors are found
+        """
+        if not VALIDATION_AVAILABLE:
+            raise ConfigError("Configuration validation is not available. Please install the package properly.")
+        
+        if not self.validator:
+            self.validator = ConfigValidator()
+        
+        self.validator.config_data = self.config_data
+        self.validation_results = self.validator.validate_config()
+        
+        # Log validation results
+        for result in self.validation_results:
+            if result.level == ValidationLevel.ERROR:
+                logger.error(f"Configuration error: {result.message}")
+            elif result.level == ValidationLevel.WARNING:
+                logger.warning(f"Configuration warning: {result.message}")
+            else:
+                logger.info(f"Configuration info: {result.message}")
+        
+        # Raise ConfigError if there are critical errors
+        errors = [r for r in self.validation_results if r.level == ValidationLevel.ERROR]
+        if errors:
+            error_summary = "\n".join([f"[{r.section}.{r.key if r.key else 'root'}] {r.message}" for r in errors])
+            raise ConfigError(f"Configuration validation failed with {len(errors)} error(s):\n{error_summary}", errors)
+        
+        return self.validation_results
+    
+    def is_valid(self) -> bool:
+        """Check if configuration is valid."""
+        if not VALIDATION_AVAILABLE:
+            return True
+        
+        return all(result.level != ValidationLevel.ERROR for result in self.validation_results)
+    
+    def get_validation_errors(self) -> List[ValidationResult]:
+        """Get all validation errors."""
+        return [r for r in self.validation_results if r.level == ValidationLevel.ERROR]
+    
+    def get_validation_warnings(self) -> List[ValidationResult]:
+        """Get all validation warnings."""
+        return [r for r in self.validation_results if r.level == ValidationLevel.WARNING]
+    
+    def get_validation_summary(self) -> Dict[str, Any]:
+        """Get validation summary."""
+        if not VALIDATION_AVAILABLE or not self.validator:
+            return {"total_issues": 0, "errors": 0, "warnings": 0, "info": 0, "is_valid": True}
+        
+        return self.validator.get_validation_summary()
+    
+    def print_validation_report(self) -> None:
+        """Print detailed validation report."""
+        if not VALIDATION_AVAILABLE or not self.validator:
+            print("Configuration validation not available")
+            return
+        
+        self.validator.print_validation_report()
+    
+    def check_feature_requirements(self, feature: str) -> List[ValidationResult]:
+        """Check if all requirements for a feature are met."""
+        if not VALIDATION_AVAILABLE:
+            return []
+        
+        results = []
+        
+        if feature == "security":
+            if self.get("security.enabled", False):
+                tokens = self.get("security.tokens", {})
+                roles = self.get("security.roles", {})
+                roles_file = self.get("security.roles_file")
+                
+                has_tokens = bool(tokens and any(tokens.values()))
+                has_roles = bool(roles and any(roles.values()))
+                has_roles_file = bool(roles_file and os.path.exists(roles_file))
+                
+                if not (has_tokens or has_roles or has_roles_file):
+                    results.append(ValidationResult(
+                        level=ValidationLevel.WARNING,
+                        message="Security is enabled but no authentication methods are configured",
+                        section="security",
+                        suggestion="Configure tokens, roles, or roles_file"
+                    ))
+        
+        elif feature == "roles":
+            if self.get("roles.enabled", False):
+                config_file = self.get("roles.config_file")
+                if not config_file:
+                    results.append(ValidationResult(
+                        level=ValidationLevel.ERROR,
+                        message="Roles are enabled but config_file is not specified",
+                        section="roles",
+                        key="config_file"
+                    ))
+                elif not os.path.exists(config_file):
+                    results.append(ValidationResult(
+                        level=ValidationLevel.ERROR,
+                        message=f"Roles config file '{config_file}' does not exist",
+                        section="roles",
+                        key="config_file"
+                    ))
+        
+        elif feature == "ssl":
+            if self.get("ssl.enabled", False):
+                cert_file = self.get("ssl.cert_file")
+                key_file = self.get("ssl.key_file")
+                
+                if not cert_file:
+                    results.append(ValidationResult(
+                        level=ValidationLevel.ERROR,
+                        message="SSL is enabled but cert_file is not specified",
+                        section="ssl",
+                        key="cert_file"
+                    ))
+                elif not os.path.exists(cert_file):
+                    results.append(ValidationResult(
+                        level=ValidationLevel.ERROR,
+                        message=f"SSL certificate file '{cert_file}' does not exist",
+                        section="ssl",
+                        key="cert_file"
+                    ))
+                
+                if not key_file:
+                    results.append(ValidationResult(
+                        level=ValidationLevel.ERROR,
+                        message="SSL is enabled but key_file is not specified",
+                        section="ssl",
+                        key="key_file"
+                    ))
+                elif not os.path.exists(key_file):
+                    results.append(ValidationResult(
+                        level=ValidationLevel.ERROR,
+                        message=f"SSL key file '{key_file}' does not exist",
+                        section="ssl",
+                        key="key_file"
+                    ))
+        
+        return results
+
+
+# Singleton instance - will be created when needed
+config = None
 
-# Singleton instance
-config = Config()
+def get_config() -> Config:
+    """Get the global configuration instance."""
+    global config
+    if config is None:
+        config = Config()
+    return config