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

mcp_proxy_adapter/examples/full_application/configs/mtls_no_roles.json

@@ -0,0 +1,39 @@
+{
+    "server": {
+        "host": "0.0.0.0",
+        "port": 9443,
+        "debug": false,
+        "log_level": "INFO"
+    },
+    "ssl": {
+        "enabled": true,
+        "cert_file": "./certs/server.crt",
+        "key_file": "./certs/server.key",
+        "ca_cert": "./certs/ca.crt",
+        "verify_client": true,
+        "client_cert_required": true
+    },
+    "security": {
+        "enabled": true,
+        "auth": {
+            "enabled": true,
+            "methods": ["certificate"],
+            "certificate_auth": true
+        },
+        "rate_limit": {
+            "enabled": true,
+            "requests_per_minute": 60,
+            "requests_per_hour": 1000,
+            "burst_limit": 10
+        }
+    },
+    "logging": {
+        "level": "INFO",
+        "console_output": true,
+        "file_output": false
+    },
+    "commands": {
+        "auto_discovery": true,
+        "commands_directory": "./commands"
+    }
+}

mcp_proxy_adapter/examples/full_application/configs/mtls_with_roles.json

@@ -0,0 +1,45 @@
+{
+    "server": {
+        "host": "0.0.0.0",
+        "port": 9444,
+        "debug": false,
+        "log_level": "INFO"
+    },
+    "ssl": {
+        "enabled": true,
+        "cert_file": "./certs/server.crt",
+        "key_file": "./certs/server.key",
+        "ca_cert": "./certs/ca.crt",
+        "verify_client": true,
+        "client_cert_required": true
+    },
+    "security": {
+        "enabled": true,
+        "auth": {
+            "enabled": true,
+            "methods": ["certificate"],
+            "certificate_auth": true
+        },
+        "permissions": {
+            "enabled": true,
+            "roles_file": "./roles.json",
+            "default_role": "user",
+            "deny_by_default": true
+        },
+        "rate_limit": {
+            "enabled": true,
+            "requests_per_minute": 60,
+            "requests_per_hour": 1000,
+            "burst_limit": 10
+        }
+    },
+    "logging": {
+        "level": "INFO",
+        "console_output": true,
+        "file_output": false
+    },
+    "commands": {
+        "auto_discovery": true,
+        "commands_directory": "./commands"
+    }
+}

mcp_proxy_adapter/examples/full_application/hooks/application_hooks.py

@@ -0,0 +1,97 @@
+"""
+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,95 @@
+"""
+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,138 @@
+#!/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.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 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)
+        
+        self.logger.info("✅ Application created successfully")
+    
+    def run(self, host: str = None, port: int = None, debug: bool = False):
+        """Run the application."""
+        # Override configuration if specified
+        if host:
+            self.config.set("server.host", host)
+        if port:
+            self.config.set("server.port", port)
+        if debug:
+            self.config.set("server.debug", True)
+        
+        # Create application
+        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}")
+        print(f"🌐 Server: {server_host}:{server_port}")
+        print(f"🔧 Debug: {server_debug}")
+        print(f"🔧 Features: Built-in commands, Custom commands, Dynamic commands, Hooks")
+        print("=" * 60)
+        
+        # Import uvicorn here to avoid dependency issues
+        import uvicorn
+        uvicorn.run(self.app, host=server_host, port=server_port, log_level="info")
+
+
+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)
+
+
+if __name__ == "__main__":
+    main()

mcp_proxy_adapter/examples/full_application/roles.json

@@ -0,0 +1,21 @@
+{
+    "roles": {
+        "admin": {
+            "permissions": ["*"],
+            "description": "Administrator with full access"
+        },
+        "user": {
+            "permissions": ["read", "write"],
+            "description": "Regular user with read/write access"
+        },
+        "readonly": {
+            "permissions": ["read"],
+            "description": "Read-only user"
+        }
+    },
+    "user_roles": {
+        "admin": "admin",
+        "user": "user",
+        "readonly": "readonly"
+    }
+}