mcp-proxy-adapter 2.0.1__py3-none-any.whl → 6.9.50__py3-none-any.whl

mcp_proxy_adapter/core/config/config.py

@@ -0,0 +1,237 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Main configuration class for MCP Proxy Adapter.
+"""
+
+from typing import Any, Dict, Optional, List
+from pathlib import Path
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from .config_loader import ConfigLoader
+from .feature_manager import FeatureManager
+from .config_factory import ConfigFactory
+
+# Import validation if available
+try:
+    VALIDATION_AVAILABLE = True
+except ImportError:
+    VALIDATION_AVAILABLE = False
+
+# Import configuration errors
+from ..errors import ConfigError, ValidationResult
+
+
+class Config:
+    """
+    Configuration management class for the microservice.
+    Allows loading settings from configuration file and environment variables.
+    Supports optional features that can be enabled/disabled.
+    """
+
+    def __init__(
+        self, config_path: Optional[str] = None, validate_on_load: bool = False
+    ):
+        """
+        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: False)
+        
+        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
+        
+        # Initialize components
+        self.logger = get_global_logger()
+        self.loader = ConfigLoader()
+        self.feature_manager = FeatureManager(self.config_data)
+        self.factory = ConfigFactory()
+        
+        # Load configuration
+        self.load_config()
+
+    def load_config(self) -> None:
+        """Load configuration from file and environment variables."""
+        try:
+            # Load from file if it exists
+            if Path(self.config_path).exists():
+                file_config = self.loader.load_from_file(self.config_path)
+                self.config_data.update(file_config)
+            
+            # Load from environment variables
+            try:
+                env_config = self.loader.load_from_env()
+                self._merge_config(env_config)
+            except AttributeError:
+                # load_from_env doesn't exist yet, skip
+                pass
+            
+            # Validate if required
+            if self.validate_on_load and VALIDATION_AVAILABLE:
+                self.validate()
+                
+        except Exception as e:
+            self.logger.error(f"Failed to load configuration: {e}")
+            raise ConfigError(f"Configuration loading failed: {e}")
+
+    def _merge_config(self, new_config: Dict[str, Any]) -> None:
+        """
+        Merge new configuration into existing configuration.
+
+        Args:
+            new_config: New configuration to merge
+        """
+        for section, values in new_config.items():
+            if section in self.config_data:
+                if isinstance(self.config_data[section], dict) and isinstance(
+                    values, dict
+                ):
+                    self.config_data[section].update(values)
+                else:
+                    self.config_data[section] = values
+            else:
+                self.config_data[section] = values
+
+    def enable_feature(self, feature: str) -> None:
+        """
+        Enable a feature.
+
+        Args:
+            feature: Feature name
+        """
+        self.feature_manager.enable_feature(feature)
+
+    def disable_feature(self, feature: str) -> None:
+        """
+        Disable a feature.
+
+        Args:
+            feature: Feature name
+        """
+        self.feature_manager.disable_feature(feature)
+
+    def is_feature_enabled(self, feature: str) -> bool:
+        """
+        Check if feature is enabled.
+
+        Args:
+            feature: Feature name
+
+        Returns:
+            True if enabled, False otherwise
+        """
+        return self.feature_manager.is_feature_enabled(feature)
+
+    def get_enabled_features(self) -> List[str]:
+        """
+        Get list of enabled features.
+
+        Returns:
+            List of enabled feature names
+        """
+        return self.feature_manager.get_enabled_features()
+
+    def validate(self) -> List[ValidationResult]:
+        """
+        Validate configuration.
+
+        Returns:
+            List of validation results
+        """
+        if not VALIDATION_AVAILABLE:
+            self.logger.warning("Configuration validation not available")
+            return []
+
+        try:
+            from ..config_validator import ConfigValidator
+
+            self.validator = ConfigValidator()
+            self.validator.config_data = self.config_data
+            self.validation_results = self.validator.validate_config()
+            return self.validation_results
+        except Exception as e:
+            self.logger.error(f"Configuration validation failed: {e}")
+            return []
+
+    def get_validation_errors(self) -> List[ValidationResult]:
+        """Get validation errors."""
+        return [result for result in self.validation_results if result.level == "error"]
+
+    def get_validation_warnings(self) -> List[ValidationResult]:
+        """Get validation warnings."""
+        return [
+            result for result in self.validation_results if result.level == "warning"
+        ]
+
+    def get_validation_summary(self) -> Dict[str, Any]:
+        """Get validation summary."""
+        errors = self.get_validation_errors()
+        warnings = self.get_validation_warnings()
+        
+        return {
+            "total": len(self.validation_results),
+            "errors": len(errors),
+            "warnings": len(warnings),
+            "is_valid": len(errors) == 0,
+        }
+
+    def check_feature_requirements(self, feature: str) -> List[ValidationResult]:
+        """
+        Check feature requirements.
+
+        Args:
+            feature: Feature name
+
+        Returns:
+            List of validation results
+        """
+        return self.feature_manager.check_feature_requirements(feature)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get configuration value using dot notation.
+
+        Supports nested dictionary access using dot notation.
+        For example: "transport.cert_file" will access config_data["transport"]["cert_file"]
+
+        Args:
+            key: Configuration key, can use dot notation (e.g., "transport.cert_file")
+            default: Default value if key not found
+
+        Returns:
+            Configuration value or default
+
+        Examples:
+            >>> config.get("server.host", "0.0.0.0")
+            >>> config.get("transport.ssl.cert_file")
+        """
+        keys = key.split(".")
+        value = self.config_data
+
+        for k in keys:
+            if isinstance(value, dict):
+                value = value.get(k)
+                if value is None:
+                    return default
+            else:
+                return default
+
+        return value if value is not None else default
+
+    def get_all(self) -> Dict[str, Any]:
+        """
+        Get all configuration data.
+
+        Returns:
+            Complete configuration dictionary
+        """
+        return self.config_data

mcp_proxy_adapter/core/config/config_factory.py

@@ -0,0 +1,22 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Configuration factory for creating predefined configurations.
+"""
+
+from typing import Dict, Any
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class ConfigFactory:
+    """Factory for creating predefined configurations."""
+
+    def __init__(self):
+        """Initialize config factory."""
+        self.logger = get_global_logger()
+
+
+
+

mcp_proxy_adapter/core/config/config_loader.py

@@ -0,0 +1,66 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Configuration loading utilities for MCP Proxy Adapter.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class ConfigLoader:
+    """Loader for configuration files and environment variables."""
+
+    def __init__(self):
+        """Initialize config loader."""
+        self.logger = get_global_logger()
+
+    def load_from_file(self, config_path: str | Path) -> dict:
+        """
+        Load configuration from JSON file.
+
+        Args:
+            config_path: Path to configuration file
+
+        Returns:
+            Configuration dictionary
+
+        Raises:
+            FileNotFoundError: If config file doesn't exist
+            json.JSONDecodeError: If config file is invalid JSON
+        """
+        path = Path(config_path)
+        if not path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+    def _convert_env_value(self, value: str) -> Any:
+        """
+        Convert environment variable value to appropriate type.
+
+        Args:
+            value: Value as string
+
+        Returns:
+            Converted value
+        """
+        # Try to convert to appropriate type
+        if value.lower() == "true":
+            return True
+        elif value.lower() == "false":
+            return False
+        elif value.isdigit():
+            return int(value)
+        else:
+            try:
+                return float(value)
+            except ValueError:
+                return value
+

mcp_proxy_adapter/core/config/feature_manager.py

@@ -0,0 +1,31 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Feature management utilities for MCP Proxy Adapter configuration.
+"""
+
+from typing import Any, Dict, List
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class FeatureManager:
+    """Manager for configuration features."""
+
+    def __init__(self, config_data: Dict[str, Any]):
+        """
+        Initialize feature manager.
+
+        Args:
+            config_data: Configuration data dictionary
+        """
+        self.config_data = config_data
+        self.logger = get_global_logger()
+
+
+
+
+
+
+

mcp_proxy_adapter/core/config/simple_config.py

@@ -0,0 +1,204 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Simple configuration data container and IO helpers for MCP Proxy Adapter.
+
+This module provides a minimal, explicit configuration model with three
+sections: server, client, registration and auth.
+
+- server: Server endpoint configuration (listening for incoming connections)
+- client: Client configuration (for connecting to external servers)
+- registration: Proxy registration configuration (for registering with proxy server)
+- auth: Authentication and authorization configuration
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class ServerConfig:
+    """Server endpoint configuration (listening for incoming connections)."""
+
+    host: str
+    port: int
+    protocol: str  # http | https | mtls
+    cert_file: Optional[str] = None
+    key_file: Optional[str] = None
+    ca_cert_file: Optional[str] = None
+    crl_file: Optional[str] = None
+    use_system_ca: bool = (
+        False  # If True, allow system CA store when ca_cert_file is not provided
+    )
+    log_dir: str = "./logs"
+
+
+@dataclass
+class ClientConfig:
+    """Client configuration (for connecting to external servers)."""
+
+    enabled: bool = False
+    protocol: str = "http"  # http | https | mtls
+    cert_file: Optional[str] = None
+    key_file: Optional[str] = None
+    ca_cert_file: Optional[str] = None
+    crl_file: Optional[str] = None
+    use_system_ca: bool = (
+        False  # If True, allow system CA store when ca_cert_file is not provided
+    )
+
+
+@dataclass
+class HeartbeatConfig:
+    endpoint: str = "/heartbeat"
+    interval: int = 30
+
+
+@dataclass
+class RegistrationConfig:
+    """Proxy registration configuration (for registering with proxy server)."""
+
+    enabled: bool = False
+    host: str = "localhost"
+    port: int = 3005
+    protocol: str = "http"  # http | https | mtls
+    server_id: Optional[str] = None  # Server identifier for registration (preferred)
+    server_name: Optional[str] = None  # Legacy field, use server_id instead
+    cert_file: Optional[str] = None
+    key_file: Optional[str] = None
+    ca_cert_file: Optional[str] = None
+    crl_file: Optional[str] = None
+    use_system_ca: bool = (
+        False  # If True, allow system CA store when ca_cert_file is not provided
+    )
+    register_endpoint: str = "/register"
+    unregister_endpoint: str = "/unregister"
+    auto_on_startup: bool = True
+    auto_on_shutdown: bool = True
+    heartbeat: HeartbeatConfig = field(default_factory=HeartbeatConfig)
+
+
+@dataclass
+class AuthConfig:
+    use_token: bool = False
+    use_roles: bool = False
+    tokens: Dict[str, List[str]] = field(default_factory=dict)
+    roles: Dict[str, List[str]] = field(default_factory=dict)
+
+
+@dataclass
+class SimpleConfigModel:
+    server: ServerConfig
+    client: ClientConfig = field(default_factory=ClientConfig)
+    registration: RegistrationConfig = field(default_factory=RegistrationConfig)
+    auth: AuthConfig = field(default_factory=AuthConfig)
+
+
+class SimpleConfig:
+    """High-level loader/saver for SimpleConfigModel."""
+
+    def __init__(self, config_path: str = "config.json") -> None:
+        self.config_path: Path = Path(config_path)
+        self.model: Optional[SimpleConfigModel] = None
+
+    def load(self) -> SimpleConfigModel:
+        content = json.loads(self.config_path.read_text(encoding="utf-8"))
+        # Filter out unknown fields from server config (like debug, log_level from old format)
+        server_data = content["server"].copy()
+        # Remove fields that are not in ServerConfig
+        known_fields = {
+            "host",
+            "port",
+            "protocol",
+            "cert_file",
+            "key_file",
+            "ca_cert_file",
+            "crl_file",
+            "use_system_ca",
+            "log_dir",
+        }
+        server_data = {k: v for k, v in server_data.items() if k in known_fields}
+
+        server = ServerConfig(**server_data)  # type: ignore[arg-type]
+
+        # Load client config (new structure)
+        client = ClientConfig(**content.get("client", {}))  # type: ignore[arg-type]
+
+        # Load registration config (new structure)
+        # Support backward compatibility: if proxy_client exists, migrate to registration
+        registration_data = content.get("registration", {})
+        if not registration_data and "proxy_client" in content:
+            # Migrate from old proxy_client structure
+            pc = content["proxy_client"]
+            registration_data = {
+                "enabled": pc.get("enabled", False),
+                "host": pc.get("host", "localhost"),
+                "port": pc.get("port", 3005),
+                "protocol": pc.get("protocol", "http"),
+                "server_id": pc.get("server_id"),
+                "server_name": pc.get("server_name"),
+                "cert_file": pc.get("cert_file"),
+                "key_file": pc.get("key_file"),
+                "ca_cert_file": pc.get("ca_cert_file"),
+                "crl_file": pc.get("crl_file"),
+                "use_system_ca": pc.get("use_system_ca", False),
+                "register_endpoint": (
+                    pc.get("registration", {}).get("register_endpoint", "/register")
+                    if isinstance(pc.get("registration"), dict)
+                    else "/register"
+                ),
+                "unregister_endpoint": (
+                    pc.get("registration", {}).get("unregister_endpoint", "/unregister")
+                    if isinstance(pc.get("registration"), dict)
+                    else "/unregister"
+                ),
+                "auto_on_startup": (
+                    pc.get("registration", {}).get("auto_on_startup", True)
+                    if isinstance(pc.get("registration"), dict)
+                    else True
+                ),
+                "auto_on_shutdown": (
+                    pc.get("registration", {}).get("auto_on_shutdown", True)
+                    if isinstance(pc.get("registration"), dict)
+                    else True
+                ),
+                "heartbeat": pc.get("heartbeat", {}),
+            }
+
+        registration = RegistrationConfig(**registration_data)  # type: ignore[arg-type]
+        # Handle nested heartbeat structure
+        if isinstance(registration_data.get("heartbeat"), dict):
+            registration.heartbeat = HeartbeatConfig(**registration_data["heartbeat"])  # type: ignore[arg-type]
+
+        auth = AuthConfig(**content.get("auth", {}))  # type: ignore[arg-type]
+        self.model = SimpleConfigModel(
+            server=server, client=client, registration=registration, auth=auth
+        )
+        return self.model
+
+    def save(self, out_path: Optional[str] = None) -> None:
+        if self.model is None:
+            raise ValueError("Configuration model is not loaded")
+        path = Path(out_path) if out_path else self.config_path
+        data: Dict[str, Any] = {
+            "server": vars(self.model.server),
+            "client": vars(self.model.client),
+            "registration": {
+                **{
+                    k: v
+                    for k, v in vars(self.model.registration).items()
+                    if k != "heartbeat"
+                },
+                "heartbeat": vars(self.model.registration.heartbeat),
+            },
+            "auth": vars(self.model.auth),
+        }
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(
+            json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8"
+        )

mcp_proxy_adapter/core/config/simple_config_generator.py

@@ -0,0 +1,131 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Simple configuration generator for MCP Proxy Adapter.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .simple_config import (
+    SimpleConfig,
+    SimpleConfigModel,
+    ServerConfig,
+    ClientConfig,
+    RegistrationConfig,
+    AuthConfig,
+)
+
+
+class SimpleConfigGenerator:
+    """Generate minimal configuration according to the plan."""
+
+    def generate(
+        self,
+        protocol: str,
+        with_proxy: bool = False,
+        out_path: str = "config.json",
+        # Server parameters
+        server_host: Optional[str] = None,
+        server_port: Optional[int] = None,
+        server_cert_file: Optional[str] = None,
+        server_key_file: Optional[str] = None,
+        server_ca_cert_file: Optional[str] = None,
+        server_crl_file: Optional[str] = None,
+        # Client parameters
+        client_enabled: bool = False,
+        client_protocol: Optional[str] = None,
+        client_cert_file: Optional[str] = None,
+        client_key_file: Optional[str] = None,
+        client_ca_cert_file: Optional[str] = None,
+        client_crl_file: Optional[str] = None,
+        # Registration parameters
+        registration_host: Optional[str] = None,
+        registration_port: Optional[int] = None,
+        registration_protocol: Optional[str] = None,
+        registration_cert_file: Optional[str] = None,
+        registration_key_file: Optional[str] = None,
+        registration_ca_cert_file: Optional[str] = None,
+        registration_crl_file: Optional[str] = None,
+    ) -> str:
+        """
+        Generate configuration with optional custom parameters.
+        
+        Args:
+            protocol: Server protocol (http, https, mtls)
+            with_proxy: Enable proxy registration (deprecated, use registration parameters)
+            out_path: Output file path
+            # Server parameters
+            server_host: Server host (default: 0.0.0.0)
+            server_port: Server port (default: 8080)
+            server_cert_file: Server certificate file path
+            server_key_file: Server key file path
+            server_ca_cert_file: Server CA certificate file path
+            server_crl_file: Server CRL file path
+            # Client parameters
+            client_enabled: Enable client configuration
+            client_protocol: Client protocol (http, https, mtls)
+            client_cert_file: Client certificate file path
+            client_key_file: Client key file path
+            client_ca_cert_file: Client CA certificate file path
+            client_crl_file: Client CRL file path
+            # Registration parameters
+            registration_host: Registration proxy host (default: localhost)
+            registration_port: Registration proxy port (default: 3005)
+            registration_protocol: Registration protocol (http, https, mtls)
+            registration_cert_file: Registration certificate file path
+            registration_key_file: Registration key file path
+            registration_ca_cert_file: Registration CA certificate file path
+            registration_crl_file: Registration CRL file path
+        """
+        # Server configuration
+        server = ServerConfig(
+            host=server_host or "0.0.0.0", port=server_port or 8080, protocol=protocol
+        )
+        if protocol in ("https", "mtls"):
+            server.cert_file = server_cert_file or "./certs/server.crt"
+            server.key_file = server_key_file or "./certs/server.key"
+        # For mtls: CA is required if use_system_ca=False (default), optional if use_system_ca=True
+        # Only set if explicitly provided
+        if protocol == "mtls" and server_ca_cert_file:
+            server.ca_cert_file = server_ca_cert_file
+        if server_crl_file:
+            server.crl_file = server_crl_file
+        # use_system_ca defaults to False (only CA from config is used by default)
+
+        # Client configuration
+        client = ClientConfig(enabled=client_enabled)
+        if client_enabled:
+            client.protocol = client_protocol or protocol
+            if client.protocol in ("https", "mtls"):
+                client.cert_file = client_cert_file or "./certs/client.crt"
+                client.key_file = client_key_file or "./certs/client.key"
+            if client.protocol == "mtls" and client_ca_cert_file:
+                client.ca_cert_file = client_ca_cert_file
+            if client_crl_file:
+                client.crl_file = client_crl_file
+
+        # Registration configuration
+        registration = RegistrationConfig(enabled=with_proxy)
+        if with_proxy:
+            registration.host = registration_host or "localhost"
+            registration.port = registration_port or 3005
+            registration.protocol = registration_protocol or "http"
+            # Client certificates for proxy connection (only if proxy itself uses HTTPS/mTLS)
+            if registration.protocol in ("https", "mtls"):
+                registration.cert_file = registration_cert_file or "./certs/registration.crt"
+                registration.key_file = registration_key_file or "./certs/registration.key"
+            if registration.protocol == "mtls" and registration_ca_cert_file:
+                registration.ca_cert_file = registration_ca_cert_file
+            if registration_crl_file:
+                registration.crl_file = registration_crl_file
+            registration.auto_on_startup = True
+
+        auth = AuthConfig(use_token=False, use_roles=False, tokens={}, roles={})
+
+        cfg = SimpleConfig()
+        cfg.model = SimpleConfigModel(server=server, client=client, registration=registration, auth=auth)
+        cfg.save(out_path)
+        return out_path