mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.30__py3-none-any.whl

mcp_proxy_adapter/core/client.py

@@ -14,13 +14,12 @@ import json
 import os
 import ssl
 import time
-from typing import Dict, Any, Optional, List, Union
-from urllib.parse import urljoin
 from pathlib import Path
+from typing import Any, Dict, Optional
+from urllib.parse import urljoin
 
 import aiohttp
 import requests
-from requests.exceptions import RequestException
 
 # Import security framework components
 try:
@@ -29,17 +28,11 @@ try:
         AuthManager,
         CertificateManager,
         PermissionManager,
-    )
-    from mcp_security_framework.utils import (
         generate_api_key,
         create_jwt_token,
         validate_jwt_token,
-    )
-    from mcp_security_framework.utils import (
         extract_roles_from_cert,
         validate_certificate_chain,
-    )
-    from mcp_security_framework.utils import (
         create_ssl_context,
         validate_server_certificate,
     )
@@ -47,6 +40,14 @@ try:
     SECURITY_FRAMEWORK_AVAILABLE = True
 except ImportError:
     SECURITY_FRAMEWORK_AVAILABLE = False
+    # Define stubs for missing imports
+    generate_api_key = None
+    create_jwt_token = None
+    validate_jwt_token = None
+    extract_roles_from_cert = None
+    validate_certificate_chain = None
+    create_ssl_context = None
+    validate_server_certificate = None
 
 
 class UniversalClient:

mcp_proxy_adapter/core/client_manager.py

@@ -213,14 +213,6 @@ class ClientManager:
             self.get_global_logger().error(f"Failed to get status for client {client_id}: {e}")
             return {"error": str(e)}
 
-    async def list_clients(self) -> List[str]:
-        """
-        Get list of all client identifiers.
-
-        Returns:
-            List of client identifiers
-        """
-        return list(self.clients.keys())
 
     async def cleanup(self):
         """Clean up all client connections."""
@@ -237,17 +229,6 @@ class ClientManager:
         await self.cleanup()
 
 
-def create_client_manager(config: Dict[str, Any]) -> ClientManager:
-    """
-    Create a ClientManager instance.
-
-    Args:
-        config: Client manager configuration
-
-    Returns:
-        ClientManager instance
-    """
-    return ClientManager(config)
 
 
 # Example usage and testing functions

mcp_proxy_adapter/core/client_security.py

@@ -15,7 +15,6 @@ from pathlib import Path
 
 # Import framework utilities
 try:
-    from mcp_security_framework.utils.crypto_utils import (
         generate_api_key,
         create_jwt_token,
         verify_jwt_token,
@@ -27,7 +26,6 @@ try:
         validate_certificate_format,
     )
     from mcp_security_framework.core.ssl_manager import SSLManager
-    from mcp_security_framework.schemas.config import SSLConfig, AuthConfig
     from mcp_security_framework.schemas.models import AuthResult, ValidationResult
 
     SECURITY_FRAMEWORK_AVAILABLE = True

mcp_proxy_adapter/core/config/__init__.py

@@ -0,0 +1,18 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Configuration management package for MCP Proxy Adapter.
+"""
+
+from .config import Config
+from .config_loader import ConfigLoader
+from .feature_manager import FeatureManager
+from .config_factory import ConfigFactory
+
+__all__ = [
+    "Config",
+    "ConfigLoader",
+    "FeatureManager",
+    "ConfigFactory",
+]

mcp_proxy_adapter/core/config/config.py

@@ -0,0 +1,195 @@
+"""
+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:
+            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)

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,112 @@
+"""
+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, proxy_client and auth.
+"""
+
+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:
+    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
+    log_dir: str = "./logs"
+
+
+@dataclass
+class HeartbeatConfig:
+    endpoint: str = "/heartbeat"
+    interval: int = 30
+
+
+@dataclass
+class RegistrationConfig:
+    register_endpoint: str = "/register"
+    unregister_endpoint: str = "/unregister"
+    auto_on_startup: bool = True
+    auto_on_shutdown: bool = True
+
+
+@dataclass
+class ProxyClientConfig:
+    enabled: bool = False
+    host: str = "localhost"
+    port: int = 3005
+    protocol: str = "http"
+    cert_file: Optional[str] = None
+    key_file: Optional[str] = None
+    ca_cert_file: Optional[str] = None
+    crl_file: Optional[str] = None
+    heartbeat: HeartbeatConfig = field(default_factory=HeartbeatConfig)
+    registration: RegistrationConfig = field(default_factory=RegistrationConfig)
+
+
+@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
+    proxy_client: ProxyClientConfig = field(default_factory=ProxyClientConfig)
+    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"))
+        server = ServerConfig(**content["server"])  # type: ignore[arg-type]
+        proxy_client = ProxyClientConfig(**content.get("proxy_client", {}))  # type: ignore[arg-type]
+        # Nested structures for proxy client (heartbeat/registration)
+        if isinstance(content.get("proxy_client"), dict):
+            pc = content["proxy_client"]
+            if isinstance(pc.get("heartbeat"), dict):
+                proxy_client.heartbeat = HeartbeatConfig(**pc["heartbeat"])  # type: ignore[arg-type]
+            if isinstance(pc.get("registration"), dict):
+                proxy_client.registration = RegistrationConfig(**pc["registration"])  # type: ignore[arg-type]
+        auth = AuthConfig(**content.get("auth", {}))  # type: ignore[arg-type]
+        self.model = SimpleConfigModel(server=server, proxy_client=proxy_client, 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),
+            "proxy_client": {
+                **{k: v for k, v in vars(self.model.proxy_client).items() if k not in {"heartbeat", "registration"}},
+                "heartbeat": vars(self.model.proxy_client.heartbeat),
+                "registration": vars(self.model.proxy_client.registration),
+            },
+            "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,50 @@
+"""
+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,
+    ProxyClientConfig,
+    AuthConfig,
+)
+
+
+class SimpleConfigGenerator:
+    """Generate minimal configuration according to the plan."""
+
+    def generate(self, protocol: str, with_proxy: bool = False, out_path: str = "config.json") -> str:
+        server = ServerConfig(host="0.0.0.0", port=8080, protocol=protocol)
+        if protocol in ("https", "mtls"):
+            server.cert_file = "./certs/server.crt"
+            server.key_file = "./certs/server.key"
+        if protocol == "mtls":
+            server.ca_cert_file = "./certs/ca.crt"
+
+        proxy = ProxyClientConfig(enabled=with_proxy)
+        if with_proxy:
+            proxy.protocol = protocol
+            proxy.host = "localhost"
+            proxy.port = 3005
+            if protocol in ("https", "mtls"):
+                proxy.cert_file = "./certs/client.crt"
+                proxy.key_file = "./certs/client.key"
+            if protocol == "mtls":
+                proxy.ca_cert_file = "./certs/ca.crt"
+
+        auth = AuthConfig(use_token=False, use_roles=False, tokens={}, roles={})
+
+        cfg = SimpleConfig()
+        cfg.model = SimpleConfigModel(server=server, proxy_client=proxy, auth=auth)
+        cfg.save(out_path)
+        return out_path
+
+

mcp_proxy_adapter/core/config/simple_config_validator.py

@@ -0,0 +1,96 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Simple configuration validator ensuring required fields and files exist.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import List
+
+from .simple_config import SimpleConfigModel
+
+
+@dataclass
+class ValidationError:
+    message: str
+
+
+class SimpleConfigValidator:
+    """Validate SimpleConfigModel instances."""
+
+    def validate(self, model: SimpleConfigModel) -> List[ValidationError]:
+        errors: List[ValidationError] = []
+        errors.extend(self._validate_server(model))
+        errors.extend(self._validate_proxy_client(model))
+        errors.extend(self._validate_auth(model))
+        return errors
+
+    def _validate_server(self, model: SimpleConfigModel) -> List[ValidationError]:
+        e: List[ValidationError] = []
+        s = model.server
+        if not s.host:
+            e.append(ValidationError("server.host is required"))
+        if not isinstance(s.port, int):
+            e.append(ValidationError("server.port must be integer"))
+        if s.protocol not in ("http", "https", "mtls"):
+            e.append(ValidationError("server.protocol must be one of: http, https, mtls"))
+        if s.protocol in ("https", "mtls"):
+            if not s.cert_file:
+                e.append(ValidationError(f"server.cert_file is required for {s.protocol}"))
+            if not s.key_file:
+                e.append(ValidationError(f"server.key_file is required for {s.protocol}"))
+        if s.protocol == "mtls" and not s.ca_cert_file:
+            e.append(ValidationError("server.ca_cert_file is required for mtls"))
+        # Files existence (if provided)
+        for label, path in ("cert_file", s.cert_file), ("key_file", s.key_file), ("ca_cert_file", s.ca_cert_file), ("crl_file", s.crl_file):
+            if path and not os.path.exists(path):
+                e.append(ValidationError(f"server.{label} not found: {path}"))
+        return e
+
+    def _validate_proxy_client(self, model: SimpleConfigModel) -> List[ValidationError]:
+        e: List[ValidationError] = []
+        pc = model.proxy_client
+        if pc.enabled:
+            if not pc.host:
+                e.append(ValidationError("proxy_client.host is required when enabled"))
+            if not isinstance(pc.port, int):
+                e.append(ValidationError("proxy_client.port must be integer"))
+            if pc.protocol not in ("http", "https", "mtls"):
+                e.append(ValidationError("proxy_client.protocol must be one of: http, https, mtls"))
+            if pc.protocol in ("https", "mtls"):
+                if not pc.cert_file:
+                    e.append(ValidationError(f"proxy_client.cert_file is required for {pc.protocol}"))
+                if not pc.key_file:
+                    e.append(ValidationError(f"proxy_client.key_file is required for {pc.protocol}"))
+            if pc.protocol == "mtls" and not pc.ca_cert_file:
+                e.append(ValidationError("proxy_client.ca_cert_file is required for mtls"))
+            # Files existence (if provided)
+            for label, path in ("cert_file", pc.cert_file), ("key_file", pc.key_file), ("ca_cert_file", pc.ca_cert_file), ("crl_file", pc.crl_file):
+                if path and not os.path.exists(path):
+                    e.append(ValidationError(f"proxy_client.{label} not found: {path}"))
+            # Heartbeat
+            if not pc.heartbeat.endpoint:
+                e.append(ValidationError("proxy_client.heartbeat.endpoint is required"))
+            if not isinstance(pc.heartbeat.interval, int) or pc.heartbeat.interval <= 0:
+                e.append(ValidationError("proxy_client.heartbeat.interval must be positive integer"))
+            # Registration endpoints
+            if not pc.registration.register_endpoint:
+                e.append(ValidationError("proxy_client.registration.register_endpoint is required"))
+            if not pc.registration.unregister_endpoint:
+                e.append(ValidationError("proxy_client.registration.unregister_endpoint is required"))
+        return e
+
+    def _validate_auth(self, model: SimpleConfigModel) -> List[ValidationError]:
+        e: List[ValidationError] = []
+        a = model.auth
+        if a.use_roles and not a.use_token:
+            e.append(ValidationError("auth.use_roles requires auth.use_token to be true"))
+        if a.use_token and not a.tokens:
+            e.append(ValidationError("auth.tokens must be provided when auth.use_token is true"))
+        return e
+
+