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

mcp_proxy_adapter/examples/custom_commands/proxy_connection_manager.py

@@ -1,278 +0,0 @@
-#!/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()

mcp_proxy_adapter/examples/custom_commands/server.py

@@ -1,252 +0,0 @@
-"""
-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 mcp_proxy_adapter.core.ssl_utils import SSLUtils
-from mcp_proxy_adapter.core.transport_manager import transport_manager
-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
-from mcp_proxy_adapter.config import config
-from mcp_proxy_adapter.commands.hooks import register_custom_commands_hook
-
-
-async def initialize_commands():
-    """
-    Initialize commands using the unified system initialization logic.
-    This function is used both at startup and during reload.
-    
-    Returns:
-        Number of commands discovered.
-    """
-    # Use the unified reload method from registry
-    result = await registry.reload_system()
-    return result["total_commands"]
-
-
-def custom_commands_hook(registry):
-    """Hook function for registering custom commands."""
-    logger = get_logger("custom_commands")
-    logger.info("Registering custom commands via hook...")
-    
-    # Get custom commands configuration from custom settings
-    custom_commands_config = get_custom_setting_value("custom_commands", {})
-    
-    # Register echo command (only if not already registered)
-    if not registry.command_exists("echo"):
-        registry.register_custom(EchoCommand)
-        logger.info("Registered: echo command")
-    else:
-        logger.debug("Command 'echo' is already registered, skipping")
-    
-    # Register custom help command (will override built-in)
-    if custom_commands_config.get("help", {}).get("enabled", True):
-        registry.register_custom(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(CustomHealthCommand)
-        logger.info("Registered: custom health command")
-    
-    # Register advanced demonstration commands
-    if custom_commands_config.get("data_transform", {}).get("enabled", True):
-        registry.register_custom(DataTransformCommand)
-        logger.info("Registered: data_transform command")
-    
-    if custom_commands_config.get("intercept", {}).get("enabled", True):
-        registry.register_custom(InterceptCommand)
-        logger.info("Registered: intercept command")
-    
-    # Register manually registered commands
-    if custom_commands_config.get("manual_echo", {}).get("enabled", True):
-        registry.register_custom(ManualEchoCommand)
-        logger.info("Registered: manual_echo command")
-    
-    logger.info(f"Total custom commands registered: {len(registry.get_commands_by_type()['custom'])}")
-
-
-def setup_hooks():
-    """Setup hooks for command processing."""
-    logger = get_logger("custom_commands")
-    logger.info("Setting up hooks...")
-    
-    # Register custom commands hook
-    from mcp_proxy_adapter.commands.hooks import register_custom_commands_hook
-    register_custom_commands_hook(custom_commands_hook)
-    
-    logger.info("Registered: custom commands hook")
-
-
-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")
-        from mcp_proxy_adapter.config import config
-        config.load_config()
-    
-    # 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", {})
-    
-    # Load transport configuration
-    if not transport_manager.load_config(config.config_data):
-        logger.error("Failed to load transport configuration")
-        return
-    
-    # Validate transport configuration
-    if not transport_manager.validate_config():
-        logger.error("Transport configuration validation failed")
-        return
-    
-    # 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()
-    # Get transport info
-    transport_info = transport_manager.get_transport_info()
-    
-    print("⚙️  Configuration:")
-    print(f"   • Server: {server_settings['host']}:{transport_manager.get_port()}")
-    print(f"   • Transport: {transport_info['type']}")
-    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(f"   • SSL Enabled: {transport_info['ssl_enabled']}")
-    if transport_info['ssl_enabled']:
-        ssl_config = transport_info['ssl_config']
-        print(f"   • SSL Cert: {ssl_config.get('cert_file', 'Not specified')}")
-        print(f"   • Client Verification: {ssl_config.get('verify_client', False)}")
-    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("   • load - Built-in load command")
-    print("   • unload - Built-in unload command")
-    print("   • plugins - Built-in plugins command")
-    print("   • echo - Custom echo command")
-    print("   • data_transform - Data transformation command")
-    print("   • intercept - Command interception example")
-    print("   • manual_echo - Manually registered echo command")
-    print("   • test - Remote command (loaded from plugin server)")
-    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(f"Transport configuration: {transport_info}")
-    logger.info("This server demonstrates custom commands with hooks and remote plugin loading:")
-    logger.info("• Custom commands: echo, help, health, data_transform, intercept, manual_echo")
-    logger.info("• Built-in commands: config, reload, settings, load, unload, plugins")
-    logger.info("• Remote commands: test (loaded from plugin server)")
-    logger.info("With advanced hooks for data transformation and command interception")
-    
-    # Setup hooks for command processing
-    setup_hooks()
-    
-    # Initialize commands
-    import asyncio
-    asyncio.run(initialize_commands())
-    
-    # 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"
-    )
-    
-    # Get uvicorn configuration from transport manager
-    uvicorn_config = transport_manager.get_uvicorn_config()
-    uvicorn_config["host"] = server_settings['host']
-    uvicorn_config["log_level"] = server_settings['log_level'].lower()
-    
-    logger.info(f"Starting server with uvicorn config: {uvicorn_config}")
-    
-    # Run the server with configuration settings
-    uvicorn.run(
-        app,
-        **uvicorn_config
-    )
-
-
-if __name__ == "__main__":
-    main() 

mcp_proxy_adapter/examples/custom_commands/simple_openapi_server.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple server with fixed OpenAPI generator.
-"""
-
-import uvicorn
-import asyncio
-import sys
-import os
-from pathlib import Path
-
-# Add current directory to path for imports
-sys.path.insert(0, os.getcwd())
-
-from fastapi import FastAPI
-from mcp_proxy_adapter.custom_openapi import CustomOpenAPIGenerator
-from mcp_proxy_adapter.commands.command_registry import registry
-
-# Create FastAPI app
-app = FastAPI(
-    title="Extended MCP Proxy Server",
-    description="Advanced MCP Proxy Adapter server with custom commands and hooks",
-    version="2.1.0"
-)
-
-async def generate_openapi_schema():
-    """Generate OpenAPI schema with custom commands."""
-    # Initialize commands
-    await registry.reload_system()
-    
-    # Load custom commands
-    custom_commands = [
-        "echo_command",
-        "custom_help_command", 
-        "custom_health_command",
-        "manual_echo_command"
-    ]
-    
-    for cmd_name in custom_commands:
-        try:
-            module = __import__(cmd_name)
-            if hasattr(module, 'EchoCommand'):
-                registry.register_custom(module.EchoCommand())
-            elif hasattr(module, 'CustomHelpCommand'):
-                registry.register_custom(module.CustomHelpCommand())
-            elif hasattr(module, 'CustomHealthCommand'):
-                registry.register_custom(module.CustomHealthCommand())
-            elif hasattr(module, 'ManualEchoCommand'):
-                registry.register_custom(module.ManualEchoCommand())
-        except Exception as e:
-            print(f"Warning: Failed to load {cmd_name}: {e}")
-    
-    # Generate schema
-    generator = CustomOpenAPIGenerator()
-    return generator.generate(
-        title="Extended MCP Proxy Server",
-        description="Advanced MCP Proxy Adapter server with custom commands and hooks",
-        version="2.1.0"
-    )
-
-# Set custom OpenAPI generator
-@app.on_event("startup")
-async def startup_event():
-    """Initialize OpenAPI schema on startup."""
-    app.openapi_schema = await generate_openapi_schema()
-
-@app.get("/openapi.json")
-async def get_openapi_schema():
-    """Returns OpenAPI schema."""
-    if not hasattr(app, 'openapi_schema'):
-        app.openapi_schema = await generate_openapi_schema()
-    return app.openapi_schema
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)