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

mcp_proxy_adapter/examples/custom_commands/advanced_hooks.py

@@ -11,8 +11,11 @@ import logging
 from typing import Dict, Any
 from datetime import datetime
 
-from mcp_proxy_adapter.commands.hooks import HookContext, HookType
+from mcp_proxy_adapter.commands.hooks import hooks
 from mcp_proxy_adapter.commands.result import CommandResult
+from mcp_proxy_adapter.commands.hooks import HookContext
+from mcp_proxy_adapter.commands.hooks import HookType
+# Import will be done locally when needed to avoid circular imports
 
 
 # Setup logging for advanced hooks
@@ -26,7 +29,7 @@ def data_transform_before_hook(context: HookContext) -> None:
     Args:
         context: Hook context with command information
     """
-    logger.info(f"🔄 Data transform before hook: {context.params}")
+    logger.info(f"🔄 Data transform before hook: {context}")
     
     # Get original data
     original_data = context.params.get("data", {})
@@ -54,7 +57,7 @@ def data_transform_before_hook(context: HookContext) -> None:
     
     logger.info(f"📊 Original data: {original_data}")
     logger.info(f"🔄 Transformed data: {transformed_data}")
-
+    
 
 def data_transform_after_hook(context: HookContext) -> None:
     """
@@ -63,7 +66,7 @@ def data_transform_after_hook(context: HookContext) -> None:
     Args:
         context: Hook context with command information
     """
-    logger.info(f"🔄 Data transform after hook: {context.result}")
+    logger.info(f"🔄 Data transform after hook: {context}")
     
     if context.result and hasattr(context.result, 'transformed_data'):
         # Get the transformed data from command result
@@ -86,7 +89,7 @@ def data_transform_after_hook(context: HookContext) -> None:
         context.result.transformed_data = formatted_data
         
         logger.info(f"✨ Formatted data: {formatted_data}")
-
+    
 
 def intercept_before_hook(context: HookContext) -> None:
     """
@@ -95,7 +98,7 @@ def intercept_before_hook(context: HookContext) -> None:
     Args:
         context: Hook context with command information
     """
-    logger.info(f"🚫 Intercept before hook: {context.params}")
+    logger.info(f"🚫 Intercept before hook: {context}")
     
     # Check bypass flag
     bypass_flag = context.params.get("bypass_flag", 1)
@@ -114,20 +117,19 @@ def intercept_before_hook(context: HookContext) -> None:
             hook_data={
                 "intercepted_by": "intercept_before_hook",
                 "interception_time": datetime.now().isoformat(),
-                "original_params": context.params.copy()
+                "bypass_flag": bypass_flag
             }
         )
         
-        # Set the result and stop standard processing
+        # Set the result and disable standard processing
         context.result = mock_result
         context.standard_processing = False
         
-        logger.info(f"✅ Command intercepted successfully")
+        logger.info(f"🚫 Command execution bypassed, result: {mock_result}")
     else:
-        # Allow normal execution
-        logger.info(f"✅ Allowing normal execution - bypass_flag = {bypass_flag}")
+        logger.info(f"✅ Command execution allowed - bypass_flag = {bypass_flag}")
         context.params["hook_processed"] = True
-
+    
 
 def intercept_after_hook(context: HookContext) -> None:
     """
@@ -211,40 +213,354 @@ def smart_intercept_hook(context: HookContext) -> None:
                 hook_data={
                     "intercepted_by": "smart_intercept_hook",
                     "interception_time": datetime.now().isoformat(),
-                    "original_params": context.params.copy(),
                     "smart_analysis": True
                 }
             )
             
-            # Set the result and stop standard processing
+            # Set the result and disable standard processing
             context.result = mock_result
             context.standard_processing = False
             
             logger.info(f"✅ Smart interception completed")
-
+    
 
 def register_advanced_hooks(hooks_manager) -> None:
     """
-    Register advanced hooks with the hooks manager.
+    Register advanced hooks with the hooks system.
     
     Args:
-        hooks_manager: The hooks manager instance
+        hooks_manager: Hooks manager instance to register hooks with
     """
     logger.info("🔧 Registering advanced hooks...")
     
-    # Register data transformation hooks
+    # Register data transform hooks
     hooks_manager.register_before_hook("data_transform", data_transform_before_hook)
     hooks_manager.register_after_hook("data_transform", data_transform_after_hook)
     
-    # Register interception hooks
+    # Register intercept hooks
     hooks_manager.register_before_hook("intercept", intercept_before_hook)
     hooks_manager.register_after_hook("intercept", intercept_after_hook)
     
-    # Register conditional hooks
+    # Register global hooks
     hooks_manager.register_global_before_hook(conditional_transform_hook)
+    hooks_manager.register_global_before_hook(smart_intercept_hook)
     hooks_manager.register_global_after_hook(conditional_transform_hook)
     
-    # Register smart interception hooks
-    hooks_manager.register_global_before_hook(smart_intercept_hook)
+    # Register system lifecycle hooks
+    hooks_manager.register_before_init_hook(system_before_init_hook)
+    hooks_manager.register_after_init_hook(system_after_init_hook)
+    
+    # Register command-specific hooks for all commands
+    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)
+    
+    hooks_manager.register_before_hook("config", config_before_hook)
+    hooks_manager.register_after_hook("config", config_after_hook)
+    
+    hooks_manager.register_before_hook("load", load_before_hook)
+    hooks_manager.register_after_hook("load", load_after_hook)
+    
+    hooks_manager.register_before_hook("unload", unload_before_hook)
+    hooks_manager.register_after_hook("unload", unload_after_hook)
+    
+    hooks_manager.register_before_hook("reload", reload_before_hook)
+    hooks_manager.register_after_hook("reload", reload_after_hook)
+    
+    hooks_manager.register_before_hook("plugins", plugins_before_hook)
+    hooks_manager.register_after_hook("plugins", plugins_after_hook)
+    
+    hooks_manager.register_before_hook("settings", settings_before_hook)
+    hooks_manager.register_after_hook("settings", settings_after_hook)
+    
+    # Register custom commands hooks
+    hooks_manager.register_before_hook("manual_echo", manual_echo_before_hook)
+    hooks_manager.register_after_hook("manual_echo", manual_echo_after_hook)
+    
+    hooks_manager.register_before_hook("auto_echo", auto_echo_before_hook)
+    hooks_manager.register_after_hook("auto_echo", auto_echo_after_hook)
+    
+    hooks_manager.register_before_hook("auto_info", auto_info_before_hook)
+    hooks_manager.register_after_hook("auto_info", auto_info_after_hook)
+    
+    logger.info("✅ Advanced hooks registered successfully")
+
+
+# ============================================================================
+# SYSTEM LIFECYCLE HOOKS
+# ============================================================================
+
+def system_before_init_hook(registry) -> None:
+    """
+    Before system initialization hook.
+    
+    Args:
+        registry: Command registry instance
+    """
+    logger.info("🚀 System before init hook: Preparing system initialization")
+    
+    # Add initialization metadata
+    registry.metadata["init_start_time"] = datetime.now().isoformat()
+    registry.metadata["init_hooks_processed"] = True
+    
+    logger.info("✅ System initialization preparation completed")
+
+
+def system_after_init_hook(registry) -> None:
+    """
+    After system initialization hook.
+    
+    Args:
+        registry: Command registry instance
+    """
+    logger.info("🎉 System after init hook: System initialization completed")
+    
+    # Add completion metadata
+    registry.metadata["init_end_time"] = datetime.now().isoformat()
+    registry.metadata["total_commands"] = len(registry.get_all_commands())
+    
+    logger.info(f"✅ System initialization completed with {registry.metadata['total_commands']} commands")
+
+
+# ============================================================================
+# BUILT-IN COMMAND HOOKS
+# ============================================================================
+
+def echo_before_hook(context: HookContext) -> None:
+    """Before hook for echo command."""
+    logger.info(f"📢 Echo before hook: {context.command_name}")
+    
+    # Add timestamp to message
+    if context.params and "message" in context.params:
+        original_message = context.params["message"]
+        context.params["message"] = f"[{datetime.now().strftime('%H:%M:%S')}] {original_message}"
+        context.params["_timestamp_added"] = True
+    
+    context.metadata["echo_processed"] = True
+
+
+def echo_after_hook(context: HookContext) -> None:
+    """After hook for echo command."""
+    logger.info(f"📢 Echo after hook: {context.command_name}")
+    
+    if context.result and hasattr(context.result, 'message'):
+        context.result.message = f"ECHO: {context.result.message}"
+        context.metadata["echo_formatted"] = True
+
+
+def help_before_hook(context: HookContext) -> None:
+    """Before hook for help command."""
+    logger.info(f"❓ Help before hook: {context.command_name}")
+    
+    # Add help metadata
+    context.metadata["help_requested"] = True
+    context.metadata["help_time"] = datetime.now().isoformat()
+
+
+def help_after_hook(context: HookContext) -> None:
+    """After hook for help command."""
+    logger.info(f"❓ Help after hook: {context.command_name}")
+    
+    if context.result and hasattr(context.result, 'commands_info'):
+        # Add hook information to help
+        context.result.commands_info["hooks_available"] = True
+        context.result.commands_info["hook_count"] = 15  # Total number of hooks
+
+
+def health_before_hook(context: HookContext) -> None:
+    """Before hook for health command."""
+    logger.info(f"🏥 Health before hook: {context.command_name}")
+    
+    # Add health check metadata
+    context.metadata["health_check_start"] = datetime.now().isoformat()
+
+
+def health_after_hook(context: HookContext) -> None:
+    """After hook for health command."""
+    logger.info(f"🏥 Health after hook: {context.command_name}")
+    
+    if context.result and hasattr(context.result, 'status'):
+        # Add hook health status
+        context.result.status["hooks_healthy"] = True
+        context.result.status["hook_count"] = 15
+
+
+def config_before_hook(context: HookContext) -> None:
+    """Before hook for config command."""
+    logger.info(f"⚙️ Config before hook: {context.command_name}")
+    
+    # Add config operation metadata
+    context.metadata["config_operation"] = context.params.get("operation", "unknown")
+    context.metadata["config_time"] = datetime.now().isoformat()
+
+
+def config_after_hook(context: HookContext) -> None:
+    """After hook for config command."""
+    logger.info(f"⚙️ Config after hook: {context.command_name}")
+    
+    if context.result and hasattr(context.result, 'config'):
+        # Add hook configuration
+        context.result.config["hooks_enabled"] = True
+        context.result.config["hook_system_version"] = "1.0.0"
+
+
+def load_before_hook(context: HookContext) -> None:
+    """Before hook for load command."""
+    logger.info(f"📦 Load before hook: {context.command_name}")
+    
+    # Add load metadata
+    context.metadata["load_source"] = context.params.get("source", "unknown")
+    context.metadata["load_time"] = datetime.now().isoformat()
+
+
+def load_after_hook(context: HookContext) -> None:
+    """After hook for load command."""
+    logger.info(f"📦 Load after hook: {context.command_name}")
+    
+    if context.result and hasattr(context.result, 'loaded_commands'):
+        # Add hook information to loaded commands
+        context.result.loaded_commands["_hooks_loaded"] = True
+
+
+def unload_before_hook(context: HookContext) -> None:
+    """Before hook for unload command."""
+    logger.info(f"🗑️ Unload before hook: {context.command_name}")
+    
+    # Add unload metadata
+    context.metadata["unload_command"] = context.params.get("command_name", "unknown")
+    context.metadata["unload_time"] = datetime.now().isoformat()
+
+
+def unload_after_hook(context: HookContext) -> None:
+    """After hook for unload command."""
+    logger.info(f"🗑️ Unload after hook: {context.command_name}")
+    
+    if context.result and hasattr(context.result, 'unloaded_commands'):
+        # Add hook information to unloaded commands
+        context.result.unloaded_commands["_hooks_cleaned"] = True
+
+
+def reload_before_hook(context: HookContext) -> None:
+    """Before hook for reload command."""
+    logger.info(f"🔄 Reload before hook: {context.command_name}")
+    
+    # Add reload metadata
+    context.metadata["reload_components"] = context.params.get("components", [])
+    context.metadata["reload_time"] = datetime.now().isoformat()
+
+
+def reload_after_hook(context: HookContext) -> None:
+    """After hook for reload command."""
+    logger.info(f"🔄 Reload after hook: {context.command_name}")
+    
+    if context.result and hasattr(context.result, 'reloaded_components'):
+        # Add hook information to reloaded components
+        context.result.reloaded_components["_hooks_reloaded"] = True
+
+
+def plugins_before_hook(context: HookContext) -> None:
+    """Before hook for plugins command."""
+    logger.info(f"🔌 Plugins before hook: {context.command_name}")
+    
+    # Add plugins metadata
+    context.metadata["plugins_check_time"] = datetime.now().isoformat()
+
+
+def plugins_after_hook(context: HookContext) -> None:
+    """After hook for plugins command."""
+    logger.info(f"🔌 Plugins after hook: {context.command_name}")
+    
+    if context.result and hasattr(context.result, 'plugins'):
+        # Add hook information to plugins
+        context.result.plugins["_hooks_plugin"] = {
+            "name": "Advanced Hooks System",
+            "version": "1.0.0",
+            "enabled": True
+        }
+
+
+def settings_before_hook(context: HookContext) -> None:
+    """Before hook for settings command."""
+    logger.info(f"🔧 Settings before hook: {context.command_name}")
+    
+    # Add settings metadata
+    context.metadata["settings_operation"] = context.params.get("operation", "unknown")
+    context.metadata["settings_time"] = datetime.now().isoformat()
+
+
+def settings_after_hook(context: HookContext) -> None:
+    """After hook for settings command."""
+    logger.info(f"🔧 Settings after hook: {context.command_name}")
+    
+    if context.result and hasattr(context.result, 'settings'):
+        # Add hook settings
+        context.result.settings["hooks"] = {
+            "enabled": True,
+            "before_hooks": 15,
+            "after_hooks": 15,
+            "global_hooks": 3
+        }
+
+
+# ============================================================================
+# CUSTOM COMMAND HOOKS
+# ============================================================================
+
+def manual_echo_before_hook(context: HookContext) -> None:
+    """Before hook for manual echo command."""
+    logger.info(f"📝 Manual echo before hook: {context.command_name}")
+    
+    # Add manual registration flag
+    if context.params and "message" in context.params:
+        context.params["_manually_registered"] = True
+        context.params["_hook_processed"] = True
+
+
+def manual_echo_after_hook(context: HookContext) -> None:
+    """After hook for manual echo command."""
+    logger.info(f"📝 Manual echo after hook: {context.command_name}")
+    
+    if context.result and hasattr(context.result, 'message'):
+        context.result.message = f"[MANUAL] {context.result.message}"
+
+
+def auto_echo_before_hook(context: HookContext) -> None:
+    """Before hook for auto echo command."""
+    logger.info(f"🤖 Auto echo before hook: {context.command_name}")
+    
+    # Add auto registration flag
+    if context.params and "message" in context.params:
+        context.params["_auto_registered"] = True
+        context.params["_hook_processed"] = True
+
+
+def auto_echo_after_hook(context: HookContext) -> None:
+    """After hook for auto echo command."""
+    logger.info(f"🤖 Auto echo after hook: {context.command_name}")
+    
+    if context.result and hasattr(context.result, 'message'):
+        context.result.message = f"[AUTO] {context.result.message}"
+
+
+def auto_info_before_hook(context: HookContext) -> None:
+    """Before hook for auto info command."""
+    logger.info(f"🤖 Auto info before hook: {context.command_name}")
+    
+    # Add auto registration flag
+    if context.params and "topic" in context.params:
+        context.params["_auto_registered"] = True
+        context.params["_hook_processed"] = True
+
+
+def auto_info_after_hook(context: HookContext) -> None:
+    """After hook for auto info command."""
+    logger.info(f"🤖 Auto info after hook: {context.command_name}")
     
-    logger.info("✅ Advanced hooks registered successfully") 
+    if context.result and hasattr(context.result, 'info'):
+        context.result.info["_auto_generated"] = True
+        context.result.info["_hook_enhanced"] = True 

mcp_proxy_adapter/examples/custom_commands/auto_commands/test_command.py

@@ -0,0 +1,105 @@
+"""
+Test command for demonstrating dynamic command loading.
+
+This command is designed to be dynamically loaded and unloaded
+to test the command discovery mechanism.
+"""
+
+from typing import Optional, Dict, Any
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import SuccessResult
+
+
+class TestCommandResult(SuccessResult):
+    """Result class for test command."""
+    
+    def __init__(self, message: str, test_data: Dict[str, Any]):
+        """
+        Initialize test command result.
+        
+        Args:
+            message: Response message
+            test_data: Additional test data
+        """
+        super().__init__()
+        self.message = message
+        self.test_data = test_data
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert result to dictionary."""
+        return {
+            "message": self.message,
+            "test_data": self.test_data,
+            "command_type": "test_command",
+            "dynamically_loaded": True
+        }
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get result schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string"},
+                "test_data": {"type": "object"},
+                "command_type": {"type": "string"},
+                "dynamically_loaded": {"type": "boolean"}
+            }
+        }
+
+
+class TestCommand(Command):
+    """
+    Test command for dynamic loading demonstration.
+    
+    This command can be used to test the dynamic command discovery
+    and loading mechanism.
+    """
+    
+    name = "test"
+    result_class = TestCommandResult
+    
+    def __init__(self):
+        """Initialize test command."""
+        super().__init__()
+    
+    async def execute(self, message: Optional[str] = None, **kwargs) -> TestCommandResult:
+        """
+        Execute test command.
+        
+        Args:
+            message: Optional test message
+            **kwargs: Additional parameters
+            
+        Returns:
+            TestCommandResult with test data
+        """
+        test_message = message or "Test command executed successfully!"
+        
+        test_data = {
+            "timestamp": self._get_timestamp(),
+            "command_name": "test_command",
+            "parameters": kwargs,
+            "status": "success"
+        }
+        
+        return TestCommandResult(test_message, test_data)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get command schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "description": "Test message to display",
+                    "default": "Test command executed successfully!"
+                }
+            }
+        }
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp."""
+        from datetime import datetime
+        return datetime.now().isoformat() 

mcp_proxy_adapter/examples/custom_commands/catalog/commands/test_command.py

@@ -0,0 +1,129 @@
+"""
+Test command for loadable commands testing.
+
+This command demonstrates the loadable commands functionality.
+"""
+
+from typing import Any, Dict
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import SuccessResult
+
+
+class TestCommandResult:
+    """
+    Result of test command execution.
+    """
+    
+    def __init__(self, message: str, test_data: Dict[str, Any]):
+        """
+        Initialize test command result.
+        
+        Args:
+            message: Result message
+            test_data: Test data
+        """
+        self.message = message
+        self.test_data = test_data
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dictionary representation of the result.
+        """
+        return {
+            "success": True,
+            "message": self.message,
+            "test_data": self.test_data
+        }
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for the result.
+        
+        Returns:
+            JSON schema dictionary.
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "success": {
+                    "type": "boolean",
+                    "description": "Whether command was successful"
+                },
+                "message": {
+                    "type": "string",
+                    "description": "Result message"
+                },
+                "test_data": {
+                    "type": "object",
+                    "description": "Test data"
+                }
+            },
+            "required": ["success", "message", "test_data"]
+        }
+
+
+class TestCommand(Command):
+    """
+    Test command for loadable commands testing.
+    """
+    
+    name = "test"
+    result_class = TestCommandResult
+    
+    async def execute(self, **kwargs) -> TestCommandResult:
+        """
+        Execute test command.
+        
+        Args:
+            **kwargs: Command parameters
+            
+        Returns:
+            TestCommandResult with test information
+        """
+        # Get parameters
+        test_param = kwargs.get("test_param", "default_value")
+        echo_text = kwargs.get("echo_text", "Hello from loadable command!")
+        
+        # Create test data
+        test_data = {
+            "command_type": "loadable",
+            "test_param": test_param,
+            "echo_text": echo_text,
+            "timestamp": "2025-08-12T09:45:00Z",
+            "status": "working"
+        }
+        
+        return TestCommandResult(
+            message=f"Test command executed successfully with param: {test_param}",
+            test_data=test_data
+        )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            JSON schema dictionary.
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "test_param": {
+                    "type": "string",
+                    "description": "Test parameter",
+                    "default": "default_value"
+                },
+                "echo_text": {
+                    "type": "string",
+                    "description": "Text to echo",
+                    "default": "Hello from loadable command!"
+                }
+            },
+            "additionalProperties": False
+        }