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

mcp_proxy_adapter/examples/full_application/proxy_endpoints.py

@@ -0,0 +1,161 @@
+"""
+Proxy Registration Endpoints
+This module provides proxy registration endpoints for testing.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Dict, List, Optional, Any
+import time
+import uuid
+
+# In-memory registry for testing
+_registry: Dict[str, Dict] = {}
+router = APIRouter(prefix="/proxy", tags=["proxy"])
+
+
+class ServerRegistration(BaseModel):
+    """Server registration request model."""
+
+    server_id: str
+    server_url: str
+    server_name: str
+    description: Optional[str] = None
+    version: Optional[str] = "1.0.0"
+    capabilities: Optional[List[str]] = None
+    endpoints: Optional[Dict[str, str]] = None
+    auth_method: Optional[str] = "none"
+    security_enabled: Optional[bool] = False
+
+
+class ServerUnregistration(BaseModel):
+    """Server unregistration request model."""
+
+    server_key: str  # Use server_key directly
+
+
+class HeartbeatData(BaseModel):
+    """Heartbeat data model."""
+
+    server_id: str
+    server_key: str
+    timestamp: Optional[int] = None
+    status: Optional[str] = "healthy"
+
+
+class RegistrationResponse(BaseModel):
+    """Registration response model."""
+
+    success: bool
+    server_key: str
+    message: str
+    copy_number: int
+
+
+class DiscoveryResponse(BaseModel):
+    """Discovery response model."""
+
+    success: bool
+    servers: List[Dict]
+    total: int
+    active: int
+
+
+@router.post("/register", response_model=RegistrationResponse)
+async def register_server(data: ServerRegistration) -> RegistrationResponse:
+    """Register a server with the proxy."""
+    server_key = str(uuid.uuid4())
+    copy_number = 1
+    if data.server_id in _registry:
+        copy_number = len(_registry[data.server_id]) + 1
+
+    if data.server_id not in _registry:
+        _registry[data.server_id] = {}
+
+    _registry[data.server_id][server_key] = {
+        "server_id": data.server_id,
+        "server_url": data.server_url,
+        "server_name": data.server_name,
+        "description": data.description,
+        "version": data.version,
+        "capabilities": data.capabilities or [],
+        "endpoints": data.endpoints or {},
+        "auth_method": data.auth_method,
+        "security_enabled": data.security_enabled,
+        "registered_at": time.time(),
+        "last_heartbeat": time.time(),
+    }
+
+    return RegistrationResponse(
+        success=True,
+        server_key=server_key,
+        message=f"Server {data.server_name} registered successfully",
+        copy_number=copy_number,
+    )
+
+
+@router.post("/unregister")
+async def unregister_server(data: ServerUnregistration) -> Dict[str, Any]:
+    """Unregister a server from the proxy."""
+    for server_id, instances in _registry.items():
+        if data.server_key in instances:
+            del instances[data.server_key]
+            if not instances:
+                del _registry[server_id]
+            return {"success": True, "message": "Server unregistered"}
+    raise HTTPException(status_code=404, detail="Server not found")
+
+
+@router.post("/heartbeat")
+async def heartbeat(data: HeartbeatData) -> Dict[str, Any]:
+    """Update server heartbeat."""
+    for server_id, instances in _registry.items():
+        if data.server_key in instances:
+            instances[data.server_key]["last_heartbeat"] = data.timestamp or time.time()
+            instances[data.server_key]["status"] = data.status
+            return {"success": True, "message": "Heartbeat updated"}
+    raise HTTPException(status_code=404, detail="Server not found")
+
+
+@router.get("/discover", response_model=DiscoveryResponse)
+async def discover_servers() -> DiscoveryResponse:
+    """Discover all registered servers."""
+    servers = []
+    for server_id, instances in _registry.items():
+        for server_key, server_data in instances.items():
+            servers.append({**server_data, "server_key": server_key})
+
+    active = sum(1 for s in servers if time.time() - s.get("last_heartbeat", 0) < 60)
+    return DiscoveryResponse(
+        success=True,
+        servers=servers,
+        total=len(servers),
+        active=active,
+    )
+
+
+@router.get("/status")
+async def get_status() -> Dict[str, Any]:
+    """Get proxy status."""
+    total_servers = sum(len(instances) for instances in _registry.values())
+    active_servers = sum(
+        1
+        for instances in _registry.values()
+        for server_data in instances.values()
+        if time.time() - server_data.get("last_heartbeat", 0) < 60
+    )
+    return {
+        "status": "running",
+        "total_servers": total_servers,
+        "active_servers": active_servers,
+        "registered_ids": list(_registry.keys()),
+    }
+
+
+@router.delete("/clear")
+async def clear_registry() -> Dict[str, Any]:
+    """Clear all registrations (for testing)."""
+    _registry.clear()
+    return {"success": True, "message": "Registry cleared"}

mcp_proxy_adapter/examples/full_application/run_mtls.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""
+mTLS Full Application Runner
+Runs the full application example with mTLS configuration.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import sys
+import argparse
+import logging
+import json
+import ssl
+import socket
+from pathlib import Path
+
+# Add the framework to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
+
+def validate_mtls_config(config_path: str) -> bool:
+    """Validate mTLS configuration file."""
+    try:
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        
+        # Check required sections
+        required_sections = [
+            'uuid', 'server', 'logging', 'commands', 'transport',
+            'proxy_registration', 'debug', 'security', 'roles', 'ssl'
+        ]
+        
+        missing_sections = []
+        for section in required_sections:
+            if section not in config:
+                missing_sections.append(section)
+        
+        if missing_sections:
+            print(f"❌ Missing required sections: {missing_sections}")
+            return False
+        
+        # Check SSL configuration
+        ssl_config = config.get('ssl', {})
+        if not ssl_config.get('enabled', False):
+            print("❌ SSL must be enabled for mTLS")
+            return False
+        
+        # Check certificate files
+        cert_file = ssl_config.get('cert_file')
+        key_file = ssl_config.get('key_file')
+        ca_cert_file = ssl_config.get('ca_cert_file')
+        
+        if not cert_file or not key_file or not ca_cert_file:
+            print("❌ SSL configuration missing certificate files")
+            return False
+        
+        # Check if certificate files exist
+        cert_path = Path(cert_file)
+        key_path = Path(key_file)
+        ca_path = Path(ca_cert_file)
+        
+        if not cert_path.exists():
+            print(f"❌ Certificate file not found: {cert_file}")
+            return False
+        
+        if not key_path.exists():
+            print(f"❌ Key file not found: {key_file}")
+            return False
+        
+        if not ca_path.exists():
+            print(f"❌ CA certificate file not found: {ca_cert_file}")
+            return False
+        
+        print("✅ mTLS Configuration validation passed")
+        return True
+        
+    except FileNotFoundError:
+        print(f"❌ Configuration file not found: {config_path}")
+        return False
+    except json.JSONDecodeError as e:
+        print(f"❌ Invalid JSON in configuration: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ Configuration validation error: {e}")
+        return False
+
+def test_mtls_connection(config_path: str):
+    """Test mTLS connection to the server."""
+    try:
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        
+        server_config = config.get('server', {})
+        host = server_config.get('host', '0.0.0.0')
+        port = server_config.get('port', 8443)
+        
+        ssl_config = config.get('ssl', {})
+        cert_file = ssl_config.get('cert_file')
+        key_file = ssl_config.get('key_file')
+        ca_cert_file = ssl_config.get('ca_cert_file')
+        
+        print(f"🔐 Testing mTLS connection to {host}:{port}")
+        
+        # Create SSL context
+        context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+        context.load_cert_chain(cert_file, key_file)
+        context.load_verify_locations(ca_cert_file)
+        context.verify_mode = ssl.CERT_REQUIRED
+        
+        # Test connection
+        with socket.create_connection((host, port), timeout=5) as sock:
+            with context.wrap_socket(sock, server_hostname=host) as ssock:
+                print(f"✅ mTLS connection successful")
+                print(f"🔒 Cipher: {ssock.cipher()}")
+                print(f"📜 Protocol: {ssock.version()}")
+                return True
+                
+    except Exception as e:
+        print(f"❌ mTLS connection failed: {e}")
+        return False
+
+def run_mtls_application(config_path: str):
+    """Run the mTLS application example."""
+    print("🚀 Starting mTLS Full Application Example")
+    print(f"📁 Configuration: {config_path}")
+    
+    # Validate configuration
+    if not validate_mtls_config(config_path):
+        print("❌ mTLS Configuration validation failed")
+        return False
+    
+    # Load configuration
+    try:
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        
+        server_config = config.get('server', {})
+        host = server_config.get('host', '0.0.0.0')
+        port = server_config.get('port', 8443)
+        protocol = server_config.get('protocol', 'https')
+        
+        ssl_config = config.get('ssl', {})
+        proxy_config = config.get('proxy_registration', {})
+        
+        print(f"🌐 Server: {host}:{port}")
+        print(f"🔗 Protocol: {protocol}")
+        print(f"🔒 SSL: {'Enabled' if ssl_config.get('enabled', False) else 'Disabled'}")
+        print(f"🔐 mTLS: {'Enabled' if ssl_config.get('verify_client', False) else 'Disabled'}")
+        print(f"🔒 Security: {'Enabled' if config.get('security', {}).get('enabled', False) else 'Disabled'}")
+        print(f"👥 Roles: {'Enabled' if config.get('roles', {}).get('enabled', False) else 'Disabled'}")
+        print(f"🌐 Proxy Registration: {'Enabled' if proxy_config.get('enabled', False) else 'Disabled'}")
+        
+        if proxy_config.get('enabled', False):
+            proxy_url = proxy_config.get('proxy_url', 'https://localhost:3004')
+            server_id = proxy_config.get('server_id', 'unknown')
+            print(f"📡 Proxy URL: {proxy_url}")
+            print(f"🆔 Server ID: {server_id}")
+        
+        # Simulate application startup
+        print("\n🔧 Setting up mTLS application components...")
+        print("✅ Configuration loaded and validated")
+        print("✅ SSL/TLS certificates loaded")
+        print("✅ mTLS context created")
+        print("✅ Logging configured")
+        print("✅ Command registry initialized")
+        print("✅ Transport layer configured with mTLS")
+        print("✅ Security layer configured")
+        print("✅ Proxy registration configured")
+        
+        if proxy_config.get('enabled', False):
+            print("✅ Proxy registration enabled")
+            print(f"📡 Will register with proxy at: {proxy_config.get('proxy_url')}")
+            print(f"🆔 Server ID: {proxy_config.get('server_id')}")
+        
+        print(f"\n🎉 mTLS Full Application Example started successfully!")
+        print(f"📡 Server listening on {host}:{port}")
+        print(f"🌐 Access via: {protocol}://{host}:{port}")
+        print("\n📋 Available features:")
+        print("  - Built-in commands (health, echo, list, help)")
+        print("  - Custom commands (custom_echo, dynamic_calculator)")
+        print("  - Application hooks")
+        print("  - Command hooks")
+        print("  - Proxy endpoints")
+        print("  - mTLS authentication")
+        print("  - Security (if enabled)")
+        print("  - Role management (if enabled)")
+        
+        print("\n🔐 mTLS Configuration:")
+        print(f"  - Certificate: {ssl_config.get('cert_file')}")
+        print(f"  - Private Key: {ssl_config.get('key_file')}")
+        print(f"  - CA Certificate: {ssl_config.get('ca_cert_file')}")
+        print(f"  - Client Verification: {'Required' if ssl_config.get('verify_client', False) else 'Optional'}")
+        print(f"  - Ciphers: {ssl_config.get('ciphers', 'Default')}")
+        print(f"  - Protocols: {ssl_config.get('protocols', 'Default')}")
+        
+        print("\n✅ mTLS Application simulation completed successfully")
+        print("💡 In a real application, the mTLS server would be running here")
+        return True
+            
+    except Exception as e:
+        print(f"❌ Application startup error: {e}")
+        return False
+
+def main():
+    """Main function."""
+    parser = argparse.ArgumentParser(
+        description="Run mTLS Full Application Example",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python run_mtls.py --config configs/mtls_no_roles_correct.json
+  python run_mtls.py --config configs/mtls_with_roles_correct.json
+  python run_mtls.py --config configs/mtls_no_roles_correct.json --test-connection
+        """
+    )
+    
+    parser.add_argument(
+        "--config",
+        default="configs/mtls_no_roles_correct.json",
+        help="Configuration file path"
+    )
+    
+    parser.add_argument(
+        "--test-connection",
+        action="store_true",
+        help="Test mTLS connection"
+    )
+    
+    args = parser.parse_args()
+    
+    # Check if config file exists
+    config_path = Path(args.config)
+    if not config_path.exists():
+        print(f"❌ Configuration file not found: {config_path}")
+        print("💡 Available mTLS configurations:")
+        configs_dir = Path("configs")
+        if configs_dir.exists():
+            for config_file in configs_dir.glob("*mtls*.json"):
+                print(f"  - {config_file}")
+        return 1
+    
+    # Test connection if requested
+    if args.test_connection:
+        success = test_mtls_connection(str(config_path))
+        return 0 if success else 1
+    
+    # Run application
+    success = run_mtls_application(str(config_path))
+    return 0 if success else 1
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_proxy_adapter/examples/full_application/run_simple.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""
+Simple Full Application Runner
+Runs the full application example without complex imports.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import sys
+import argparse
+import logging
+import json
+from pathlib import Path
+
+# Add the framework to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
+
+def validate_config(config_path: str) -> bool:
+    """Validate configuration file."""
+    try:
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        
+        # Check required sections
+        required_sections = [
+            'uuid', 'server', 'logging', 'commands', 'transport',
+            'proxy_registration', 'debug', 'security', 'roles'
+        ]
+        
+        missing_sections = []
+        for section in required_sections:
+            if section not in config:
+                missing_sections.append(section)
+        
+        if missing_sections:
+            print(f"❌ Missing required sections: {missing_sections}")
+            return False
+        
+        # Check server section
+        server = config.get('server', {})
+        if 'host' not in server or 'port' not in server:
+            print("❌ Server section missing host or port")
+            return False
+        
+        print("✅ Configuration validation passed")
+        return True
+        
+    except FileNotFoundError:
+        print(f"❌ Configuration file not found: {config_path}")
+        return False
+    except json.JSONDecodeError as e:
+        print(f"❌ Invalid JSON in configuration: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ Configuration validation error: {e}")
+        return False
+
+def run_application(config_path: str):
+    """Run the full application example."""
+    print("🚀 Starting Full Application Example")
+    print(f"📁 Configuration: {config_path}")
+    
+    # Validate configuration
+    if not validate_config(config_path):
+        print("❌ Configuration validation failed")
+        return False
+    
+    # Load configuration
+    try:
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        
+        server_config = config.get('server', {})
+        host = server_config.get('host', '0.0.0.0')
+        port = server_config.get('port', 8000)
+        protocol = server_config.get('protocol', 'http')
+        
+        print(f"🌐 Server: {host}:{port}")
+        print(f"🔗 Protocol: {protocol}")
+        print(f"🔒 Security: {'Enabled' if config.get('security', {}).get('enabled', False) else 'Disabled'}")
+        print(f"👥 Roles: {'Enabled' if config.get('roles', {}).get('enabled', False) else 'Disabled'}")
+        
+        # Simulate application startup
+        print("\n🔧 Setting up application components...")
+        print("✅ Configuration loaded")
+        print("✅ Logging configured")
+        print("✅ Command registry initialized")
+        print("✅ Transport layer configured")
+        print("✅ Security layer configured")
+        print("✅ Proxy registration configured")
+        
+        print(f"\n🎉 Full Application Example started successfully!")
+        print(f"📡 Server listening on {host}:{port}")
+        print(f"🌐 Access via: {protocol}://{host}:{port}")
+        print("\n📋 Available features:")
+        print("  - Built-in commands (health, echo, list, help)")
+        print("  - Custom commands (custom_echo, dynamic_calculator)")
+        print("  - Application hooks")
+        print("  - Command hooks")
+        print("  - Proxy endpoints")
+        print("  - Security (if enabled)")
+        print("  - Role management (if enabled)")
+        
+        print("\n🛑 Press Ctrl+C to stop the server")
+        
+        # Simulate running server (non-blocking)
+        print("✅ Server simulation completed successfully")
+        print("💡 In a real application, the server would be running here")
+        return True
+            
+    except Exception as e:
+        print(f"❌ Application startup error: {e}")
+        return False
+
+def main():
+    """Main function."""
+    parser = argparse.ArgumentParser(
+        description="Run Full Application Example",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python run_simple.py --config configs/http_simple_correct.json
+  python run_simple.py --config configs/http_auth_correct.json
+        """
+    )
+    
+    parser.add_argument(
+        "--config",
+        default="configs/http_simple_correct.json",
+        help="Configuration file path"
+    )
+    
+    args = parser.parse_args()
+    
+    # Check if config file exists
+    config_path = Path(args.config)
+    if not config_path.exists():
+        print(f"❌ Configuration file not found: {config_path}")
+        print("💡 Available configurations:")
+        configs_dir = Path("configs")
+        if configs_dir.exists():
+            for config_file in configs_dir.glob("*.json"):
+                print(f"  - {config_file}")
+        return 1
+    
+    # Run application
+    success = run_application(str(config_path))
+    return 0 if success else 1
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_proxy_adapter/examples/full_application/test_minimal_server.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""
+Minimal server test without lifespan issues.
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# Add the project root to the path
+project_root = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from fastapi import FastAPI
+import uvicorn
+
+def main():
+    """Test minimal server startup."""
+    print("🚀 Testing Minimal Server Startup")
+    print("=" * 50)
+    
+    # Create minimal FastAPI app
+    app = FastAPI(
+        title="Test Server",
+        description="Minimal test server",
+        version="1.0.0"
+    )
+    
+    # Add health endpoint
+    @app.get("/health")
+    
+    # Add JSON-RPC endpoint
+    @app.post("/api/jsonrpc")
+    
+    print("✅ FastAPI app created successfully")
+    
+    # Start server
+    print("🚀 Starting server on http://0.0.0.0:8000")
+    print("📡 Test with: curl -X POST http://localhost:8000/api/jsonrpc -H 'Content-Type: application/json' -d '{\"jsonrpc\": \"2.0\", \"method\": \"health\", \"id\": 1}'")
+    print("🛑 Press Ctrl+C to stop")
+    
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+if __name__ == "__main__":
+    main()