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

mcp_proxy_adapter/api/middleware/factory.py

@@ -13,9 +13,10 @@ from fastapi import FastAPI
 from mcp_proxy_adapter.core.logging import logger
 from mcp_proxy_adapter.core.security_factory import SecurityFactory
 from .base import BaseMiddleware
-from .security import SecurityMiddleware
+from .unified_security import UnifiedSecurityMiddleware
 from .error_handling import ErrorHandlingMiddleware
 from .logging import LoggingMiddleware
+from .user_info_middleware import UserInfoMiddleware
 
 
 class MiddlewareFactory:
@@ -40,12 +41,12 @@ class MiddlewareFactory:
         
         logger.info("Middleware factory initialized")
     
-    def create_security_middleware(self) -> Optional[SecurityMiddleware]:
+    def create_security_middleware(self) -> Optional[UnifiedSecurityMiddleware]:
         """
-        Create security middleware.
+        Create unified security middleware.
         
         Returns:
-            SecurityMiddleware instance or None if creation failed
+            UnifiedSecurityMiddleware instance or None if creation failed
         """
         try:
             security_config = self.config.get("security", {})
@@ -54,14 +55,14 @@ class MiddlewareFactory:
                 logger.info("Security middleware disabled by configuration")
                 return None
             
-            middleware = SecurityMiddleware(self.app, self.config)
+            middleware = UnifiedSecurityMiddleware(self.app, self.config)
             self.middleware_stack.append(middleware)
             
-            logger.info("Security middleware created successfully")
+            logger.info("Unified security middleware created successfully")
             return middleware
             
         except Exception as e:
-            logger.error(f"Failed to create security middleware: {e}")
+            logger.error(f"Failed to create unified security middleware: {e}")
             return None
     
     def create_error_handling_middleware(self) -> Optional[ErrorHandlingMiddleware]:
@@ -106,6 +107,24 @@ class MiddlewareFactory:
             logger.error(f"Failed to create logging middleware: {e}")
             return None
     
+    def create_user_info_middleware(self) -> Optional[UserInfoMiddleware]:
+        """
+        Create user info middleware.
+        
+        Returns:
+            UserInfoMiddleware instance or None if creation failed
+        """
+        try:
+            middleware = UserInfoMiddleware(self.app, self.config)
+            self.middleware_stack.append(middleware)
+            
+            logger.info("User info middleware created successfully")
+            return middleware
+            
+        except Exception as e:
+            logger.error(f"Failed to create user info middleware: {e}")
+            return None
+    
 
     
     def create_all_middleware(self) -> List[BaseMiddleware]:
@@ -132,6 +151,11 @@ class MiddlewareFactory:
         if logging_middleware:
             middleware_list.append(logging_middleware)
         
+        # Create user info middleware
+        user_info_middleware = self.create_user_info_middleware()
+        if user_info_middleware:
+            middleware_list.append(user_info_middleware)
+        
         logger.info(f"Created {len(middleware_list)} middleware components")
         return middleware_list
     
@@ -152,14 +176,14 @@ class MiddlewareFactory:
                 return middleware
         return None
     
-    def get_security_middleware(self) -> Optional[SecurityMiddleware]:
+    def get_security_middleware(self) -> Optional[UnifiedSecurityMiddleware]:
         """
-        Get security middleware instance.
+        Get unified security middleware instance.
         
         Returns:
-            SecurityMiddleware instance or None if not found
+            UnifiedSecurityMiddleware instance or None if not found
         """
-        return self.get_middleware_by_type(SecurityMiddleware)
+        return self.get_middleware_by_type(UnifiedSecurityMiddleware)
     
     def validate_middleware_config(self) -> bool:
         """
@@ -213,7 +237,7 @@ class MiddlewareFactory:
             middleware_type = type(middleware).__name__
             info["middleware_types"].append(middleware_type)
             
-            if isinstance(middleware, SecurityMiddleware):
+            if isinstance(middleware, UnifiedSecurityMiddleware):
                 info["security_enabled"] = True
         
         return 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

@@ -0,0 +1,160 @@
+"""
+Unified Security Middleware - Direct Framework Integration
+
+This middleware now directly uses mcp_security_framework components
+instead of custom implementations.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import time
+import logging
+from typing import Dict, Any, Optional, Callable, Awaitable
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+
+# Direct import from framework
+try:
+    from mcp_security_framework.middleware.fastapi_middleware import FastAPISecurityMiddleware
+    from mcp_security_framework import SecurityManager
+    from mcp_security_framework.schemas.config import SecurityConfig
+    SECURITY_FRAMEWORK_AVAILABLE = True
+except ImportError:
+    SECURITY_FRAMEWORK_AVAILABLE = False
+    FastAPISecurityMiddleware = None
+    SecurityManager = None
+    SecurityConfig = None
+
+from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.security_integration import create_security_integration
+
+
+class SecurityValidationError(Exception):
+    """Security validation error."""
+    
+    def __init__(self, message: str, error_code: int):
+        self.message = message
+        self.error_code = error_code
+        super().__init__(self.message)
+
+
+class UnifiedSecurityMiddleware(BaseHTTPMiddleware):
+    """
+    Unified security middleware using mcp_security_framework.
+    
+    This middleware now directly uses the security framework's FastAPI middleware
+    and components instead of custom implementations.
+    """
+    
+    def __init__(self, app, config: Dict[str, Any]):
+        """
+        Initialize unified security middleware.
+        
+        Args:
+            app: FastAPI application
+            config: mcp_proxy_adapter configuration dictionary
+        """
+        super().__init__(app)
+        self.config = config
+        
+        # Create security integration
+        try:
+            self.security_integration = create_security_integration(config)
+            # Use framework's FastAPI middleware
+            self.framework_middleware = self.security_integration.create_fastapi_middleware(app)
+            logger.info("Using mcp_security_framework FastAPI middleware")
+        except Exception as e:
+            logger.error(f"Security framework integration failed: {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")
+    
+    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+        """
+        Process request using framework middleware.
+        
+        Args:
+            request: Request object
+            call_next: Next handler
+            
+        Returns:
+            Response object
+        """
+        try:
+            # 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
+            return await self._handle_security_error(request, e)
+        except Exception as e:
+            # Handle other errors
+            logger.error(f"Unexpected error in unified security middleware: {e}")
+            return await self._handle_general_error(request, e)
+    
+
+    
+    async def _handle_security_error(self, request: Request, error: SecurityValidationError) -> Response:
+        """
+        Handle security validation errors.
+        
+        Args:
+            request: Request object
+            error: Security validation error
+            
+        Returns:
+            Error response
+        """
+        from fastapi.responses import JSONResponse
+        
+        error_response = {
+            "error": {
+                "code": error.error_code,
+                "message": error.message,
+                "type": "security_validation_error"
+            }
+        }
+        
+        logger.warning(f"Security validation failed: {error.message}")
+        
+        return JSONResponse(
+            status_code=error.error_code,
+            content=error_response
+        )
+    
+    async def _handle_general_error(self, request: Request, error: Exception) -> Response:
+        """
+        Handle general errors.
+        
+        Args:
+            request: Request object
+            error: General error
+            
+        Returns:
+            Error response
+        """
+        from fastapi.responses import JSONResponse
+        
+        error_response = {
+                "error": {
+                "code": 500,
+                    "message": "Internal server error",
+                "type": "general_error"
+            }
+        }
+        
+        logger.error(f"General error in security middleware: {error}")
+        
+        return JSONResponse(
+            status_code=500,
+            content=error_response
+        )

mcp_proxy_adapter/api/middleware/user_info_middleware.py

@@ -0,0 +1,83 @@
+"""
+User Info Middleware
+
+This middleware extracts user information from authentication headers
+and sets it in request.state for use by commands.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import logging
+from typing import Dict, Any, Optional, Callable, Awaitable
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from mcp_proxy_adapter.core.logging import logger
+
+
+class UserInfoMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware for setting user information in request.state.
+    
+    This middleware extracts user information from authentication headers
+    and sets it in request.state for use by commands.
+    """
+    
+    def __init__(self, app, config: Dict[str, Any]):
+        """
+        Initialize user info middleware.
+        
+        Args:
+            app: FastAPI application
+            config: Configuration dictionary
+        """
+        super().__init__(app)
+        self.config = config
+        
+        # Get API keys configuration
+        security_config = config.get("security", {})
+        auth_config = security_config.get("auth", {})
+        self.api_keys = auth_config.get("api_keys", {})
+        
+        logger.info("User info middleware initialized")
+    
+    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+        """
+        Process request and set user info in request.state.
+        
+        Args:
+            request: Request object
+            call_next: Next handler
+            
+        Returns:
+            Response object
+        """
+        # Extract API key from headers
+        api_key = request.headers.get("X-API-Key")
+        
+        if api_key and api_key in self.api_keys:
+            # Get user info from API key configuration
+            user_config = self.api_keys[api_key]
+            
+            # Set user info in request.state
+            request.state.user = {
+                "id": api_key,
+                "role": user_config.get("roles", ["guest"])[0] if user_config.get("roles") else "guest",
+                "roles": user_config.get("roles", ["guest"]),
+                "permissions": user_config.get("permissions", ["read"])
+            }
+            
+            logger.debug(f"Set user info for {api_key}: {request.state.user}")
+        else:
+            # Set default guest user info
+            request.state.user = {
+                "id": None,
+                "role": "guest",
+                "roles": ["guest"],
+                "permissions": ["read"]
+            }
+            
+            logger.debug("Set default guest user info")
+        
+        return await call_next(request)

mcp_proxy_adapter/commands/__init__.py

@@ -12,6 +12,9 @@ from mcp_proxy_adapter.commands.certificate_management_command import Certificat
 from mcp_proxy_adapter.commands.key_management_command import KeyManagementCommand
 from mcp_proxy_adapter.commands.cert_monitor_command import CertMonitorCommand
 from mcp_proxy_adapter.commands.transport_management_command import TransportManagementCommand
+from mcp_proxy_adapter.commands.role_test_command import RoleTestCommand
+from mcp_proxy_adapter.commands.echo_command import EchoCommand
+from mcp_proxy_adapter.commands.proxy_registration_command import ProxyRegistrationCommand
 
 __all__ = [
     "Command",
@@ -27,5 +30,8 @@ __all__ = [
     "CertificateManagementCommand",
     "KeyManagementCommand",
     "CertMonitorCommand",
-    "TransportManagementCommand"
+    "TransportManagementCommand",
+    "RoleTestCommand",
+    "EchoCommand",
+    "ProxyRegistrationCommand"
 ]

mcp_proxy_adapter/commands/base.py

@@ -48,7 +48,7 @@ class Command(ABC):
         Execute command with the specified parameters.
         
         Args:
-            **kwargs: Command parameters.
+            **kwargs: Command parameters including optional 'context' parameter.
             
         Returns:
             Command result.
@@ -153,11 +153,14 @@ class Command(ABC):
         Runs the command with the specified arguments.
 
         Args:
-            **kwargs: Command arguments.
+            **kwargs: Command arguments including optional 'context' parameter.
 
         Returns:
             Command result.
         """
+        # Extract context from kwargs
+        context = kwargs.pop('context', {}) if 'context' in kwargs else {}
+        
         try:
             logger.debug(f"Running command {cls.__name__} with params: {kwargs}")
             
@@ -185,8 +188,8 @@ class Command(ABC):
             command = command_class()
             validated_params = command.validate_params(kwargs)
             
-            # Execute command with validated parameters
-            result = await command.execute(**validated_params)
+            # Execute command with validated parameters and context
+            result = await command.execute(**validated_params, context=context)
             
             logger.debug(f"Command {cls.__name__} executed successfully")
             return result

mcp_proxy_adapter/commands/builtin_commands.py

@@ -17,6 +17,8 @@ from mcp_proxy_adapter.commands.unload_command import UnloadCommand
 from mcp_proxy_adapter.commands.plugins_command import PluginsCommand
 from mcp_proxy_adapter.commands.transport_management_command import TransportManagementCommand
 from mcp_proxy_adapter.commands.proxy_registration_command import ProxyRegistrationCommand
+from mcp_proxy_adapter.commands.echo_command import EchoCommand
+from mcp_proxy_adapter.commands.role_test_command import RoleTestCommand
 from mcp_proxy_adapter.core.logging import logger
 
 
@@ -39,7 +41,9 @@ def register_builtin_commands() -> int:
         UnloadCommand,
         PluginsCommand,
         TransportManagementCommand,
-        ProxyRegistrationCommand
+        ProxyRegistrationCommand,
+        EchoCommand,
+        RoleTestCommand
     ]
     
     registered_count = 0
@@ -85,5 +89,7 @@ def get_builtin_commands_list() -> list:
         UnloadCommand,
         PluginsCommand,
         TransportManagementCommand,
-        ProxyRegistrationCommand
+        ProxyRegistrationCommand,
+        EchoCommand,
+        RoleTestCommand
     ] 

mcp_proxy_adapter/commands/command_registry.py

@@ -660,6 +660,14 @@ class CommandRegistry:
         except Exception as e:
             logger.error(f"❌ Failed to initialize logging: {e}")
         
+        # Step 2.5: Reload protocol manager configuration
+        try:
+            from mcp_proxy_adapter.core.protocol_manager import protocol_manager
+            protocol_manager.reload_config()
+            logger.info("✅ Protocol manager configuration reloaded")
+        except Exception as e:
+            logger.error(f"❌ Failed to reload protocol manager: {e}")
+        
         # Step 3: Clear all commands (always clear for consistency)
         self.clear()
         

mcp_proxy_adapter/commands/echo_command.py

@@ -0,0 +1,81 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Echo command for testing purposes.
+"""
+
+import asyncio
+from typing import Any, Dict, Optional
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import SuccessResult
+
+
+class EchoCommandResult(SuccessResult):
+    """Result for echo command."""
+    
+    def __init__(self, message: str, timestamp: Optional[str] = None):
+        data = {"message": message}
+        if timestamp:
+            data["timestamp"] = timestamp
+        super().__init__(data=data, message=message)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get JSON schema for result."""
+        return {
+            "type": "object",
+            "properties": {
+                "success": {"type": "boolean"},
+                "data": {
+                    "type": "object",
+                    "properties": {
+                        "message": {"type": "string"},
+                        "timestamp": {"type": "string", "nullable": True}
+                    }
+                },
+                "message": {"type": "string"}
+            },
+            "required": ["success", "data"]
+        }
+
+
+class EchoCommand(Command):
+    """Echo command for testing purposes."""
+    
+    name = "echo"
+    version = "1.0.0"
+    descr = "Echo command for testing"
+    category = "testing"
+    author = "Vasiliy Zdanovskiy"
+    email = "vasilyvz@gmail.com"
+    result_class = EchoCommandResult
+    
+    async def execute(self, **kwargs) -> EchoCommandResult:
+        """Execute echo command."""
+        message = kwargs.get("message", "Hello, World!")
+        timestamp = kwargs.get("timestamp")
+        
+        # Simulate some processing time
+        await asyncio.sleep(0.001)
+        
+        return EchoCommandResult(message=message, timestamp=timestamp)
+    
+    def get_schema(self) -> Dict[str, Any]:
+        """Get command schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "description": "Message to echo",
+                    "default": "Hello, World!"
+                },
+                "timestamp": {
+                    "type": "string",
+                    "description": "Optional timestamp",
+                    "nullable": True
+                }
+            }
+        }