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

mcp_proxy_adapter/examples/custom_commands/get_openapi.py

@@ -1,103 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script to get OpenAPI schema directly from the code.
-"""
-
-import json
-import asyncio
-import sys
-import os
-from pathlib import Path
-
-# Add current directory to path for imports
-sys.path.insert(0, os.getcwd())
-
-from mcp_proxy_adapter.custom_openapi import CustomOpenAPIGenerator
-from mcp_proxy_adapter.commands.command_registry import registry
-
-async def main():
-    """Generate and save OpenAPI schema."""
-    try:
-        # Initialize commands first
-        print("🔄 Initializing commands...")
-        result = await registry.reload_system()
-        print(f"✅ Commands initialized: {result}")
-        
-        # Load custom commands manually
-        print("🔄 Loading custom commands...")
-        custom_commands = [
-            "echo_command",
-            "custom_help_command", 
-            "custom_health_command",
-            "manual_echo_command"
-        ]
-        
-        for cmd_name in custom_commands:
-            try:
-                # Import the command module
-                module = __import__(cmd_name)
-                print(f"✅ Loaded custom command: {cmd_name}")
-                
-                # Try to register the command if it has a command class
-                if hasattr(module, 'EchoCommand'):
-                    registry.register_custom(module.EchoCommand())
-                    print(f"✅ Registered EchoCommand")
-                elif hasattr(module, 'CustomHelpCommand'):
-                    registry.register_custom(module.CustomHelpCommand())
-                    print(f"✅ Registered CustomHelpCommand")
-                elif hasattr(module, 'CustomHealthCommand'):
-                    registry.register_custom(module.CustomHealthCommand())
-                    print(f"✅ Registered CustomHealthCommand")
-                elif hasattr(module, 'ManualEchoCommand'):
-                    registry.register_custom(module.ManualEchoCommand())
-                    print(f"✅ Registered ManualEchoCommand")
-                    
-            except Exception as e:
-                print(f"⚠️ Failed to load {cmd_name}: {e}")
-        
-        # Get commands after registration
-        print("📋 Getting commands after registration...")
-        commands = registry.get_all_commands()
-        print(f"   Total commands: {len(commands)}")
-        print(f"   Command names: {list(commands.keys())}")
-        
-        # Create generator
-        generator = CustomOpenAPIGenerator()
-        
-        # Generate schema
-        schema = generator.generate(
-            title="Extended MCP Proxy Server",
-            description="Advanced MCP Proxy Adapter server with custom commands and hooks",
-            version="2.1.0"
-        )
-        
-        # Save to file
-        with open("generated_openapi.json", "w", encoding="utf-8") as f:
-            json.dump(schema, f, indent=2, ensure_ascii=False)
-        
-        print("✅ OpenAPI schema generated successfully!")
-        print(f"📄 Saved to: generated_openapi.json")
-        print(f"📊 Schema size: {len(json.dumps(schema))} characters")
-        
-        # Show basic info
-        print(f"\n📋 Schema info:")
-        print(f"   Title: {schema['info']['title']}")
-        print(f"   Version: {schema['info']['version']}")
-        
-        # Get commands info
-        commands = registry.get_all_commands()
-        print(f"   Commands: {len(commands)}")
-        print(f"   Command names: {list(commands.keys())}")
-        
-        # Check CommandRequest enum
-        command_enum = schema['components']['schemas'].get('CommandRequest', {}).get('properties', {}).get('command', {}).get('enum', [])
-        print(f"   Commands in schema: {len(command_enum)}")
-        print(f"   Schema commands: {command_enum}")
-        
-    except Exception as e:
-        print(f"❌ Error generating schema: {e}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    asyncio.run(main()) 

mcp_proxy_adapter/examples/custom_commands/hooks.py

@@ -1,230 +0,0 @@
-"""
-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

@@ -1,123 +0,0 @@
-"""
-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/loadable_commands/test_ignored.py

@@ -1,129 +0,0 @@
-"""
-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
-        } 

mcp_proxy_adapter/examples/custom_commands/manual_echo_command.py

@@ -1,103 +0,0 @@
-"""
-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!"
-                }
-            }
-        }