mcp-proxy-adapter 6.2.23__py3-none-any.whl → 6.2.25__py3-none-any.whl

mcp_proxy_adapter/examples/examples/full_application/main.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+Full Application Example
+This is a complete application that demonstrates all features of MCP Proxy Adapter framework:
+- Built-in commands
+- Custom commands
+- Dynamically loaded commands
+- Built-in command hooks
+- Application hooks
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import sys
+import argparse
+import logging
+from pathlib import Path
+# Add the framework to the path
+sys.path.insert(0, str(Path(__file__).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
+class FullApplication:
+    """Full application example with all framework features."""
+    def __init__(self, config_path: str):
+        self.config_path = config_path
+        self.config = Config(config_path)
+        self.app = None
+        self.command_registry = None
+        # Setup logging
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+    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."""
+        # Override configuration if specified
+        config_overrides = {}
+        if host:
+            config_overrides["host"] = host
+        if port:
+            config_overrides["port"] = port
+        if debug:
+            config_overrides["debug"] = True
+        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")
+        print("=" * 60)
+        # Create application with configuration
+        self.create_application()
+        # Get server configuration
+        server_host = self.config.get("server.host", "0.0.0.0")
+        server_port = self.config.get("server.port", 8000)
+        server_debug = self.config.get("server.debug", False)
+        # Get SSL configuration
+        ssl_enabled = self.config.get("ssl.enabled", False)
+        ssl_cert_file = self.config.get("ssl.cert_file")
+        ssl_key_file = self.config.get("ssl.key_file")
+        ssl_ca_cert = self.config.get("ssl.ca_cert")
+        verify_client = self.config.get("ssl.verify_client", False)
+        print(f"🌐 Server: {server_host}:{server_port}")
+        print(f"🔧 Debug: {server_debug}")
+        if ssl_enabled:
+            print(f"🔐 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("=" * 60)
+        # Use hypercorn directly to run the application with proxy endpoints
+        try:
+            import hypercorn.asyncio
+            import hypercorn.config
+            import asyncio
+            # Configure hypercorn
+            config_hypercorn = hypercorn.config.Config()
+            config_hypercorn.bind = [f"{server_host}:{server_port}"]
+            config_hypercorn.loglevel = "debug" if server_debug else "info"
+            if ssl_enabled and ssl_cert_file and ssl_key_file:
+                config_hypercorn.certfile = ssl_cert_file
+                config_hypercorn.keyfile = ssl_key_file
+                if ssl_ca_cert:
+                    config_hypercorn.ca_certs = ssl_ca_cert
+                if verify_client:
+                    import ssl
+                    config_hypercorn.verify_mode = ssl.CERT_REQUIRED
+                print(f"🔐 Starting HTTPS server with hypercorn...")
+            else:
+                print(f"🌐 Starting HTTP server with hypercorn...")
+            # Run the server
+            asyncio.run(hypercorn.asyncio.serve(self.app, config_hypercorn))
+        except ImportError:
+            print("❌ hypercorn not installed. Installing...")
+            import subprocess
+            subprocess.run([sys.executable, "-m", "pip", "install", "hypercorn"])
+            print("✅ hypercorn installed. Please restart the application.")
+            return
+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
+
+if __name__ == "__main__":
+    main()

mcp_proxy_adapter/examples/examples/full_application/proxy_endpoints.py

@@ -0,0 +1,154 @@
+"""
+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
+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(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/generate_test_configs.py

@@ -9,7 +9,7 @@ import json
 import os
 import argparse
 from typing import Dict, Any
-def generate_http_simple_config(port: int = 20000, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_http_simple_config(port: int = 20000, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
     """Generate HTTP configuration without authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
@@ -29,7 +29,7 @@ def generate_http_simple_config(port: int = 20000, certs_dir: str = "./certs", k
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http"]}
     }
-def generate_http_token_config(port: int = 20001, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_http_token_config(port: int = 20001, certs_dir: str = "certs", keys_dir: str = "keys", roles_file: str = "configs/roles.json") -> Dict[str, Any]:
     """Generate HTTP configuration with token authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
@@ -48,7 +48,7 @@ def generate_http_token_config(port: int = 20001, certs_dir: str = "./certs", ke
                     "proxy-token-123": "proxy"
                 }
             },
-            "permissions": {"enabled": True, "roles_file": "./roles.json"}
+            "permissions": {"enabled": True, "roles_file": roles_file}
         },
         "registration": {
             "enabled": True,
@@ -61,14 +61,14 @@ def generate_http_token_config(port: int = 20001, certs_dir: str = "./certs", ke
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http"]}
     }
-def generate_https_simple_config(port: int = 20002, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_https_simple_config(port: int = 20002, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
     """Generate HTTPS configuration without client certificate verification and authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
-            "cert_file": "./certs/localhost_server.crt", 
-            "key_file": "./keys/localhost_server.key"
+            "cert_file": f"{certs_dir}/localhost_server.crt",
+            "key_file": f"{keys_dir}/localhost_server.key"
         },
         "security": {"enabled": False},
         "registration": {
@@ -82,14 +82,14 @@ def generate_https_simple_config(port: int = 20002, certs_dir: str = "./certs",
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http", "https"]}
     }
-def generate_https_token_config(port: int = 20003, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_https_token_config(port: int = 20003, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
     """Generate HTTPS configuration without client certificate verification with token authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
-            "cert_file": "./certs/localhost_server.crt", 
-            "key_file": "./keys/localhost_server.key"
+            "cert_file": f"{certs_dir}/localhost_server.crt",
+            "key_file": f"{keys_dir}/localhost_server.key"
         },
         "security": {
             "enabled": True,
@@ -104,7 +104,7 @@ def generate_https_token_config(port: int = 20003, certs_dir: str = "./certs", k
                     "proxy-token-123": "proxy"
                 }
             },
-            "permissions": {"enabled": True, "roles_file": "./roles.json"}
+            "permissions": {"enabled": True, "roles_file": "./configs/roles.json"}
         },
         "registration": {
             "enabled": True,
@@ -117,33 +117,33 @@ def generate_https_token_config(port: int = 20003, certs_dir: str = "./certs", k
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http", "https"]}
     }
-def generate_mtls_no_roles_config(port: int = 20004, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_mtls_no_roles_config(port: int = 20004, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
     """Generate mTLS configuration without roles."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
-            "cert_file": "./certs/localhost_server.crt", 
-            "key_file": "./keys/localhost_server.key",
-            "ca_cert": "./certs/mcp_proxy_adapter_ca_ca.crt",
+            "cert_file": f"{certs_dir}/localhost_server.crt",
+            "key_file": f"{keys_dir}/localhost_server.key",
+            "ca_cert": f"{certs_dir}/mcp_proxy_adapter_ca_ca.crt",
             "verify_client": True
         },
         "security": {
             "enabled": True,
             "auth": {"enabled": True, "methods": ["certificate"]},
-            "permissions": {"enabled": True, "roles_file": "./roles.json"}
+            "permissions": {"enabled": False}
         },
         "protocols": {"enabled": True, "allowed_protocols": ["https", "mtls"]}
     }
-def generate_mtls_with_roles_config(port: int = 20005, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_mtls_with_roles_config(port: int = 20005, certs_dir: str = "certs", keys_dir: str = "keys", roles_file: str = "configs/roles.json") -> Dict[str, Any]:
     """Generate mTLS configuration with roles."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
-            "cert_file": "./certs/localhost_server.crt", 
-            "key_file": "./keys/localhost_server.key",
-            "ca_cert": "./certs/mcp_proxy_adapter_ca_ca.crt",
+            "cert_file": f"{certs_dir}/localhost_server.crt",
+            "key_file": f"{keys_dir}/localhost_server.key",
+            "ca_cert": f"{certs_dir}/mcp_proxy_adapter_ca_ca.crt",
             "verify_client": True
         },
         "registration": {
@@ -161,7 +161,7 @@ def generate_mtls_with_roles_config(port: int = 20005, certs_dir: str = "./certs
         "security": {
             "enabled": True,
             "auth": {"enabled": True, "methods": ["certificate"]},
-            "permissions": {"enabled": True, "roles_file": "./roles.json"}
+            "permissions": {"enabled": True, "roles_file": roles_file}
         },
         "protocols": {"enabled": True, "allowed_protocols": ["https", "mtls"]}
     }
@@ -222,15 +222,18 @@ def generate_roles_config() -> Dict[str, Any]:
             "tokens": ["proxy-token-123"]
         }
     }
-def generate_all_configs(output_dir: str, certs_dir: str = "./certs", keys_dir: str = "./keys") -> None:
+def generate_all_configs(output_dir: str, certs_dir: str = "certs", keys_dir: str = "keys", roles_file: str = "configs/roles.json") -> None:
     """Generate all 6 configuration types and save them to files."""
+    # Ensure output directory exists first
+    os.makedirs(output_dir, exist_ok=True)
+
     configs = {
         "http_simple": generate_http_simple_config(20000, certs_dir, keys_dir),
-        "http_token": generate_http_token_config(20001, certs_dir, keys_dir),
+        "http_token": generate_http_token_config(20001, certs_dir, keys_dir, roles_file),
         "https_simple": generate_https_simple_config(20002, certs_dir, keys_dir),
         "https_token": generate_https_token_config(20003, certs_dir, keys_dir),
         "mtls_no_roles": generate_mtls_no_roles_config(20004, certs_dir, keys_dir),
-        "mtls_with_roles": generate_mtls_with_roles_config(20005, certs_dir, keys_dir)
+        "mtls_with_roles": generate_mtls_with_roles_config(20005, certs_dir, keys_dir, roles_file)
     }
     # Ensure output directory exists
     os.makedirs(output_dir, exist_ok=True)
@@ -242,17 +245,36 @@ def generate_all_configs(output_dir: str, certs_dir: str = "./certs", keys_dir:
         print(f"Generated: {filename}")
     # Generate roles configuration
     roles_config = generate_roles_config()
+    
+    # Create roles.json in the root directory (test environment root) for compatibility
+    # When running as module, we need to create roles.json in the current working directory
+    # This is the directory where the user is running the command from
+    try:
+        # Get the current working directory where the user is running the command
+        current_dir = os.getcwd()
+        root_roles_filename = os.path.join(current_dir, "roles.json")
+        
+        # Create roles.json in the current working directory
+        with open(root_roles_filename, 'w', encoding='utf-8') as f:
+            json.dump(roles_config, f, indent=2, ensure_ascii=False)
+        print(f"Generated: {root_roles_filename}")
+        
+        # Also create a copy in the output directory for reference
+        backup_roles_filename = os.path.join(output_dir, "roles_backup.json")
+        with open(backup_roles_filename, 'w', encoding='utf-8') as f:
+            json.dump(roles_config, f, indent=2, ensure_ascii=False)
+        print(f"Generated backup: {backup_roles_filename}")
+        
+    except Exception as e:
+        print(f"Warning: Could not create roles.json in current directory: {e}")
+        print(f"Current working directory: {os.getcwd()}")
+        print(f"Script directory: {os.path.dirname(os.path.abspath(__file__))}")
+    
+    # Also create roles.json in configs directory for reference
     roles_filename = os.path.join(output_dir, "roles.json")
     with open(roles_filename, 'w', encoding='utf-8') as f:
         json.dump(roles_config, f, indent=2, ensure_ascii=False)
     print(f"Generated: {roles_filename}")
-    # Also create roles.json in certs directory for compatibility
-    certs_dir = os.path.join(os.path.dirname(output_dir), "certs")
-    if os.path.exists(certs_dir):
-        certs_roles_filename = os.path.join(certs_dir, "roles.json")
-        with open(certs_roles_filename, 'w', encoding='utf-8') as f:
-            json.dump(roles_config, f, indent=2, ensure_ascii=False)
-        print(f"Generated: {certs_roles_filename}")
     print(f"\nGenerated {len(configs)} configuration files and roles.json in {output_dir}")
     
     print("\n" + "=" * 60)
@@ -273,12 +295,27 @@ def main():
     )
     parser.add_argument(
         "--output-dir",
-        default="./configs",
-        help="Output directory for configuration files (default: ./configs)"
+        default="configs",
+        help="Output directory for configuration files (default: configs)"
+    )
+    parser.add_argument(
+        "--certs-dir",
+        default="certs",
+        help="Certificates directory (default: certs)"
+    )
+    parser.add_argument(
+        "--keys-dir",
+        default="keys",
+        help="Keys directory (default: keys)"
+    )
+    parser.add_argument(
+        "--roles-file",
+        default="configs/roles.json",
+        help="Roles file path (default: configs/roles.json)"
     )
     args = parser.parse_args()
     try:
-        generate_all_configs(args.output_dir)
+        generate_all_configs(args.output_dir, args.certs_dir, args.keys_dir, args.roles_file)
         print("Configuration generation completed successfully!")
     except Exception as e:
         print(f"\n❌ CONFIGURATION GENERATION FAILED: {e}")