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

mcp_proxy_adapter/api/middleware/user_info_middleware.py

@@ -0,0 +1,158 @@
+"""
+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
+
+# Import mcp_security_framework components
+try:
+    from mcp_security_framework import AuthManager
+    from mcp_security_framework.schemas.config import AuthConfig
+    _MCP_SECURITY_AVAILABLE = True
+    print("✅ mcp_security_framework available in middleware")
+except ImportError:
+    _MCP_SECURITY_AVAILABLE = False
+    print("⚠️ mcp_security_framework not available in middleware, using basic auth")
+
+
+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
+
+        # Initialize AuthManager if available
+        self.auth_manager = None
+        self._security_available = _MCP_SECURITY_AVAILABLE
+
+        if self._security_available:
+            try:
+                # Get API keys configuration
+                security_config = config.get("security", {})
+                auth_config = security_config.get("auth", {})
+
+                # Create AuthConfig for mcp_security_framework
+                mcp_auth_config = AuthConfig(
+                    enabled=True,
+                    methods=["api_key"],
+                    api_keys=auth_config.get("api_keys", {})
+                )
+
+                self.auth_manager = AuthManager(mcp_auth_config)
+                logger.info("✅ User info middleware initialized with mcp_security_framework")
+            except Exception as e:
+                logger.warning(f"⚠️ Failed to initialize AuthManager: {e}")
+                self._security_available = False
+
+        if not self._security_available:
+            # Fallback to basic API key handling
+            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 with basic auth")
+    
+    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:
+            if self.auth_manager and self._security_available:
+                try:
+                    # Use mcp_security_framework AuthManager
+                    auth_result = self.auth_manager.authenticate_api_key(api_key)
+
+                    if auth_result.is_valid:
+                        # Set user info from AuthManager result
+                        request.state.user = {
+                            "id": api_key,
+                            "role": auth_result.roles[0] if auth_result.roles else "guest",
+                            "roles": auth_result.roles or ["guest"],
+                            "permissions": getattr(auth_result, 'permissions', ["read"])
+                        }
+                        logger.debug(f"✅ Authenticated user with mcp_security_framework: {request.state.user}")
+                    else:
+                        # Authentication failed
+                        request.state.user = {
+                            "id": None,
+                            "role": "guest",
+                            "roles": ["guest"],
+                            "permissions": ["read"]
+                        }
+                        logger.debug(f"❌ Authentication failed for API key: {api_key[:8]}...")
+                except Exception as e:
+                    logger.warning(f"⚠️ AuthManager error: {e}, falling back to basic auth")
+                    self._security_available = False
+
+            if not self._security_available:
+                # Fallback to basic API key handling
+                if api_key in getattr(self, 'api_keys', {}):
+                    user_role = self.api_keys[api_key]
+
+                    # Get permissions for this role from roles file if available
+                    role_permissions = ["read"]  # default permissions
+                    if hasattr(self, 'roles_config') and self.roles_config and user_role in self.roles_config:
+                        role_permissions = self.roles_config[user_role].get("permissions", ["read"])
+
+                    # Set user info in request.state
+                    request.state.user = {
+                        "id": api_key,
+                        "role": user_role,
+                        "roles": [user_role],
+                        "permissions": role_permissions
+                    }
+
+                    logger.debug(f"✅ Authenticated user with basic auth: {request.state.user}")
+                else:
+                    # API key not found
+                    request.state.user = {
+                        "id": None,
+                        "role": "guest",
+                        "roles": ["guest"],
+                        "permissions": ["read"]
+                    }
+                    logger.debug(f"❌ API key not found: {api_key[:8]}...")
+        else:
+            # No API key provided - guest access
+            request.state.user = {
+                "id": None,
+                "role": "guest",
+                "roles": ["guest"],
+                "permissions": ["read"]
+            }
+            logger.debug("ℹ️ No API key provided, using guest access")
+        
+        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/health_command.py

@@ -80,7 +80,7 @@ class HealthCommand(Command):
     name = "health"
     result_class = HealthResult
     
-    async def execute(self) -> HealthResult:
+    async def execute(self, **kwargs) -> HealthResult:
         """
         Execute health command.
         

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