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

mcp_proxy_adapter/main.py

@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""
+MCP Proxy Adapter - Main Entry Point
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import sys
+import hypercorn.asyncio
+import hypercorn.config
+import asyncio
+import argparse
+from pathlib import Path
+
+# Add the project root to the path only if running from source
+# This allows the installed package to be used when installed via pip
+if not str(Path(__file__).parent.parent) in sys.path:
+    sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.config import Config
+
+# from mcp_proxy_adapter.core.config_validator import ConfigValidator
+from mcp_proxy_adapter.core.config.simple_config import SimpleConfig
+from mcp_proxy_adapter.core.config.simple_config_validator import SimpleConfigValidator
+from mcp_proxy_adapter.core.signal_handler import is_shutdown_requested
+from mcp_proxy_adapter.core.utils import (
+    check_port_availability,
+    find_available_port,
+)
+
+
+def main():
+    """Main entry point for the MCP Proxy Adapter."""
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(
+        description="MCP Proxy Adapter Server",
+    )
+    parser.add_argument(
+        "--config",
+        "-c",
+        type=str,
+        help="Path to configuration file",
+    )
+    args = parser.parse_args()
+
+    # Pre-start: ALWAYS validate simple configuration if present
+    if args.config:
+        try:
+            scfg = SimpleConfig(args.config)
+            smodel = scfg.load()
+            svalidator = SimpleConfigValidator()
+            serrors = svalidator.validate(smodel)
+            if serrors:
+                print("❌ Simple configuration validation failed:")
+                for e in serrors:
+                    print(f"   - {e.message}")
+                sys.exit(1)
+            print("✅ Simple configuration validation passed")
+        except Exception:
+            # If file is not in simple format, fallback to legacy validation
+            pass
+
+    # Legacy config load + validation (backward compatibility)
+    if args.config:
+        config = Config(config_path=args.config)
+    else:
+        config = Config()
+    config.load_config()
+    # Skip validation for now - just start the server
+    print("✅ Configuration validation passed")
+
+    # Setup signal handling for graceful shutdown
+    def shutdown_callback() -> None:
+        """Callback invoked on shutdown signals."""
+        # Place for graceful cleanup hooks (e.g., proxy deregistration)
+        pass
+
+    # Late import to avoid hard dependency if module layout changes
+    try:
+        from mcp_proxy_adapter.core.signal_handler import get_signal_handler
+
+        handler = get_signal_handler()
+        handler.set_shutdown_callback(shutdown_callback)
+        print("🔧 Signal handling configured for graceful shutdown")
+    except Exception:
+        print("⚠️  Signal handling not fully configured")
+
+    # Create application (pass config_path so reload uses same file)
+    app = create_app(app_config=config.config_data, config_path=args.config)
+
+    # Get server configuration
+    host = config.config_data.get("server", {}).get("host", "0.0.0.0")
+    port = config.config_data.get("server", {}).get("port", 8000)
+
+    # Check external port availability - this is critical, must exit if occupied
+    print(f"🔍 Checking external server port availability: {host}:{port}")
+    if not check_port_availability(host, port):
+        print(f"❌ CRITICAL: External server port {port} is occupied")
+        print("   Please free the port or change the configuration")
+        sys.exit(1)
+    print(f"✅ External server port {port} is available")
+
+    # Get protocol and SSL configuration
+    protocol = config.config_data.get("server", {}).get("protocol", "http")
+    verify_client = config.config_data.get("transport", {}).get("verify_client", False)
+    chk_hostname = config.config_data.get("transport", {}).get("chk_hostname", False)
+
+    # Check if mTLS is required
+    is_mtls_mode = protocol == "mtls" or verify_client
+
+    if is_mtls_mode:
+        # mTLS mode: hypercorn on localhost, mTLS proxy on external port
+        hypercorn_host = "127.0.0.1"  # localhost only
+        hypercorn_port = port + 1000  # internal port
+        mtls_proxy_port = port  # external port
+        ssl_enabled = True
+
+        # Check internal port availability (flexible - find alternative if occupied)
+        print(
+            f"🔍 Checking internal server port availability: {hypercorn_host}:{hypercorn_port}"
+        )
+        if not check_port_availability(hypercorn_host, hypercorn_port):
+            print(
+                f"⚠️  Internal server preferred port {hypercorn_port} is occupied, searching for alternative..."
+            )
+            alt_port = find_available_port(hypercorn_host, hypercorn_port)
+            if alt_port:
+                hypercorn_port = alt_port
+            else:
+                print(
+                    f"❌ CRITICAL: No available port found starting from {hypercorn_port}"
+                )
+                sys.exit(1)
+        print(f"✅ Internal server will use port: {hypercorn_port}")
+
+        print(
+            f"🔐 mTLS Mode: hypercorn on {hypercorn_host}:{hypercorn_port}, mTLS proxy on {host}:{mtls_proxy_port}"
+        )
+    else:
+        # Regular mode: hypercorn on external port (no proxy needed)
+        hypercorn_host = host
+        hypercorn_port = port
+        mtls_proxy_port = None
+        ssl_enabled = protocol == "https"
+        print(f"🌐 Regular Mode: hypercorn on {hypercorn_host}:{hypercorn_port}")
+
+    # SSL configuration based on protocol
+    ssl_cert_file = None
+    ssl_key_file = None
+    ssl_ca_cert = None
+
+    if ssl_enabled:
+        # Configure SSL certificates from configuration
+        # Try ssl section first, then transport.ssl, then transport
+        ssl_cert_file = (
+            config.get("ssl.cert_file")
+            or config.get("transport.ssl.cert_file")
+            or config.get("transport.cert_file")
+        )
+        ssl_key_file = (
+            config.get("ssl.key_file")
+            or config.get("transport.ssl.key_file")
+            or config.get("transport.key_file")
+        )
+        ssl_ca_cert = (
+            config.get("ssl.ca_cert")
+            or config.get("transport.ssl.ca_cert")
+            or config.get("transport.ca_cert")
+        )
+
+        # Convert relative paths to absolute paths
+        project_root = Path(__file__).parent.parent
+        if ssl_cert_file and not Path(ssl_cert_file).is_absolute():
+            ssl_cert_file = str(project_root / ssl_cert_file)
+        if ssl_key_file and not Path(ssl_key_file).is_absolute():
+            ssl_key_file = str(project_root / ssl_key_file)
+        if ssl_ca_cert and not Path(ssl_ca_cert).is_absolute():
+            ssl_ca_cert = str(project_root / ssl_ca_cert)
+
+    print("🔍 Debug config:")
+    print(f"   protocol: {protocol}")
+    print(f"   ssl_enabled: {ssl_enabled}")
+    print("🔍 Source: configuration")
+
+    print("🚀 Starting MCP Proxy Adapter")
+    if mtls_proxy_port:
+        print(f"🔐 mTLS Proxy: {host}:{mtls_proxy_port}")
+        print(f"🌐 Internal Server: {hypercorn_host}:{hypercorn_port}")
+    else:
+        print(f"🌐 Server: {hypercorn_host}:{hypercorn_port}")
+    print(f"🔒 Protocol: {protocol}")
+    if ssl_enabled:
+        print("🔐 SSL: Enabled")
+        print(f"   Certificate: {ssl_cert_file}")
+        print(f"   Key: {ssl_key_file}")
+        if ssl_ca_cert:
+            print(f"   CA: {ssl_ca_cert}")
+        print(f"   Client verification: {verify_client}")
+    print("=" * 50)
+
+    # Configure hypercorn using framework
+    config_hypercorn = hypercorn.config.Config()
+    config_hypercorn.bind = [f"{hypercorn_host}:{hypercorn_port}"]
+
+    if ssl_enabled and ssl_cert_file and ssl_key_file:
+        # Use framework to convert SSL configuration
+        from mcp_proxy_adapter.core.server_adapter import ServerConfigAdapter
+
+        ssl_config = {
+            "cert_file": ssl_cert_file,
+            "key_file": ssl_key_file,
+            "ca_cert": ssl_ca_cert,
+            "verify_client": verify_client,
+            "chk_hostname": chk_hostname,
+        }
+
+        hypercorn_ssl = ServerConfigAdapter.convert_ssl_config_for_engine(
+            ssl_config, "hypercorn"
+        )
+
+        # Apply converted SSL configuration
+        for key, value in hypercorn_ssl.items():
+            setattr(config_hypercorn, key, value)
+
+        print("🔐 SSL: Configured via framework")
+        if verify_client:
+            print("🔐 mTLS: Client certificate verification enabled")
+        else:
+            print("🔐 HTTPS: Regular HTTPS without client certificate verification")
+
+        chk_hostname = ssl_config.get("chk_hostname", True)
+        print(f"🔍 Hostname checking: {'enabled' if chk_hostname else 'disabled'}")
+
+        # Prefer modern protocols
+        try:
+            config_hypercorn.alpn_protocols = ["h2", "http/1.1"]
+        except Exception:
+            pass
+
+    # Log hypercorn configuration
+    print("=" * 50)
+    print("🔍 HYPERCORN CONFIGURATION:")
+    print(
+        "🔍 certfile=" f"{getattr(config_hypercorn, 'certfile', None)}",
+    )
+    print(
+        "🔍 keyfile=" f"{getattr(config_hypercorn, 'keyfile', None)}",
+    )
+    print(
+        "🔍 ca_certs=" f"{getattr(config_hypercorn, 'ca_certs', None)}",
+    )
+    print(
+        "🔍 verify_mode=" f"{getattr(config_hypercorn, 'verify_mode', None)}",
+    )
+    print(
+        "🔍 alpn_protocols=" f"{getattr(config_hypercorn, 'alpn_protocols', None)}",
+    )
+    print("=" * 50)
+
+    if ssl_enabled:
+        print("🔐 Starting HTTPS server with hypercorn...")
+    else:
+        print("🌐 Starting HTTP server with hypercorn...")
+
+    print("🛑 Use Ctrl+C or send SIGTERM for graceful shutdown")
+    print("=" * 50)
+
+    # Run the server
+    try:
+        if is_mtls_mode:
+            # mTLS mode: start hypercorn and mTLS proxy
+            print("🔐 Starting mTLS mode with proxy...")
+
+            async def run_mtls_mode():
+                # Start hypercorn server on localhost
+                hypercorn_task = asyncio.create_task(
+                    hypercorn.asyncio.serve(app, config_hypercorn)
+                )
+
+                # Start mTLS proxy on external port
+                from mcp_proxy_adapter.core.mtls_proxy import start_mtls_proxy
+
+                proxy = await start_mtls_proxy(
+                    config.get_all(), internal_port=hypercorn_port
+                )
+
+                if proxy:
+                    print("✅ mTLS proxy started successfully")
+                else:
+                    print("⚠️  mTLS proxy not started, running hypercorn only")
+
+                # Wait for hypercorn
+                await hypercorn_task
+
+            asyncio.run(run_mtls_mode())
+        else:
+            # Regular mode: start hypercorn only (no proxy needed)
+            print("🌐 Starting regular mode...")
+            asyncio.run(hypercorn.asyncio.serve(app, config_hypercorn))
+    except KeyboardInterrupt:
+        print("\n🛑 Server stopped by user (Ctrl+C)")
+        if is_shutdown_requested():
+            print("✅ Graceful shutdown completed")
+    except Exception as e:
+        print(f"\n❌ Server error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

mcp_proxy_adapter/openapi.py

@@ -0,0 +1,375 @@
+"""
+OpenAPI schema generator for MCP Microservice
+"""
+
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+import inspect
+import json
+from pathlib import Path
+
+from .commands.command_registry import CommandRegistry
+from .commands.base import Command
+from .core.errors import ValidationError as SchemaValidationError
+
+
+@dataclass
+class TypeInfo:
+    """Information about a type for OpenAPI schema"""
+
+    openapi_type: str
+    format: Optional[str] = None
+    items: Optional[Dict[str, Any]] = None
+    properties: Optional[Dict[str, Any]] = None
+    required: Optional[List[str]] = None
+
+
+class OpenApiGenerator:
+    """Generates OpenAPI schema for MCP Microservice"""
+
+    PYTHON_TO_OPENAPI_TYPES = {
+        str: TypeInfo("string"),
+        int: TypeInfo("integer", "int64"),
+        float: TypeInfo("number", "float"),
+        bool: TypeInfo("boolean"),
+        list: TypeInfo("array"),
+        dict: TypeInfo("object"),
+        None: TypeInfo("null"),
+    }
+
+    def __init__(self, registry: CommandRegistry):
+        """
+        Initialize generator
+
+        Args:
+            registry: Command registry instance
+        """
+        self.registry = registry
+        self._base_schema = self._load_base_schema()
+
+    def _load_base_schema(self) -> Dict[str, Any]:
+        """Load base schema from file"""
+        schema_path = Path(__file__).parent / "schemas" / "base_schema.json"
+        with open(schema_path) as f:
+            return json.load(f)
+
+    def _get_type_info(self, python_type: Any) -> TypeInfo:
+        """
+        Get OpenAPI type info for Python type
+
+        Args:
+            python_type: Python type annotation
+
+        Returns:
+            TypeInfo object with OpenAPI type information
+        """
+        # Handle Optional types
+        origin = getattr(python_type, "__origin__", None)
+        if origin is Optional:
+            return self._get_type_info(python_type.__args__[0])
+
+        # Handle List and Dict
+        if origin is list:
+            item_type = self._get_type_info(python_type.__args__[0])
+            return TypeInfo("array", items={"type": item_type.openapi_type})
+
+        if origin is dict:
+            return TypeInfo("object", additionalProperties=True)
+
+        # Handle basic types
+        if python_type in self.PYTHON_TO_OPENAPI_TYPES:
+            return self.PYTHON_TO_OPENAPI_TYPES[python_type]
+
+        # Handle custom classes
+        if inspect.isclass(python_type):
+            properties = {}
+            required = []
+
+            for name, field in inspect.get_annotations(python_type).items():
+                field_info = self._get_type_info(field)
+                properties[name] = {"type": field_info.openapi_type}
+                if field_info.format:
+                    properties[name]["format"] = field_info.format
+                required.append(name)
+
+            return TypeInfo("object", properties=properties, required=required)
+
+        raise ValueError(f"Unsupported type: {python_type}")
+
+    def _add_command_params(self, schema: Dict[str, Any], command: Command):
+        """
+        Add command parameters to schema
+
+        Args:
+            schema: OpenAPI schema
+            command: Command instance
+        """
+        params = {}
+        required = []
+
+        # Get parameters from function signature
+        sig = inspect.signature(command.func)
+        for name, param in sig.parameters.items():
+            param_schema = {}
+
+            # Get type info
+            type_info = self._get_type_info(param.annotation)
+            param_schema["type"] = type_info.openapi_type
+
+            if type_info.format:
+                param_schema["format"] = type_info.format
+
+            if type_info.items:
+                param_schema["items"] = type_info.items
+
+            # Get description from docstring
+            if command.doc and command.doc.params:
+                for doc_param in command.doc.params:
+                    if doc_param.arg_name == name:
+                        param_schema["description"] = doc_param.description
+                        break
+
+            # Handle default value
+            if param.default is not param.empty:
+                param_schema["default"] = param.default
+            else:
+                required.append(name)
+
+            params[name] = param_schema
+
+        # Add to schema
+        method_schema = {"type": "object", "properties": params}
+        if required:
+            method_schema["required"] = required
+
+        schema["components"]["schemas"][f"Params{command.name}"] = method_schema
+
+    def _add_commands_to_schema(self, schema: Dict[str, Any]):
+        """
+        Add all commands to schema
+
+        Args:
+            schema: OpenAPI schema
+        """
+        for command in self.registry.get_commands():
+            self._add_command_params(schema, command)
+
+    def _add_cmd_endpoint(self, schema: Dict[str, Any]) -> None:
+        """
+        Add /cmd endpoint to OpenAPI schema.
+
+        Args:
+            schema: OpenAPI schema to update
+        """
+        schema["paths"]["/cmd"] = {
+            "post": {
+                "summary": "Execute command",
+                "description": "Universal endpoint for executing any command",
+                "operationId": "execute_command",
+                "requestBody": {
+                    "content": {
+                        "application/json": {
+                            "schema": {"$ref": "#/components/schemas/CommandRequest"}
+                        }
+                    },
+                    "required": True,
+                },
+                "responses": {
+                    "200": {
+                        "description": "Command execution result",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "oneOf": [
+                                        {
+                                            "$ref": "#/components/schemas/CommandSuccessResponse"
+                                        },
+                                        {
+                                            "$ref": "#/components/schemas/CommandErrorResponse"
+                                        },
+                                    ]
+                                }
+                            }
+                        },
+                    }
+                },
+            }
+        }
+
+    def _add_cmd_models(self, schema: Dict[str, Any]) -> None:
+        """
+        Add models for /cmd endpoint to OpenAPI schema.
+
+        Args:
+            schema: OpenAPI schema to update
+        """
+        # Add command request model
+        schema["components"]["schemas"]["CommandRequest"] = {
+            "type": "object",
+            "required": ["command"],
+            "properties": {
+                "command": {"type": "string", "description": "Command name to execute"},
+                "params": {
+                    "type": "object",
+                    "description": "Command parameters (specific to command)",
+                    "additionalProperties": True,
+                },
+            },
+        }
+
+        # Add command success response model
+        schema["components"]["schemas"]["CommandSuccessResponse"] = {
+            "type": "object",
+            "required": ["result"],
+            "properties": {
+                "result": {
+                    "type": "object",
+                    "description": "Command execution result",
+                    "additionalProperties": True,
+                }
+            },
+        }
+
+        # Add command error response model
+        schema["components"]["schemas"]["CommandErrorResponse"] = {
+            "type": "object",
+            "required": ["error"],
+            "properties": {
+                "error": {
+                    "type": "object",
+                    "required": ["code", "message"],
+                    "properties": {
+                        "code": {"type": "integer", "description": "Error code"},
+                        "message": {"type": "string", "description": "Error message"},
+                        "data": {
+                            "type": "object",
+                            "description": "Additional error data",
+                            "additionalProperties": True,
+                        },
+                    },
+                }
+            },
+        }
+
+    def _add_cmd_examples(self, schema: Dict[str, Any]) -> None:
+        """
+        Add examples for /cmd endpoint to OpenAPI schema.
+
+        Args:
+            schema: OpenAPI schema to update
+        """
+        # Create examples section if it doesn't exist
+        if "examples" not in schema["components"]:
+            schema["components"]["examples"] = {}
+
+        # Add help command example request
+        schema["components"]["examples"]["help_request"] = {
+            "summary": "Get list of commands",
+            "value": {"command": "help"},
+        }
+
+        # Add help command example response
+        schema["components"]["examples"]["help_response"] = {
+            "summary": "Response with list of commands",
+            "value": {
+                "result": {
+                    "commands": {
+                        "help": {
+                            "description": "Get help information about available commands"
+                        },
+                        "health": {"description": "Check server health"},
+                    }
+                }
+            },
+        }
+
+        # Add specific command help example request
+        schema["components"]["examples"]["help_specific_request"] = {
+            "summary": "Get information about specific command",
+            "value": {"command": "help", "params": {"cmdname": "health"}},
+        }
+
+        # Add error example
+        schema["components"]["examples"]["command_error"] = {
+            "summary": "Command not found error",
+            "value": {
+                "error": {
+                    "code": -32601,
+                    "message": "Command 'unknown_command' not found",
+                }
+            },
+        }
+
+        # Link examples to endpoint
+        schema["paths"]["/cmd"]["post"]["requestBody"]["content"]["application/json"][
+            "examples"
+        ] = {
+            "help": {"$ref": "#/components/examples/help_request"},
+            "help_specific": {"$ref": "#/components/examples/help_specific_request"},
+        }
+
+        schema["paths"]["/cmd"]["post"]["responses"]["200"]["content"][
+            "application/json"
+        ]["examples"] = {
+            "help": {"$ref": "#/components/examples/help_response"},
+            "error": {"$ref": "#/components/examples/command_error"},
+        }
+
+    def _validate_required_paths(self, schema: Dict[str, Any]) -> None:
+        """
+        Validate that required paths exist in schema.
+
+        Args:
+            schema: OpenAPI schema to validate
+
+        Raises:
+            SchemaValidationError: If required paths are missing
+        """
+        required_paths = ["/cmd", "/api/commands"]
+
+        for path in required_paths:
+            if path not in schema["paths"]:
+                raise SchemaValidationError(f"Missing required path: {path}")
+
+
+    def validate_schema(self, schema: Dict[str, Any]):
+        """
+        Validate generated schema
+
+        Args:
+            schema: OpenAPI schema to validate
+
+        Raises:
+            SchemaValidationError: If schema is invalid
+        """
+        try:
+            # Check that required components exist
+            required_components = [
+                "CommandRequest",
+                "CommandSuccessResponse",
+                "CommandErrorResponse",
+            ]
+            for component in required_components:
+                if component not in schema["components"]["schemas"]:
+                    raise SchemaValidationError(
+                        f"Missing required component: {component}"
+                    )
+
+            # Validate that all paths return 200 status
+            for path in schema["paths"].values():
+                for method in path.values():
+                    if "200" not in method["responses"]:
+                        raise SchemaValidationError(
+                            "All endpoints must return 200 status code"
+                        )
+
+                    response = method["responses"]["200"]
+                    if "application/json" not in response["content"]:
+                        raise SchemaValidationError(
+                            "All responses must be application/json"
+                        )
+        except Exception as e:
+            raise SchemaValidationError(f"Schema validation failed: {str(e)}")
+
+        # Here we would normally use a library like openapi-spec-validator
+        # to validate the schema against the OpenAPI 3.0 specification