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

mcp_proxy_adapter/core/transport_manager.py

@@ -54,80 +54,7 @@ class TransportManager:
         self._config: Optional[TransportConfig] = None
         self._current_transport: Optional[TransportType] = None
 
-    def load_config(self, config: Dict[str, Any]) -> bool:
-        """
-        Load transport configuration from config dict.
-
-        Args:
-            config: Configuration dictionary
 
-        Returns:
-            True if config loaded successfully, False otherwise
-        """
-        try:
-            transport_config = config.get("transport", {})
-
-            # Get transport type
-            transport_type_str = transport_config.get("type", "http").lower()
-            try:
-                transport_type = TransportType(transport_type_str)
-            except ValueError:
-                get_global_logger().error(f"Invalid transport type: {transport_type_str}")
-                return False
-
-            # Get port (use default if not specified)
-            port = transport_config.get("port")
-            if port is None:
-                port = self.DEFAULT_PORTS.get(transport_type, 8000)
-
-            # Get SSL configuration
-            ssl_config = transport_config.get("ssl", {})
-            ssl_enabled = ssl_config.get("enabled", False)
-
-            # Validate SSL requirements
-            if (
-                transport_type in [TransportType.HTTPS, TransportType.MTLS]
-                and not ssl_enabled
-            ):
-                get_global_logger().error(
-                    f"SSL must be enabled for transport type: {transport_type.value}"
-                )
-                return False
-
-            if transport_type == TransportType.HTTP and ssl_enabled:
-                get_global_logger().warning("SSL enabled for HTTP transport - this may cause issues")
-
-            # Create transport config
-            self._config = TransportConfig(
-                type=transport_type,
-                port=port,
-                ssl_enabled=ssl_enabled,
-                cert_file=ssl_config.get("cert_file") if ssl_enabled else None,
-                key_file=ssl_config.get("key_file") if ssl_enabled else None,
-                ca_cert=ssl_config.get("ca_cert") if ssl_enabled else None,
-                verify_client=ssl_config.get("verify_client", False),
-                client_cert_required=ssl_config.get("client_cert_required", False),
-            )
-
-            self._current_transport = transport_type
-
-            get_global_logger().info(
-                f"Transport config loaded: {transport_type.value} on port {port}"
-            )
-            return True
-
-        except Exception as e:
-            get_global_logger().error(f"Failed to load transport config: {e}")
-            return False
-
-    def get_transport_type(self) -> Optional[TransportType]:
-        """
-        Get current transport type.
-
-        Returns:
-            Current transport type or None if not configured
-        """
-        return self._current_transport
 
     def get_port(self) -> Optional[int]:
         """
@@ -192,63 +119,7 @@ class TransportManager:
         """
         return self._current_transport == TransportType.HTTP
 
-    def get_transport_info(self) -> Dict[str, Any]:
-        """
-        Get transport information.
-
-        Returns:
-            Dictionary with transport information
-        """
-        if not self._config:
-            return {"error": "Transport not configured"}
-
-        return {
-            "type": self._config.type.value,
-            "port": self._config.port,
-            "ssl_enabled": self._config.ssl_enabled,
-            "is_mtls": self.is_mtls(),
-            "is_https": self.is_https(),
-            "is_http": self.is_http(),
-            "ssl_config": self.get_ssl_config(),
-        }
-
-    def validate_config(self) -> bool:
-        """
-        Validate current transport configuration.
-
-        Returns:
-            True if configuration is valid, False otherwise
-        """
-        if not self._config:
-            get_global_logger().error("Transport not configured")
-            return False
-
-        # Validate SSL requirements
-        if self._config.type in [TransportType.HTTPS, TransportType.MTLS]:
-            if not self._config.ssl_enabled:
-                get_global_logger().error(f"SSL must be enabled for {self._config.type.value}")
-                return False
-
-            if not self._config.cert_file or not self._config.key_file:
-                get_global_logger().error(
-                    f"SSL certificate and key required for {self._config.type.value}"
-                )
-                return False
-
-        # Validate SSL files exist
-        if not self.validate_ssl_files():
-            return False
-
-        # Validate MTLS requirements
-        if self._config.type == TransportType.MTLS:
-            if not self._config.verify_client:
-                get_global_logger().warning("MTLS transport should have client verification enabled")
 
-            if not self._config.ca_cert:
-                get_global_logger().warning("CA certificate recommended for MTLS transport")
-
-        get_global_logger().info(f"Transport configuration validated: {self._config.type.value}")
-        return True
 
     def validate_ssl_files(self) -> bool:
         """
@@ -276,28 +147,6 @@ class TransportManager:
         get_global_logger().info(f"All SSL files validated successfully: {files_to_check}")
         return True
 
-    def get_hypercorn_config(self) -> Dict[str, Any]:
-        """
-        Get configuration for hypercorn.
-
-        Returns:
-            Hypercorn configuration dictionary
-        """
-        config = {
-            "host": "0.0.0.0",  # Can be moved to settings
-            "port": self.get_port(),
-            "log_level": "info",
-        }
-
-        if self.is_ssl_enabled():
-            ssl_config = self.get_ssl_config()
-            if ssl_config:
-                from mcp_proxy_adapter.core.ssl_utils import SSLUtils
-
-                hypercorn_ssl = SSLUtils.get_ssl_config_for_hypercorn(ssl_config)
-                config.update(hypercorn_ssl)
-
-        return config
 
 
 # Global transport manager instance

mcp_proxy_adapter/core/unified_config_adapter.py

@@ -10,9 +10,9 @@ to SecurityConfig format used by mcp_security_framework.
 
 import json
 import logging
-from typing import Dict, Any, Optional, List, Union
 from pathlib import Path
 from dataclasses import dataclass
+from typing import List, Dict, Any
 
 # Import mcp_security_framework components
 try:
@@ -70,53 +70,6 @@ class UnifiedConfigAdapter:
         self.validation_errors = []
         self.validation_warnings = []
 
-    def convert_to_security_config(
-        self, config: Dict[str, Any]
-    ) -> Optional[SecurityConfig]:
-        """
-        Convert mcp_proxy_adapter configuration to SecurityConfig.
-
-        Args:
-            config: mcp_proxy_adapter configuration dictionary
-
-        Returns:
-            SecurityConfig instance or None if conversion failed
-        """
-        if not SECURITY_FRAMEWORK_AVAILABLE:
-            get_global_logger().error(
-                "mcp_security_framework not available, cannot convert configuration"
-            )
-            return None
-
-        try:
-            # Validate configuration first
-            validation_result = self.validate_configuration(config)
-            if not validation_result.is_valid:
-                get_global_logger().error(
-                    f"Configuration validation failed: {validation_result.errors}"
-                )
-                return None
-
-            # Convert configuration sections
-            auth_config = self._convert_auth_config(config)
-            ssl_config = self._convert_ssl_config(config)
-            permission_config = self._convert_permission_config(config)
-            rate_limit_config = self._convert_rate_limit_config(config)
-
-            # Create SecurityConfig
-            security_config = SecurityConfig(
-                auth=auth_config,
-                ssl=ssl_config,
-                permissions=permission_config,
-                rate_limit=rate_limit_config,
-            )
-
-            get_global_logger().info("Configuration successfully converted to SecurityConfig")
-            return security_config
-
-        except Exception as e:
-            get_global_logger().error(f"Failed to convert configuration: {e}")
-            return None
 
     def validate_configuration(self, config: Dict[str, Any]) -> ValidationResult:
         """
@@ -479,151 +432,6 @@ class UnifiedConfigAdapter:
 
         return rate_limit_config
 
-    def get_public_paths(self, config: Dict[str, Any]) -> List[str]:
-        """
-        Get public paths from configuration.
 
-        Args:
-            config: Configuration dictionary
 
-        Returns:
-            List of public paths
-        """
-        security_config = config.get("security", {})
-
-        # Ensure security_config is a dictionary
-        if not isinstance(security_config, dict):
-            return ["/health", "/docs", "/redoc", "/openapi.json", "/favicon.ico"]
-
-        public_paths = security_config.get("public_paths", [])
-
-        # Add default public paths if none specified
-        if not public_paths:
-            public_paths = [
-                "/health",
-                "/docs",
-                "/redoc",
-                "/openapi.json",
-                "/favicon.ico",
-            ]
 
-        return public_paths
-
-    def get_security_enabled(self, config: Dict[str, Any]) -> bool:
-        """
-        Check if security is enabled in configuration.
-
-        Args:
-            config: Configuration dictionary
-
-        Returns:
-            True if security is enabled
-        """
-        security_config = config.get("security", {})
-
-        # Ensure security_config is a dictionary
-        if not isinstance(security_config, dict):
-            return True  # Default to enabled for safety
-
-        return security_config.get("enabled", True)
-
-    def migrate_legacy_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Migrate legacy configuration to new format.
-
-        Args:
-            config: Legacy configuration dictionary
-
-        Returns:
-            Migrated configuration dictionary
-        """
-        migrated_config = config.copy()
-
-        # Create security section if it doesn't exist
-        if "security" not in migrated_config:
-            migrated_config["security"] = {}
-
-        security_config = migrated_config["security"]
-
-        # Migrate SSL configuration
-        if "ssl" in migrated_config and "ssl" not in security_config:
-            security_config["ssl"] = migrated_config["ssl"]
-            # Don't remove legacy SSL yet for backward compatibility
-
-        # Migrate roles configuration
-        if "roles" in migrated_config and "permissions" not in security_config:
-            security_config["permissions"] = migrated_config["roles"]
-            # Don't remove legacy roles yet for backward compatibility
-
-        # Migrate auth_enabled flag
-        if "auth_enabled" in migrated_config and "auth" not in security_config:
-            security_config["auth"] = {"enabled": migrated_config["auth_enabled"]}
-
-        # Migrate rate_limit_enabled flag
-        if (
-            "rate_limit_enabled" in migrated_config
-            and "rate_limit" not in security_config
-        ):
-            security_config["rate_limit"] = {
-                "enabled": migrated_config["rate_limit_enabled"]
-            }
-
-        get_global_logger().info("Legacy configuration migrated to new format")
-        return migrated_config
-
-    def get_default_config(self) -> Dict[str, Any]:
-        """
-        Get default configuration.
-
-        Returns:
-            Default configuration dictionary
-        """
-        return {
-            "security": {
-                "enabled": True,
-                "auth": {
-                    "enabled": True,
-                    "methods": ["api_key"],
-                    "api_keys": {},
-                    "jwt_secret": "",
-                    "jwt_algorithm": "HS256",
-                    "jwt_expiration": 3600,
-                },
-                "ssl": {
-                    "enabled": False,
-                    "cert_file": None,
-                    "key_file": None,
-                    "ca_cert": None,
-                    "min_tls_version": "TLSv1.2",
-                    "verify_client": False,
-                    "client_cert_required": False,
-                    "cipher_suites": [],
-                },
-                "permissions": {
-                    "enabled": True,
-                    "roles_file": "roles.json",
-                    "default_role": "user",
-                    "deny_by_default": True,
-                    "role_mappings": {},
-                },
-                "rate_limit": {
-                    "enabled": True,
-                    "requests_per_minute": 60,
-                    "requests_per_hour": 1000,
-                    "requests_per_day": 10000,
-                    "burst_limit": 10,
-                    "by_ip": True,
-                    "by_user": True,
-                    "by_endpoint": False,
-                    "exempt_roles": [],
-                    "exempt_endpoints": [],
-                },
-                "public_paths": [
-                    "/health",
-                    "/docs",
-                    "/redoc",
-                    "/openapi.json",
-                    "/favicon.ico",
-                ],
-            }
-        }

mcp_proxy_adapter/core/utils.py

@@ -10,135 +10,25 @@ import sys
 import time
 import uuid
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Optional, Dict, Any, List
 
 from mcp_proxy_adapter.core.logging import get_global_logger
 
 
-def generate_id() -> str:
-    """
-    Generates a unique identifier.
 
-    Returns:
-        String with unique identifier.
-    """
-    return str(uuid.uuid4())
 
 
-def get_timestamp() -> int:
-    """
-    Returns current timestamp in milliseconds.
 
-    Returns:
-        Integer - timestamp in milliseconds.
-    """
-    return int(time.time() * 1000)
 
 
-def format_datetime(
-    dt: Optional[datetime] = None, format_str: str = "%Y-%m-%dT%H:%M:%S.%fZ"
-) -> str:
-    """
-    Formats date and time as string.
 
-    Args:
-        dt: Datetime object to format. If None, current time is used.
-        format_str: Format string for output.
 
-    Returns:
-        Formatted date/time string.
-    """
-    dt = dt or datetime.now(timezone.utc)
-    return dt.strftime(format_str)
 
 
-def parse_datetime(dt_str: str, format_str: str = "%Y-%m-%dT%H:%M:%S.%fZ") -> datetime:
-    """
-    Parses date/time string into datetime object.
 
-    Args:
-        dt_str: Date/time string.
-        format_str: Date/time string format.
 
-    Returns:
-        Datetime object.
-    """
-    return datetime.strptime(dt_str, format_str)
 
 
-def safe_json_loads(s: str, default: Any = None) -> Any:
-    """
-    Safe JSON string loading.
-
-    Args:
-        s: JSON string to load.
-        default: Default value on parsing error.
-
-    Returns:
-        Loaded object or default value on error.
-    """
-    try:
-        return json.loads(s)
-    except Exception as e:
-        get_global_logger().error(f"Error parsing JSON: {e}")
-        return default
-
-
-def safe_json_dumps(obj: Any, default: str = "{}", indent: Optional[int] = None) -> str:
-    """
-    Safe object conversion to JSON string.
-
-    Args:
-        obj: Object to convert.
-        default: Default string on serialization error.
-        indent: Indentation for JSON formatting.
-
-    Returns:
-        JSON string or default string on error.
-    """
-    try:
-        return json.dumps(obj, ensure_ascii=False, indent=indent)
-    except Exception as e:
-        get_global_logger().error(f"Error serializing to JSON: {e}")
-        return default
-
-
-def calculate_hash(data: Union[str, bytes], algorithm: str = "sha256") -> str:
-    """
-    Calculates hash for data.
-
-    Args:
-        data: Data to hash (string or bytes).
-        algorithm: Hashing algorithm (md5, sha1, sha256, etc.).
-
-    Returns:
-        String with hash in hexadecimal format.
-    """
-    if isinstance(data, str):
-        data = data.encode("utf-8")
-
-    hash_obj = hashlib.new(algorithm)
-    hash_obj.update(data)
-    return hash_obj.hexdigest()
-
-
-def ensure_directory(path: str) -> bool:
-    """
-    Checks directory existence and creates it if necessary.
-
-    Args:
-        path: Path to directory.
-
-    Returns:
-        True if directory exists or was successfully created, otherwise False.
-    """
-    try:
-        if not os.path.exists(path):
-            os.makedirs(path, exist_ok=True)
-        return True
-    except Exception as e:
-        get_global_logger().error(f"Error creating directory {path}: {e}")
-        return False
 
 
 def check_port_availability(host: str, port: int, timeout: float = 1.0) -> bool:
@@ -207,76 +97,5 @@ def get_port_usage_info(port: int) -> str:
         return f"Port {port} is in use (unable to get process info: {e})"
 
 
-def handle_port_conflict(host: str, port: int) -> None:
-    """
-    Handles port conflict with user-friendly error message and suggestions.
-    This is for MAIN server port conflicts - application must exit.
-    
-    Args:
-        host: Host address
-        port: Port number that's in conflict
-    """
-    print(f"❌ ERROR: Port {port} is already in use on {host}")
-    print(f"💡 Suggestions:")
-    print(f"   1. Choose a different port: --port <different_port>")
-    print(f"   2. Stop the conflicting service")
-    print(f"   3. Check what's using the port:")
-    print(f"      lsof -i :{port}")
-    print(f"      netstat -tulpn | grep :{port}")
-    
-    # Try to get more detailed info about port usage
-    usage_info = get_port_usage_info(port)
-    print(f"🔍 Port usage details:")
-    print(f"   {usage_info}")
-    
-    # Try to find an alternative port
-    alt_port = find_available_port(host, port + 1, 10)
-    if alt_port:
-        print(f"💡 Alternative port suggestion: {alt_port}")
-        print(f"   Try: --port {alt_port}")
-    else:
-        print(f"💡 Try ports in range {port + 1}-{port + 20}")
-    
-    print(f"🛑 Application cannot start due to port conflict")
-    sys.exit(1)
 
 
-def find_port_for_internal_server(host: str, preferred_port: int) -> int:
-    """
-    Finds an available port for internal server (mTLS, etc.).
-    If preferred port is occupied, finds any available port.
-    
-    Args:
-        host: Host address
-        preferred_port: Preferred port number
-        
-    Returns:
-        Available port number
-    """
-    # First try the preferred port
-    if check_port_availability(host, preferred_port):
-        print(f"✅ Internal server port {preferred_port} is available")
-        return preferred_port
-    
-    # If preferred port is occupied, find any available port
-    print(f"⚠️  Internal server preferred port {preferred_port} is occupied, searching for alternative...")
-    
-    alt_port = find_available_port(host, preferred_port + 1, 50)
-    if alt_port:
-        print(f"✅ Found alternative port for internal server: {alt_port}")
-        return alt_port
-    
-    # If no port found in range, try from 9000
-    alt_port = find_available_port(host, 9000, 100)
-    if alt_port:
-        print(f"✅ Found alternative port for internal server: {alt_port}")
-        return alt_port
-    
-    # Last resort - try from 10000
-    alt_port = find_available_port(host, 10000, 100)
-    if alt_port:
-        print(f"✅ Found alternative port for internal server: {alt_port}")
-        return alt_port
-    
-    # If still no port found, raise error
-    raise RuntimeError(f"Unable to find available port for internal server on {host}")

mcp_proxy_adapter/core/validation/__init__.py

@@ -0,0 +1,21 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Configuration validation package for MCP Proxy Adapter.
+"""
+
+from .config_validator import ConfigValidator
+from .validation_result import ValidationResult, ValidationLevel
+from .file_validator import FileValidator
+from .security_validator import SecurityValidator
+from .protocol_validator import ProtocolValidator
+
+__all__ = [
+    "ConfigValidator",
+    "ValidationResult", 
+    "ValidationLevel",
+    "FileValidator",
+    "SecurityValidator",
+    "ProtocolValidator",
+]