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

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.
+"""

mcp_proxy_adapter/examples/basic_framework/main.py

@@ -1,63 +1,44 @@
 #!/usr/bin/env python3
 """
-Basic Framework Example Application
-
-This is a simple application that demonstrates the basic usage of MCP Proxy Adapter framework.
-
+Basic Framework Example
+This example demonstrates the basic usage of the MCP Proxy Adapter framework
+with minimal configuration and built-in commands.
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import sys
 import argparse
 from pathlib import Path
-
 # Add the framework to the path
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from mcp_proxy_adapter.api.app import create_app
-from mcp_proxy_adapter.config import Config
-
-
+from mcp_proxy_adapter.core.app_factory import create_and_run_server
 def main():
     """Main entry point for the basic framework example."""
     parser = argparse.ArgumentParser(description="Basic Framework Example")
     parser.add_argument("--config", "-c", required=True, help="Path to configuration file")
-    parser.add_argument("--host", default="0.0.0.0", help="Server host")
-    parser.add_argument("--port", type=int, help="Server port (overrides config)")
+    parser.add_argument("--host", help="Server host")
+    parser.add_argument("--port", type=int, help="Server port")
     parser.add_argument("--debug", action="store_true", help="Enable debug mode")
-    
     args = parser.parse_args()
-    
-    # Load configuration
-    config = Config(args.config)
-    
-    # Override port if specified
+    # Override configuration if specified
+    config_overrides = {}
+    if args.host:
+        config_overrides["host"] = args.host
     if args.port:
-        config.set("server.port", args.port)
-    
-    # Override debug if specified
+        config_overrides["port"] = args.port
     if args.debug:
-        config.set("server.debug", True)
-    
-    # Create application
-    app = create_app(app_config=config)
-    
-    # Get server configuration
-    host = config.get("server.host", "0.0.0.0")
-    port = config.get("server.port", 8000)
-    debug = config.get("server.debug", False)
-    
+        config_overrides["debug"] = True
     print(f"🚀 Starting Basic Framework Example")
     print(f"📋 Configuration: {args.config}")
-    print(f"🌐 Server: {host}:{port}")
-    print(f"🔧 Debug: {debug}")
     print("=" * 50)
-    
-    # Import uvicorn here to avoid dependency issues
-    import uvicorn
-    uvicorn.run(app, host=host, port=port, log_level="info")
-
-
+    # Use the factory method to create and run the server
+    create_and_run_server(
+        config_path=args.config,
+        title="Basic Framework Example",
+        description="Basic MCP Proxy Adapter with minimal configuration",
+        version="1.0.0",
+        host=config_overrides.get("host", "0.0.0.0"),
+        log_level="debug" if config_overrides.get("debug", False) else "info"
+    )
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/commands/__init__.py

@@ -1 +1,5 @@
-# Commands package
+"""Example Commands Package.
+
+This package contains example command implementations demonstrating
+various patterns for creating custom commands in MCP Proxy Adapter.
+"""