mcp-proxy-adapter 2.0.1__py3-none-any.whl → 6.9.50__py3-none-any.whl

mcp_proxy_adapter/examples/config_builder.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""
+Simple Configuration Generator for MCP Proxy Adapter
+Generates a complete configuration with HTTP protocol and all restrictions disabled.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+import uuid
+import argparse
+from pathlib import Path
+from typing import Dict, Any
+
+
+def generate_complete_config(host: str = "0.0.0.0", port: int = 8000) -> Dict[str, Any]:
+    """
+    Generate a complete configuration with all required sections.
+    HTTP protocol with all security features disabled.
+    
+    Args:
+        host: Server host
+        port: Server port
+        
+    Returns:
+        Complete configuration dictionary
+    """
+    return {
+        "uuid": str(uuid.uuid4()),  # This generates valid UUID4
+        "server": {
+            "host": host,
+            "port": port,
+            "protocol": "http",
+            "debug": False,
+            "log_level": "INFO"
+        },
+        "logging": {
+            "level": "INFO",
+            "file": None,
+            "log_dir": "./logs",
+            "log_file": "mcp_proxy_adapter.log",
+            "error_log_file": "mcp_proxy_adapter_error.log",
+            "access_log_file": "mcp_proxy_adapter_access.log",
+            "max_file_size": "10MB",
+            "backup_count": 5,
+            "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            "date_format": "%Y-%m-%d %H:%M:%S",
+            "console_output": True,
+            "file_output": True
+        },
+        "commands": {
+            "auto_discovery": True,
+            "commands_directory": "./commands",
+            "catalog_directory": "./catalog",
+            "plugin_servers": [],
+            "auto_install_dependencies": True,
+            "enabled_commands": ["health", "echo", "list", "help"],
+            "disabled_commands": [],
+            "custom_commands_path": "./commands"
+        },
+        "transport": {
+            "type": "http",
+            "port": None,
+            "verify_client": False,
+            "chk_hostname": False
+        },
+        "proxy_registration": {
+            "enabled": False,
+            "protocol": "mtls",
+            "proxy_url": "https://172.28.0.10:3004",
+            "server_id": "mcp_proxy_adapter",
+            "server_name": "MCP Proxy Adapter",
+            "description": "JSON-RPC API for interacting with MCP Proxy",
+            "version": "6.2.33",
+            "registration_timeout": 30,
+            "retry_attempts": 3,
+            "retry_delay": 5,
+            "auto_register_on_startup": True,
+            "auto_unregister_on_shutdown": True,
+            "verify_ssl": True,
+            "verify_hostname": False,
+            "heartbeat": {
+                "enabled": True,
+                "interval": 30,
+                "timeout": 10,
+                "retry_attempts": 3,
+                "retry_delay": 5,
+                "url": "/heartbeat"
+            }
+        },
+        "debug": {
+            "enabled": False,
+            "level": "WARNING"
+        },
+        "ssl": {
+            "enabled": False,
+            "cert_file": None,
+            "key_file": None,
+            "ca_cert": None
+        },
+        "security": {
+            "enabled": False,
+            "tokens": {},
+            "roles": {},
+            "roles_file": None
+        },
+        "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
+        }
+    }
+
+
+def save_config(config: Dict[str, Any], output_file: str) -> None:
+    """
+    Save configuration to file.
+    
+    Args:
+        config: Configuration dictionary
+        output_file: Output file path
+    """
+    output_path = Path(output_file)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+    
+    print(f"✅ Configuration saved to: {output_path}")
+
+
+def main():
+    """Main function to generate configuration."""
+    parser = argparse.ArgumentParser(
+        description="Generate complete MCP Proxy Adapter configuration",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python config_builder.py
+  python config_builder.py --host 127.0.0.1 --port 9000
+  python config_builder.py --output ./configs/my_config.json
+        """
+    )
+    
+    parser.add_argument(
+        "--host",
+        default="0.0.0.0",
+        help="Server host (default: 0.0.0.0)"
+    )
+    
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Server port (default: 8000)"
+    )
+    
+    parser.add_argument(
+        "--output",
+        default="config.json",
+        help="Output file path (default: config.json)"
+    )
+    
+    parser.add_argument(
+        "--validate",
+        action="store_true",
+        help="Validate generated configuration"
+    )
+    
+    args = parser.parse_args()
+    
+    print("🔧 Generating MCP Proxy Adapter configuration...")
+    print(f"   Host: {args.host}")
+    print(f"   Port: {args.port}")
+    print(f"   Protocol: HTTP")
+    print(f"   Security: Disabled")
+    print(f"   SSL: Disabled")
+    print(f"   Roles: Disabled")
+    print()
+    
+    # Generate configuration
+    config = generate_complete_config(args.host, args.port)
+    
+    # Save configuration
+    save_config(config, args.output)
+    
+    # Validate if requested
+    if args.validate:
+        print("\n🔍 Validating configuration...")
+        try:
+            from mcp_proxy_adapter.core.config_validator import ConfigValidator
+            
+            validator = ConfigValidator()
+            validator.config_data = config
+            results = validator.validate_config()
+            
+            if results:
+                print("⚠️  Validation issues found:")
+                for result in results:
+                    level_symbol = {
+                        "error": "❌",
+                        "warning": "⚠️",
+                        "info": "ℹ️"
+                    }[result.level]
+                    print(f"  {level_symbol} {result.message}")
+                    if result.suggestion:
+                        print(f"     Suggestion: {result.suggestion}")
+            else:
+                print("✅ Configuration validation passed!")
+                
+        except ImportError:
+            print("⚠️  Configuration validation not available")
+        except Exception as e:
+            print(f"❌ Validation error: {e}")
+    
+    print(f"\n📋 Configuration summary:")
+    print(f"   - Server: {config['server']['host']}:{config['server']['port']}")
+    print(f"   - Protocol: {config['server']['protocol']}")
+    print(f"   - Security: {'Enabled' if config['security']['enabled'] else 'Disabled'}")
+    print(f"   - SSL: {'Enabled' if config.get('ssl', {}).get('enabled', False) else 'Disabled'}")
+    print(f"   - Roles: {'Enabled' if config['roles']['enabled'] else 'Disabled'}")
+    print(f"   - Proxy Registration: {'Enabled' if config['proxy_registration']['enabled'] else 'Disabled'}")
+
+
+if __name__ == "__main__":
+    main()

mcp_proxy_adapter/examples/config_cli.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+"""
+CLI Utility for MCP Proxy Adapter Configuration Builder
+Command-line interface for creating configurations with various parameters.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from config_builder import ConfigBuilder, ConfigFactory, Protocol, AuthMethod
+
+
+def parse_protocol(protocol_str: str) -> Protocol:
+    """Parse protocol string to Protocol enum."""
+    protocol_map = {
+        "http": Protocol.HTTP,
+        "https": Protocol.HTTPS,
+        "mtls": Protocol.MTLS
+    }
+    if protocol_str.lower() not in protocol_map:
+        raise ValueError(f"Invalid protocol: {protocol_str}. Must be one of: {list(protocol_map.keys())}")
+    return protocol_map[protocol_str.lower()]
+
+
+def parse_auth_method(auth_str: str) -> AuthMethod:
+    """Parse authentication method string to AuthMethod enum."""
+    auth_map = {
+        "none": AuthMethod.NONE,
+        "token": AuthMethod.TOKEN,
+        "basic": AuthMethod.BASIC
+    }
+    if auth_str.lower() not in auth_map:
+        raise ValueError(f"Invalid auth method: {auth_str}. Must be one of: {list(auth_map.keys())}")
+    return auth_map[auth_str.lower()]
+
+
+def parse_api_keys(api_keys_str: str) -> Dict[str, str]:
+    """Parse API keys from string format 'key1:value1,key2:value2'."""
+    if not api_keys_str:
+        return {}
+    
+    api_keys = {}
+    for pair in api_keys_str.split(','):
+        if ':' not in pair:
+            raise ValueError(f"Invalid API key format: {pair}. Expected 'key:value'")
+        key, value = pair.split(':', 1)
+        api_keys[key.strip()] = value.strip()
+    
+    return api_keys
+
+
+def parse_roles(roles_str: str) -> Dict[str, List[str]]:
+    """Parse roles from string format 'role1:perm1,perm2;role2:perm3,perm4'."""
+    if not roles_str:
+        return {}
+    
+    roles = {}
+    for role_def in roles_str.split(';'):
+        if ':' not in role_def:
+            raise ValueError(f"Invalid role format: {role_def}. Expected 'role:perm1,perm2'")
+        role, perms = role_def.split(':', 1)
+        roles[role.strip()] = [perm.strip() for perm in perms.split(',')]
+    
+    return roles
+
+
+def create_custom_config(args) -> Dict[str, Any]:
+    """Create custom configuration based on command line arguments."""
+    builder = ConfigBuilder()
+    
+    # Set server configuration
+    builder.set_server(
+        host=args.host,
+        port=args.port,
+        debug=args.debug,
+        log_level=args.log_level
+    )
+    
+    # Set logging configuration
+    builder.set_logging(
+        log_dir=args.log_dir,
+        level=args.log_level,
+        console_output=not args.no_console,
+        file_output=not args.no_file_log
+    )
+    
+    # Set protocol
+    protocol = parse_protocol(args.protocol)
+    builder.set_protocol(
+        protocol,
+        cert_dir=args.cert_dir,
+        key_dir=args.key_dir
+    )
+    
+    # Set authentication
+    auth_method = parse_auth_method(args.auth)
+    api_keys = parse_api_keys(args.api_keys) if args.api_keys else None
+    roles = parse_roles(args.roles) if args.roles else None
+    
+    builder.set_auth(auth_method, api_keys=api_keys, roles=roles)
+    
+    # Set proxy registration
+    if args.proxy_url:
+        builder.set_proxy_registration(
+            enabled=True,
+            proxy_url=args.proxy_url,
+            server_id=args.server_id,
+            cert_dir=args.cert_dir
+        )
+    
+    # Set debug
+    if args.debug:
+        builder.set_debug(enabled=True, log_level=args.log_level)
+    
+    # Set commands
+    if args.enabled_commands or args.disabled_commands:
+        enabled = args.enabled_commands.split(',') if args.enabled_commands else None
+        disabled = args.disabled_commands.split(',') if args.disabled_commands else None
+        builder.set_commands(enabled_commands=enabled, disabled_commands=disabled)
+    
+    return builder.build()
+
+
+def create_preset_config(preset: str, **kwargs) -> Dict[str, Any]:
+    """Create preset configuration."""
+    preset_map = {
+        "http_simple": ConfigFactory.create_http_simple,
+        "http_token": ConfigFactory.create_http_token,
+        "https_simple": ConfigFactory.create_https_simple,
+        "https_token": ConfigFactory.create_https_token,
+        "mtls_simple": ConfigFactory.create_mtls_simple,
+        "mtls_with_roles": ConfigFactory.create_mtls_with_roles,
+        "mtls_with_proxy": ConfigFactory.create_mtls_with_proxy,
+        "full_featured": ConfigFactory.create_full_featured,
+    }
+    
+    if preset not in preset_map:
+        raise ValueError(f"Invalid preset: {preset}. Must be one of: {list(preset_map.keys())}")
+    
+    return preset_map[preset](**kwargs)
+
+
+def list_presets():
+    """List available presets."""
+    presets = [
+        ("http_simple", "Simple HTTP server without authentication"),
+        ("http_token", "HTTP server with token authentication"),
+        ("https_simple", "Simple HTTPS server without authentication"),
+        ("https_token", "HTTPS server with token authentication"),
+        ("mtls_simple", "Simple mTLS server without authentication"),
+        ("mtls_with_roles", "mTLS server with role-based access control"),
+        ("mtls_with_proxy", "mTLS server with proxy registration"),
+        ("full_featured", "Full-featured server with all options enabled"),
+    ]
+    
+    print("📋 Available Configuration Presets:")
+    print("=" * 50)
+    for preset, description in presets:
+        print(f"  {preset:<20} - {description}")
+
+
+def main():
+    """Main CLI function."""
+    parser = argparse.ArgumentParser(
+        description="MCP Proxy Adapter Configuration Builder CLI",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Create HTTP simple configuration
+  python config_cli.py --preset http_simple --output configs/http_simple.json
+  
+  # Create custom HTTPS configuration with token auth
+  python config_cli.py --protocol https --auth token --api-keys "admin:admin-key,user:user-key" --output configs/https_token.json
+  
+  # Create mTLS configuration with proxy registration
+  python config_cli.py --protocol mtls --proxy-url "https://proxy.example.com:8080" --server-id "my_server" --output configs/mtls_proxy.json
+  
+  # List all available presets
+  python config_cli.py --list-presets
+        """
+    )
+    
+    # Main options
+    parser.add_argument("--preset", help="Use a preset configuration")
+    parser.add_argument("--list-presets", action="store_true", help="List available presets")
+    parser.add_argument("--output", "-o", help="Output file path (default: stdout)")
+    
+    # Server configuration
+    parser.add_argument("--host", default="0.0.0.0", help="Server host (default: 0.0.0.0)")
+    parser.add_argument("--port", type=int, default=8000, help="Server port (default: 8000)")
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
+    parser.add_argument("--log-level", default="INFO", choices=["DEBUG", "INFO", "WARNING", "ERROR"], help="Log level (default: INFO)")
+    
+    # Logging configuration
+    parser.add_argument("--log-dir", default="./logs", help="Log directory (default: ./logs)")
+    parser.add_argument("--no-console", action="store_true", help="Disable console output")
+    parser.add_argument("--no-file-log", action="store_true", help="Disable file logging")
+    
+    # Protocol configuration
+    parser.add_argument("--protocol", choices=["http", "https", "mtls"], default="http", help="Protocol (default: http)")
+    parser.add_argument("--cert-dir", default="./certs", help="Certificate directory (default: ./certs)")
+    parser.add_argument("--key-dir", default="./keys", help="Key directory (default: ./keys)")
+    
+    # Authentication configuration
+    parser.add_argument("--auth", choices=["none", "token", "basic"], default="none", help="Authentication method (default: none)")
+    parser.add_argument("--api-keys", help="API keys in format 'key1:value1,key2:value2'")
+    parser.add_argument("--roles", help="Roles in format 'role1:perm1,perm2;role2:perm3,perm4'")
+    
+    # Proxy registration
+    parser.add_argument("--proxy-url", help="Proxy URL for registration")
+    parser.add_argument("--server-id", default="mcp_proxy_adapter", help="Server ID for proxy registration (default: mcp_proxy_adapter)")
+    
+    # Commands configuration
+    parser.add_argument("--enabled-commands", help="Comma-separated list of enabled commands")
+    parser.add_argument("--disabled-commands", help="Comma-separated list of disabled commands")
+    
+    # Preset-specific options
+    parser.add_argument("--preset-host", help="Host for preset configurations")
+    parser.add_argument("--preset-port", type=int, help="Port for preset configurations")
+    parser.add_argument("--preset-log-dir", help="Log directory for preset configurations")
+    parser.add_argument("--preset-cert-dir", help="Certificate directory for preset configurations")
+    parser.add_argument("--preset-key-dir", help="Key directory for preset configurations")
+    parser.add_argument("--preset-proxy-url", help="Proxy URL for preset configurations")
+    parser.add_argument("--preset-server-id", help="Server ID for preset configurations")
+    
+    args = parser.parse_args()
+    
+    try:
+        # Handle list presets
+        if args.list_presets:
+            list_presets()
+            return 0
+        
+        # Create configuration
+        if args.preset:
+            # Use preset configuration
+            preset_kwargs = {}
+            if args.preset_host:
+                preset_kwargs["host"] = args.preset_host
+            if args.preset_port:
+                preset_kwargs["port"] = args.preset_port
+            if args.preset_log_dir:
+                preset_kwargs["log_dir"] = args.preset_log_dir
+            if args.preset_cert_dir:
+                preset_kwargs["cert_dir"] = args.preset_cert_dir
+            if args.preset_key_dir:
+                preset_kwargs["key_dir"] = args.preset_key_dir
+            if args.preset_proxy_url:
+                preset_kwargs["proxy_url"] = args.preset_proxy_url
+            if args.preset_server_id:
+                preset_kwargs["server_id"] = args.preset_server_id
+            
+            config = create_preset_config(args.preset, **preset_kwargs)
+        else:
+            # Create custom configuration
+            config = create_custom_config(args)
+        
+        # Output configuration
+        config_json = json.dumps(config, indent=2, ensure_ascii=False)
+        
+        if args.output:
+            output_path = Path(args.output)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write(config_json)
+            print(f"✅ Configuration saved to: {output_path}")
+        else:
+            print(config_json)
+        
+        return 0
+        
+    except Exception as e:
+        print(f"❌ Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_proxy_adapter/examples/create_test_configs.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""
+Test Configuration Generator
+Creates test configurations using the advanced ConfigBuilder utility.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import json
+from pathlib import Path
+
+from config_builder import ConfigBuilder, ConfigFactory, Protocol, AuthMethod
+
+
+class TestConfigGenerator:
+    """Generator for test configurations using ConfigBuilder."""
+
+    def __init__(self, output_dir: str = "configs"):
+        """
+        Initialize the generator.
+        
+        Args:
+            output_dir: Directory to output test configurations
+        """
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True)
+        
+    def _save_config(self, name: str, config: Dict[str, Any]) -> Path:
+        """Save configuration to file."""
+        output_path = self.output_dir / f"{name}.json"
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(config, f, indent=2, ensure_ascii=False)
+        print(f"✅ Created test config: {output_path}")
+        return output_path
+
+    def create_all_test_configs(self):
+        """Create all standard test configurations using ConfigFactory."""
+        print("🔧 Creating test configurations using ConfigBuilder...")
+        
+        # Create output directory
+        self.output_dir.mkdir(exist_ok=True)
+        
+        # 1. HTTP Simple
+        config = ConfigFactory.create_http_simple(port=20020, log_dir=str(self.output_dir.parent / "logs"))
+        self._save_config("http_simple", config)
+        
+        # 2. HTTP with Token Auth
+        api_keys = {
+                "admin": "admin-secret-key",
+                "user": "user-secret-key"
+        }
+        config = ConfigFactory.create_http_token(port=20021, log_dir=str(self.output_dir.parent / "logs"), api_keys=api_keys)
+        self._save_config("http_token", config)
+        
+        # 3. HTTPS Simple
+        config = ConfigFactory.create_https_simple(
+            port=20022, 
+            log_dir=str(self.output_dir.parent / "logs"),
+            cert_dir=str(self.output_dir.parent / "certs"),
+            key_dir=str(self.output_dir.parent / "keys")
+        )
+        self._save_config("https_simple", config)
+        
+        # 4. HTTPS with Token Auth
+        config = ConfigFactory.create_https_token(
+            port=20023,
+            log_dir=str(self.output_dir.parent / "logs"),
+            cert_dir=str(self.output_dir.parent / "certs"),
+            key_dir=str(self.output_dir.parent / "keys"),
+            api_keys=api_keys
+        )
+        self._save_config("https_token", config)
+        
+        # 5. mTLS Simple
+        config = ConfigFactory.create_mtls_simple(
+            port=20024,
+            log_dir=str(self.output_dir.parent / "logs"),
+            cert_dir=str(self.output_dir.parent / "certs"),
+            key_dir=str(self.output_dir.parent / "keys")
+        )
+        self._save_config("mtls_simple", config)
+        
+        # 6. mTLS with Roles
+        roles = {
+            "admin": ["read", "write", "delete", "admin"],
+            "user": ["read", "write"],
+            "guest": ["read"]
+        }
+        config = ConfigFactory.create_mtls_with_roles(
+            port=20025,
+            log_dir=str(self.output_dir.parent / "logs"),
+            cert_dir=str(self.output_dir.parent / "certs"),
+            key_dir=str(self.output_dir.parent / "keys"),
+            roles=roles
+        )
+        self._save_config("mtls_with_roles", config)
+        
+        # 7. mTLS with Proxy Registration
+        config = ConfigFactory.create_mtls_with_proxy(
+            port=20026,
+            log_dir=str(self.output_dir.parent / "logs"),
+            cert_dir=str(self.output_dir.parent / "certs"),
+            key_dir=str(self.output_dir.parent / "keys"),
+            proxy_url="https://127.0.0.1:20005",
+            server_id="mcp_test_server"
+        )
+        self._save_config("mtls_with_proxy", config)
+        
+        # 8. Full Featured Configuration
+        config = ConfigFactory.create_full_featured(
+            port=20027,
+            log_dir=str(self.output_dir.parent / "logs"),
+            cert_dir=str(self.output_dir.parent / "certs"),
+            key_dir=str(self.output_dir.parent / "keys"),
+            proxy_url="https://127.0.0.1:20005",
+            server_id="mcp_full_server"
+        )
+        self._save_config("full_featured", config)
+        
+        # 9. Additional configurations for comprehensive testing
+        
+        # mTLS No Roles (for testing without role-based access)
+        config = ConfigFactory.create_mtls_simple(
+            port=20028,
+            log_dir=str(self.output_dir.parent / "logs"),
+            cert_dir=str(self.output_dir.parent / "certs"),
+            key_dir=str(self.output_dir.parent / "keys")
+        )
+        self._save_config("mtls_no_roles", config)
+        
+        print(f"✅ Created {len(list(self.output_dir.glob('*.json')))} test configurations in {self.output_dir}/")
+        
+        # Create roles.json file for role-based configurations
+        self._create_roles_file(roles)
+
+    def _create_roles_file(self, roles: Dict[str, list]):
+        """Create roles.json file for role-based access control."""
+        roles_config = {
+            "enabled": True,
+            "default_policy": {
+                "deny_by_default": False,
+                "require_role_match": False,
+                "case_sensitive": False,
+                "allow_wildcard": False
+            },
+            "roles": roles,
+            "permissions": {
+                "read": ["GET"],
+                "write": ["POST", "PUT", "PATCH"],
+                "delete": ["DELETE"],
+                "admin": ["*"]
+            }
+        }
+        
+        roles_path = self.output_dir / "roles.json"
+        with open(roles_path, 'w', encoding='utf-8') as f:
+            json.dump(roles_config, f, indent=2, ensure_ascii=False)
+        print(f"✅ Created roles.json: {roles_path}")
+
+
+
+def main():
+    """Main function to create all test configurations."""
+    print("🔧 Creating Test Configurations")
+    print("=" * 40)
+    
+    generator = TestConfigGenerator()
+    generator.create_all_test_configs()
+    
+    print("\n🎉 All test configurations created successfully!")
+    print(f"📁 Output directory: {generator.output_dir}")
+
+
+if __name__ == "__main__":
+    main()