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

mcp_proxy_adapter/api/core/registration_tasks.py

@@ -0,0 +1,84 @@
+"""Async helper routines for proxy heartbeat and unregister flows.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Dict, List
+
+from mcp_proxy_adapter.client.jsonrpc_client import JsonRpcClient
+
+from .registration_context import HeartbeatSettings, ProxyCredentials
+
+
+def create_heartbeat_task(
+    proxy_url: str,
+    server_name: str,
+    server_url: str,
+    capabilities: List[str],
+    metadata: Dict[str, Any],
+    settings: HeartbeatSettings,
+    credentials: ProxyCredentials,
+    logger: Any,
+) -> asyncio.Task:
+    """Create and return an asyncio Task that sends heartbeats."""
+
+    interval = max(2, settings.interval)
+
+    async def heartbeat_loop() -> None:
+        client = JsonRpcClient(protocol="http", host="127.0.0.1", port=8080)
+        try:
+
+            async def _send() -> None:
+                await client.heartbeat_to_proxy(
+                    proxy_url=proxy_url,
+                    server_name=server_name,
+                    server_url=server_url,
+                    capabilities=list(capabilities),
+                    metadata=metadata,
+                    cert=credentials.cert,
+                    verify=credentials.verify,
+                )
+
+            while True:
+                try:
+                    await asyncio.sleep(interval)
+                    await _send()
+                    logger.debug("\ud83d\udc93 Heartbeat sent successfully")
+                except asyncio.CancelledError:
+                    raise
+                except Exception as exc:  # noqa: BLE001
+                    logger.error(f"Heartbeat error: {exc}")
+        except asyncio.CancelledError:
+            logger.debug("Heartbeat loop cancelled")
+            raise
+        finally:
+            await client.close()
+
+    return asyncio.create_task(heartbeat_loop())
+
+
+async def unregister_from_proxy(
+    proxy_url: str,
+    server_name: str,
+    endpoint: str,
+    credentials: ProxyCredentials,
+    logger: Any,
+) -> None:
+    """Unregister adapter from proxy using provided credentials."""
+
+    client = JsonRpcClient(protocol="http", host="127.0.0.1", port=8080)
+    try:
+        full_url = f"{proxy_url}{endpoint}"
+        await client.unregister_from_proxy(
+            proxy_url=full_url,
+            server_name=server_name,
+            cert=credentials.cert,
+            verify=credentials.verify,
+        )
+        logger.info(f"\ud83d\udd1a Unregistered from proxy: {server_name}")
+    finally:
+        await client.close()

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

mcp_proxy_adapter/api/handlers.py

@@ -0,0 +1,181 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+HTTP handlers for the MCP Proxy Adapter API.
+Provides JSON-RPC handling and health/commands endpoints.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any, Dict, List, Optional
+
+from fastapi import Request
+
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.errors import (
+    MicroserviceError,
+    NotFoundError,
+    InvalidRequestError,
+    MethodNotFoundError,
+    InvalidParamsError,
+    InternalError,
+)
+from mcp_proxy_adapter.core.logging import get_global_logger, RequestLogger
+
+
+async def execute_command(
+    command_name: str,
+    params: Dict[str, Any],
+    request_id: Optional[str] = None,
+    request: Optional[Request] = None,
+) -> Dict[str, Any]:
+    """Execute a registered command by name with parameters.
+
+    Raises MethodNotFoundError if command is not found.
+    Wraps unexpected exceptions into InternalError.
+    """
+    logger = RequestLogger(__name__, request_id) if request_id else get_global_logger()
+
+    try:
+        logger.info(f"Executing command: {command_name}")
+
+        # Resolve command
+        try:
+            command_class = registry.get_command(command_name)
+        except Exception:
+            raise MethodNotFoundError(f"Method not found: {command_name}")
+
+        # Build context (user info if middleware set state)
+        context: Dict[str, Any] = {}
+        if request is not None and hasattr(request, "state"):
+            user_id = getattr(request.state, "user_id", None)
+            user_role = getattr(request.state, "user_role", None)
+            user_roles = getattr(request.state, "user_roles", None)
+            if user_id or user_role or user_roles:
+                context["user"] = {
+                    "id": user_id,
+                    "role": user_role,
+                    "roles": user_roles or [],
+                }
+
+        # Execute with timeout
+        started_at = time.time()
+        try:
+            result_obj = await asyncio.wait_for(
+                command_class.run(**params, context=context), timeout=30.0
+            )
+        except asyncio.TimeoutError:
+            elapsed = time.time() - started_at
+            raise InternalError(f"Command timed out after {elapsed:.2f}s")
+
+        elapsed = time.time() - started_at
+        logger.info(f"Command '{command_name}' executed in {elapsed:.3f}s")
+        return result_obj.to_dict()
+
+    except MicroserviceError:
+        raise
+    except Exception as exc:
+        logger.exception(f"Unhandled error in command '{command_name}': {exc}")
+        raise InternalError("Internal error", data={"error": str(exc)})
+
+
+async def handle_batch_json_rpc(
+    batch_requests: List[Dict[str, Any]], request: Optional[Request] = None
+) -> List[Dict[str, Any]]:
+    """Handle batch JSON-RPC requests."""
+    responses: List[Dict[str, Any]] = []
+    request_id = getattr(request.state, "request_id", None) if request else None
+    for item in batch_requests:
+        responses.append(await handle_json_rpc(item, request_id, request))
+    return responses
+
+
+async def handle_json_rpc(
+    request_data: Dict[str, Any],
+    request_id: Optional[str] = None,
+    request: Optional[Request] = None,
+) -> Dict[str, Any]:
+    """Handle a single JSON-RPC request with strict 2.0 compatibility.
+
+    Also supports simplified form: {"command": "echo", "params": {...}}.
+    """
+    logger = RequestLogger(__name__, request_id) if request_id else get_global_logger()
+
+    method: Optional[str]
+    params: Dict[str, Any]
+    json_rpc_id: Any
+
+    if "jsonrpc" in request_data:
+        if request_data.get("jsonrpc") != "2.0":
+            return _error_response(InvalidRequestError("Invalid Request: jsonrpc must be '2.0'"), request_data.get("id"))
+        method = request_data.get("method")
+        params = request_data.get("params", {})
+        json_rpc_id = request_data.get("id")
+        if not method:
+            return _error_response(InvalidRequestError("Invalid Request: method is required"), json_rpc_id)
+    else:
+        # Simplified
+        method = request_data.get("command")
+        params = request_data.get("params", {})
+        json_rpc_id = request_data.get("id", 1)
+        if not method:
+            return _error_response(InvalidRequestError("Invalid Request: command is required"), json_rpc_id)
+
+    try:
+        result = await execute_command(method, params, request_id, request)
+        return {"jsonrpc": "2.0", "result": result, "id": json_rpc_id}
+    except MicroserviceError as err:
+        return _error_response(err, json_rpc_id)
+    except Exception as exc:
+        logger.exception(f"Unhandled error in JSON-RPC handler: {exc}")
+        return _error_response(InternalError("Internal error", data={"error": str(exc)}), json_rpc_id)
+
+
+def _error_response(error: MicroserviceError, request_id: Any) -> Dict[str, Any]:
+    return {"jsonrpc": "2.0", "error": error.to_dict(), "id": request_id}
+
+
+async def get_server_health() -> Dict[str, Any]:
+    """Return server health info."""
+    import os
+    import platform
+    import sys
+    import psutil
+    from datetime import datetime
+
+    process = psutil.Process(os.getpid())
+    start_time = datetime.fromtimestamp(process.create_time())
+    uptime_seconds = (datetime.now() - start_time).total_seconds()
+    mem = process.memory_info().rss / (1024 * 1024)
+
+    return {
+        "status": "ok",
+        "model": "mcp-proxy-adapter",
+        "version": "1.0.0",
+        "uptime": uptime_seconds,
+        "components": {
+            "system": {
+                "python_version": sys.version,
+                "platform": platform.platform(),
+                "cpu_count": os.cpu_count(),
+            },
+            "process": {
+                "pid": os.getpid(),
+                "memory_usage_mb": mem,
+                "start_time": start_time.isoformat(),
+            },
+            "commands": {"registered_count": len(registry.get_all_commands())},
+        },
+    }
+
+
+async def get_commands_list() -> Dict[str, Dict[str, Any]]:
+    """Return list of registered commands with schemas."""
+    result: Dict[str, Dict[str, Any]] = {}
+    for name, cls in registry.get_all_commands().items():
+        schema = cls.get_schema()
+        result[name] = {"name": name, "schema": schema, "description": schema.get("description", "")}
+    return result

mcp_proxy_adapter/api/middleware/__init__.py

@@ -0,0 +1,21 @@
+"""
+Middleware package for API.
+This package contains middleware components for request processing.
+"""
+
+from typing import Dict, Any, Optional
+from fastapi import FastAPI
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from mcp_proxy_adapter.config import config
+from .factory import MiddlewareFactory
+# from .protocol_middleware import setup_protocol_middleware
+
+# Export mcp_security_framework availability
+try:
+    from .user_info_middleware import _MCP_SECURITY_AVAILABLE
+    mcp_security_framework = _MCP_SECURITY_AVAILABLE
+except ImportError:
+    mcp_security_framework = False
+
+

mcp_proxy_adapter/api/middleware/base.py

@@ -0,0 +1,54 @@
+"""
+Base middleware module.
+"""
+
+from typing import Callable, Awaitable
+import logging
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from fastapi import Request, Response
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class BaseMiddleware(BaseHTTPMiddleware):
+    """
+    Base class for all middleware.
+    """
+
+
+    async def before_request(self, request: Request) -> None:
+        """
+        Method for processing request before calling the main handler.
+
+        Args:
+            request: Request.
+        """
+        pass
+
+    async def after_response(self, request: Request, response: Response) -> Response:
+        """
+        Method for processing response after calling the main handler.
+
+        Args:
+            request: Request.
+            response: Response.
+
+        Returns:
+            Processed response.
+        """
+        return response
+
+    async def handle_error(self, request: Request, exception: Exception) -> Response:
+        """
+        Method for handling errors that occurred in middleware.
+
+        Args:
+            request: Request.
+            exception: Exception.
+
+        Returns:
+            Error response.
+        """
+        # By default, just pass the error further
+        raise exception

mcp_proxy_adapter/api/middleware/command_permission_middleware.py

@@ -0,0 +1,73 @@
+"""
+Command Permission Middleware
+
+This middleware checks permissions for specific commands based on user roles.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+import logging
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class CommandPermissionMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware for checking command permissions.
+
+    This middleware checks if the authenticated user has the required
+    permissions to execute specific commands.
+    """
+
+    def __init__(self, app, config: Dict[str, Any]):
+        """
+        Initialize command permission middleware.
+
+        Args:
+            app: FastAPI application
+            config: Configuration dictionary
+        """
+        super().__init__(app)
+        self.config = config
+
+        # Define command permissions
+        self.command_permissions = {
+            "echo": ["read"],
+            "health": ["read"],
+            "role_test": ["read"],
+            "config": ["read"],
+            "help": ["read"],
+            # Add more commands as needed
+        }
+
+        get_global_logger().info("Command permission middleware initialized")
+
+
+    def _check_permissions(
+        self, user_roles: list, user_permissions: list, required_permissions: list
+    ) -> bool:
+        """
+        Check if user has required permissions.
+
+        Args:
+            user_roles: User roles
+            user_permissions: User permissions
+            required_permissions: Required permissions
+
+        Returns:
+            True if user has required permissions
+        """
+        # Admin has all permissions
+        if "admin" in user_roles or "*" in user_permissions:
+            return True
+
+        # Check if user has all required permissions
+        for required in required_permissions:
+            if required not in user_permissions:
+                return False
+
+        return True

mcp_proxy_adapter/api/middleware/error_handling.py

@@ -0,0 +1,76 @@
+"""
+Middleware for error handling.
+"""
+
+import json
+from typing import Optional, Any
+
+from fastapi import Request, Response
+from starlette.responses import JSONResponse
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from mcp_proxy_adapter.core.errors import (
+    MicroserviceError,
+    CommandError,
+    ValidationError,
+)
+from .base import BaseMiddleware
+
+
+class ErrorHandlingMiddleware(BaseMiddleware):
+    """
+    Middleware for handling and formatting errors.
+    """
+
+    def __init__(self, app):
+        """
+        Initialize error handling middleware.
+
+        Args:
+            app: FastAPI application
+        """
+        super().__init__(app)
+
+
+    def _is_json_rpc_request(self, request: Request) -> bool:
+        """
+        Checks if request is a JSON-RPC request.
+
+        Args:
+            request: Request.
+
+        Returns:
+            True if request is JSON-RPC, False otherwise.
+        """
+        # Only requests to /api/jsonrpc are JSON-RPC requests
+        return request.url.path == "/api/jsonrpc"
+
+    async def _get_json_rpc_id(self, request: Request) -> Optional[Any]:
+        """
+        Gets JSON-RPC request ID.
+
+        Args:
+            request: Request.
+
+        Returns:
+            JSON-RPC request ID if available, None otherwise.
+        """
+        try:
+            # Use request state to avoid body parsing if already done
+            if hasattr(request.state, "json_rpc_id"):
+                return request.state.json_rpc_id
+
+            # Parse request body
+            body = await request.body()
+            if body:
+                body_text = body.decode("utf-8")
+                body_json = json.loads(body_text)
+                request_id = body_json.get("id")
+
+                # Save ID in request state to avoid reparsing
+                request.state.json_rpc_id = request_id
+                return request_id
+        except Exception as e:
+            get_global_logger().warning(f"Error parsing JSON-RPC ID: {str(e)}")
+
+        return None