mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.29__py3-none-any.whl

mcp_proxy_adapter/api/core/__init__.py

@@ -0,0 +1,18 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Core API utilities for MCP Proxy Adapter.
+"""
+
+from .app_factory import AppFactory
+from .ssl_context_factory import SSLContextFactory
+from .registration_manager import RegistrationManager
+from .lifespan_manager import LifespanManager
+
+__all__ = [
+    "AppFactory",
+    "SSLContextFactory",
+    "RegistrationManager",
+    "LifespanManager",
+]

mcp_proxy_adapter/api/core/app_factory.py

@@ -0,0 +1,243 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Application factory for MCP Proxy Adapter API.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from fastapi import FastAPI, Body
+from typing import List, Union
+from mcp_proxy_adapter.api.handlers import (
+    execute_command,
+    handle_json_rpc,
+    handle_batch_json_rpc,
+    get_server_health,
+    get_commands_list,
+)
+
+# from mcp_proxy_adapter.api.middleware import setup_middleware
+try:
+    from mcp_proxy_adapter.api.schemas import (
+        JsonRpcRequest,
+        JsonRpcSuccessResponse,
+        JsonRpcErrorResponse,
+        HealthResponse,
+        CommandListResponse,
+        APIToolDescription,
+    )
+except Exception:
+    # If schemas are unavailable, define minimal type aliases to satisfy annotations
+    JsonRpcRequest = Dict[str, Any]  # type: ignore
+    JsonRpcSuccessResponse = Dict[str, Any]  # type: ignore
+    JsonRpcErrorResponse = Dict[str, Any]  # type: ignore
+    HealthResponse = Dict[str, Any]  # type: ignore
+    CommandListResponse = Dict[str, Any]  # type: ignore
+    APIToolDescription = Dict[str, Any]  # type: ignore
+
+try:
+    from mcp_proxy_adapter.api.tools import get_tool_description, execute_tool
+except Exception:
+    get_tool_description = None
+    execute_tool = None
+from mcp_proxy_adapter.core.logging import get_global_logger
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.custom_openapi import custom_openapi_with_fallback
+from .ssl_context_factory import SSLContextFactory
+from .lifespan_manager import LifespanManager
+
+
+class AppFactory:
+    """Factory for creating FastAPI applications."""
+
+    def __init__(self):
+        """Initialize app factory."""
+        self.logger = get_global_logger()
+        self.ssl_factory = SSLContextFactory()
+        self.lifespan_manager = LifespanManager()
+
+    def create_app(
+        self,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        version: Optional[str] = None,
+        app_config: Optional[Dict[str, Any]] = None,
+        config_path: Optional[str] = None,
+    ) -> FastAPI:
+        """
+        Creates and configures FastAPI application.
+
+        Args:
+            title: Application title (default: "MCP Proxy Adapter")
+            description: Application description (default: "JSON-RPC API for interacting with MCP Proxy")
+            version: Application version (default: "1.0.0")
+            app_config: Application configuration dictionary (optional)
+            config_path: Path to configuration file (optional)
+
+        Returns:
+            Configured FastAPI application.
+
+        Raises:
+            SystemExit: If authentication is enabled but required files are missing (security issue)
+        """
+        # Use provided configuration or fallback to global config
+        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:
+                # If app_config is not a dict-like object, use it as is
+                current_config = app_config
+        else:
+            # If no app_config provided, try to get global config
+            try:
+                from mcp_proxy_adapter.config import get_config
+                current_config = get_config().get_all()
+            except Exception:
+                # If global config is not available, create empty config
+                current_config = {}
+
+        # Debug: Check what config is passed to create_app
+        if app_config:
+            if hasattr(app_config, "keys"):
+                print(
+                    f"🔍 Debug: create_app received app_config keys: {list(app_config.keys())}"
+                )
+                # Debug SSL configuration
+                protocol = app_config.get("server", {}).get("protocol", "http")
+                verify_client = app_config.get("transport", {}).get("verify_client", False)
+                ssl_enabled = protocol in ["https", "mtls"] or verify_client
+                print(f"🔍 Debug: create_app SSL config: enabled={ssl_enabled}")
+                print(f"🔍 Debug: create_app protocol: {protocol}")
+                print(f"🔍 Debug: create_app verify_client: {verify_client}")
+            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")
+
+        # Security check: Validate configuration strictly at startup (fail-fast)
+        self._validate_configuration(current_config)
+
+        # Security check: Validate all authentication configurations before startup
+        self._validate_security_configuration(current_config)
+
+        # Set default values
+        title = title or "MCP Proxy Adapter"
+        description = description or "JSON-RPC API for interacting with MCP Proxy"
+        version = version or "1.0.0"
+
+        # Create lifespan manager
+        lifespan = self.lifespan_manager.create_lifespan(config_path, current_config)
+
+        # Create FastAPI application
+        app = FastAPI(
+            title=title,
+            description=description,
+            version=version,
+            lifespan=lifespan,
+        )
+
+        # Setup middleware - disabled for now
+        # setup_middleware(app, current_config)
+
+        # Setup routes
+        self._setup_routes(app)
+
+        # Setup OpenAPI
+        app.openapi = lambda: custom_openapi_with_fallback(app)
+
+        return app
+
+    def _validate_configuration(self, current_config: Dict[str, Any]) -> None:
+        """Validate configuration at startup."""
+        try:
+            from mcp_proxy_adapter.core.config_validator import ConfigValidator
+
+            validator = ConfigValidator()
+            validator.config_data = current_config
+            validation_results = validator.validate_config()
+            errors = [r for r in validation_results if r.level == "error"]
+            warnings = [r for r in validation_results if r.level == "warning"]
+            
+            if errors:
+                self.logger.critical("CRITICAL CONFIG ERROR: Invalid configuration at startup:")
+                for error in errors:
+                    self.logger.critical(f"  - {error.message}")
+                raise SystemExit(1)
+            for warning in warnings:
+                self.logger.warning(f"Config warning: {warning.message}")
+        except Exception as ex:
+            self.logger.error(f"Failed to run startup configuration validation: {ex}")
+
+    def _validate_security_configuration(self, current_config: Dict[str, Any]) -> None:
+        """Validate security configuration at startup."""
+        security_errors = []
+
+        print(f"🔍 Debug: current_config keys: {list(current_config.keys())}")
+        if "security" in current_config:
+            print(f"🔍 Debug: security config: {current_config['security']}")
+        if "roles" in current_config:
+            print(f"🔍 Debug: roles config: {current_config['roles']}")
+
+        # Check security framework configuration only if enabled
+        security_config = current_config.get("security", {})
+        if security_config.get("enabled", False):
+            # Validate security framework configuration
+            from mcp_proxy_adapter.core.unified_config_adapter import UnifiedConfigAdapter
+
+            adapter = UnifiedConfigAdapter()
+            validation_result = adapter.validate_configuration(current_config)
+
+            if not validation_result.is_valid:
+                security_errors.extend(validation_result.errors)
+
+        # Check roles configuration only if enabled
+        roles_config = current_config.get("roles", {})
+        if roles_config.get("enabled", False):
+            # Validate roles configuration
+            from mcp_proxy_adapter.core.role_utils import RoleUtils
+
+            role_utils = RoleUtils()
+            validation_result = role_utils.validate_configuration(current_config)
+
+            if not validation_result.is_valid:
+                security_errors.extend(validation_result.errors)
+
+        # Fail if there are security errors
+        if security_errors:
+            self.logger.critical("CRITICAL SECURITY ERROR: Invalid security configuration at startup:")
+            for error in security_errors:
+                self.logger.critical(f"  - {error}")
+            raise SystemExit(1)
+
+    def _setup_routes(self, app: FastAPI) -> None:
+        """Setup application routes."""
+        @app.get("/health", response_model=HealthResponse)
+        async def health():  # type: ignore
+            return await get_server_health()  # type: ignore[misc]
+
+        @app.get("/commands", response_model=CommandListResponse)
+        async def commands():  # type: ignore
+            return await get_commands_list()  # type: ignore[misc]
+
+        @app.post("/api/jsonrpc", response_model=Union[JsonRpcSuccessResponse, JsonRpcErrorResponse])
+        async def jsonrpc(request: JsonRpcRequest):  # type: ignore
+            return await handle_json_rpc(request.dict())  # type: ignore[misc]
+
+        @app.post("/api/jsonrpc/batch", response_model=List[Union[JsonRpcSuccessResponse, JsonRpcErrorResponse]])
+        async def jsonrpc_batch(requests: List[JsonRpcRequest]):  # type: ignore
+            return await handle_batch_json_rpc([req.dict() for req in requests])  # type: ignore[misc]
+
+        # Optional tool endpoints if tools module is available
+        if get_tool_description and execute_tool:
+            @app.get("/api/tools", response_model=List[APIToolDescription])
+            async def tools():  # type: ignore
+                return await get_tool_description()  # type: ignore[misc]
+
+            @app.post("/api/tools/{tool_name}")
+            async def execute_tool_endpoint(tool_name: str, params: Dict[str, Any] = Body(...)):
+                return await execute_tool(tool_name, params)  # type: ignore[misc]

mcp_proxy_adapter/api/core/lifespan_manager.py

@@ -0,0 +1,55 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Lifespan management utilities for MCP Proxy Adapter API.
+"""
+
+import asyncio
+from contextlib import asynccontextmanager
+from typing import Any, Dict, Optional
+
+from fastapi import FastAPI
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from .registration_manager import RegistrationManager
+
+
+class LifespanManager:
+    """Manager for application lifespan events."""
+
+    def __init__(self):
+        """Initialize lifespan manager."""
+        self.logger = get_global_logger()
+        self.registration_manager = RegistrationManager()
+
+    def create_lifespan(self, config_path: Optional[str] = None, current_config: Optional[Dict[str, Any]] = None):
+        """
+        Create lifespan manager for the FastAPI application.
+
+        Args:
+            config_path: Path to configuration file (optional)
+            current_config: Current configuration data (optional)
+
+        Returns:
+            Lifespan context manager
+        """
+
+        @asynccontextmanager
+        async def lifespan(app: FastAPI):
+            """Lifespan context manager."""
+            # Startup
+            get_global_logger().info("Starting MCP Proxy Adapter")
+            
+            # Register with proxy if configured
+            if current_config:
+                await self.registration_manager.register_with_proxy(current_config)
+                await self.registration_manager.start_heartbeat(current_config)
+            
+            yield
+            
+            # Shutdown
+            get_global_logger().info("Shutting down MCP Proxy Adapter")
+            await self.registration_manager.stop()
+
+        return lifespan

mcp_proxy_adapter/api/core/registration_manager.py

@@ -0,0 +1,166 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Registration management utilities for MCP Proxy Adapter API.
+"""
+
+import os
+import socket
+import asyncio
+from typing import Dict, Any, Optional
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from mcp_proxy_adapter.client.jsonrpc_client import JsonRpcClient
+
+
+class RegistrationManager:
+    """Manager for proxy registration functionality using JsonRpcClient."""
+
+    def __init__(self):
+        """Initialize registration manager."""
+        self.logger = get_global_logger()
+        self.registered = False
+        self.registration_task: Optional[asyncio.Task] = None
+        self.server_name: Optional[str] = None
+        self.server_url: Optional[str] = None
+        self.proxy_url: Optional[str] = None
+        self.capabilities: list = []
+        self.metadata: Dict[str, Any] = {}
+
+    async def register_with_proxy(self, config: Dict[str, Any]) -> bool:
+        """Register this server with the proxy using JsonRpcClient."""
+        try:
+            proxy_config = config.get("proxy_registration", {})
+            if not proxy_config.get("enabled", False):
+                self.logger.info("Proxy registration disabled")
+                return True
+
+            proxy_url = proxy_config.get("proxy_url") or proxy_config.get("server_url")
+            if not proxy_url:
+                self.logger.warning("No proxy server URL configured")
+                return False
+
+            # Get server info
+            server_config = config.get("server", {})
+            host = server_config.get("host", "127.0.0.1")
+            port = server_config.get("port", 8000)
+            protocol = server_config.get("protocol", "http")
+
+            # Use advertised host if available
+            advertised_host = server_config.get("advertised_host") or host
+            scheme = "https" if protocol in ("https", "mtls") else "http"
+            advertised_url = f"{scheme}://{advertised_host}:{port}"
+
+            # Get server name from config or generate default
+            server_name = (
+                proxy_config.get("server_id")
+                or proxy_config.get("server_name")
+                or f"mcp-adapter-{host}-{port}"
+            )
+
+            self.server_name = server_name
+            self.server_url = advertised_url
+            self.proxy_url = proxy_url
+
+            # Get capabilities and metadata
+            self.capabilities = proxy_config.get("capabilities", ["jsonrpc", "health"])
+            self.metadata = {
+                "uuid": config.get("uuid"),
+                "protocol": protocol,
+                "host": host,
+                "port": port,
+                **(proxy_config.get("metadata") or {}),
+            }
+
+            # Use JsonRpcClient for registration (run in executor as it's synchronous)
+            loop = asyncio.get_event_loop()
+            client = JsonRpcClient(protocol="http", host="127.0.0.1", port=8080)  # Dummy, just for methods
+
+            # Register synchronously in executor
+            def _register():
+                return client.register_with_proxy(
+                    proxy_url=proxy_url,
+                    server_name=server_name,
+                    server_url=advertised_url,
+                    capabilities=self.capabilities,
+                    metadata=self.metadata,
+                )
+
+            try:
+                result = await loop.run_in_executor(None, _register)
+                self.logger.info(f"✅ Successfully registered with proxy as {server_name} -> {advertised_url}")
+                self.registered = True
+                return True
+            except Exception as exc:
+                self.logger.error(f"❌ Failed to register with proxy: {exc}")
+                return False
+
+        except Exception as e:
+            self.logger.error(f"❌ Registration error: {e}")
+            return False
+
+    async def start_heartbeat(self, config: Dict[str, Any]) -> None:
+        """Start heartbeat task using JsonRpcClient."""
+        if not self.registered or not self.proxy_url or not self.server_name or not self.server_url:
+            return
+
+        proxy_config = config.get("proxy_registration", {})
+        heartbeat_config = proxy_config.get("heartbeat", {}) or {}
+        heartbeat_interval = heartbeat_config.get("interval", proxy_config.get("heartbeat_interval", 30))
+
+        self.logger.info(f"💓 Starting heartbeat task (interval: {heartbeat_interval}s)")
+
+        async def heartbeat_loop():
+            loop = asyncio.get_event_loop()
+            client = JsonRpcClient(protocol="http", host="127.0.0.1", port=8080)  # Dummy, just for methods
+
+            def _heartbeat():
+                return client.heartbeat_to_proxy(
+                    proxy_url=self.proxy_url,
+                    server_name=self.server_name,
+                    server_url=self.server_url,
+                    capabilities=self.capabilities,
+                    metadata=self.metadata,
+                )
+
+            while True:
+                try:
+                    await asyncio.sleep(max(2, heartbeat_interval))
+                    await loop.run_in_executor(None, _heartbeat)
+                    self.logger.debug("💓 Heartbeat sent successfully")
+                except asyncio.CancelledError:
+                    break
+                except Exception as e:
+                    self.logger.error(f"Heartbeat error: {e}")
+
+        self.registration_task = asyncio.create_task(heartbeat_loop())
+
+    async def stop(self) -> None:
+        """Stop registration manager and unregister from proxy."""
+        # Cancel heartbeat task
+        if self.registration_task:
+            self.registration_task.cancel()
+            try:
+                await self.registration_task
+            except asyncio.CancelledError:
+                pass
+
+        # Unregister from proxy if registered
+        if self.registered and self.proxy_url and self.server_name:
+            try:
+                loop = asyncio.get_event_loop()
+                client = JsonRpcClient(protocol="http", host="127.0.0.1", port=8080)  # Dummy, just for methods
+
+                def _unregister():
+                    return client.unregister_from_proxy(
+                        proxy_url=self.proxy_url,
+                        server_name=self.server_name,
+                    )
+
+                await loop.run_in_executor(None, _unregister)
+                self.logger.info(f"🛑 Unregistered from proxy: {self.server_name}")
+            except Exception as e:
+                self.logger.error(f"Error unregistering from proxy: {e}")
+
+        self.registered = False

mcp_proxy_adapter/api/core/ssl_context_factory.py

@@ -0,0 +1,88 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+SSL context factory for MCP Proxy Adapter API.
+"""
+
+import ssl
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from mcp_proxy_adapter.core.ssl_utils import SSLUtils
+
+
+class SSLContextFactory:
+    """Factory for creating SSL contexts."""
+
+    def __init__(self):
+        """Initialize SSL context factory."""
+        self.logger = get_global_logger()
+
+    def create_ssl_context(
+        self,
+        app_config: Optional[Dict[str, Any]] = None
+    ) -> Optional[ssl.SSLContext]:
+        """
+        Create SSL context based on configuration.
+
+        Args:
+            app_config: Application configuration dictionary (optional)
+
+        Returns:
+            SSL context if SSL is enabled and properly configured, None otherwise
+        """
+        from mcp_proxy_adapter.config import config
+        
+        current_config = app_config if app_config is not None else config.get_all()
+
+        # Check SSL configuration from new structure
+        protocol = current_config.get("server", {}).get("protocol", "http")
+        verify_client = current_config.get("transport", {}).get("verify_client", False)
+        ssl_enabled = protocol in ["https", "mtls"] or verify_client
+
+        if not ssl_enabled:
+            self.logger.info("SSL is disabled in configuration")
+            return None
+
+        # Get certificate paths from configuration
+        cert_file = current_config.get("transport", {}).get("cert_file")
+        key_file = current_config.get("transport", {}).get("key_file")
+        ca_cert = current_config.get("transport", {}).get("ca_cert")
+        
+        # Convert relative paths to absolute paths
+        if cert_file and not Path(cert_file).is_absolute():
+            project_root = Path(__file__).parent.parent.parent.parent
+            cert_file = str(project_root / cert_file)
+        if key_file and not Path(key_file).is_absolute():
+            project_root = Path(__file__).parent.parent.parent.parent
+            key_file = str(project_root / key_file)
+        if ca_cert and not Path(ca_cert).is_absolute():
+            project_root = Path(__file__).parent.parent.parent.parent
+            ca_cert = str(project_root / ca_cert)
+
+        if not cert_file or not key_file:
+            self.logger.warning("SSL enabled but certificate or key file not specified")
+            return None
+
+        try:
+            # Create SSL context using SSLUtils
+            ssl_context = SSLUtils.create_ssl_context(
+                cert_file=cert_file,
+                key_file=key_file,
+                ca_cert=ca_cert,
+                verify_client=current_config.get("transport", {}).get("verify_client", False),
+                cipher_suites=[],
+                min_tls_version="1.2",
+                max_tls_version="1.3",
+            )
+
+            self.logger.info(
+                f"SSL context created successfully for mode: https_only"
+            )
+            return ssl_context
+
+        except Exception as e:
+            self.logger.error(f"Failed to create SSL context: {e}")
+            return None