mcp-proxy-adapter 2.0.1__py3-none-any.whl → 6.9.50__py3-none-any.whl

mcp_proxy_adapter/api/middleware/user_info_middleware.py

@@ -0,0 +1,132 @@
+"""
+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
+"""
+
+from typing import Dict, Any, Callable, Awaitable
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+# Import mcp_security_framework components
+try:
+    from mcp_security_framework import AuthManager, PermissionManager
+    from mcp_security_framework.schemas.config import AuthConfig, PermissionConfig
+
+    _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", {})
+                
+                # Check if security is enabled
+                security_enabled = security_config.get("enabled", False)
+                if not security_enabled:
+                    get_global_logger().info("ℹ️ Security disabled in configuration, using basic auth")
+                    self._security_available = False
+                else:
+                    auth_config = security_config.get("auth", {})
+                    permissions_config = security_config.get("permissions", {})
+
+                    # Check if permissions are enabled
+                    permissions_enabled = permissions_config.get("enabled", False)
+
+                    # Only use mcp_security_framework if permissions are enabled
+                    if permissions_enabled:
+                        # Create AuthConfig for mcp_security_framework
+                        mcp_auth_config = AuthConfig(
+                            enabled=True,
+                            methods=["api_key"],
+                            api_keys=auth_config.get("api_keys", {}),
+                        )
+
+                        # Create PermissionConfig for mcp_security_framework
+                        roles_file = permissions_config.get("roles_file")
+                        if roles_file is None:
+                            get_global_logger().warning("⚠️ Permissions enabled but no roles_file specified, using default configuration")
+                            roles_file = None
+                        
+                        mcp_permission_config = PermissionConfig(
+                            roles_file=roles_file,
+                            default_role=permissions_config.get("default_role", "guest"),
+                            admin_role=permissions_config.get("admin_role", "admin"),
+                            role_hierarchy=permissions_config.get("role_hierarchy", {}),
+                            permission_cache_enabled=permissions_config.get(
+                                "permission_cache_enabled", True
+                            ),
+                            permission_cache_ttl=permissions_config.get(
+                                "permission_cache_ttl", 300
+                            ),
+                            wildcard_permissions=permissions_config.get(
+                                "wildcard_permissions", False
+                            ),
+                            strict_mode=permissions_config.get("strict_mode", True),
+                            roles=permissions_config.get("roles", {}),
+                        )
+
+                        # Initialize PermissionManager first
+                        self.permission_manager = PermissionManager(mcp_permission_config)
+
+                        # Initialize AuthManager with permission_manager
+                        self.auth_manager = AuthManager(
+                            mcp_auth_config, self.permission_manager
+                        )
+                        get_global_logger().info(
+                            "✅ User info middleware initialized with " "mcp_security_framework"
+                        )
+                    else:
+                        # When permissions are disabled, use basic auth without mcp_security_framework
+                        get_global_logger().info("ℹ️ Permissions disabled, using basic token auth without mcp_security_framework")
+                        self._security_available = False
+                        # Initialize api_keys for basic auth
+                        self.api_keys = auth_config.get("api_keys", {})
+            except Exception as e:
+                get_global_logger().warning(f"⚠️ Failed to initialize AuthManager: {e}")
+                self._security_available = False
+
+        # Always initialize api_keys for fallback
+        security_config = config.get("security", {})
+        auth_config = security_config.get("auth", {})
+        self.api_keys = auth_config.get("api_keys", {})
+        
+        if not self._security_available:
+            # Fallback to basic API key handling
+            get_global_logger().info("ℹ️ User info middleware initialized with basic auth")
+        else:
+            get_global_logger().info("ℹ️ User info middleware initialized with mcp_security_framework (fallback enabled)")
+

mcp_proxy_adapter/api/openapi/__init__.py

@@ -0,0 +1,21 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+OpenAPI schema generation package for MCP Proxy Adapter.
+"""
+
+from .openapi_generator import CustomOpenAPIGenerator
+from .schema_loader import SchemaLoader
+from .command_integration import CommandIntegrator
+from .openapi_registry import OpenAPIRegistry
+from .custom_openapi import custom_openapi, custom_openapi_with_fallback
+
+__all__ = [
+    "CustomOpenAPIGenerator",
+    "SchemaLoader",
+    "CommandIntegrator",
+    "OpenAPIRegistry",
+    "custom_openapi",
+    "custom_openapi_with_fallback",
+]

mcp_proxy_adapter/api/openapi/command_integration.py

@@ -0,0 +1,105 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Command integration utilities for OpenAPI generation.
+"""
+
+from typing import Dict, Any, Type
+
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class CommandIntegrator:
+    """Integrator for adding commands to OpenAPI schema."""
+
+    def __init__(self):
+        """Initialize command integrator."""
+        self.logger = get_global_logger()
+
+
+    def _create_params_schema(self, cmd_class: Type[Command]) -> Dict[str, Any]:
+        """
+        Create a schema for command parameters.
+
+        Args:
+            cmd_class: The command class to create schema for.
+
+        Returns:
+            Dict containing the parameter schema.
+        """
+        try:
+            # Get the command schema
+            schema = cmd_class.get_schema()
+            
+            if not schema or "properties" not in schema:
+                return {"type": "object", "properties": {}}
+
+            # Convert to OpenAPI format
+            openapi_schema = {
+                "type": "object",
+                "properties": {},
+                "required": schema.get("required", [])
+            }
+
+            # Convert properties
+            for prop_name, prop_schema in schema["properties"].items():
+                openapi_schema["properties"][prop_name] = self._convert_property_schema(prop_schema)
+
+            return openapi_schema
+
+        except Exception as e:
+            self.logger.warning(f"Failed to create params schema for {cmd_class.__name__}: {e}")
+            return {"type": "object", "properties": {}}
+
+    def _convert_property_schema(self, prop_schema: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Convert property schema to OpenAPI format.
+
+        Args:
+            prop_schema: Property schema to convert.
+
+        Returns:
+            OpenAPI property schema.
+        """
+        openapi_prop = {}
+
+        # Handle type
+        if "type" in prop_schema:
+            openapi_prop["type"] = prop_schema["type"]
+
+        # Handle description
+        if "description" in prop_schema:
+            openapi_prop["description"] = prop_schema["description"]
+
+        # Handle default
+        if "default" in prop_schema:
+            openapi_prop["default"] = prop_schema["default"]
+
+        # Handle enum
+        if "enum" in prop_schema:
+            openapi_prop["enum"] = prop_schema["enum"]
+
+        # Handle minimum/maximum
+        if "minimum" in prop_schema:
+            openapi_prop["minimum"] = prop_schema["minimum"]
+        if "maximum" in prop_schema:
+            openapi_prop["maximum"] = prop_schema["maximum"]
+
+        # Handle minLength/maxLength
+        if "minLength" in prop_schema:
+            openapi_prop["minLength"] = prop_schema["minLength"]
+        if "maxLength" in prop_schema:
+            openapi_prop["maxLength"] = prop_schema["maxLength"]
+
+        # Handle pattern
+        if "pattern" in prop_schema:
+            openapi_prop["pattern"] = prop_schema["pattern"]
+
+        # Handle items for arrays
+        if "items" in prop_schema:
+            openapi_prop["items"] = self._convert_property_schema(prop_schema["items"])
+
+        return openapi_prop

mcp_proxy_adapter/api/openapi/openapi_generator.py

@@ -0,0 +1,40 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Main OpenAPI generator for MCP Proxy Adapter.
+"""
+
+from copy import deepcopy
+from typing import Any, Dict, Optional
+
+from fastapi import FastAPI
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from .schema_loader import SchemaLoader
+from .command_integration import CommandIntegrator
+
+
+class CustomOpenAPIGenerator:
+    """
+    Custom OpenAPI schema generator for compatibility with MCP-Proxy.
+
+    EN:
+    This generator creates an OpenAPI schema that matches the format expected by MCP-Proxy,
+    enabling dynamic command loading and proper tool representation in AI models.
+    Allows overriding title, description, and version for schema customization.
+
+    RU:
+    Кастомный генератор схемы OpenAPI для совместимости с MCP-Proxy.
+    Позволяет создавать схему OpenAPI в формате, ожидаемом MCP-Proxy,
+    с возможностью динамической подгрузки команд и корректного отображения инструментов для AI-моделей.
+    Поддерживает переопределение title, description и version для кастомизации схемы.
+    """
+
+    def __init__(self):
+        """Initialize the generator."""
+        self.logger = get_global_logger()
+        self.schema_loader = SchemaLoader()
+        self.command_integrator = CommandIntegrator()
+        self.base_schema = self.schema_loader.load_base_schema()
+

mcp_proxy_adapter/api/openapi/openapi_registry.py

@@ -0,0 +1,62 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Registry for OpenAPI generators.
+"""
+
+from typing import Dict, Callable, Optional, List
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class OpenAPIRegistry:
+    """Registry for OpenAPI generators."""
+
+    def __init__(self):
+        """Initialize OpenAPI registry."""
+        self.logger = get_global_logger()
+        self._generators: Dict[str, Callable] = {}
+
+    def register_generator(self, name: str, generator: Callable) -> None:
+        """
+        Register an OpenAPI generator.
+
+        Args:
+            name: Generator name
+            generator: Generator function
+        """
+        self._generators[name] = generator
+        self.logger.debug(f"Registered OpenAPI generator: {name}")
+
+    def get_generator(self, name: str) -> Optional[Callable]:
+        """
+        Get an OpenAPI generator by name.
+
+        Args:
+            name: Generator name
+
+        Returns:
+            Generator function or None if not found
+        """
+        return self._generators.get(name)
+
+    def list_generators(self) -> List[str]:
+        """
+        List all registered generators.
+
+        Returns:
+            List of generator names
+        """
+        return list(self._generators.keys())
+
+
+
+# Global registry instance
+_registry = OpenAPIRegistry()
+
+
+
+
+
+

mcp_proxy_adapter/api/openapi/schema_loader.py

@@ -0,0 +1,116 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Schema loading utilities for OpenAPI generation.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class SchemaLoader:
+    """Loader for OpenAPI base schemas."""
+
+    def __init__(self):
+        """Initialize schema loader."""
+        self.logger = get_global_logger()
+        self.base_schema_path = (
+            Path(__file__).parent.parent.parent / "schemas" / "openapi_schema.json"
+        )
+
+
+    def get_fallback_schema(self) -> Dict[str, Any]:
+        """
+        Get a fallback OpenAPI schema when the base schema file is not available.
+
+        Returns:
+            Dict containing a basic OpenAPI schema.
+        """
+        return {
+            "openapi": "3.0.2",
+            "info": {
+                "title": "MCP Microservice API",
+                "description": "API для выполнения команд микросервиса",
+                "version": "1.0.0"
+            },
+            "paths": {
+                "/cmd": {
+                    "post": {
+                        "summary": "Execute Command",
+                        "description": "Executes a command via JSON-RPC protocol.",
+                        "operationId": "execute_command",
+                        "requestBody": {
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "oneOf": [
+                                            { "$ref": "#/components/schemas/CommandRequest" },
+                                            { "$ref": "#/components/schemas/JsonRpcRequest" }
+                                        ]
+                                    }
+                                }
+                            },
+                            "required": True
+                        },
+                        "responses": {
+                            "200": {
+                                "description": "Successful Response",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "oneOf": [
+                                                { "$ref": "#/components/schemas/CommandResponse" },
+                                                { "$ref": "#/components/schemas/JsonRpcResponse" }
+                                            ]
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            "components": {
+                "schemas": {
+                    "CommandRequest": {
+                        "type": "object",
+                        "properties": {
+                            "command": {"type": "string"},
+                            "params": {"type": "object"}
+                        },
+                        "required": ["command"]
+                    },
+                    "CommandResponse": {
+                        "type": "object",
+                        "properties": {
+                            "success": {"type": "boolean"},
+                            "data": {"type": "object"},
+                            "error": {"type": "string"}
+                        }
+                    },
+                    "JsonRpcRequest": {
+                        "type": "object",
+                        "properties": {
+                            "jsonrpc": {"type": "string", "enum": ["2.0"]},
+                            "method": {"type": "string"},
+                            "params": {"type": "object"},
+                            "id": {"type": "string"}
+                        },
+                        "required": ["jsonrpc", "method", "id"]
+                    },
+                    "JsonRpcResponse": {
+                        "type": "object",
+                        "properties": {
+                            "jsonrpc": {"type": "string", "enum": ["2.0"]},
+                            "result": {"type": "object"},
+                            "error": {"type": "object"},
+                            "id": {"type": "string"}
+                        }
+                    }
+                }
+            }
+        }