mcp-proxy-adapter 6.3.10__py3-none-any.whl → 6.3.12__py3-none-any.whl

mcp_proxy_adapter/__main__.py

@@ -18,6 +18,7 @@ def main():
     """Main CLI entry point."""
     # Import and run the actual main function from main.py
     from mcp_proxy_adapter.main import main as run_server
+
     run_server()
 
 

mcp_proxy_adapter/core/app_factory.py

@@ -21,7 +21,7 @@ from mcp_proxy_adapter.commands.builtin_commands import register_builtin_command
 logger = get_logger("app_factory")
 
 
-def create_and_run_server(
+async def create_and_run_server(
     config_path: Optional[str] = None,
     log_config_path: Optional[str] = None,
     title: str = "MCP Proxy Adapter Server",
@@ -361,7 +361,14 @@ def create_and_run_server(
             print(f"🌐 Starting HTTP server with hypercorn...")
 
         # Run the server
-        asyncio.run(hypercorn.asyncio.serve(app, config_hypercorn))
+        try:
+            # Check if we're already in an event loop
+            loop = asyncio.get_running_loop()
+            # If we're in a loop, use await instead of asyncio.run
+            await hypercorn.asyncio.serve(app, config_hypercorn)
+        except RuntimeError:
+            # No event loop running, use asyncio.run
+            asyncio.run(hypercorn.asyncio.serve(app, config_hypercorn))
 
     except KeyboardInterrupt:
         print("\n🛑 Server stopped by user")

mcp_proxy_adapter/core/client_security.py

@@ -74,7 +74,7 @@ class ClientSecurityManager:
     def _create_ssl_config(self) -> SSLConfig:
         """Create SSL configuration for client connections."""
         ssl_section = self.security_config.get("ssl", {})
-        
+
         # Determine verify_mode based on verify_server setting
         verify_server = ssl_section.get("verify_server", True)
         if verify_server:

mcp_proxy_adapter/core/proxy_registration.py

@@ -147,19 +147,84 @@ class ProxyRegistrationManager:
 
     def _create_ssl_context(self) -> Optional[ssl.SSLContext]:
         """
-        Create SSL context for secure connections.
+        Create SSL context for secure connections using registration SSL configuration.
 
         Returns:
             SSL context or None if SSL not needed
         """
+        logger.debug("_create_ssl_context called")
         if not self.client_security:
+            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", {})
-            if cert_config.get("enabled", False):
-                return self.client_security.create_client_ssl_context()
+            ssl_config = self.registration_config.get("ssl", {})
+
+            logger.debug(
+                f"SSL context creation: cert_config={cert_config}, ssl_config={ssl_config}"
+            )
+
+            # SSL is enabled if certificate config exists or SSL config exists
+            if cert_config or ssl_config:
+                # Create a custom SSL context based on registration configuration
+                context = ssl.create_default_context()
+
+                # Load client certificates if provided
+                if cert_config:
+                    cert_file = cert_config.get("cert_file")
+                    key_file = cert_config.get("key_file")
+
+                    if cert_file and key_file:
+                        context.load_cert_chain(cert_file, key_file)
+                        logger.debug(
+                            f"Loaded client certificates: {cert_file}, {key_file}"
+                        )
+
+                # Configure SSL verification based on registration settings
+                if ssl_config:
+                    ca_cert_file = ssl_config.get("ca_cert")
+                    verify_mode = ssl_config.get("verify_mode", "CERT_REQUIRED")
+
+                    # Load CA certificate if provided
+                    if ca_cert_file:
+                        context.load_verify_locations(ca_cert_file)
+                        logger.debug(f"Loaded CA certificate: {ca_cert_file}")
+
+                    # Set verification mode based on ssl_config verify_mode
+                    if verify_mode == "CERT_NONE":
+                        context.check_hostname = False
+                        context.verify_mode = ssl.CERT_NONE
+                        logger.debug("SSL verification disabled (CERT_NONE)")
+                    elif verify_mode == "CERT_REQUIRED":
+                        context.check_hostname = True
+                        context.verify_mode = ssl.CERT_REQUIRED
+                        logger.debug("SSL verification enabled (CERT_REQUIRED)")
+                    else:
+                        # Default to CERT_REQUIRED
+                        context.check_hostname = True
+                        context.verify_mode = ssl.CERT_REQUIRED
+                        logger.debug("SSL verification enabled (default)")
+                else:
+                    # Check certificate config for verify_server setting
+                    verify_server = cert_config.get("verify_server", True)
+                    if not verify_server:
+                        context.check_hostname = False
+                        context.verify_mode = ssl.CERT_NONE
+                        logger.debug("SSL verification disabled (verify_server: false)")
+                    else:
+                        # Default SSL context if no specific SSL config
+                        context.check_hostname = True
+                        context.verify_mode = ssl.CERT_REQUIRED
+                        logger.debug("Using default SSL verification")
+
+                logger.info("Created custom SSL context for proxy registration")
+                return context
+            else:
+                logger.debug(
+                    "SSL context creation skipped: no cert_config or ssl_config"
+                )
 
             return None
         except Exception as e: