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

mcp_proxy_adapter/commands/unload_command.py

@@ -0,0 +1,158 @@
+"""
+Module with unload command implementation.
+"""
+
+from typing import Dict, Any, Optional, List
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult
+from mcp_proxy_adapter.commands.command_registry import registry
+
+
+class UnloadResult(SuccessResult):
+    """
+    Result of the unload command execution.
+    """
+    
+    def __init__(self, success: bool, command_name: str, message: str, error: Optional[str] = None):
+        """
+        Initialize unload command result.
+        
+        Args:
+            success: Whether unloading was successful
+            command_name: Name of the command that was unloaded
+            message: Result message
+            error: Error message if unloading failed
+        """
+        data = {
+            "success": success,
+            "command_name": command_name
+        }
+        if error:
+            data["error"] = error
+            
+        super().__init__(data=data, message=message)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result validation.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "data": {
+                    "type": "object",
+                    "properties": {
+                        "success": {"type": "boolean"},
+                        "command_name": {"type": "string"},
+                        "error": {"type": "string"}
+                    },
+                    "required": ["success", "command_name"]
+                }
+            },
+            "required": ["data"]
+        }
+
+
+class UnloadCommand(Command):
+    """
+    Command that unloads loaded commands from registry.
+    
+    This command allows removal of dynamically loaded commands from the command registry.
+    Only commands that were loaded via the 'load' command or from the commands directory
+    can be unloaded. Built-in commands and custom commands registered with higher priority
+    cannot be unloaded using this command.
+    
+    When a command is unloaded:
+    - The command class is removed from the loaded commands registry
+    - Any command instances are also removed
+    - The command becomes unavailable for execution
+    - Built-in and custom commands with the same name remain unaffected
+    
+    This is useful for:
+    - Removing outdated or problematic commands
+    - Managing memory usage by unloading unused commands
+    - Testing different versions of commands
+    - Cleaning up temporary commands loaded for testing
+    
+    Note: Unloading a command does not affect other commands and does not require
+    a system restart. The command can be reloaded later if needed.
+    """
+    
+    name = "unload"
+    result_class = UnloadResult
+    
+    async def execute(self, command_name: str, **kwargs) -> UnloadResult:
+        """
+        Execute unload command.
+        
+        Args:
+            command_name: Name of the command to unload
+            **kwargs: Additional parameters
+            
+        Returns:
+            UnloadResult: Unload command result
+        """
+        # Unload command from registry
+        result = registry.unload_command(command_name)
+        
+        return UnloadResult(
+            success=result.get("success", False),
+            command_name=result.get("command_name", command_name),
+            message=result.get("message", "Unknown result"),
+            error=result.get("error")
+        )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "command_name": {
+                    "type": "string",
+                    "description": "Name of the command to unload (must be a loaded command)"
+                }
+            },
+            "required": ["command_name"]
+        }
+    
+    @classmethod
+    def _generate_examples(cls, params: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Generate custom examples for unload command.
+        
+        Args:
+            params: Information about command parameters
+            
+        Returns:
+            List of examples
+        """
+        examples = [
+            {
+                "command": cls.name,
+                "params": {"command_name": "test_command"},
+                "description": "Unload a previously loaded test command"
+            },
+            {
+                "command": cls.name,
+                "params": {"command_name": "remote_command"},
+                "description": "Unload a command that was loaded from URL"
+            },
+            {
+                "command": cls.name,
+                "params": {"command_name": "custom_command"},
+                "description": "Unload a custom command loaded from local file"
+            }
+        ]
+        
+        return examples 

mcp_proxy_adapter/config.py

@@ -1,5 +1,8 @@
 """
 Module for microservice configuration management.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
 """
 
 import json
@@ -53,8 +56,162 @@ class Config:
             },
             "commands": {
                 "auto_discovery": True,
-                "discovery_path": "mcp_proxy_adapter.commands",  # Path to package with commands (e.g., "myproject.commands")
-                "custom_commands_path": None
+                "commands_directory": "./commands",  # Path to directory with command files
+                "catalog_directory": "./catalog",  # Path to command catalog directory
+                "plugin_servers": [],  # List of plugin server URLs
+                "auto_install_dependencies": True  # Automatically install plugin dependencies
+            },
+            "ssl": {
+                "enabled": False,
+                "mode": "https_only",
+                "cert_file": None,
+                "key_file": None,
+                "ca_cert": None,
+                "verify_client": False,
+                "client_cert_required": False,
+                "cipher_suites": ["TLS_AES_256_GCM_SHA384", "TLS_CHACHA20_POLY1305_SHA256"],
+                "min_tls_version": "TLSv1.2",
+                "max_tls_version": "1.3",
+                "token_auth": {
+                    "enabled": False,
+                    "header_name": "Authorization",
+                    "token_prefix": "Bearer",
+                    "tokens_file": "tokens.json",
+                    "token_expiry": 3600,
+                    "jwt_secret": "",
+                    "jwt_algorithm": "HS256"
+                }
+            },
+            "roles": {
+                "enabled": False,
+                "config_file": None,
+                "default_policy": {
+                    "deny_by_default": False,
+                    "require_role_match": False,
+                    "case_sensitive": False,
+                    "allow_wildcard": False
+                },
+                "auto_load": False,
+                "validation_enabled": False
+            },
+            "transport": {
+                "type": "http",
+                "port": None,
+                "ssl": {
+                    "enabled": False,
+                    "cert_file": None,
+                    "key_file": None,
+                    "ca_cert": None,
+                    "verify_client": False,
+                    "client_cert_required": False
+                }
+            },
+            "proxy_registration": {
+                "enabled": False,
+                "proxy_url": "http://localhost:3004",
+                "server_id": "mcp_proxy_adapter",
+                "server_name": "MCP Proxy Adapter",
+                "description": "JSON-RPC API for interacting with MCP Proxy",
+                "registration_timeout": 30,
+                "retry_attempts": 3,
+                "retry_delay": 5,
+                "auto_register_on_startup": True,
+                "auto_unregister_on_shutdown": True
+            },
+            "debug": {
+                "enabled": False,
+                "level": "WARNING"
+            },
+            "security": {
+                "framework": "mcp_security_framework",
+                "enabled": True,
+                "debug": False,
+                "environment": "dev",
+                "version": "1.0.0",
+                "auth": {
+                    "enabled": True,
+                    "methods": ["api_key"],
+                    "api_keys": {},
+                    "user_roles": {},
+                    "jwt_secret": "",
+                    "jwt_algorithm": "HS256",
+                    "jwt_expiry_hours": 24,
+                    "certificate_auth": False,
+                    "certificate_roles_oid": "1.3.6.1.4.1.99999.1.1",
+                    "certificate_permissions_oid": "1.3.6.1.4.1.99999.1.2",
+                    "basic_auth": False,
+                    "oauth2_config": None,
+                    "public_paths": ["/health", "/docs", "/openapi.json"],
+                    "security_headers": None
+                },
+                "ssl": {
+                    "enabled": False,
+                    "cert_file": None,
+                    "key_file": None,
+                    "ca_cert_file": None,
+                    "client_cert_file": None,
+                    "client_key_file": None,
+                    "verify_mode": "CERT_NONE",
+                    "min_tls_version": "TLSv1.2",
+                    "max_tls_version": None,
+                    "cipher_suite": None,
+                    "check_hostname": True,
+                    "check_expiry": True,
+                    "expiry_warning_days": 30
+                },
+                "certificates": {
+                    "enabled": False,
+                    "ca_cert_path": None,
+                    "ca_key_path": None,
+                    "cert_storage_path": "./certs",
+                    "key_storage_path": "./keys",
+                    "default_validity_days": 365,
+                    "key_size": 2048,
+                    "hash_algorithm": "sha256",
+                    "crl_enabled": False,
+                    "crl_path": None,
+                    "crl_validity_days": 30,
+                    "auto_renewal": False,
+                    "renewal_threshold_days": 30
+                },
+                "permissions": {
+                    "enabled": False,
+                    "roles_file": None,
+                    "default_role": "guest",
+                    "admin_role": "admin",
+                    "role_hierarchy": {},
+                    "permission_cache_enabled": False,
+                    "permission_cache_ttl": 300,
+                    "wildcard_permissions": False,
+                    "strict_mode": False,
+                    "roles": None
+                },
+                "rate_limit": {
+                    "enabled": True,
+                    "default_requests_per_minute": 60,
+                    "default_requests_per_hour": 1000,
+                    "burst_limit": 2,
+                    "window_size_seconds": 60,
+                    "storage_backend": "memory",
+                    "redis_config": None,
+                    "cleanup_interval": 300,
+                    "exempt_paths": ["/health", "/docs", "/openapi.json"],
+                    "exempt_roles": ["admin"]
+                },
+                "logging": {
+                    "enabled": True,
+                    "level": "INFO",
+                    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+                    "date_format": "%Y-%m-%d %H:%M:%S",
+                    "file_path": None,
+                    "max_file_size": 10,
+                    "backup_count": 5,
+                    "console_output": True,
+                    "json_format": False,
+                    "include_timestamp": True,
+                    "include_level": True,
+                    "include_module": True
+                }
             }
         }
         

mcp_proxy_adapter/core/app_factory.py

@@ -0,0 +1,326 @@
+"""
+Application Factory for MCP Proxy Adapter
+
+This module provides a factory function for creating and running MCP Proxy Adapter servers
+with proper configuration validation and initialization.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import logging
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.core.logging import setup_logging, get_logger
+from mcp_proxy_adapter.core.server_adapter import UnifiedServerRunner
+from mcp_proxy_adapter.config import config
+from mcp_proxy_adapter.commands.builtin_commands import register_builtin_commands
+
+logger = get_logger("app_factory")
+
+
+def create_and_run_server(
+    config_path: Optional[str] = None,
+    log_config_path: Optional[str] = None,
+    title: str = "MCP Proxy Adapter Server",
+    description: str = "Model Context Protocol Proxy Adapter with Security Framework",
+    version: str = "1.0.0",
+    host: str = "0.0.0.0",
+    log_level: str = "info",
+    engine: Optional[str] = None
+) -> None:
+    """
+    Create and run MCP Proxy Adapter server with proper validation.
+    
+    This factory function validates all configuration files, sets up logging,
+    initializes the application, and starts the server with optimal settings.
+    
+    Args:
+        config_path: Path to configuration file (JSON)
+        log_config_path: Path to logging configuration file (optional)
+        title: Application title for OpenAPI schema
+        description: Application description for OpenAPI schema
+        version: Application version
+        host: Server host address
+        port: Server port
+        log_level: Logging level
+        engine: Specific server engine to use (optional)
+        
+    Raises:
+        SystemExit: If configuration validation fails or server cannot start
+    """
+    print("🚀 MCP Proxy Adapter Server Factory")
+    print("=" * 60)
+    print(f"📋 Title: {title}")
+    print(f"📝 Description: {description}")
+    print(f"🔢 Version: {version}")
+    print(f"🌐 Host: {host}")
+    print(f"📊 Log Level: {log_level}")
+    print("=" * 60)
+    print()
+    
+    # 1. Validate and load configuration file
+    app_config = None
+    if config_path:
+        config_file = Path(config_path)
+        if not config_file.exists():
+            print(f"❌ Configuration file not found: {config_path}")
+            print("   Please provide a valid path to config.json")
+            sys.exit(1)
+        
+        try:
+            config.load_from_file(str(config_file))
+            app_config = config.get_all()
+            print(f"✅ Configuration loaded from: {config_path}")
+            
+            # Debug: Check what config.get_all() actually returns
+            print(f"🔍 Debug: config.get_all() keys: {list(app_config.keys())}")
+            if "security" in app_config:
+                security_ssl = app_config["security"].get("ssl", {})
+                print(f"🔍 Debug: config.get_all() security.ssl: {security_ssl}")
+            
+            # Debug: Check if root ssl section exists after loading
+            if "ssl" in app_config:
+                print(f"🔍 Debug: Root SSL section after loading: enabled={app_config['ssl'].get('enabled', False)}")
+                print(f"🔍 Debug: Root SSL section after loading: cert_file={app_config['ssl'].get('cert_file')}")
+                print(f"🔍 Debug: Root SSL section after loading: key_file={app_config['ssl'].get('key_file')}")
+            else:
+                print(f"🔍 Debug: No root SSL section after loading")
+            
+            # Debug: Check app_config immediately after get_all()
+            if app_config and "security" in app_config:
+                ssl_config = app_config["security"].get("ssl", {})
+                print(f"🔍 Debug: app_config after get_all(): SSL enabled={ssl_config.get('enabled', False)}")
+                print(f"🔍 Debug: app_config after get_all(): SSL cert_file={ssl_config.get('cert_file')}")
+                print(f"🔍 Debug: app_config after get_all(): SSL key_file={ssl_config.get('key_file')}")
+            
+            # Debug: Check SSL configuration after loading
+            if app_config and "security" in app_config:
+                ssl_config = app_config["security"].get("ssl", {})
+                print(f"🔍 Debug: SSL config after loading: enabled={ssl_config.get('enabled', False)}")
+                print(f"🔍 Debug: SSL config after loading: cert_file={ssl_config.get('cert_file')}")
+                print(f"🔍 Debug: SSL config after loading: key_file={ssl_config.get('key_file')}")
+                
+                # Debug: Check if SSL config is correct
+                if ssl_config.get('enabled', False):
+                    print(f"🔍 Debug: SSL config is enabled and correct")
+                else:
+                    print(f"🔍 Debug: SSL config is disabled or incorrect")
+                    # Try to get SSL config from root level
+                    root_ssl = app_config.get("ssl", {})
+                    print(f"🔍 Debug: Root SSL config: enabled={root_ssl.get('enabled', False)}")
+                    print(f"🔍 Debug: Root SSL config: cert_file={root_ssl.get('cert_file')}")
+                    print(f"🔍 Debug: Root SSL config: key_file={root_ssl.get('key_file')}")
+            
+            # Validate security framework configuration only if enabled
+            security_config = app_config.get("security", {})
+            if security_config.get("enabled", False):
+                framework = security_config.get("framework", "mcp_security_framework")
+                print(f"🔒 Security framework: {framework}")
+                
+                # Debug: Check SSL config before validation
+                ssl_config = security_config.get("ssl", {})
+                print(f"🔍 Debug: SSL config before validation: enabled={ssl_config.get('enabled', False)}")
+                
+                # Validate security configuration
+                from mcp_proxy_adapter.core.unified_config_adapter import UnifiedConfigAdapter
+                adapter = UnifiedConfigAdapter()
+                validation_result = adapter.validate_configuration(app_config)
+                
+                # Debug: Check SSL config after validation
+                ssl_config = app_config.get("security", {}).get("ssl", {})
+                print(f"🔍 Debug: SSL config after validation: enabled={ssl_config.get('enabled', False)}")
+                
+                if not validation_result.is_valid:
+                    print("❌ Security configuration validation failed:")
+                    for error in validation_result.errors:
+                        print(f"   - {error}")
+                    sys.exit(1)
+                
+                if validation_result.warnings:
+                    print("⚠️  Security configuration warnings:")
+                    for warning in validation_result.warnings:
+                        print(f"   - {warning}")
+                
+                print("✅ Security configuration validated successfully")
+            else:
+                print("🔓 Security framework disabled")
+                
+        except Exception as e:
+            print(f"❌ Failed to load configuration from {config_path}: {e}")
+            sys.exit(1)
+    else:
+        print("⚠️  No configuration file provided, using defaults")
+        app_config = config.get_all()
+    
+    # 2. Setup logging
+    try:
+        if log_config_path:
+            log_config_file = Path(log_config_path)
+            if not log_config_file.exists():
+                print(f"❌ Log configuration file not found: {log_config_path}")
+                sys.exit(1)
+            setup_logging(log_config_path=str(log_config_file))
+            print(f"✅ Logging configured from: {log_config_path}")
+        else:
+            setup_logging()
+            print("✅ Logging configured with defaults")
+    except Exception as e:
+        print(f"❌ Failed to setup logging: {e}")
+        sys.exit(1)
+    
+    # 3. Register built-in commands
+    try:
+        builtin_count = register_builtin_commands()
+        print(f"✅ Registered {builtin_count} built-in commands")
+    except Exception as e:
+        print(f"❌ Failed to register built-in commands: {e}")
+        sys.exit(1)
+    
+    # 4. Create FastAPI application with configuration
+    try:
+        # Debug: Check app_config before passing to create_app
+        if app_config and "security" in app_config:
+            ssl_config = app_config["security"].get("ssl", {})
+            print(f"🔍 Debug: app_config before create_app: SSL enabled={ssl_config.get('enabled', False)}")
+            print(f"🔍 Debug: app_config before create_app: SSL cert_file={ssl_config.get('cert_file')}")
+            print(f"🔍 Debug: app_config before create_app: SSL key_file={ssl_config.get('key_file')}")
+        
+        app = create_app(
+            title=title,
+            description=description,
+            version=version,
+            app_config=app_config,  # Pass configuration to create_app
+            config_path=config_path  # Pass config path to preserve SSL settings
+        )
+        print("✅ FastAPI application created successfully")
+    except Exception as e:
+        print(f"❌ Failed to create FastAPI application: {e}")
+        sys.exit(1)
+    
+    # 5. Create server configuration
+    # Get port from config if available, otherwise use default
+    server_port = app_config.get("server", {}).get("port", 8000) if app_config else 8000
+    print(f"🔌 Port: {server_port}")
+    
+    server_config = {
+        "host": host,
+        "port": server_port,
+        "log_level": log_level,
+        "reload": False
+    }
+    
+    # Add SSL configuration if present
+    print(f"🔍 Debug: app_config keys: {list(app_config.keys()) if app_config else 'None'}")
+    
+    # Check for SSL config in root section first (higher priority)
+    if app_config and "ssl" in app_config:
+        print(f"🔍 Debug: SSL config found in root: {app_config['ssl']}")
+        print(f"🔍 Debug: SSL enabled: {app_config['ssl'].get('enabled', False)}")
+        if app_config["ssl"].get("enabled", False):
+            ssl_config = app_config["ssl"]
+            # Add SSL config directly to server_config for Hypercorn
+            server_config["certfile"] = ssl_config.get("cert_file")
+            server_config["keyfile"] = ssl_config.get("key_file")
+            server_config["ca_certs"] = ssl_config.get("ca_cert_file")
+            server_config["verify_mode"] = ssl_config.get("verify_mode")
+            print(f"🔒 SSL enabled: {ssl_config.get('cert_file', 'N/A')}")
+            print(f"🔒 SSL enabled: cert={ssl_config.get('cert_file')}, key={ssl_config.get('key_file')}")
+            print(f"🔒 Server config SSL: certfile={server_config.get('certfile')}, keyfile={server_config.get('keyfile')}, ca_certs={server_config.get('ca_certs')}, verify_mode={server_config.get('verify_mode')}")
+    
+    # Check for SSL config in security section (fallback)
+    if app_config and "security" in app_config:
+        security_config = app_config["security"]
+        print(f"🔍 Debug: security_config keys: {list(security_config.keys())}")
+        if "ssl" in security_config:
+            print(f"🔍 Debug: SSL config found in security: {security_config['ssl']}")
+            print(f"🔍 Debug: SSL enabled: {security_config['ssl'].get('enabled', False)}")
+            if security_config["ssl"].get("enabled", False):
+                ssl_config = security_config["ssl"]
+                # Add SSL config directly to server_config for Hypercorn
+                server_config["certfile"] = ssl_config.get("cert_file")
+                server_config["keyfile"] = ssl_config.get("key_file")
+                server_config["ca_certs"] = ssl_config.get("ca_cert_file")
+                server_config["verify_mode"] = ssl_config.get("verify_mode")
+                print(f"🔒 SSL enabled: {ssl_config.get('cert_file', 'N/A')}")
+                print(f"🔒 SSL enabled: cert={ssl_config.get('cert_file')}, key={ssl_config.get('key_file')}")
+                print(f"🔒 Server config SSL: certfile={server_config.get('certfile')}, keyfile={server_config.get('keyfile')}, ca_certs={server_config.get('ca_certs')}, verify_mode={server_config.get('verify_mode')}")
+        print(f"🔍 Debug: SSL config found in root: {app_config['ssl']}")
+        print(f"🔍 Debug: SSL enabled: {app_config['ssl'].get('enabled', False)}")
+        if app_config["ssl"].get("enabled", False):
+            ssl_config = app_config["ssl"]
+            # Add SSL config directly to server_config for Hypercorn
+            server_config["certfile"] = ssl_config.get("cert_file")
+            server_config["keyfile"] = ssl_config.get("key_file")
+            server_config["ca_certs"] = ssl_config.get("ca_cert_file")
+            server_config["verify_mode"] = ssl_config.get("verify_mode")
+            print(f"🔒 SSL enabled: {ssl_config.get('cert_file', 'N/A')}")
+            print(f"🔒 SSL enabled: cert={ssl_config.get('cert_file')}, key={ssl_config.get('key_file')}")
+            print(f"🔒 Server config SSL: certfile={server_config.get('certfile')}, keyfile={server_config.get('keyfile')}, ca_certs={server_config.get('ca_certs')}, verify_mode={server_config.get('verify_mode')}")
+    
+    # 6. Start server
+    try:
+        print("🚀 Starting server...")
+        print("   Use Ctrl+C to stop the server")
+        print("=" * 60)
+        
+        server_runner = UnifiedServerRunner()
+        server_runner.run_server(app, server_config, "hypercorn")
+        
+    except KeyboardInterrupt:
+        print("\n🛑 Server stopped by user")
+    except Exception as e:
+        print(f"\n❌ Failed to start server: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+def validate_config_file(config_path: str) -> bool:
+    """
+    Validate configuration file exists and is readable.
+    
+    Args:
+        config_path: Path to configuration file
+        
+    Returns:
+        True if valid, False otherwise
+    """
+    try:
+        config_file = Path(config_path)
+        if not config_file.exists():
+            print(f"❌ Configuration file not found: {config_path}")
+            return False
+        
+        # Try to load configuration to validate JSON format
+        config.load_from_file(str(config_file))
+        return True
+        
+    except Exception as e:
+        print(f"❌ Configuration file validation failed: {e}")
+        return False
+
+
+def validate_log_config_file(log_config_path: str) -> bool:
+    """
+    Validate logging configuration file exists and is readable.
+    
+    Args:
+        log_config_path: Path to logging configuration file
+        
+    Returns:
+        True if valid, False otherwise
+    """
+    try:
+        log_config_file = Path(log_config_path)
+        if not log_config_file.exists():
+            print(f"❌ Log configuration file not found: {log_config_path}")
+            return False
+        return True
+        
+    except Exception as e:
+        print(f"❌ Log configuration file validation failed: {e}")
+        return False