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

mcp_proxy_adapter/core/protocol_manager.py

@@ -6,8 +6,8 @@ including HTTP, HTTPS, and MTLS protocols with their respective ports.
 """
 
 import ssl
-from typing import Dict, List, Optional, Tuple, Union
 from urllib.parse import urlparse
+from typing import Dict, List, Any, Optional
 
 from mcp_proxy_adapter.config import config
 from mcp_proxy_adapter.core.logging import get_global_logger
@@ -89,49 +89,8 @@ class ProtocolManager:
             f"Protocol manager loaded config: enabled={self.enabled}, allowed_protocols={self.allowed_protocols}"
         )
 
-    def _is_ssl_enabled(self, current_config: Dict) -> bool:
-        """
-        Check if SSL is enabled in configuration.
-
-        Args:
-            current_config: Current configuration dictionary
-
-        Returns:
-            True if SSL is enabled, False otherwise
-        """
-        # Try security framework SSL config first
-        security_config = current_config.get("security", {})
-        ssl_config = security_config.get("ssl", {})
 
-        if ssl_config.get("enabled", False):
-            get_global_logger().debug("SSL enabled via security.ssl configuration")
-            return True
 
-        # Fallback to legacy SSL config
-        legacy_ssl_config = current_config.get("ssl", {})
-        if legacy_ssl_config.get("enabled", False):
-            get_global_logger().debug("SSL enabled via legacy ssl configuration")
-            return True
-
-        get_global_logger().debug("SSL is disabled in configuration")
-        return False
-
-    def update_config(self, new_config: Dict):
-        """
-        Update configuration and reload protocol settings.
-
-        Args:
-            new_config: New configuration dictionary
-        """
-        self.app_config = new_config
-        self._load_config()
-        get_global_logger().info(
-            f"Protocol manager configuration updated: allowed_protocols={self.allowed_protocols}"
-        )
-
-    def reload_config(self):
-        """Reload protocol configuration from global config."""
-        self._load_config()
 
     def is_protocol_allowed(self, protocol: str) -> bool:
         """
@@ -157,35 +116,7 @@ class ProtocolManager:
         get_global_logger().debug(f"🔍 ProtocolManager.is_protocol_allowed - Protocol '{protocol}' allowed: {is_allowed}")
         return is_allowed
 
-    def get_protocol_port(self, protocol: str) -> Optional[int]:
-        """
-        Get the configured port for a specific protocol.
 
-        Args:
-            protocol: Protocol name (http, https, mtls)
-
-        Returns:
-            Port number if configured, None otherwise
-        """
-        protocol_lower = protocol.lower()
-        protocol_config = self.protocols_config.get(protocol_lower, {})
-
-        if not protocol_config.get("enabled", False):
-            get_global_logger().debug(f"Protocol '{protocol}' is not enabled")
-            return None
-
-        port = protocol_config.get("port")
-        get_global_logger().debug(f"Protocol '{protocol}' port: {port}")
-        return port
-
-    def get_allowed_protocols(self) -> List[str]:
-        """
-        Get list of all allowed protocols.
-
-        Returns:
-            List of allowed protocol names
-        """
-        return self.allowed_protocols.copy()
 
     def get_protocol_config(self, protocol: str) -> Dict:
         """
@@ -207,33 +138,6 @@ class ProtocolManager:
                 return {}
         return {}
 
-    def validate_url_protocol(self, url: str) -> Tuple[bool, Optional[str]]:
-        """
-        Validate if the URL protocol is allowed.
-
-        Args:
-            url: URL to validate
-
-        Returns:
-            Tuple of (is_allowed, error_message)
-        """
-        try:
-            parsed = urlparse(url)
-            protocol = parsed.scheme.lower()
-
-            if not protocol:
-                return False, "No protocol specified in URL"
-
-            if not self.is_protocol_allowed(protocol):
-                return (
-                    False,
-                    f"Protocol '{protocol}' is not allowed. Allowed protocols: {self.allowed_protocols}",
-                )
-
-            return True, None
-
-        except Exception as e:
-            return False, f"Invalid URL format: {str(e)}"
 
     def get_ssl_context_for_protocol(self, protocol: str) -> Optional[ssl.SSLContext]:
         """
@@ -319,104 +223,10 @@ class ProtocolManager:
         # Return empty config if SSL is disabled
         return {"enabled": False}
 
-    def get_protocol_info(self) -> Dict[str, Dict]:
-        """
-        Get information about all configured protocols.
 
-        Returns:
-            Dictionary with protocol information
-        """
-        info = {}
-
-        for protocol in ["http", "https", "mtls"]:
-            protocol_config = self.get_protocol_config(protocol)
-            info[protocol] = {
-                "enabled": protocol_config.get("enabled", False),
-                "allowed": self.is_protocol_allowed(protocol),
-                "port": protocol_config.get("port"),
-                "requires_ssl": protocol in ["https", "mtls"],
-                "ssl_context_available": self.get_ssl_context_for_protocol(protocol)
-                is not None,
-            }
-
-        return info
-
-    def validate_protocol_configuration(self) -> List[str]:
-        """
-        Validate the current protocol configuration.
-
-        Returns:
-            List of validation errors (empty if configuration is valid)
-        """
-        errors = []
-
-        if not self.enabled:
-            return errors
-
-        # Check if allowed protocols are configured
-        for protocol in self.allowed_protocols:
-            if protocol not in ["http", "https", "mtls"]:
-                errors.append(f"Unknown protocol '{protocol}' in allowed_protocols")
-                continue
-
-            protocol_config = self.get_protocol_config(protocol)
-
-            if not protocol_config.get("enabled", False):
-                errors.append(
-                    f"Protocol '{protocol}' is in allowed_protocols but not enabled"
-                )
-                continue
-
-            port = protocol_config.get("port")
-            if not port:
-                errors.append(
-                    f"Protocol '{protocol}' is enabled but no port configured"
-                )
-                continue
-
-            # Check SSL requirements
-            if protocol in ["https", "mtls"]:
-                # Use provided config or fallback to global config
-                current_config = (
-                    self.app_config if self.app_config is not None else config.get_all()
-                )
-                ssl_config = self._get_ssl_config(current_config)
-
-                if not ssl_config.get("enabled", False):
-                    errors.append(
-                        f"Protocol '{protocol}' requires SSL but SSL is disabled"
-                    )
-                elif not ssl_config.get("cert_file") or not ssl_config.get("key_file"):
-                    errors.append(
-                        f"Protocol '{protocol}' requires SSL but certificate files not configured"
-                    )
-
-        return errors
 
 
 # Global protocol manager instance - will be updated with config when needed
 protocol_manager = None
 
 
-def get_protocol_manager(app_config: Optional[Dict] = None) -> ProtocolManager:
-    """
-    Get protocol manager instance with current configuration.
-
-    Args:
-        app_config: Application configuration dictionary (optional)
-
-    Returns:
-        ProtocolManager instance
-    """
-    global protocol_manager
-
-    # If no app_config provided, use global config
-    if app_config is None:
-        app_config = config.get_all()
-
-    # Create new instance if none exists or config changed
-    if protocol_manager is None or protocol_manager.app_config != app_config:
-        protocol_manager = ProtocolManager(app_config)
-        get_global_logger().info("Protocol manager created with new configuration")
-
-    return protocol_manager

mcp_proxy_adapter/core/proxy/__init__.py

@@ -0,0 +1,22 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Proxy registration package for MCP Proxy Adapter.
+"""
+
+from .proxy_registration_manager import ProxyRegistrationManager, ProxyRegistrationError
+from .auth_manager import AuthManager
+from .ssl_manager import SSLManager
+from .registration_client import RegistrationClient
+from .proxy_registration import initialize_proxy_registration, get_proxy_registration_status
+
+__all__ = [
+    "ProxyRegistrationManager",
+    "ProxyRegistrationError",
+    "AuthManager",
+    "SSLManager", 
+    "RegistrationClient",
+    "initialize_proxy_registration",
+    "get_proxy_registration_status",
+]

mcp_proxy_adapter/core/proxy/auth_manager.py

@@ -0,0 +1,27 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Authentication management for proxy registration.
+"""
+
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class AuthManager:
+    """Manager for authentication in proxy registration."""
+
+    def __init__(self, client_security, registration_config: Dict[str, Any]):
+        """
+        Initialize authentication manager.
+
+        Args:
+            client_security: Client security manager instance
+            registration_config: Registration configuration
+        """
+        self.client_security = client_security
+        self.registration_config = registration_config
+        self.logger = get_global_logger()
+
+

mcp_proxy_adapter/core/proxy/proxy_registration_manager.py

@@ -0,0 +1,137 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Main proxy registration manager for MCP Proxy Adapter.
+"""
+
+import time
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from mcp_proxy_adapter.core.client_security import create_client_security_manager
+from .registration_client import RegistrationClient
+
+
+class ProxyRegistrationError(Exception):
+    """Exception raised when proxy registration fails."""
+    pass
+
+
+class ProxyRegistrationManager:
+    """
+    Manager for proxy registration functionality with security framework integration.
+
+    Handles automatic registration and unregistration of the server
+    with the MCP proxy server using secure authentication methods.
+    """
+
+    def __init__(self, config: Dict[str, Any]):
+        """
+        Initialize the proxy registration manager.
+
+        Args:
+            config: Application configuration
+        """
+        self.config = config
+        self.logger = get_global_logger()
+        
+        # Get registration configuration
+        self.registration_config = config.get("proxy_registration", {})
+        
+        # Initialize client security
+        self.client_security = create_client_security_manager(config)
+        
+        # Registration state
+        self.proxy_url = self.registration_config.get("proxy_url")
+        self.server_url = None
+        self.registered = False
+        self.registration_time = None
+        
+        # Initialize registration client
+        self.registration_client = RegistrationClient(
+            self.client_security,
+            self.registration_config,
+            config,
+            self.proxy_url
+        )
+
+    def is_enabled(self) -> bool:
+        """
+        Check if proxy registration is enabled.
+
+        Returns:
+            True if enabled, False otherwise
+        """
+        return self.registration_config.get("enabled", False)
+
+
+    async def register(self) -> bool:
+        """
+        Register server with proxy.
+
+        Returns:
+            True if registration successful, False otherwise
+        """
+        if not self.is_enabled():
+            self.logger.info("Proxy registration is disabled")
+            return True
+
+        if not self.server_url:
+            self.logger.error("Server URL not set for registration")
+            return False
+
+        if not self.proxy_url:
+            self.logger.error("Proxy URL not configured")
+            return False
+
+        try:
+            self.logger.info(f"Registering with proxy: {self.proxy_url}")
+            
+            success = await self.registration_client.register(self.server_url)
+            
+            if success:
+                self.registered = True
+                self.registration_time = time.time()
+                self.logger.info("✅ Proxy registration completed successfully")
+            else:
+                self.logger.error("❌ Proxy registration failed")
+            
+            return success
+
+        except Exception as e:
+            self.logger.error(f"Registration error: {e}")
+            return False
+
+    async def unregister(self) -> bool:
+        """
+        Unregister server from proxy.
+
+        Returns:
+            True if unregistration successful, False otherwise
+        """
+        if not self.is_enabled():
+            self.logger.info("Proxy registration is disabled")
+            return True
+
+        if not self.registered:
+            self.logger.info("Server not registered, skipping unregistration")
+            return True
+
+        try:
+            self.logger.info("Unregistering from proxy")
+            
+            success = await self.registration_client.unregister()
+            
+            if success:
+                self.registered = False
+                self.registration_time = None
+                self.logger.info("✅ Proxy unregistration completed successfully")
+            else:
+                self.logger.warning("⚠️ Proxy unregistration failed")
+            
+            return success
+
+        except Exception as e:
+            self.logger.error(f"Unregistration error: {e}")
+            return False
+

mcp_proxy_adapter/core/proxy/registration_client.py

@@ -0,0 +1,60 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Registration client for proxy registration.
+"""
+
+import time
+import traceback
+
+import aiohttp
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from .auth_manager import AuthManager
+from .ssl_manager import SSLManager
+
+
+class RegistrationClient:
+    """Client for proxy registration operations."""
+
+    def __init__(self, client_security, registration_config: Dict[str, Any], config: Dict[str, Any], proxy_url: str):
+        """
+        Initialize registration client.
+
+        Args:
+            client_security: Client security manager instance
+            registration_config: Registration configuration
+            config: Application configuration
+            proxy_url: Proxy server URL
+        """
+        self.client_security = client_security
+        self.registration_config = registration_config
+        self.config = config
+        self.proxy_url = proxy_url
+        self.logger = get_global_logger()
+        
+        # Initialize managers
+        self.auth_manager = AuthManager(client_security, registration_config)
+        self.ssl_manager = SSLManager(client_security, registration_config, config, proxy_url)
+
+
+
+    def _prepare_registration_data(self, server_url: str) -> Dict[str, Any]:
+        """
+        Prepare registration data.
+
+        Args:
+            server_url: Server URL to register
+
+        Returns:
+            Registration data dictionary
+        """
+        return {
+            "server_id": self.registration_config.get("server_id"),
+            "server_name": self.registration_config.get("server_name"),
+            "server_url": server_url,
+            "description": self.registration_config.get("description", ""),
+            "version": self.registration_config.get("version", "1.0.0"),
+            "capabilities": self.registration_config.get("capabilities", []),
+        }

mcp_proxy_adapter/core/proxy/ssl_manager.py

@@ -0,0 +1,101 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+SSL management for proxy registration.
+"""
+
+import ssl
+from typing import Dict, Any, Optional
+from urllib.parse import urlparse
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class SSLManager:
+    """Manager for SSL connections in proxy registration."""
+
+    def __init__(self, client_security, registration_config: Dict[str, Any], config: Dict[str, Any], proxy_url: str):
+        """
+        Initialize SSL manager.
+
+        Args:
+            client_security: Client security manager instance
+            registration_config: Registration configuration
+            config: Application configuration
+            proxy_url: Proxy server URL
+        """
+        self.client_security = client_security
+        self.registration_config = registration_config
+        self.config = config
+        self.proxy_url = proxy_url
+        self.logger = get_global_logger()
+
+    def create_ssl_context(self) -> Optional[ssl.SSLContext]:
+        """
+        Create SSL context for secure connections using registration SSL configuration.
+
+        Returns:
+            SSL context or None if SSL not needed
+        """
+        self.logger.debug("_create_ssl_context called")
+        
+        # Decide SSL strictly by proxy URL scheme: use SSL only for https proxy URLs
+        try:
+            scheme = urlparse(self.proxy_url).scheme if self.proxy_url else "http"
+            if scheme.lower() != "https":
+                self.logger.debug("Proxy URL is HTTP, skipping SSL context creation for registration")
+                return None
+        except Exception:
+            self.logger.debug("Failed to parse proxy_url, assuming HTTP and skipping SSL context")
+            return None
+            
+        if not self.client_security:
+            self.logger.debug("SSL context creation failed: client_security is None")
+            return None
+
+        try:
+            # Check if SSL is enabled for registration
+            cert_config = self.registration_config.get("certificate", {})
+            ssl_config = self.registration_config.get("ssl", {})
+
+            # FALLBACK: if no explicit registration SSL/certs provided, reuse global SSL config
+            if not cert_config and not ssl_config:
+                global_ssl = self.config.get("security", {}).get("ssl", {}) or self.config.get("ssl", {})
+                if global_ssl:
+                    # Map global ssl to registration-style configs
+                    mapped_cert = {}
+                    if global_ssl.get("cert_file") and global_ssl.get("key_file"):
+                        mapped_cert = {
+                            "cert_file": global_ssl.get("cert_file"),
+                            "key_file": global_ssl.get("key_file"),
+                        }
+                    mapped_ssl = {}
+                    if global_ssl.get("ca_cert"):
+                        mapped_ssl["ca_cert"] = global_ssl.get("ca_cert")
+                    if global_ssl.get("verify_client") is not None:
+                        mapped_ssl["verify_mode"] = (
+                            "CERT_REQUIRED" if global_ssl.get("verify_client") else "CERT_NONE"
+                        )
+                    cert_config = mapped_cert
+                    ssl_config = mapped_ssl
+
+            # Use client security manager to create SSL context
+            if cert_config or ssl_config:
+                ssl_context = self.client_security.create_ssl_context(
+                    cert_config=cert_config,
+                    ssl_config=ssl_config
+                )
+                if ssl_context:
+                    self.logger.debug("SSL context created successfully for registration")
+                    return ssl_context
+                else:
+                    self.logger.warning("Failed to create SSL context for registration")
+                    return None
+            else:
+                self.logger.debug("No SSL configuration found for registration")
+                return None
+
+        except Exception as e:
+            self.logger.error(f"Error creating SSL context for registration: {e}")
+            return None

mcp_proxy_adapter/core/proxy_client.py

@@ -12,7 +12,6 @@ mutual TLS. Designed to be used by services built on this framework to:
 This client intentionally avoids framework-specific configuration objects and
 accepts explicit parameters for clarity and portability.
 """
-from __future__ import annotations
 
 import json
 import ssl