mcp-proxy-adapter 6.1.0__py3-none-any.whl → 6.2.0__py3-none-any.whl

mcp_proxy_adapter/examples/full_application/hooks/application_hooks.py

@@ -1,95 +1,73 @@
 """
 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")

mcp_proxy_adapter/examples/full_application/hooks/builtin_command_hooks.py

@@ -1,64 +1,47 @@
 """
 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"] = {
@@ -66,30 +49,23 @@ class BuiltinCommandHooks:
                 "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

@@ -1,124 +1,149 @@
 #!/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."""
+        """Run the application using the factory method."""
         # Override configuration if specified
+        config_overrides = {}
         if host:
-            self.config.set("server.host", host)
+            config_overrides["host"] = host
         if port:
-            self.config.set("server.port", port)
+            config_overrides["port"] = port
         if debug:
-            self.config.set("server.debug", True)
-        
-        # Create application
+            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)
-        
-        print(f"🚀 Starting Full Application Example")
-        print(f"📋 Configuration: {self.config_path}")
+        # 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}")
-        print(f"🔧 Features: Built-in commands, Custom commands, Dynamic commands, Hooks")
+        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)
-        
-        # Import uvicorn here to avoid dependency issues
-        import uvicorn
-        uvicorn.run(self.app, host=server_host, port=server_port, log_level="info")
-
-
+        # 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")
@@ -126,13 +151,9 @@ def main():
     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)
-
-
 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)}")