mcp-proxy-adapter 6.0.0__py3-none-any.whl → 6.1.0__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/unified_security.py

@@ -0,0 +1,152 @@
+"""
+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}")
+            raise RuntimeError("Security framework integration failed - framework must be available for production use") from e
+        
+        logger.info("Unified security middleware initialized with mcp_security_framework")
+    
+    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 only
+            return await self.framework_middleware.dispatch(request, call_next)
+            
+        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
+                }
+            }
+        }

mcp_proxy_adapter/commands/help_command.py

@@ -46,13 +46,15 @@ class HelpResult(CommandResult):
             if self.command_info is not None:
                 logger.debug(f"HelpResult.to_dict: returning command_info for {self.command_info.get('name', 'unknown')}")
                 # Делаем безопасное получение всех полей с дефолтными значениями
+                metadata = self.command_info.get("metadata", {})
+                schema = self.command_info.get("schema", {})
                 return {
                     "cmdname": self.command_info.get("name", "unknown"),
                     "info": {
-                        "description": self.command_info.get("description", ""),
-                        "summary": self.command_info.get("summary", ""),
-                        "params": self.command_info.get("params", {}),
-                        "examples": self.command_info.get("examples", [])
+                        "description": metadata.get("description", ""),
+                        "summary": metadata.get("summary", ""),
+                        "params": schema.get("properties", {}),
+                        "examples": metadata.get("examples", [])
                     }
                 }
 
@@ -190,14 +192,16 @@ class HelpCommand(Command):
             if cmdname is not None and cmdname != "":
                 logger.debug(f"Обработка запроса для конкретной команды: {cmdname}")
                 try:
-                    # Get command metadata from registry
-                    command_metadata = registry.get_command_metadata(cmdname)
+                    # Get command info from registry
+                    command_info = registry.get_command_info(cmdname)
+                    if command_info is None:
+                        raise NotFoundError(f"Command '{cmdname}' not found")
                     logger.debug(f"Получены метаданные для команды {cmdname}")
-                    return HelpResult(command_info=command_metadata)
+                    return HelpResult(command_info=command_info)
                 except NotFoundError:
                     logger.warning(f"Команда '{cmdname}' не найдена")
                     # Получаем список всех команд
-                    all_commands = list(registry.get_all_metadata().keys())
+                    all_commands = list(registry.get_all_commands().keys())
                     if all_commands:
                         example_cmd = all_commands[0]
                         example = {
@@ -218,9 +222,9 @@ class HelpCommand(Command):
             # Otherwise, return information about all available commands
             logger.debug("Обработка запроса для всех команд")
 
-            # Get metadata for all commands
-            all_metadata = registry.get_all_metadata()
-            logger.debug(f"Получены метаданные для {len(all_metadata)} команд")
+            # Get info for all commands
+            all_commands_info = registry.get_all_commands_info()
+            logger.debug(f"Получены метаданные для {len(all_commands_info.get('commands', {}))} команд")
 
             # Prepare response format with tool metadata
             result = {
@@ -240,17 +244,20 @@ class HelpCommand(Command):
             }
 
             # Add brief information about commands
-            for name, metadata in all_metadata.items():
+            commands_data = all_commands_info.get("commands", {})
+            for name, command_info in commands_data.items():
                 try:
                     logger.debug(f"Обработка метаданных команды {name}")
                     # Безопасное получение параметров с проверкой на наличие ключей
+                    metadata = command_info.get("metadata", {})
+                    schema = command_info.get("schema", {})
                     result["commands"][name] = {
                         "summary": metadata.get("summary", ""),
-                        "params_count": len(metadata.get("params", {}))
+                        "params_count": len(schema.get("properties", {}))
                     }
                 except Exception as e:
                     logger.error(f"Ошибка при обработке метаданных команды {name}: {e}")
-                    logger.debug(f"Метаданные команды {name}: {metadata}")
+                    logger.debug(f"Метаданные команды {name}: {command_info}")
                     # Пропускаем проблемную команду
                     continue