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

mcp_proxy_adapter/__main__.py

@@ -1,12 +1,32 @@
-#!/usr/bin/env python3
-"""
-Main entry point for MCP Proxy Adapter.
+"""Main entry point for MCP Proxy Adapter CLI.
 
-This module allows running the MCP Proxy Adapter as a module:
-    python -m mcp_proxy_adapter
+This module provides a command-line interface for running
+MCP Proxy Adapter applications.
 """
 
-from mcp_proxy_adapter.main import main
+import sys
+from pathlib import Path
+
+# Add the current directory to Python path for imports
+current_dir = Path(__file__).parent
+sys.path.insert(0, str(current_dir))
+
+from mcp_proxy_adapter.api.app import create_app
+
+
+def main():
+    """Main CLI entry point."""
+    print("MCP Proxy Adapter v6.2.0")
+    print("========================")
+    print()
+    print("Usage:")
+    print("  python -m mcp_proxy_adapter")
+    print("  # or")
+    print("  mcp-proxy-adapter")
+    print()
+    print("For more information, see:")
+    print("  https://github.com/maverikod/mcp-proxy-adapter#readme")
+
 
 if __name__ == "__main__":
-    main()
+    main()

mcp_proxy_adapter/api/app.py

@@ -170,16 +170,27 @@ def create_app(title: Optional[str] = None, description: Optional[str] = None, v
         SystemExit: If authentication is enabled but required files are missing (security issue)
     """
     # Use provided configuration or fallback to global config
-    current_config = app_config if app_config is not None else config.get_all()
+    if app_config is not None:
+        if hasattr(app_config, 'get_all'):
+            current_config = app_config.get_all()
+        elif hasattr(app_config, 'keys'):
+            current_config = app_config
+        else:
+            current_config = config.get_all()
+    else:
+        current_config = config.get_all()
     
     # Debug: Check what config is passed to create_app
     if app_config:
-        print(f"🔍 Debug: create_app received app_config keys: {list(app_config.keys())}")
-        if "security" in app_config:
-            ssl_config = app_config["security"].get("ssl", {})
-            print(f"🔍 Debug: create_app SSL config: enabled={ssl_config.get('enabled', False)}")
-            print(f"🔍 Debug: create_app SSL config: cert_file={ssl_config.get('cert_file')}")
-            print(f"🔍 Debug: create_app SSL config: key_file={ssl_config.get('key_file')}")
+        if hasattr(app_config, 'keys'):
+            print(f"🔍 Debug: create_app received app_config keys: {list(app_config.keys())}")
+            if "security" in app_config:
+                ssl_config = app_config["security"].get("ssl", {})
+                print(f"🔍 Debug: create_app SSL config: enabled={ssl_config.get('enabled', False)}")
+                print(f"🔍 Debug: create_app SSL config: cert_file={ssl_config.get('cert_file')}")
+                print(f"🔍 Debug: create_app SSL config: key_file={ssl_config.get('key_file')}")
+        else:
+            print(f"🔍 Debug: create_app received app_config type: {type(app_config)}")
     else:
         print("🔍 Debug: create_app received no app_config, using global config")
     

mcp_proxy_adapter/api/middleware/__init__.py

@@ -43,8 +43,8 @@ def setup_middleware(app: FastAPI, app_config: Optional[Dict[str, Any]] = None)
         else:
             logger.warning(f"Middleware {middleware.__class__.__name__} doesn't have dispatch method")
     
-    # Add protocol middleware (always needed)
-    setup_protocol_middleware(app)
+    # Add protocol middleware with current configuration
+    setup_protocol_middleware(app, current_config)
     
     # Log middleware information
     middleware_info = factory.get_middleware_info()

mcp_proxy_adapter/api/middleware/protocol_middleware.py

@@ -4,12 +4,12 @@ Protocol middleware module.
 This module provides middleware for validating protocol access based on configuration.
 """
 
-from typing import Callable
+from typing import Callable, Dict, Any, Optional
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import JSONResponse
 
-from mcp_proxy_adapter.core.protocol_manager import protocol_manager
+from mcp_proxy_adapter.core.protocol_manager import get_protocol_manager
 from mcp_proxy_adapter.core.logging import logger
 
 
@@ -21,16 +21,29 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
     based on the protocol configuration.
     """
     
-    def __init__(self, app, protocol_manager_instance=None):
+    def __init__(self, app, app_config: Optional[Dict[str, Any]] = None):
         """
         Initialize protocol middleware.
         
         Args:
             app: FastAPI application
-            protocol_manager_instance: Protocol manager instance (optional)
+            app_config: Application configuration dictionary (optional)
         """
         super().__init__(app)
-        self.protocol_manager = protocol_manager_instance or protocol_manager
+        self.app_config = app_config
+        # Get protocol manager with current configuration
+        self.protocol_manager = get_protocol_manager(app_config)
+    
+    def update_config(self, new_config: Dict[str, Any]):
+        """
+        Update configuration and reload protocol manager.
+        
+        Args:
+            new_config: New configuration dictionary
+        """
+        self.app_config = new_config
+        self.protocol_manager = get_protocol_manager(new_config)
+        logger.info("Protocol middleware configuration updated")
     
     async def dispatch(self, request: Request, call_next: Callable) -> Response:
         """
@@ -116,20 +129,26 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
         return "http"
 
 
-def setup_protocol_middleware(app, protocol_manager_instance=None):
+def setup_protocol_middleware(app, app_config: Optional[Dict[str, Any]] = None):
     """
     Setup protocol middleware for FastAPI application.
     
     Args:
         app: FastAPI application
-        protocol_manager_instance: Protocol manager instance (optional)
+        app_config: Application configuration dictionary (optional)
     """
-    if protocol_manager_instance is None:
-        protocol_manager_instance = protocol_manager
+    # Check if protocol management is enabled
+    if app_config is None:
+        from mcp_proxy_adapter.config import config
+        app_config = config.get_all()
+    
+    protocols_config = app_config.get("protocols", {})
+    enabled = protocols_config.get("enabled", True)
     
-    # Only add middleware if protocol management is enabled
-    if protocol_manager_instance.enabled:
-        app.add_middleware(ProtocolMiddleware, protocol_manager_instance=protocol_manager_instance)
+    if enabled:
+        # Create protocol middleware with current configuration
+        middleware = ProtocolMiddleware(app, app_config)
+        app.add_middleware(ProtocolMiddleware, app_config=app_config)
         logger.info("Protocol middleware added to application")
     else:
-        logger.debug("Protocol management is disabled, skipping protocol middleware") 
+        logger.info("Protocol management is disabled, skipping protocol middleware") 

mcp_proxy_adapter/api/middleware/unified_security.py

@@ -66,9 +66,12 @@ class UnifiedSecurityMiddleware(BaseHTTPMiddleware):
             logger.info("Using mcp_security_framework FastAPI middleware")
         except Exception as e:
             logger.error(f"Security framework integration failed: {e}")
-            raise RuntimeError("Security framework integration failed - framework must be available for production use") from e
+            # Instead of raising error, log warning and continue without security
+            logger.warning("Continuing without security framework - some security features will be disabled")
+            self.security_integration = None
+            self.framework_middleware = None
         
-        logger.info("Unified security middleware initialized with mcp_security_framework")
+        logger.info("Unified security middleware initialized")
     
     async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
         """
@@ -82,8 +85,13 @@ class UnifiedSecurityMiddleware(BaseHTTPMiddleware):
             Response object
         """
         try:
-            # Use framework middleware only
-            return await self.framework_middleware.dispatch(request, call_next)
+            # Use framework middleware if available
+            if self.framework_middleware is not None:
+                return await self.framework_middleware.dispatch(request, call_next)
+            else:
+                # Fallback: continue without security middleware
+                logger.debug("Security framework not available, continuing without security checks")
+                return await call_next(request)
             
         except SecurityValidationError as e:
             # Handle security validation errors