mcp-proxy-adapter 6.0.0__py3-none-any.whl → 6.0.1__py3-none-any.whl

mcp_proxy_adapter/examples/full_application/commands/dynamic_calculator_command.py

@@ -0,0 +1,90 @@
+"""
+Dynamic Calculator Command
+This module demonstrates a dynamically loaded command implementation for the full application example.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+from typing import Dict, Any, Optional
+from mcp_proxy_adapter.commands.base import BaseCommand
+from mcp_proxy_adapter.commands.result import CommandResult
+class CalculatorResult(CommandResult):
+    """Result class for calculator command."""
+    def __init__(self, operation: str, result: float, expression: str):
+        self.operation = operation
+        self.result = result
+        self.expression = expression
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert result to dictionary."""
+        return {
+            "operation": self.operation,
+            "result": self.result,
+            "expression": self.expression,
+            "command_type": "dynamic_calculator"
+        }
+    def get_schema(self) -> Dict[str, Any]:
+        """Get result schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "operation": {"type": "string", "description": "Mathematical operation"},
+                "result": {"type": "number", "description": "Calculation result"},
+                "expression": {"type": "string", "description": "Full expression"},
+                "command_type": {"type": "string", "description": "Command type"}
+            },
+            "required": ["operation", "result", "expression", "command_type"]
+        }
+class DynamicCalculatorCommand(BaseCommand):
+    """Dynamic calculator command implementation."""
+    def get_name(self) -> str:
+        """Get command name."""
+        return "dynamic_calculator"
+    def get_description(self) -> str:
+        """Get command description."""
+        return "Dynamic calculator with basic mathematical operations"
+    def get_schema(self) -> Dict[str, Any]:
+        """Get command schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "operation": {
+                    "type": "string",
+                    "description": "Mathematical operation (add, subtract, multiply, divide)",
+                    "enum": ["add", "subtract", "multiply", "divide"]
+                },
+                "a": {
+                    "type": "number",
+                    "description": "First number"
+                },
+                "b": {
+                    "type": "number",
+                    "description": "Second number"
+                }
+            },
+            "required": ["operation", "a", "b"]
+        }
+    async def execute(self, params: Dict[str, Any]) -> CalculatorResult:
+        """Execute the calculator command."""
+        operation = params.get("operation")
+        a = params.get("a")
+        b = params.get("b")
+        if operation == "add":
+            result = a + b
+            expression = f"{a} + {b}"
+        elif operation == "subtract":
+            result = a - b
+            expression = f"{a} - {b}"
+        elif operation == "multiply":
+            result = a * b
+            expression = f"{a} * {b}"
+        elif operation == "divide":
+            if b == 0:
+                raise ValueError("Division by zero is not allowed")
+            result = a / b
+            expression = f"{a} / {b}"
+        else:
+            raise ValueError(f"Unknown operation: {operation}")
+        return CalculatorResult(
+            operation=operation,
+            result=result,
+            expression=expression
+        )

mcp_proxy_adapter/examples/full_application/hooks/__init__.py

@@ -0,0 +1,7 @@
+"""Full Application Hooks.
+
+Application and command hooks for the full application example.
+"""
+
+from .application_hooks import ApplicationHooks
+from .builtin_command_hooks import BuiltinCommandHooks

mcp_proxy_adapter/examples/full_application/hooks/application_hooks.py

@@ -0,0 +1,75 @@
+"""
+Application Hooks
+This module demonstrates application-level hooks in the full application example.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import logging
+from typing import Dict, Any, Optional
+from datetime import datetime
+logger = logging.getLogger(__name__)
+class ApplicationHooks:
+    """Application-level hooks."""
+    @staticmethod
+    def on_startup():
+        """Hook executed on application startup."""
+        logger.info("🚀 Application startup hook executed")
+        # Initialize application-specific resources
+        logger.info("📊 Initializing application metrics")
+        logger.info("🔐 Loading security configurations")
+        logger.info("📝 Setting up logging")
+    @staticmethod
+    def on_shutdown():
+        """Hook executed on application shutdown."""
+        logger.info("🛑 Application shutdown hook executed")
+        # Cleanup application resources
+        logger.info("🧹 Cleaning up resources")
+        logger.info("💾 Saving application state")
+        logger.info("📊 Finalizing metrics")
+    @staticmethod
+    def before_request(request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed before processing any request."""
+        logger.info(f"🔧 Application hook: before_request with data: {request_data}")
+        # Add request metadata
+        request_data["app_metadata"] = {
+            "request_id": f"req_{datetime.now().timestamp()}",
+            "timestamp": datetime.now().isoformat(),
+            "application": "full_application_example"
+        }
+        return request_data
+    @staticmethod
+    def after_request(result: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed after processing any request."""
+        logger.info(f"🔧 Application hook: after_request with result: {result}")
+        # Add response metadata
+        result["app_response_metadata"] = {
+            "processed_at": datetime.now().isoformat(),
+            "application": "full_application_example",
+            "version": "1.0.0"
+        }
+        return result
+    @staticmethod
+    def on_error(error: Exception, context: Dict[str, Any]):
+        """Hook executed when an error occurs."""
+        logger.error(f"🔧 Application hook: on_error - {error} in context: {context}")
+        # Log error details
+        logger.error(f"Error type: {type(error).__name__}")
+        logger.error(f"Error message: {str(error)}")
+        logger.error(f"Context: {context}")
+    @staticmethod
+    def on_command_registered(command_name: str, command_info: Dict[str, Any]):
+        """Hook executed when a command is registered."""
+        logger.info(f"🔧 Application hook: on_command_registered - {command_name}")
+        logger.info(f"Command info: {command_info}")
+        # Track registered commands
+        logger.info(f"📝 Command '{command_name}' registered successfully")
+    @staticmethod
+    def on_command_executed(command_name: str, execution_time: float, success: bool):
+        """Hook executed when a command is executed."""
+        logger.info(f"🔧 Application hook: on_command_executed - {command_name}")
+        logger.info(f"Execution time: {execution_time}s, Success: {success}")
+        # Track command execution metrics
+        if success:
+            logger.info(f"✅ Command '{command_name}' executed successfully in {execution_time}s")
+        else:
+            logger.warning(f"⚠️ Command '{command_name}' failed after {execution_time}s")

mcp_proxy_adapter/examples/full_application/hooks/builtin_command_hooks.py

@@ -0,0 +1,71 @@
+"""
+Built-in Command Hooks
+This module demonstrates hooks for built-in commands in the full application example.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import logging
+from typing import Dict, Any, Optional
+from datetime import datetime
+logger = logging.getLogger(__name__)
+class BuiltinCommandHooks:
+    """Hooks for built-in commands."""
+    @staticmethod
+    def before_echo_command(params: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed before echo command."""
+        logger.info(f"🔧 Built-in hook: before_echo_command with params: {params}")
+        # Add timestamp to message
+        if "message" in params:
+            timestamp = datetime.now().isoformat()
+            params["message"] = f"[{timestamp}] {params['message']}"
+        return params
+    @staticmethod
+    def after_echo_command(result: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed after echo command."""
+        logger.info(f"🔧 Built-in hook: after_echo_command with result: {result}")
+        # Add hook metadata
+        result["hook_metadata"] = {
+            "hook_type": "builtin_after_echo",
+            "timestamp": datetime.now().isoformat(),
+            "processed": True
+        }
+        return result
+    @staticmethod
+    def before_health_command(params: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed before health command."""
+        logger.info(f"🔧 Built-in hook: before_health_command with params: {params}")
+        # Add custom health check parameters
+        params["include_detailed_info"] = True
+        params["check_dependencies"] = True
+        return params
+    @staticmethod
+    def after_health_command(result: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed after health command."""
+        logger.info(f"🔧 Built-in hook: after_health_command with result: {result}")
+        # Add custom health metrics
+        if "status" in result and result["status"] == "healthy":
+            result["custom_metrics"] = {
+                "uptime": "24h",
+                "memory_usage": "45%",
+                "cpu_usage": "12%"
+            }
+        return result
+    @staticmethod
+    def before_config_command(params: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed before config command."""
+        logger.info(f"🔧 Built-in hook: before_config_command with params: {params}")
+        # Add configuration validation
+        params["validate_config"] = True
+        params["include_secrets"] = False
+        return params
+    @staticmethod
+    def after_config_command(result: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed after config command."""
+        logger.info(f"🔧 Built-in hook: after_config_command with result: {result}")
+        # Add configuration metadata
+        result["config_metadata"] = {
+            "last_modified": datetime.now().isoformat(),
+            "version": "1.0.0",
+            "environment": "development"
+        }
+        return result

mcp_proxy_adapter/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/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)}")