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

mcp_proxy_adapter/examples/full_application/main.py

@@ -10,175 +10,211 @@ This is a complete application that demonstrates all features of MCP Proxy Adapt
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-import sys
 import argparse
-import logging
+import asyncio
+import json
 from pathlib import Path
 
-# Add the framework to the path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
-from mcp_proxy_adapter.core.app_factory import create_and_run_server
-from mcp_proxy_adapter.api.app import create_app
-from mcp_proxy_adapter.config import Config
-from mcp_proxy_adapter.commands.command_registry import CommandRegistry
+from hypercorn.asyncio import serve
+from hypercorn.config import Config as HyperConfig
 
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.client.proxy import ProxyClient
+from mcp_proxy_adapter.commands.command_registry import registry
 
-class FullApplication:
-    """Full application example with all framework features."""
 
-    def __init__(self, config_path: str):
-        self.config_path = config_path
-        try:
-            self.config = Config(config_path, validate_on_load=True)
-            self.config.load_config()  # Explicitly load the configuration
-            self.logger = logging.getLogger(__name__)
-            self.logger.info("✅ Configuration loaded and validated successfully")
-        except Exception as e:
-            logging.basicConfig(level=logging.ERROR)
-            self.logger = logging.getLogger(__name__)
-            self.logger.error(f"❌ Configuration error: {e}")
-            raise
-        
-        self.app = None
-        self.command_registry = None
-        # Setup logging
-        logging.basicConfig(level=logging.INFO)
-
-    def setup_hooks(self):
-        """Setup application hooks."""
-        try:
-            # Import hooks
-            from hooks.application_hooks import ApplicationHooks
-            from hooks.builtin_command_hooks import BuiltinCommandHooks
-
-            # Register application hooks
-            self.logger.info("🔧 Setting up application hooks...")
-            # Register built-in command hooks
-            self.logger.info("🔧 Setting up built-in command hooks...")
-            # Note: In a real implementation, these hooks would be registered
-            # with the framework's hook system
-            self.logger.info("✅ Hooks setup completed")
-        except ImportError as e:
-            self.logger.warning(f"⚠️ Could not import hooks: {e}")
-
-    def setup_custom_commands(self):
-        """Setup custom commands."""
-        try:
-            self.logger.info("🔧 Setting up custom commands...")
-            # Import custom commands
-            from commands.custom_echo_command import CustomEchoCommand
-            from commands.dynamic_calculator_command import DynamicCalculatorCommand
-
-            # Register custom commands
-            # Note: In a real implementation, these would be registered
-            # with the framework's command registry
-            self.logger.info("✅ Custom commands setup completed")
-        except ImportError as e:
-            self.logger.warning(f"⚠️ Could not import custom commands: {e}")
-
-    def setup_proxy_endpoints(self):
-        """Setup proxy registration endpoints."""
-        try:
-            self.logger.info("🔧 Setting up proxy endpoints...")
-            # Import proxy endpoints
-            from proxy_endpoints import router as proxy_router
-
-            # Add proxy router to the application
-            self.app.include_router(proxy_router)
-            self.logger.info("✅ Proxy endpoints setup completed")
-        except ImportError as e:
-            self.logger.warning(f"⚠️ Could not import proxy endpoints: {e}")
-
-    def create_application(self):
-        """Create the FastAPI application."""
-        self.logger.info("🔧 Creating application...")
-        # Setup hooks and commands before creating app
-        self.setup_hooks()
-        self.setup_custom_commands()
-        # Create application with configuration
-        self.app = create_app(app_config=self.config)
-        # Setup proxy endpoints after app creation
-        self.setup_proxy_endpoints()
-        self.logger.info("✅ Application created successfully")
-
-    def run(self, host: str = None, port: int = None, debug: bool = False):
-        """Run the application using the factory method with port checking."""
-        print(f"🚀 Starting Full Application Example")
-        print(f"📋 Configuration: {self.config_path}")
-        print(
-            f"🔧 Features: Built-in commands, Custom commands, Dynamic commands, Hooks, Proxy endpoints"
+def register_all_commands():
+    """Register all available commands (built-in, load, queue)."""
+    from mcp_proxy_adapter.commands.load_command import LoadCommand
+    
+    # Register load command
+    registry._commands["load"] = LoadCommand
+    registry._command_types["load"] = "builtin"
+    
+    # Register queue commands (will fail gracefully if queuemgr not available)
+    try:
+        from mcp_proxy_adapter.commands.queue_commands import (
+            QueueAddJobCommand,
+            QueueStartJobCommand,
+            QueueStopJobCommand,
+            QueueDeleteJobCommand,
+            QueueGetJobStatusCommand,
+            QueueListJobsCommand,
+            QueueHealthCommand,
         )
-        print("=" * 60)
-        
-        # Use the factory method to create and run the server with port checking
-        import asyncio
-        asyncio.run(create_and_run_server(
-            config_path=self.config_path,
-            title="Full Application Example",
-            description="Complete MCP Proxy Adapter with all features",
-            version="1.0.0",
-            host=host or "0.0.0.0",
-            log_level="debug" if debug else "info"
-        ))
+        registry._commands["queue_add_job"] = QueueAddJobCommand
+        registry._command_types["queue_add_job"] = "builtin"
+        registry._commands["queue_start_job"] = QueueStartJobCommand
+        registry._command_types["queue_start_job"] = "builtin"
+        registry._commands["queue_stop_job"] = QueueStopJobCommand
+        registry._command_types["queue_stop_job"] = "builtin"
+        registry._commands["queue_delete_job"] = QueueDeleteJobCommand
+        registry._command_types["queue_delete_job"] = "builtin"
+        registry._commands["queue_get_job_status"] = QueueGetJobStatusCommand
+        registry._command_types["queue_get_job_status"] = "builtin"
+        registry._commands["queue_list_jobs"] = QueueListJobsCommand
+        registry._command_types["queue_list_jobs"] = "builtin"
+        registry._commands["queue_health"] = QueueHealthCommand
+        registry._command_types["queue_health"] = "builtin"
+        print("✅ Queue commands registered")
+    except Exception as e:
+        print(f"⚠️  Queue commands not available: {e}")
 
 
 def main():
-    """Main entry point for the full application example."""
-    parser = argparse.ArgumentParser(description="Full Application Example")
-    parser.add_argument(
-        "--config", "-c", required=True, help="Path to configuration file"
-    )
-    parser.add_argument("--host", help="Server host")
-    parser.add_argument("--port", type=int, help="Server port")
-    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
-    args = parser.parse_args()
-    # Create and run application
-    app = FullApplication(args.config)
-    app.run(host=args.host, port=args.port, debug=args.debug)
-
-
-# Create global app instance for import
-app = None
-
-
-def get_app():
-    """Get the FastAPI application instance."""
-    global app
-    if app is None:
-        # Create a default configuration for import
-        config = Config("configs/mtls_with_roles.json")  # Default config
-        app_instance = FullApplication("configs/mtls_with_roles.json")
-        app_instance.create_application()
-        app = app_instance.app
-    return app
-
-
-def main():
-    """Main entry point."""
-    import argparse
-    
+    """Minimal runnable entrypoint for full application example."""
     parser = argparse.ArgumentParser(description="MCP Proxy Adapter Full Application")
     parser.add_argument("--config", required=True, help="Path to configuration file")
-    parser.add_argument("--port", type=int, help="Port to run server on")
+    parser.add_argument("--port", type=int, help="Port to run server on (override)")
     parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
-    
     args = parser.parse_args()
-    
-    # Create application
-    app_instance = FullApplication(args.config)
-    
-    # Override port if specified
+
+    cfg_path = Path(args.config)
+    if not cfg_path.exists():
+        print(f"❌ Configuration file not found: {cfg_path}")
+        raise SystemExit(1)
+
+    try:
+        with cfg_path.open("r", encoding="utf-8") as f:
+            app_config = json.load(f)
+    except Exception as exc:  # noqa: BLE001
+        print(f"❌ Failed to load configuration: {exc}")
+        raise SystemExit(1)
+
     if args.port:
-        app_instance.config.config_data["server"]["port"] = args.port
+        app_config.setdefault("server", {}).update({"port": args.port})
         print(f"🔧 Overriding port to {args.port}")
-    
-    # Override host if specified
     if args.host:
-        app_instance.config.config_data["server"]["host"] = args.host
+        app_config.setdefault("server", {}).update({"host": args.host})
         print(f"🔧 Overriding host to {args.host}")
+
+    # Strict protocol checks: forbid any form of mTLS over HTTP
+    proto = str(app_config.get("server", {}).get("protocol", "http")).lower()
+    ssl_cfg = app_config.get("ssl", {}) or {}
+    transport = app_config.get("transport", {}) or {}
+    require_client_cert = bool(
+        ssl_cfg.get("require_client_cert") or transport.get("verify_client")
+    )
+
+    # --- SimpleConfig compatibility bridge: synthesize ssl section when absent ---
+    if not app_config.get("ssl") and isinstance(app_config.get("server"), dict):
+        srv = app_config["server"]
+        cert_file = srv.get("cert_file")
+        key_file = srv.get("key_file")
+        ca_file = srv.get("ca_cert_file")
+        if cert_file and key_file:
+            app_config["ssl"] = {
+                "enabled": True,
+                "cert_file": cert_file,
+                "key_file": key_file,
+            }
+            if ca_file:
+                app_config["ssl"]["ca_cert"] = ca_file
+            # For mtls protocol, enforce client verification
+            if proto == "mtls":
+                app_config.setdefault("transport", {}).update({"verify_client": True})
+        # Refresh local vars after synthesis
+        ssl_cfg = app_config.get("ssl", {}) or {}
+        transport = app_config.get("transport", {}) or {}
+        require_client_cert = bool(
+            ssl_cfg.get("require_client_cert") or transport.get("verify_client")
+        )
+    # ---------------------------------------------------------------------------
+
+    if proto == "http":
+        if require_client_cert:
+            raise SystemExit(
+                "CRITICAL CONFIG ERROR: mTLS (client certificate verification) cannot be used with HTTP. "
+                "Switch protocol to 'mtls' (or 'https' without client verification), and configure SSL certificates."
+            )
+
+    if proto == "mtls":
+        if not ssl_cfg.get("enabled"):
+            raise SystemExit(
+                "CRITICAL CONFIG ERROR: Protocol 'mtls' requires SSL to be enabled."
+            )
+        if not require_client_cert:
+            raise SystemExit(
+                "CRITICAL CONFIG ERROR: Protocol 'mtls' requires client certificate verification. "
+                "Set ssl.require_client_cert=true or transport.verify_client=true."
+            )
+        cert = ssl_cfg.get("certfile") or ssl_cfg.get("cert_file")
+        key = ssl_cfg.get("keyfile") or ssl_cfg.get("key_file")
+        ca = ssl_cfg.get("cafile") or ssl_cfg.get("ca_cert") or ssl_cfg.get("ca_cert_file")
+        if not (cert and key and ca):
+            raise SystemExit(
+                "CRITICAL CONFIG ERROR: 'mtls' requires ssl.certfile/keyfile (or cert_file/key_file) and CA certificate."
+            )
+
+    app = create_app(title="Full Application Example", description="Complete MCP Proxy Adapter with all features", version="1.0.0", app_config=app_config, config_path=str(cfg_path))
+
+    port = int(app_config.get("server", {}).get("port", 8080))
+    host = app_config.get("server", {}).get("host", args.host)
+
+    hc = HyperConfig()
+    hc.bind = [f"{host}:{port}"]
+    hc.loglevel = "info"
+    ssl_cfg = app_config.get("ssl", {})
+    if ssl_cfg.get("enabled"):
+        cert = ssl_cfg.get("certfile") or ssl_cfg.get("cert_file")
+        key = ssl_cfg.get("keyfile") or ssl_cfg.get("key_file")
+        ca = ssl_cfg.get("cafile") or ssl_cfg.get("ca_cert") or ssl_cfg.get("ca_cert_file")
+        if cert and key:
+            hc.certfile = cert
+            hc.keyfile = key
+        if ca:
+            hc.ca_certs = ca
+
+    print("🚀 Starting Full Application Example")
+    print(f"📋 Configuration: {cfg_path}")
+    print("============================================================")
     
-    # Run server
-    app_instance.run()
+    # Register all commands
+    register_all_commands()
+    print(f"📋 Registered commands: {', '.join(sorted(registry.get_all_commands().keys()))}")
+
+    async def _run():
+        # Optional proxy registration
+        pr = (app_config.get("proxy_registration") or {}) if isinstance(app_config, dict) else {}
+        name = pr.get("server_id") or pr.get("server_name") or "mcp-adapter"
+        scheme = "https" if str(app_config.get("server", {}).get("protocol", "http")) in ("https", "mtls") else "http"
+        advertised_host = app_config.get("server", {}).get("advertised_host") or "mcp-adapter"
+        advertised_url = f"{scheme}://{advertised_host}:{port}"
+
+        heartbeat_task = None
+        try:
+            if pr.get("enabled") and pr.get("proxy_url"):
+                pc = ProxyClient(pr["proxy_url"])
+                try:
+                    pc.register(name=name, url=advertised_url, capabilities=["jsonrpc"], metadata={})
+                    print(f"✅ Registered on proxy as {name} -> {advertised_url}")
+                except Exception as exc:  # noqa: BLE001
+                    print(f"⚠️  Proxy registration failed: {exc}")
+
+                async def _hb():
+                    interval = int((pr.get("heartbeat") or {}).get("interval", 15))
+                    while True:
+                        try:
+                            pc.heartbeat(name=name, url=advertised_url)
+                        except Exception:
+                            pass
+                        await asyncio.sleep(max(2, interval))
+
+                heartbeat_task = asyncio.create_task(_hb())
+
+            await serve(app, hc)
+        finally:
+            if heartbeat_task:
+                heartbeat_task.cancel()
+            if pr.get("enabled") and pr.get("proxy_url"):
+                try:
+                    ProxyClient(pr["proxy_url"]).unregister(name)
+                    print(f"🛑 Unregistered from proxy: {name}")
+                except Exception:
+                    pass
+
+    asyncio.run(_run())
+
 
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/full_application/proxy_endpoints.py

@@ -64,125 +64,18 @@ class DiscoveryResponse(BaseModel):
 
 
 @router.post("/register", response_model=RegistrationResponse)
-async def register_server(registration: ServerRegistration):
-    """Register a server with the proxy."""
-    try:
-        # Generate unique server key
-        server_key = f"{registration.server_id}_{uuid.uuid4().hex[:8]}"
-        copy_number = 1
-        # Store server information
-        _registry[server_key] = {
-            "server_id": registration.server_id,
-            "server_url": registration.server_url,
-            "server_name": registration.server_name,
-            "description": registration.description,
-            "version": registration.version,
-            "capabilities": registration.capabilities or [],
-            "endpoints": registration.endpoints or {},
-            "auth_method": registration.auth_method,
-            "security_enabled": registration.security_enabled,
-            "registered_at": int(time.time()),
-            "last_heartbeat": int(time.time()),
-            "status": "active",
-        }
-        return RegistrationResponse(
-            success=True,
-            server_key=server_key,
-            message=f"Server {registration.server_name} registered successfully",
-            copy_number=copy_number,
-        )
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Registration failed: {str(e)}")
 
 
 @router.post("/unregister")
-async def unregister_server(unregistration: ServerUnregistration):
-    """Unregister a server from the proxy."""
-    try:
-        # Check if server exists in registry
-        if unregistration.server_key not in _registry:
-            raise HTTPException(status_code=404, detail="Server not found")
-        # Remove from registry
-        del _registry[unregistration.server_key]
-        return {"success": True, "message": "Server unregistered successfully"}
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Unregistration failed: {str(e)}")
 
 
 @router.post("/heartbeat")
-async def send_heartbeat(heartbeat: HeartbeatData):
-    """Send heartbeat for a registered server."""
-    try:
-        if heartbeat.server_key not in _registry:
-            raise HTTPException(status_code=404, detail="Server not found")
-        # Update heartbeat information
-        _registry[heartbeat.server_key]["last_heartbeat"] = heartbeat.timestamp or int(
-            time.time()
-        )
-        _registry[heartbeat.server_key]["status"] = heartbeat.status
-        return {"success": True, "message": "Heartbeat received"}
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Heartbeat failed: {str(e)}")
 
 
 @router.get("/discover", response_model=DiscoveryResponse)
-async def discover_servers():
-    """Discover active servers."""
-    try:
-        current_time = int(time.time())
-        active_servers = []
-        for server_key, server in _registry.items():
-            # Consider server active if heartbeat was within last 5 minutes
-            if current_time - server["last_heartbeat"] < 300:
-                active_servers.append(
-                    {
-                        "server_key": server_key,
-                        "server_id": server["server_id"],
-                        "server_name": server["server_name"],
-                        "server_url": server["server_url"],
-                        "status": server["status"],
-                        "last_heartbeat": server["last_heartbeat"],
-                    }
-                )
-        return DiscoveryResponse(
-            success=True,
-            servers=active_servers,
-            total=len(_registry),
-            active=len(active_servers),
-        )
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Discovery failed: {str(e)}")
 
 
 @router.get("/status")
-async def get_proxy_status():
-    """Get proxy status."""
-    try:
-        current_time = int(time.time())
-        active_count = sum(
-            1
-            for server in _registry.values()
-            if current_time - server["last_heartbeat"] < 300
-        )
-        return {
-            "success": True,
-            "total_registered": len(_registry),
-            "active_servers": active_count,
-            "inactive_servers": len(_registry) - active_count,
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Status check failed: {str(e)}")
 
 
 @router.delete("/clear")
-async def clear_registry():
-    """Clear the registry (for testing)."""
-    try:
-        _registry.clear()
-        return {"success": True, "message": "Registry cleared"}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Clear failed: {str(e)}")

mcp_proxy_adapter/examples/full_application/test_minimal_server.py

@@ -12,7 +12,6 @@ project_root = Path(__file__).parent.parent.parent.parent
 sys.path.insert(0, str(project_root))
 
 from fastapi import FastAPI
-from mcp_proxy_adapter.api.handlers import execute_command
 import uvicorn
 
 def main():
@@ -29,32 +28,9 @@ def main():
     
     # Add health endpoint
     @app.get("/health")
-    async def health():
-        return {"status": "ok", "message": "Server is running"}
     
     # Add JSON-RPC endpoint
     @app.post("/api/jsonrpc")
-    async def jsonrpc_endpoint(request: dict):
-        try:
-            # Simple health command
-            if request.get("method") == "health":
-                return {
-                    "jsonrpc": "2.0",
-                    "id": request.get("id"),
-                    "result": {"status": "ok", "message": "Health check passed"}
-                }
-            else:
-                return {
-                    "jsonrpc": "2.0",
-                    "id": request.get("id"),
-                    "error": {"code": -32601, "message": "Method not found"}
-                }
-        except Exception as e:
-            return {
-                "jsonrpc": "2.0",
-                "id": request.get("id"),
-                "error": {"code": -32603, "message": str(e)}
-            }
     
     print("✅ FastAPI app created successfully")
     

mcp_proxy_adapter/examples/full_application/test_server.py

@@ -19,58 +19,7 @@ from http.server import HTTPServer, BaseHTTPRequestHandler
 class TestMTLSHandler(BaseHTTPRequestHandler):
     """Test handler for mTLS requests."""
     
-    def do_GET(self):
-        """Handle GET requests."""
-        if self.path == '/health':
-            self.send_response(200)
-            self.send_header('Content-type', 'application/json')
-            self.end_headers()
-            response = {
-                "status": "healthy",
-                "service": "mcp_proxy_adapter",
-                "version": "6.2.33",
-                "protocol": "mTLS",
-                "timestamp": time.time()
-            }
-            self.wfile.write(json.dumps(response).encode())
-        elif self.path == '/echo':
-            self.send_response(200)
-            self.send_header('Content-type', 'application/json')
-            self.end_headers()
-            response = {
-                "message": "Echo from mTLS server",
-                "timestamp": time.time(),
-                "client_cert": self.get_client_cert_info()
-            }
-            self.wfile.write(json.dumps(response).encode())
-        else:
-            self.send_response(404)
-            self.send_header('Content-type', 'application/json')
-            self.end_headers()
-            response = {"error": "Not found", "path": self.path}
-            self.wfile.write(json.dumps(response).encode())
     
-    def do_POST(self):
-        """Handle POST requests."""
-        content_length = int(self.headers.get('Content-Length', 0))
-        post_data = self.rfile.read(content_length)
-        
-        try:
-            data = json.loads(post_data.decode())
-        except json.JSONDecodeError:
-            data = {"raw": post_data.decode()}
-        
-        self.send_response(200)
-        self.send_header('Content-type', 'application/json')
-        self.end_headers()
-        
-        response = {
-            "received": data,
-            "timestamp": time.time(),
-            "client_cert": self.get_client_cert_info(),
-            "method": "POST"
-        }
-        self.wfile.write(json.dumps(response).encode())
     
     def get_client_cert_info(self):
         """Get client certificate information."""
@@ -88,13 +37,6 @@ class TestMTLSHandler(BaseHTTPRequestHandler):
             pass
         return None
     
-    def log_message(self, format, *args):
-        """Override log message to include client cert info."""
-        client_cert = self.get_client_cert_info()
-        if client_cert:
-            print(f"[{self.address_string()}] {format % args} [Client: {client_cert.get('subject', {}).get('CN', 'Unknown')}]")
-        else:
-            print(f"[{self.address_string()}] {format % args} [No client cert]")
 
 class TestMTLSServer:
     """Test mTLS server for the full application example."""