mcp-proxy-adapter 3.1.6__py3-none-any.whl → 4.0.0__py3-none-any.whl

mcp_proxy_adapter/examples/custom_commands/hooks.py

@@ -0,0 +1,230 @@
+"""
+Custom Hooks Example
+
+This module demonstrates how to use hooks in the MCP Proxy Adapter framework.
+Hooks allow you to intercept command execution before and after processing.
+"""
+
+import time
+import logging
+from typing import Dict, Any
+from datetime import datetime
+
+from mcp_proxy_adapter.commands.hooks import HookContext, HookType
+
+
+# Setup logging for hooks
+logger = logging.getLogger("mcp_proxy_adapter.examples.hooks")
+
+
+def echo_before_hook(context: HookContext) -> None:
+    """
+    Before hook for echo command.
+    
+    Args:
+        context: Hook context with command information
+    """
+    logger.info(f"🔔 Echo command will be executed with params: {context.params}")
+    
+    # Add timestamp to params
+    context.params["hook_timestamp"] = datetime.now().isoformat()
+    
+    # Log the message that will be echoed
+    message = context.params.get("message", context.params.get("text", "Hello, World!"))
+    logger.info(f"📢 Will echo message: '{message}'")
+
+
+def echo_after_hook(context: HookContext) -> None:
+    """
+    After hook for echo command.
+    
+    Args:
+        context: Hook context with command information
+    """
+    logger.info(f"✅ Echo command completed successfully")
+    
+    # Log the result
+    if context.result and hasattr(context.result, 'data'):
+        echoed_message = context.result.data.get("message", "Unknown")
+        timestamp = context.result.data.get("timestamp", "Unknown")
+        logger.info(f"📤 Echoed: '{echoed_message}' at {timestamp}")
+
+
+def help_before_hook(context: HookContext) -> None:
+    """
+    Before hook for help command.
+    
+    Args:
+        context: Hook context with command information
+    """
+    logger.info(f"🔔 Help command will be executed")
+    
+    # Add request tracking
+    context.params["request_id"] = f"help_{int(time.time())}"
+    context.params["hook_processed"] = True
+    
+    cmdname = context.params.get("cmdname")
+    if cmdname:
+        logger.info(f"📖 Will get help for command: {cmdname}")
+    else:
+        logger.info(f"📖 Will get help for all commands")
+
+
+def help_after_hook(context: HookContext) -> None:
+    """
+    After hook for help command.
+    
+    Args:
+        context: Hook context with command information
+    """
+    logger.info(f"✅ Help command completed successfully")
+    
+    # Log the result summary
+    if context.result and hasattr(context.result, 'to_dict'):
+        result_dict = context.result.to_dict()
+        total_commands = result_dict.get("total", 0)
+        logger.info(f"📚 Help returned {total_commands} commands")
+
+
+def health_before_hook(context: HookContext) -> None:
+    """
+    Before hook for health command.
+    
+    Args:
+        context: Hook context with command information
+    """
+    logger.info(f"🔔 Health command will be executed")
+    
+    # Add health check metadata
+    context.params["health_check_id"] = f"health_{int(time.time())}"
+    context.params["hook_enhanced"] = True
+    
+    logger.info(f"🏥 Starting enhanced health check")
+
+
+def health_after_hook(context: HookContext) -> None:
+    """
+    After hook for health command.
+    
+    Args:
+        context: Hook context with command information
+    """
+    logger.info(f"✅ Health command completed successfully")
+    
+    # Log health status
+    if context.result and hasattr(context.result, 'data'):
+        status = context.result.data.get("status", "unknown")
+        uptime = context.result.data.get("uptime", 0)
+        logger.info(f"🏥 Health status: {status}, Uptime: {uptime:.2f}s")
+
+
+def global_before_hook(context: HookContext) -> None:
+    """
+    Global before hook for all commands.
+    
+    Args:
+        context: Hook context with command information
+    """
+    logger.info(f"🌐 Global before hook: {context.command_name}")
+    
+    # Add global tracking
+    context.params["global_hook_processed"] = True
+    context.params["execution_start_time"] = time.time()
+    
+    logger.info(f"🚀 Starting execution of '{context.command_name}'")
+
+
+def global_after_hook(context: HookContext) -> None:
+    """
+    Global after hook for all commands.
+    
+    Args:
+        context: Hook context with command information
+    """
+    start_time = context.params.get("execution_start_time", time.time())
+    execution_time = time.time() - start_time
+    
+    logger.info(f"🌐 Global after hook: {context.command_name}")
+    logger.info(f"⏱️  Execution time: {execution_time:.3f}s")
+    
+    # Log success/failure
+    if context.result:
+        logger.info(f"✅ Command '{context.command_name}' completed successfully")
+    else:
+        logger.warning(f"⚠️  Command '{context.command_name}' completed with issues")
+
+
+def performance_hook(context: HookContext) -> None:
+    """
+    Performance monitoring hook.
+    
+    Args:
+        context: Hook context with command information
+    """
+    if context.hook_type == HookType.BEFORE_EXECUTION:
+        # Store start time
+        context.params["_performance_start"] = time.time()
+        logger.debug(f"⏱️  Performance monitoring started for {context.command_name}")
+    
+    elif context.hook_type == HookType.AFTER_EXECUTION:
+        # Calculate execution time
+        start_time = context.params.get("_performance_start", time.time())
+        execution_time = time.time() - start_time
+        
+        logger.info(f"📊 Performance: {context.command_name} took {execution_time:.3f}s")
+        
+        # Log slow commands
+        if execution_time > 1.0:
+            logger.warning(f"🐌 Slow command detected: {context.command_name} ({execution_time:.3f}s)")
+
+
+def security_hook(context: HookContext) -> None:
+    """
+    Security monitoring hook.
+    
+    Args:
+        context: Hook context with command information
+    """
+    if context.hook_type == HookType.BEFORE_EXECUTION:
+        # Check for sensitive data in params
+        sensitive_keys = ["password", "token", "secret", "key"]
+        found_sensitive = [key for key in context.params.keys() if any(s in key.lower() for s in sensitive_keys)]
+        
+        if found_sensitive:
+            logger.warning(f"🔒 Security: Sensitive parameters detected in {context.command_name}: {found_sensitive}")
+        
+        # Add security metadata
+        context.params["_security_checked"] = True
+        logger.debug(f"🔒 Security check completed for {context.command_name}")
+
+
+def register_all_hooks(hooks_manager) -> None:
+    """
+    Register all hooks with the hooks manager.
+    
+    Args:
+        hooks_manager: The hooks manager instance
+    """
+    logger.info("🔧 Registering custom hooks...")
+    
+    # Register command-specific hooks
+    hooks_manager.register_before_hook("echo", echo_before_hook)
+    hooks_manager.register_after_hook("echo", echo_after_hook)
+    
+    hooks_manager.register_before_hook("help", help_before_hook)
+    hooks_manager.register_after_hook("help", help_after_hook)
+    
+    hooks_manager.register_before_hook("health", health_before_hook)
+    hooks_manager.register_after_hook("health", health_after_hook)
+    
+    # Register global hooks
+    hooks_manager.register_global_before_hook(global_before_hook)
+    hooks_manager.register_global_after_hook(global_after_hook)
+    
+    # Register utility hooks
+    hooks_manager.register_global_before_hook(performance_hook)
+    hooks_manager.register_global_after_hook(performance_hook)
+    
+    hooks_manager.register_global_before_hook(security_hook)
+    
+    logger.info("✅ All hooks registered successfully") 

mcp_proxy_adapter/examples/custom_commands/intercept_command.py

@@ -0,0 +1,123 @@
+"""
+Intercept Command Example
+
+A command that can be completely intercepted by hooks based on conditions.
+"""
+
+from typing import Dict, Any, Optional
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult
+
+
+class InterceptResult(CommandResult):
+    """
+    Result of the intercept command execution.
+    """
+    
+    def __init__(self, message: str, executed: bool, intercept_reason: Optional[str] = None,
+                 hook_data: Optional[Dict[str, Any]] = None):
+        """
+        Initialize intercept command result.
+        
+        Args:
+            message: Result message
+            executed: Whether the command was actually executed
+            intercept_reason: Reason for interception (if any)
+            hook_data: Data from hooks
+        """
+        self.message = message
+        self.executed = executed
+        self.intercept_reason = intercept_reason
+        self.hook_data = hook_data or {}
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dict[str, Any]: Result as dictionary
+        """
+        return {
+            "message": self.message,
+            "executed": self.executed,
+            "intercept_reason": self.intercept_reason,
+            "hook_data": self.hook_data,
+            "command_type": "intercept"
+        }
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for the result.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string"},
+                "executed": {"type": "boolean"},
+                "intercept_reason": {"type": "string"},
+                "hook_data": {"type": "object"},
+                "command_type": {"type": "string"}
+            }
+        }
+
+
+class InterceptCommand(Command):
+    """
+    Intercept command for demonstrating hook interception.
+    """
+    
+    name = "intercept"
+    result_class = InterceptResult
+    
+    async def execute(self, action: Optional[str] = None, 
+                     bypass_flag: Optional[int] = None, **kwargs) -> InterceptResult:
+        """
+        Execute intercept command.
+        
+        Args:
+            action: Action to perform
+            bypass_flag: Flag to determine if command should be bypassed (0 = bypass, 1 = execute)
+            **kwargs: Additional parameters
+            
+        Returns:
+            InterceptResult: Intercept command result
+        """
+        action = action or "default"
+        bypass_flag = bypass_flag if bypass_flag is not None else 1
+        
+        # This should only execute if bypass_flag == 1
+        # If bypass_flag == 0, hooks should intercept and return result
+        
+        return InterceptResult(
+            message=f"Command executed with action: {action}",
+            executed=True,
+            intercept_reason=None,
+            hook_data=kwargs
+        )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "description": "Action to perform"
+                },
+                "bypass_flag": {
+                    "type": "integer",
+                    "enum": [0, 1],
+                    "description": "Flag to determine execution (0 = bypass, 1 = execute)"
+                }
+            }
+        } 

mcp_proxy_adapter/examples/custom_commands/manual_echo_command.py

@@ -0,0 +1,103 @@
+"""
+Manually registered Echo Command
+
+This command must be manually registered in the server code.
+"""
+
+from typing import Dict, Any, Optional
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult
+
+
+class ManualEchoResult(CommandResult):
+    """
+    Result of the manually registered echo command execution.
+    """
+    
+    def __init__(self, message: str, manually_registered: bool = True):
+        """
+        Initialize manual echo command result.
+        
+        Args:
+            message: Echoed message
+            manually_registered: Flag indicating this was manually registered
+        """
+        self.message = message
+        self.manually_registered = manually_registered
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dict[str, Any]: Result as dictionary
+        """
+        return {
+            "message": self.message,
+            "manually_registered": self.manually_registered,
+            "command_type": "manual_echo"
+        }
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for the result.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string"},
+                "manually_registered": {"type": "boolean"},
+                "command_type": {"type": "string"}
+            }
+        }
+
+
+class ManualEchoCommand(Command):
+    """
+    Manually registered echo command.
+    """
+    
+    name = "manual_echo"
+    result_class = ManualEchoResult
+    
+    async def execute(self, message: Optional[str] = None, **kwargs) -> ManualEchoResult:
+        """
+        Execute manually registered echo command.
+        
+        Args:
+            message: Message to echo
+            **kwargs: Additional parameters
+            
+        Returns:
+            ManualEchoResult: Manual echo command result
+        """
+        if message is None:
+            message = "Hello from manually registered command!"
+        
+        return ManualEchoResult(
+            message=message,
+            manually_registered=True
+        )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "description": "Message to echo",
+                    "default": "Hello from manually registered command!"
+                }
+            }
+        } 

mcp_proxy_adapter/examples/custom_commands/server.py

@@ -0,0 +1,223 @@
+"""
+Custom Commands Server Example
+
+This example demonstrates a MCP Proxy Adapter server
+with custom commands: echo, custom help, and custom health.
+Includes hooks for before and after command processing.
+"""
+
+import asyncio
+import uvicorn
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+from mcp_proxy_adapter import create_app
+from mcp_proxy_adapter.core.logging import get_logger, setup_logging
+from mcp_proxy_adapter.core.settings import (
+    Settings,
+    get_server_host,
+    get_server_port,
+    get_server_debug,
+    get_setting,
+    get_custom_setting_value
+)
+from .custom_settings_manager import CustomSettingsManager, get_app_name, is_feature_enabled
+
+# Import custom commands and hooks
+from .custom_help_command import CustomHelpCommand
+from .custom_health_command import CustomHealthCommand
+from .data_transform_command import DataTransformCommand
+from .intercept_command import InterceptCommand
+from .advanced_hooks import register_advanced_hooks
+
+# Import auto-registered commands
+from .auto_commands.auto_echo_command import AutoEchoCommand
+from .auto_commands.auto_info_command import AutoInfoCommand
+
+# Import manual registration example
+from .manual_echo_command import ManualEchoCommand
+
+# Import echo command
+from .echo_command import EchoCommand
+
+# Import custom OpenAPI generator
+from .custom_openapi_generator import custom_openapi_generator
+
+# Import command registry for manual registration
+from mcp_proxy_adapter.commands.command_registry import registry
+
+
+def register_custom_commands():
+    """Register custom commands with the registry."""
+    logger = get_logger("custom_commands")
+    logger.info("Registering custom commands...")
+    
+    # Get custom commands configuration from custom settings
+    custom_commands_config = get_custom_setting_value("custom_commands", {})
+    
+    # Register echo command
+    registry.register(EchoCommand)
+    logger.info("Registered: echo command")
+    
+    # Register custom help command (will override built-in)
+    if custom_commands_config.get("help", {}).get("enabled", True):
+        registry.register_custom_command(CustomHelpCommand)
+        logger.info("Registered: custom help command")
+    
+    # Register custom health command (will override built-in)
+    if custom_commands_config.get("health", {}).get("enabled", True):
+        registry.register_custom_command(CustomHealthCommand)
+        logger.info("Registered: custom health command")
+    
+    # Register advanced demonstration commands
+    if custom_commands_config.get("data_transform", {}).get("enabled", True):
+        registry.register(DataTransformCommand)
+        logger.info("Registered: data_transform command")
+    
+    if custom_commands_config.get("intercept", {}).get("enabled", True):
+        registry.register(InterceptCommand)
+        logger.info("Registered: intercept command")
+    
+    # Register manually registered commands
+    if custom_commands_config.get("manual_echo", {}).get("enabled", True):
+        registry.register(ManualEchoCommand)
+        logger.info("Registered: manual_echo command")
+    
+    logger.info(f"Total commands registered: {len(registry.get_all_commands())}")
+
+
+def setup_hooks():
+    """Setup hooks for command processing."""
+    logger = get_logger("custom_commands")
+    logger.info("Setting up hooks...")
+    
+    # Get hooks configuration from custom settings
+    hooks_config = get_custom_setting_value("hooks", {})
+    
+    # Register basic hooks
+    # register_all_hooks(hooks) # This line was removed as per the new_code, as hooks is no longer imported.
+    logger.info("Registered: basic hooks")
+    
+    # Register advanced hooks based on configuration
+    if hooks_config.get("data_transform", {}).get("enabled", True):
+        # register_advanced_hooks(None)  # Temporarily disabled for simplicity
+        logger.info("Registered: data transformation hooks (disabled for now)")
+    
+    if hooks_config.get("intercept", {}).get("enabled", True):
+        logger.info("Registered: interception hooks")
+    
+    logger.info("Registered: command-specific hooks")
+    logger.info("Registered: global hooks")
+    logger.info("Registered: performance monitoring hooks")
+    logger.info("Registered: security monitoring hooks")
+    logger.info("Registered: data transformation hooks")
+    logger.info("Registered: interception hooks")
+
+
+def main():
+    """Run the custom commands server example with hooks."""
+    # Load configuration from config.json in the same directory
+    config_path = os.path.join(os.path.dirname(__file__), "config.json")
+    if os.path.exists(config_path):
+        from mcp_proxy_adapter.config import config
+        config.load_from_file(config_path)
+        print(f"✅ Loaded configuration from: {config_path}")
+    else:
+        print(f"⚠️  Configuration file not found: {config_path}")
+        print("   Using default configuration")
+    
+    # Setup logging with configuration
+    setup_logging()
+    logger = get_logger("custom_commands")
+    
+    # Initialize custom settings manager
+    custom_settings_manager = CustomSettingsManager("custom_settings.json")
+    
+    # Print custom settings summary
+    custom_settings_manager.print_settings_summary()
+    
+    # Get settings from configuration
+    server_settings = Settings.get_server_settings()
+    logging_settings = Settings.get_logging_settings()
+    commands_settings = Settings.get_commands_settings()
+    custom_settings = Settings.get_custom_setting("custom", {})
+    
+    # Print server header and description
+    print("=" * 80)
+    print("🔧 ADVANCED MCP PROXY ADAPTER SERVER WITH HOOKS")
+    print("=" * 80)
+    print("📋 Description:")
+    print(f"   {get_app_name()} - Advanced server with custom settings management")
+    print()
+    print("⚙️  Configuration:")
+    print(f"   • Server: {server_settings['host']}:{server_settings['port']}")
+    print(f"   • Debug: {server_settings['debug']}")
+    print(f"   • Log Level: {logging_settings['level']}")
+    print(f"   • Log Directory: {logging_settings['log_dir']}")
+    print(f"   • Auto Discovery: {commands_settings['auto_discovery']}")
+    print()
+    print("🔧 Available Commands:")
+    print("   • help - Custom help command (overrides built-in)")
+    print("   • health - Custom health command (overrides built-in)")
+    print("   • config - Built-in config command")
+    print("   • reload - Built-in reload command")
+    print("   • settings - Built-in settings command")
+    print("   • reload_settings - Built-in reload settings command")
+    print("   • data_transform - Data transformation command")
+    print("   • intercept - Command interception example")
+    print("   • manual_echo - Manually registered echo command")
+    print("   • auto_echo - Auto-registered echo command")
+    print("   • auto_info - Auto-registered info command")
+    print()
+    print("🎯 Features:")
+    print("   • Advanced JSON-RPC API")
+    print("   • Custom commands with hooks")
+    print("   • Data transformation hooks")
+    print("   • Command interception hooks")
+    print("   • Auto-registration and manual registration")
+    print("   • Custom OpenAPI schema generation")
+    print("   • Configuration-driven settings")
+    print("   • Custom settings management")
+    print("=" * 80)
+    print()
+    
+    logger.info("Starting Advanced Custom Commands MCP Proxy Adapter Server with Hooks...")
+    logger.info(f"Server configuration: {server_settings}")
+    logger.info(f"Logging configuration: {logging_settings}")
+    logger.info(f"Commands configuration: {commands_settings}")
+    logger.info("This server demonstrates both auto-registration and manual registration:")
+    logger.info("• Auto-registered: auto_echo, auto_info (from auto_commands/ package)")
+    logger.info("• Manually registered: echo, help, health, data_transform, intercept, manual_echo")
+    logger.info("• Built-in commands: help, health (if not overridden)")
+    logger.info("With advanced hooks for data transformation and command interception")
+    
+    # Register custom commands
+    register_custom_commands()
+    
+    # Discover auto-registered commands
+    logger.info("Discovering auto-registered commands...")
+    auto_commands_path = commands_settings.get("auto_commands_path", "mcp_proxy_adapter.examples.custom_commands.auto_commands")
+    registry.discover_commands(auto_commands_path)
+    
+    # Setup hooks
+    setup_hooks()
+    
+    # Create application with settings from configuration
+    app = create_app(
+        title=get_app_name(),
+        description="Advanced MCP Proxy Adapter server with custom settings management, demonstrating hook capabilities including data transformation, command interception, conditional processing, and smart interception hooks. Features custom commands with enhanced functionality and comprehensive settings management.",
+        version="2.1.0"
+    )
+    
+    # Run the server with configuration settings
+    uvicorn.run(
+        app,
+        host=server_settings['host'],
+        port=server_settings['port'],
+        log_level=server_settings['log_level'].lower()
+    )
+
+
+if __name__ == "__main__":
+    main()