mcp-proxy-adapter 6.1.1__py3-none-any.whl → 6.2.0__py3-none-any.whl

mcp_proxy_adapter/core/client_manager.py

@@ -0,0 +1,284 @@
+"""
+Client Manager for MCP Proxy Adapter Framework
+
+This module provides client management functionality for the MCP Proxy Adapter framework.
+It handles client creation, connection management, and proxy registration.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import json
+import logging
+from typing import Dict, Any, Optional, List
+from pathlib import Path
+
+from .client import UniversalClient, create_client_from_config
+
+
+class ClientManager:
+    """
+    Manages client connections and proxy registrations.
+    
+    This class provides functionality for:
+    - Creating and managing client connections
+    - Proxy registration
+    - Connection pooling
+    - Authentication management
+    """
+    
+    def __init__(self, config: Dict[str, Any]):
+        """
+        Initialize client manager.
+        
+        Args:
+            config: Client manager configuration
+        """
+        self.config = config
+        self.logger = logging.getLogger(__name__)
+        self.clients: Dict[str, UniversalClient] = {}
+        self.connection_pool: Dict[str, UniversalClient] = {}
+        
+        # Client manager settings
+        self.max_connections = config.get("max_connections", 10)
+        self.connection_timeout = config.get("connection_timeout", 30)
+        self.retry_attempts = config.get("retry_attempts", 3)
+        self.retry_delay = config.get("retry_delay", 1)
+        
+        self.logger.info("Client manager initialized")
+    
+    async def create_client(self, client_id: str, config_file: str) -> UniversalClient:
+        """
+        Create a new client instance.
+        
+        Args:
+            client_id: Unique identifier for the client
+            config_file: Path to client configuration file
+            
+        Returns:
+            UniversalClient instance
+        """
+        try:
+            if client_id in self.clients:
+                self.logger.warning(f"Client {client_id} already exists, reusing existing connection")
+                return self.clients[client_id]
+            
+            client = create_client_from_config(config_file)
+            self.clients[client_id] = client
+            
+            self.logger.info(f"Client {client_id} created successfully")
+            return client
+            
+        except Exception as e:
+            self.logger.error(f"Failed to create client {client_id}: {e}")
+            raise
+    
+    async def get_client(self, client_id: str) -> Optional[UniversalClient]:
+        """
+        Get an existing client instance.
+        
+        Args:
+            client_id: Client identifier
+            
+        Returns:
+            UniversalClient instance or None if not found
+        """
+        return self.clients.get(client_id)
+    
+    async def remove_client(self, client_id: str) -> bool:
+        """
+        Remove a client instance.
+        
+        Args:
+            client_id: Client identifier
+            
+        Returns:
+            True if client was removed, False otherwise
+        """
+        if client_id in self.clients:
+            client = self.clients[client_id]
+            await client.disconnect()
+            del self.clients[client_id]
+            self.logger.info(f"Client {client_id} removed")
+            return True
+        return False
+    
+    async def test_client_connection(self, client_id: str) -> bool:
+        """
+        Test connection for a specific client.
+        
+        Args:
+            client_id: Client identifier
+            
+        Returns:
+            True if connection is successful, False otherwise
+        """
+        client = await self.get_client(client_id)
+        if not client:
+            self.logger.error(f"Client {client_id} not found")
+            return False
+        
+        try:
+            return await client.test_connection()
+        except Exception as e:
+            self.logger.error(f"Connection test failed for client {client_id}: {e}")
+            return False
+    
+    async def register_proxy(self, client_id: str, proxy_config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Register with proxy server using a specific client.
+        
+        Args:
+            client_id: Client identifier
+            proxy_config: Proxy registration configuration
+            
+        Returns:
+            Registration result
+        """
+        client = await self.get_client(client_id)
+        if not client:
+            return {"error": f"Client {client_id} not found"}
+        
+        try:
+            result = await client.register_proxy(proxy_config)
+            self.logger.info(f"Proxy registration completed for client {client_id}")
+            return result
+        except Exception as e:
+            self.logger.error(f"Proxy registration failed for client {client_id}: {e}")
+            return {"error": str(e)}
+    
+    async def execute_command(self, client_id: str, command: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        Execute a command using a specific client.
+        
+        Args:
+            client_id: Client identifier
+            command: Command name
+            params: Command parameters
+            
+        Returns:
+            Command result
+        """
+        client = await self.get_client(client_id)
+        if not client:
+            return {"error": f"Client {client_id} not found"}
+        
+        try:
+            result = await client.execute_command(command, params or {})
+            self.logger.info(f"Command {command} executed for client {client_id}")
+            return result
+        except Exception as e:
+            self.logger.error(f"Command execution failed for client {client_id}: {e}")
+            return {"error": str(e)}
+    
+    async def get_client_status(self, client_id: str) -> Dict[str, Any]:
+        """
+        Get status information for a specific client.
+        
+        Args:
+            client_id: Client identifier
+            
+        Returns:
+            Client status information
+        """
+        client = await self.get_client(client_id)
+        if not client:
+            return {"error": f"Client {client_id} not found"}
+        
+        try:
+            # Test connection
+            connection_ok = await client.test_connection()
+            
+            # Test security features
+            security_features = await client.test_security_features()
+            
+            status = {
+                "client_id": client_id,
+                "base_url": client.base_url,
+                "auth_method": client.auth_method,
+                "connection_ok": connection_ok,
+                "security_features": security_features,
+                "session_active": client.session is not None
+            }
+            
+            return status
+        except Exception as e:
+            self.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."""
+        for client_id in list(self.clients.keys()):
+            await self.remove_client(client_id)
+        self.logger.info("All client connections cleaned up")
+    
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        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
+async def test_client_manager():
+    """Test client manager functionality."""
+    # Example configuration
+    config = {
+        "max_connections": 5,
+        "connection_timeout": 30,
+        "retry_attempts": 3,
+        "retry_delay": 1
+    }
+    
+    async with ClientManager(config) as manager:
+        # Create a client
+        client_id = "test_client"
+        config_file = "configs/http_simple.json"
+        
+        try:
+            client = await manager.create_client(client_id, config_file)
+            print(f"✅ Client {client_id} created successfully")
+            
+            # Test connection
+            connection_ok = await manager.test_client_connection(client_id)
+            print(f"✅ Connection test: {connection_ok}")
+            
+            # Get status
+            status = await manager.get_client_status(client_id)
+            print(f"✅ Client status: {json.dumps(status, indent=2)}")
+            
+            # Execute command
+            result = await manager.execute_command(client_id, "help")
+            print(f"✅ Command result: {json.dumps(result, indent=2)}")
+            
+        except Exception as e:
+            print(f"❌ Test failed: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_client_manager())

mcp_proxy_adapter/core/server_adapter.py

@@ -35,7 +35,7 @@ class ServerConfigAdapter:
         
         Args:
             ssl_config: Source SSL configuration
-            target_engine: Target engine name (uvicorn, hypercorn, etc.)
+            target_engine: Target engine name (hypercorn)
             
         Returns:
             Converted SSL configuration for the target engine
@@ -45,35 +45,12 @@ class ServerConfigAdapter:
             logger.error(f"Unknown server engine: {target_engine}")
             return {}
         
-        if target_engine == "uvicorn":
-            return ServerConfigAdapter._convert_to_uvicorn_ssl(ssl_config)
-        elif target_engine == "hypercorn":
+        if target_engine == "hypercorn":
             return ServerConfigAdapter._convert_to_hypercorn_ssl(ssl_config)
         else:
             logger.warning(f"No SSL conversion available for engine: {target_engine}")
             return {}
     
-    @staticmethod
-    def _convert_to_uvicorn_ssl(ssl_config: Dict[str, Any]) -> Dict[str, Any]:
-        """Convert SSL configuration to uvicorn format."""
-        uvicorn_ssl = {}
-        
-        # Map SSL parameters
-        if ssl_config.get("cert_file"):
-            uvicorn_ssl["ssl_certfile"] = ssl_config["cert_file"]
-        if ssl_config.get("key_file"):
-            uvicorn_ssl["ssl_keyfile"] = ssl_config["key_file"]
-        if ssl_config.get("ca_cert"):
-            uvicorn_ssl["ssl_ca_certs"] = ssl_config["ca_cert"]
-        
-        # Map verification mode
-        if ssl_config.get("verify_client", False):
-            import ssl
-            uvicorn_ssl["ssl_cert_reqs"] = ssl.CERT_REQUIRED
-        
-        logger.debug(f"Converted SSL config to uvicorn: {uvicorn_ssl}")
-        return uvicorn_ssl
-    
     @staticmethod
     def _convert_to_hypercorn_ssl(ssl_config: Dict[str, Any]) -> Dict[str, Any]:
         """Convert SSL configuration to hypercorn format."""
@@ -99,49 +76,16 @@ class ServerConfigAdapter:
         """
         Determine the optimal server engine for a given configuration.
         
+        Currently only hypercorn is supported.
+        
         Args:
             config: Server configuration
             
         Returns:
-            Name of the optimal engine or None if no suitable engine found
+            Optimal engine name (currently always "hypercorn")
         """
-        # Check if mTLS is required
-        ssl_config = config.get("ssl", {})
-        if not ssl_config:
-            # Try to get SSL config from security section
-            ssl_config = config.get("security", {}).get("ssl", {})
-        
-        # Prefer hypercorn for all SSL/TLS scenarios due to better mTLS support
-        if ssl_config.get("enabled", False):
-            engine = ServerEngineFactory.get_engine("hypercorn")
-            if engine:
-                logger.info("Selected hypercorn for SSL/TLS support (better mTLS capabilities)")
-                return engine.get_name()
-            else:
-                logger.warning("SSL enabled but hypercorn not available")
-        
-        # For mTLS client verification, hypercorn is required
-        if ssl_config.get("verify_client", False) or ssl_config.get("client_cert_required", False):
-            engine = ServerEngineFactory.get_engine_with_feature("mtls_client_certs")
-            if engine:
-                logger.info(f"Selected {engine.get_name()} for mTLS support")
-                return engine.get_name()
-            else:
-                logger.warning("mTLS required but no suitable engine available")
-                return None
-        
-        # Default to hypercorn for better async support, fallback to uvicorn
-        engine = ServerEngineFactory.get_engine("hypercorn")
-        if engine:
-            logger.info("Selected hypercorn as default engine (better async support)")
-            return engine.get_name()
-        
-        engine = ServerEngineFactory.get_engine("uvicorn")
-        if engine:
-            logger.info("Selected uvicorn as fallback engine")
-            return "uvicorn"
-        
-        return None
+        # Currently only hypercorn is supported
+        return "hypercorn"
     
     @staticmethod
     def validate_engine_compatibility(
@@ -201,19 +145,18 @@ class ServerConfigAdapter:
 
 class UnifiedServerRunner:
     """
-    Unified server runner that abstracts the choice of server engine.
+    Unified server runner that uses hypercorn as the default engine.
     
-    This class provides a unified interface for running servers regardless
-    of the underlying engine, automatically selecting the best engine
-    for the given configuration.
+    This class provides a unified interface for running servers using hypercorn
+    as the underlying engine.
     """
     
-    def __init__(self, default_engine: str = "uvicorn"):
+    def __init__(self, default_engine: str = "hypercorn"):
         """
         Initialize the unified server runner.
         
         Args:
-            default_engine: Default engine to use if no specific requirements
+            default_engine: Default engine to use (currently only hypercorn is supported)
         """
         self.default_engine = default_engine
         self.available_engines = ServerEngineFactory.get_available_engines()
@@ -228,22 +171,16 @@ class UnifiedServerRunner:
         engine_name: Optional[str] = None
     ) -> None:
         """
-        Run server with the specified or optimal engine.
+        Run server with hypercorn engine.
         
         Args:
             app: ASGI application
             config: Server configuration
-            engine_name: Specific engine to use (optional)
+            engine_name: Engine to use (currently only hypercorn is supported)
         """
-        # Determine which engine to use
-        if engine_name:
-            selected_engine = engine_name
-            logger.info(f"Using specified engine: {selected_engine}")
-        else:
-            selected_engine = ServerConfigAdapter.get_optimal_engine_for_config(config)
-            if not selected_engine:
-                selected_engine = self.default_engine
-                logger.info(f"Using default engine: {selected_engine}")
+        # Use hypercorn as the only supported engine
+        selected_engine = "hypercorn"
+        logger.info(f"Using hypercorn engine")
         
         # Validate compatibility
         if not ServerConfigAdapter.validate_engine_compatibility(config, selected_engine):

mcp_proxy_adapter/core/server_engine.py

@@ -1,8 +1,8 @@
 """
 Server Engine Abstraction
 
-This module provides an abstraction layer for different ASGI server engines,
-allowing easy switching between uvicorn, hypercorn, and other servers.
+This module provides an abstraction layer for the hypercorn ASGI server engine,
+providing full mTLS support and SSL capabilities.
 
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
@@ -74,97 +74,6 @@ class ServerEngine(ABC):
         pass
 
 
-class UvicornEngine(ServerEngine):
-    """
-    Uvicorn server engine implementation.
-    
-    Provides basic SSL/TLS support but limited mTLS capabilities.
-    """
-    
-    def get_name(self) -> str:
-        return "uvicorn"
-    
-    def get_supported_features(self) -> Dict[str, bool]:
-        return {
-            "ssl_tls": True,
-            "mtls_client_certs": False,  # Limited support
-            "ssl_scope_info": False,     # No SSL info in request scope
-            "client_cert_verification": False,
-            "websockets": True,
-            "http2": True,
-            "reload": True
-        }
-    
-    def get_config_schema(self) -> Dict[str, Any]:
-        return {
-            "host": {"type": "string", "default": "127.0.0.1"},
-            "port": {"type": "integer", "default": 8000},
-            "log_level": {"type": "string", "default": "info"},
-            "ssl_certfile": {"type": "string", "optional": True},
-            "ssl_keyfile": {"type": "string", "optional": True},
-            "ssl_ca_certs": {"type": "string", "optional": True},
-            "ssl_cert_reqs": {"type": "integer", "optional": True},
-            "reload": {"type": "boolean", "default": False},
-            "workers": {"type": "integer", "optional": True}
-        }
-    
-    def validate_config(self, config: Dict[str, Any]) -> bool:
-        """Validate uvicorn configuration."""
-        required_fields = ["host", "port"]
-        
-        for field in required_fields:
-            if field not in config:
-                logger.error(f"Missing required field: {field}")
-                return False
-        
-        # Validate SSL files exist if specified
-        ssl_files = ["ssl_certfile", "ssl_keyfile", "ssl_ca_certs"]
-        for ssl_file in ssl_files:
-            if ssl_file in config and config[ssl_file]:
-                if not Path(config[ssl_file]).exists():
-                    logger.error(f"SSL file not found: {config[ssl_file]}")
-                    return False
-        
-        return True
-    
-    def run_server(self, app: Any, config: Dict[str, Any]) -> None:
-        """Run uvicorn server."""
-        try:
-            import uvicorn
-            
-            # Prepare uvicorn config
-            uvicorn_config = {
-                "host": config.get("host", "127.0.0.1"),
-                "port": config.get("port", 8000),
-                "log_level": config.get("log_level", "info").lower(),
-                "reload": config.get("reload", False)
-            }
-            
-            # Add SSL configuration if provided
-            if "ssl_certfile" in config and config["ssl_certfile"]:
-                uvicorn_config["ssl_certfile"] = config["ssl_certfile"]
-            if "ssl_keyfile" in config and config["ssl_keyfile"]:
-                uvicorn_config["ssl_keyfile"] = config["ssl_keyfile"]
-            if "ssl_ca_certs" in config and config["ssl_ca_certs"]:
-                uvicorn_config["ssl_ca_certs"] = config["ssl_ca_certs"]
-            if "ssl_cert_reqs" in config and config["ssl_cert_reqs"]:
-                uvicorn_config["ssl_cert_reqs"] = config["ssl_cert_reqs"]
-            
-            # Add workers if specified
-            if "workers" in config and config["workers"]:
-                uvicorn_config["workers"] = config["workers"]
-            
-            logger.info(f"Starting uvicorn server with config: {uvicorn_config}")
-            uvicorn.run(app, **uvicorn_config)
-            
-        except ImportError:
-            logger.error("uvicorn not installed. Install with: pip install uvicorn[standard]")
-            raise
-        except Exception as e:
-            logger.error(f"Failed to start uvicorn server: {e}")
-            raise
-
-
 class HypercornEngine(ServerEngine):
     """
     Hypercorn server engine implementation.
@@ -347,17 +256,14 @@ class ServerEngineFactory:
     @classmethod
     def initialize_default_engines(cls) -> None:
         """Initialize default server engines."""
-        # Try to register hypercorn engine first (preferred for mTLS)
+        # Register hypercorn engine (only supported engine)
         try:
             import hypercorn
             cls.register_engine(HypercornEngine())
             logger.info("Hypercorn engine registered (full mTLS support available)")
         except ImportError:
-            logger.info("Hypercorn not available")
-        
-        # Register uvicorn engine as fallback
-        cls.register_engine(UvicornEngine())
-        logger.info("Uvicorn engine registered (fallback)")
+            logger.error("Hypercorn not available - this is required for the framework")
+            raise
 
 
 # Initialize default engines

mcp_proxy_adapter/core/ssl_utils.py

@@ -201,33 +201,34 @@ class SSLUtils:
         return min_tls <= max_tls
     
     @staticmethod
-    def get_ssl_config_for_uvicorn(ssl_config: Dict[str, Any]) -> Dict[str, Any]:
+    def get_ssl_config_for_hypercorn(ssl_config: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Get SSL configuration for uvicorn from transport configuration.
+        Get SSL configuration for hypercorn from transport configuration.
         
         Args:
             ssl_config: SSL configuration from transport manager
             
         Returns:
-            Configuration for uvicorn
+            Configuration for hypercorn
         """
-        uvicorn_ssl = {}
+        hypercorn_ssl = {}
         
         if not ssl_config:
-            return uvicorn_ssl
+            return hypercorn_ssl
         
         # Basic SSL parameters
         if ssl_config.get("cert_file"):
-            uvicorn_ssl["ssl_certfile"] = ssl_config["cert_file"]
+            hypercorn_ssl["certfile"] = ssl_config["cert_file"]
         
         if ssl_config.get("key_file"):
-            uvicorn_ssl["ssl_keyfile"] = ssl_config["key_file"]
+            hypercorn_ssl["keyfile"] = ssl_config["key_file"]
         
         if ssl_config.get("ca_cert"):
-            uvicorn_ssl["ssl_ca_certs"] = ssl_config["ca_cert"]
+            hypercorn_ssl["ca_certs"] = ssl_config["ca_cert"]
         
-        # Note: uvicorn doesn't support ssl_verify_mode parameter
-        # Client verification is handled at the application level
+        # Client verification mode
+        if ssl_config.get("verify_client", False):
+            hypercorn_ssl["verify_mode"] = "CERT_REQUIRED"
         
-        logger.info(f"Generated uvicorn SSL config: {uvicorn_ssl}")
-        return uvicorn_ssl 
+        logger.info(f"Generated hypercorn SSL config: {hypercorn_ssl}")
+        return hypercorn_ssl 

mcp_proxy_adapter/core/transport_manager.py

@@ -265,12 +265,12 @@ class TransportManager:
         logger.info(f"All SSL files validated successfully: {files_to_check}")
         return True
     
-    def get_uvicorn_config(self) -> Dict[str, Any]:
+    def get_hypercorn_config(self) -> Dict[str, Any]:
         """
-        Get configuration for uvicorn.
+        Get configuration for hypercorn.
         
         Returns:
-            Uvicorn configuration dictionary
+            Hypercorn configuration dictionary
         """
         config = {
             "host": "0.0.0.0",  # Can be moved to settings
@@ -282,8 +282,8 @@ class TransportManager:
             ssl_config = self.get_ssl_config()
             if ssl_config:
                 from mcp_proxy_adapter.core.ssl_utils import SSLUtils
-                uvicorn_ssl = SSLUtils.get_ssl_config_for_uvicorn(ssl_config)
-                config.update(uvicorn_ssl)
+                hypercorn_ssl = SSLUtils.get_ssl_config_for_hypercorn(ssl_config)
+                config.update(hypercorn_ssl)
         
         return config
 

mcp_proxy_adapter/examples/__init__.py

@@ -0,0 +1,16 @@
+"""MCP Proxy Adapter Examples Package.
+
+This package contains comprehensive examples demonstrating various
+features and usage patterns of the MCP Proxy Adapter framework.
+
+Examples include:
+- Basic framework usage
+- Full application with proxy registration
+- Security configurations (HTTP, HTTPS, mTLS)
+- Client implementations
+- Command creation and registration
+
+For detailed documentation, see the main README.md file.
+"""
+
+__version__ = "6.2.0"

mcp_proxy_adapter/examples/basic_framework/__init__.py

@@ -0,0 +1,7 @@
+"""Basic Framework Example.
+
+This example demonstrates the fundamental usage of MCP Proxy Adapter
+with minimal configuration and basic command registration.
+"""
+
+from .main import app

mcp_proxy_adapter/examples/basic_framework/commands/__init__.py

@@ -0,0 +1,4 @@
+"""Basic Framework Commands.
+
+Commands for the basic framework example.
+"""

mcp_proxy_adapter/examples/basic_framework/hooks/__init__.py

@@ -0,0 +1,4 @@
+"""Basic Framework Hooks.
+
+Hooks for the basic framework example.
+"""