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

mcp_proxy_adapter/examples/custom_commands/get_openapi.py

@@ -0,0 +1,103 @@
+#!/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/loadable_commands/test_ignored.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
+        } 

mcp_proxy_adapter/examples/custom_commands/proxy_connection_manager.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+"""
+Proxy Connection Manager
+
+Manages connection to the proxy server with regular health checks
+and automatic re-registration when needed.
+"""
+
+import asyncio
+import time
+import logging
+from typing import Optional, Dict, Any
+from datetime import datetime, timedelta
+
+from mcp_proxy_adapter.core.proxy_registration import register_with_proxy, unregister_from_proxy
+from mcp_proxy_adapter.config import config
+from mcp_proxy_adapter.core.logging import get_logger
+
+
+class ProxyConnectionManager:
+    """
+    Manages connection to proxy server with health monitoring and auto-reconnection.
+    """
+    
+    def __init__(self, check_interval: int = 30, max_retries: int = 3):
+        """
+        Initialize proxy connection manager.
+        
+        Args:
+            check_interval: Interval between health checks in seconds
+            max_retries: Maximum number of retry attempts
+        """
+        self.logger = get_logger("proxy_connection_manager")
+        self.check_interval = check_interval
+        self.max_retries = max_retries
+        self.is_running = False
+        self.last_registration = None
+        self.registration_count = 0
+        self.failed_attempts = 0
+        self.server_url = None
+        self.server_id = None
+        
+        # Get configuration
+        proxy_config = config.get("proxy_registration", {})
+        self.proxy_url = proxy_config.get("proxy_url", "http://localhost:3004")
+        self.server_id = proxy_config.get("server_id", "mcp_proxy_adapter_custom")
+        
+        # Get server configuration
+        server_config = config.get("server", {})
+        server_host = server_config.get("host", "0.0.0.0")
+        server_port = server_config.get("port", 8000)
+        
+        # Use localhost for external access if host is 0.0.0.0
+        if server_host == "0.0.0.0":
+            server_host = "localhost"
+        
+        self.server_url = f"http://{server_host}:{server_port}"
+        
+        self.logger.info(f"Proxy Connection Manager initialized:")
+        self.logger.info(f"  • Server URL: {self.server_url}")
+        self.logger.info(f"  • Proxy URL: {self.proxy_url}")
+        self.logger.info(f"  • Server ID: {self.server_id}")
+        self.logger.info(f"  • Check interval: {check_interval}s")
+        self.logger.info(f"  • Max retries: {max_retries}")
+    
+    async def start(self) -> None:
+        """
+        Start the proxy connection manager.
+        """
+        if self.is_running:
+            self.logger.warning("Proxy Connection Manager is already running")
+            return
+        
+        self.is_running = True
+        self.logger.info("🚀 Starting Proxy Connection Manager")
+        
+        # Initial registration
+        await self.register_with_proxy()
+        
+        # Start monitoring loop
+        asyncio.create_task(self._monitoring_loop())
+    
+    async def stop(self) -> None:
+        """
+        Stop the proxy connection manager.
+        """
+        if not self.is_running:
+            return
+        
+        self.is_running = False
+        self.logger.info("🛑 Stopping Proxy Connection Manager")
+        
+        # Unregister from proxy
+        await self.unregister_from_proxy()
+    
+    async def register_with_proxy(self) -> bool:
+        """
+        Register server with proxy.
+        
+        Returns:
+            True if registration was successful, False otherwise
+        """
+        try:
+            self.logger.info(f"📡 Attempting to register server with proxy at {self.proxy_url}")
+            
+            success = await register_with_proxy(self.server_url)
+            
+            if success:
+                self.last_registration = datetime.now()
+                self.registration_count += 1
+                self.failed_attempts = 0
+                self.logger.info(f"✅ Successfully registered with proxy (attempt #{self.registration_count})")
+                return True
+            else:
+                self.failed_attempts += 1
+                self.logger.warning(f"⚠️ Failed to register with proxy (attempt #{self.failed_attempts})")
+                return False
+                
+        except Exception as e:
+            self.failed_attempts += 1
+            self.logger.error(f"❌ Error registering with proxy: {e}")
+            return False
+    
+    async def unregister_from_proxy(self) -> bool:
+        """
+        Unregister server from proxy.
+        
+        Returns:
+            True if unregistration was successful, False otherwise
+        """
+        try:
+            self.logger.info("📡 Unregistering from proxy")
+            
+            success = await unregister_from_proxy()
+            
+            if success:
+                self.logger.info("✅ Successfully unregistered from proxy")
+            else:
+                self.logger.warning("⚠️ Failed to unregister from proxy")
+            
+            return success
+            
+        except Exception as e:
+            self.logger.error(f"❌ Error unregistering from proxy: {e}")
+            return False
+    
+    async def check_proxy_health(self) -> bool:
+        """
+        Check if proxy is accessible and server is registered.
+        
+        Returns:
+            True if proxy is healthy, False otherwise
+        """
+        try:
+            import httpx
+            
+            # Check if proxy is accessible
+            async with httpx.AsyncClient(timeout=5.0) as client:
+                response = await client.get(f"{self.proxy_url}/health")
+                
+                if response.status_code == 200:
+                    self.logger.debug("✅ Proxy health check passed")
+                    return True
+                else:
+                    self.logger.warning(f"⚠️ Proxy health check failed: {response.status_code}")
+                    return False
+                    
+        except Exception as e:
+            self.logger.warning(f"⚠️ Proxy health check error: {e}")
+            return False
+    
+    async def _monitoring_loop(self) -> None:
+        """
+        Main monitoring loop that checks proxy health and re-registers if needed.
+        """
+        self.logger.info("🔄 Starting proxy monitoring loop")
+        
+        while self.is_running:
+            try:
+                # Check if we need to re-register
+                should_reregister = False
+                
+                # Check if last registration was too long ago (more than 5 minutes)
+                if self.last_registration:
+                    time_since_registration = datetime.now() - self.last_registration
+                    if time_since_registration > timedelta(minutes=5):
+                        self.logger.info("⏰ Last registration was more than 5 minutes ago, re-registering")
+                        should_reregister = True
+                
+                # Check proxy health
+                proxy_healthy = await self.check_proxy_health()
+                
+                if not proxy_healthy:
+                    self.logger.warning("⚠️ Proxy health check failed, attempting re-registration")
+                    should_reregister = True
+                
+                # Re-register if needed
+                if should_reregister:
+                    if self.failed_attempts >= self.max_retries:
+                        self.logger.error(f"❌ Max retries ({self.max_retries}) reached, stopping re-registration attempts")
+                        break
+                    
+                    await self.register_with_proxy()
+                
+                # Log status
+                if self.last_registration:
+                    time_since = datetime.now() - self.last_registration
+                    self.logger.info(f"📊 Status: Registered {time_since.total_seconds():.0f}s ago, "
+                                   f"attempts: {self.registration_count}, "
+                                   f"failed: {self.failed_attempts}")
+                
+                # Wait for next check
+                await asyncio.sleep(self.check_interval)
+                
+            except asyncio.CancelledError:
+                self.logger.info("🛑 Monitoring loop cancelled")
+                break
+            except Exception as e:
+                self.logger.error(f"❌ Error in monitoring loop: {e}")
+                await asyncio.sleep(self.check_interval)
+        
+        self.logger.info("🔄 Proxy monitoring loop stopped")
+    
+    def get_status(self) -> Dict[str, Any]:
+        """
+        Get current status of the connection manager.
+        
+        Returns:
+            Dictionary with status information
+        """
+        status = {
+            "is_running": self.is_running,
+            "server_url": self.server_url,
+            "proxy_url": self.proxy_url,
+            "server_id": self.server_id,
+            "registration_count": self.registration_count,
+            "failed_attempts": self.failed_attempts,
+            "check_interval": self.check_interval,
+            "max_retries": self.max_retries
+        }
+        
+        if self.last_registration:
+            time_since = datetime.now() - self.last_registration
+            status["last_registration"] = self.last_registration.isoformat()
+            status["time_since_registration"] = time_since.total_seconds()
+        else:
+            status["last_registration"] = None
+            status["time_since_registration"] = None
+        
+        return status
+
+
+# Global instance
+proxy_manager = ProxyConnectionManager()
+
+
+async def start_proxy_manager() -> None:
+    """
+    Start the global proxy connection manager.
+    """
+    await proxy_manager.start()
+
+
+async def stop_proxy_manager() -> None:
+    """
+    Stop the global proxy connection manager.
+    """
+    await proxy_manager.stop()
+
+
+def get_proxy_manager_status() -> Dict[str, Any]:
+    """
+    Get status of the global proxy connection manager.
+    
+    Returns:
+        Dictionary with status information
+    """
+    return proxy_manager.get_status()