mcp-proxy-adapter 6.9.43__py3-none-any.whl

mcp_proxy_adapter/cli/commands/config_generate.py

@@ -0,0 +1,35 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+CLI command: config generate (Simple configuration generator)
+"""
+
+from __future__ import annotations
+
+from argparse import Namespace
+
+from mcp_proxy_adapter.core.config.simple_config_generator import SimpleConfigGenerator
+
+
+def config_generate_command(args: Namespace) -> int:
+    generator = SimpleConfigGenerator()
+    out = generator.generate(
+        protocol=args.protocol,
+        with_proxy=args.with_proxy,
+        out_path=args.out,
+        server_host=getattr(args, "server_host", None),
+        server_port=getattr(args, "server_port", None),
+        server_cert_file=getattr(args, "server_cert_file", None),
+        server_key_file=getattr(args, "server_key_file", None),
+        server_ca_cert_file=getattr(args, "server_ca_cert_file", None),
+        proxy_host=getattr(args, "proxy_host", None),
+        proxy_port=getattr(args, "proxy_port", None),
+        proxy_cert_file=getattr(args, "proxy_cert_file", None),
+        proxy_key_file=getattr(args, "proxy_key_file", None),
+        proxy_ca_cert_file=getattr(args, "proxy_ca_cert_file", None),
+    )
+    print(f"✅ Configuration generated: {out}")
+    return 0
+
+

mcp_proxy_adapter/cli/commands/config_validate.py

@@ -0,0 +1,74 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+CLI command: config validate (Configuration validation)
+Supports both SimpleConfig and full configuration formats.
+Uses the same ConfigValidator as server startup.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from argparse import Namespace
+from pathlib import Path
+
+from mcp_proxy_adapter.core.validation.config_validator import ConfigValidator
+
+
+def config_validate_command(args: Namespace) -> int:
+    """
+    Validate configuration file using ConfigValidator.
+    
+    This uses the same validator as server startup to ensure consistency.
+    """
+    config_file = Path(args.file)
+    
+    if not config_file.exists():
+        print(f"❌ Configuration file not found: {config_file}")
+        return 1
+    
+    try:
+        # Load configuration
+        with open(config_file, 'r', encoding='utf-8') as f:
+            config_data = json.load(f)
+    except json.JSONDecodeError as e:
+        print(f"❌ Invalid JSON in configuration file: {e}")
+        return 1
+    except Exception as e:
+        print(f"❌ Failed to load config: {e}")
+        return 1
+    
+    # Use the same ConfigValidator as server startup
+    validator = ConfigValidator(config_path=str(config_file))
+    validator.config_data = config_data
+    validation_results = validator.validate_config()
+    
+    # Separate errors and warnings
+    errors = [r for r in validation_results if r.level == "error"]
+    warnings = [r for r in validation_results if r.level == "warning"]
+    
+    if errors:
+        print("❌ Validation failed:")
+        for err in errors:
+            section_info = f" ({err.section}" + (f".{err.key}" if err.key else "") + ")" if err.section else ""
+            print(f"   - {err.message}{section_info}")
+        if warnings:
+            print("\n⚠️  Warnings:")
+            for warn in warnings:
+                section_info = f" ({warn.section}" + (f".{warn.key}" if warn.key else "") + ")" if warn.section else ""
+                print(f"   - {warn.message}{section_info}")
+        return 1
+    
+    if warnings:
+        print("✅ Validation passed with warnings:")
+        for warn in warnings:
+            section_info = f" ({warn.section}" + (f".{warn.key}" if warn.key else "") + ")" if warn.section else ""
+            print(f"   ⚠️  {warn.message}{section_info}")
+        return 0
+    
+    print("✅ Validation OK")
+    return 0
+
+

mcp_proxy_adapter/cli/commands/generate.py

@@ -0,0 +1,259 @@
+"""
+Generate Command
+
+This module implements the generate command for creating configuration files.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# Import the existing config generator
+try:
+    from mcp_proxy_adapter.examples.config_builder import generate_complete_config
+    from mcp_proxy_adapter.core.config_validator import ConfigValidator
+    VALIDATION_AVAILABLE = True
+except ImportError:
+    VALIDATION_AVAILABLE = False
+    print("Warning: Configuration validation not available. Install the package to enable validation.")
+
+
+class GenerateCommand:
+    """Command for generating configuration files."""
+    
+    def __init__(self):
+        """Initialize the generate command."""
+        pass
+    
+    def execute(self, args: Dict[str, Any]) -> int:
+        """
+        Execute the generate command.
+        
+        Args:
+            args: Parsed command arguments
+            
+        Returns:
+            Exit code (0 for success, 1 for error)
+        """
+        try:
+            # Handle special cases
+            if args.get('all'):
+                return self._generate_all_configs(args)
+            
+            # Generate single configuration
+            return self._generate_single_config(args)
+            
+        except Exception as e:
+            print(f"❌ Error generating configuration: {e}")
+            return 1
+    
+    def _generate_single_config(self, args: Dict[str, Any]) -> int:
+        """Generate a single configuration file."""
+        # Create configuration
+        config = self._create_config_from_args(args)
+        
+        # Save configuration
+        if args.get('stdout'):
+            # Output to stdout
+            print(json.dumps(config, indent=2, ensure_ascii=False))
+        else:
+            # Save to file
+            config_file = self._save_config(config, args)
+            print(f"✅ Configuration saved to: {config_file}")
+        
+        return 0
+    
+    def _generate_all_configs(self, args: Dict[str, Any]) -> int:
+        """Generate all standard configurations."""
+        print("🔧 Generating MCP Proxy Adapter configurations...")
+        print("=" * 60)
+        
+        # Define all standard configurations
+        configs = [
+            # HTTP configurations
+            ("http", False, False, 20000),
+            ("http", True, True, 20001),  # token + roles
+            ("http", True, False, 20002),  # token only
+            
+            # HTTPS configurations
+            ("https", False, False, 20003),
+            ("https", True, True, 20004),  # token + roles
+            ("https", True, False, 20005),  # token only
+            
+            # mTLS configurations
+            ("mtls", False, False, 20006),
+            ("mtls", False, True, 20007),  # roles only (from certificate)
+        ]
+        
+        generated_files = []
+        
+        for protocol, token, roles, port in configs:
+            # Create configuration name
+            name_parts = [protocol]
+            if token:
+                name_parts.append("token")
+            if roles:
+                name_parts.append("roles")
+            
+            config_name = "_".join(name_parts)
+            
+            # Create args for this configuration
+            config_args = args.copy()
+            config_args.update({
+                'protocol': protocol,
+                'token': token,
+                'roles': roles,
+                'port': port
+            })
+            
+            # Generate configuration
+            config = self._create_config_from_args(config_args)
+            
+            # Save configuration
+            config_file = self._save_config(config, config_args, config_name)
+            generated_files.append(config_file)
+            
+            print(f"✅ Created {config_name}.json (port {port})")
+        
+        # Create roles.json file if any role-based configs were generated
+        self._create_roles_file(args.get('output_dir', './configs'))
+        
+        print(f"\n🎉 Generated {len(generated_files)} configurations in {args.get('output_dir', './configs')}/")
+        print("\n📋 Generated configurations:")
+        for config_file in generated_files:
+            print(f"  - {config_file.name}")
+        
+        return 0
+    
+    def _create_config_from_args(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Create configuration dictionary from arguments."""
+        # Start with basic configuration
+        config = generate_complete_config(
+            args.get('host', '127.0.0.1'),
+            args.get('port', 8000)
+        )
+        
+        # Set protocol
+        config["server"]["protocol"] = args.get('protocol', 'http')
+        
+        # Configure SSL based on protocol
+        if args.get('protocol') == 'https':
+            config["ssl"]["enabled"] = True
+            config["ssl"]["cert_file"] = f"{args.get('cert_dir', './certs')}/server.crt"
+            config["ssl"]["key_file"] = f"{args.get('key_dir', './keys')}/server.key"
+        elif args.get('protocol') == 'mtls':
+            config["ssl"]["enabled"] = True
+            config["ssl"]["cert_file"] = f"{args.get('cert_dir', './certs')}/server.crt"
+            config["ssl"]["key_file"] = f"{args.get('key_dir', './keys')}/server.key"
+            config["ssl"]["ca_cert"] = f"{args.get('cert_dir', './certs')}/ca.crt"
+            config["transport"]["verify_client"] = True
+        
+        # Configure security if token authentication is enabled
+        if args.get('token'):
+            config["security"]["enabled"] = True
+            config["security"]["tokens"] = {
+                "admin": "admin-secret-key",
+                "user": "user-secret-key",
+                "readonly": "readonly-secret-key"
+            }
+            
+            if args.get('roles'):
+                config["security"]["roles"] = {
+                    "admin": ["read", "write", "delete", "admin"],
+                    "user": ["read", "write"],
+                    "readonly": ["read"]
+                }
+                config["security"]["roles_file"] = f"{args.get('output_dir', './configs')}/roles.json"
+                config["roles"]["enabled"] = True
+                config["roles"]["config_file"] = f"{args.get('output_dir', './configs')}/roles.json"
+        elif args.get('roles') and args.get('protocol') == 'mtls':
+            # For mTLS, roles can be enabled without tokens (from certificate)
+            config["roles"]["enabled"] = True
+            config["roles"]["config_file"] = f"{args.get('output_dir', './configs')}/roles.json"
+        
+        # Configure proxy registration if enabled
+        if args.get('proxy_url'):
+            config["proxy_registration"]["enabled"] = True
+            config["proxy_registration"]["proxy_url"] = args['proxy_url']
+            config["proxy_registration"]["server_id"] = args.get('server_id', 'mcp-proxy-adapter')
+        
+        return config
+    
+    def _save_config(self, config: Dict[str, Any], args: Dict[str, Any], filename: Optional[str] = None) -> Path:
+        """Save configuration to file with optional validation."""
+        output_dir = Path(args.get('output_dir', './configs'))
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Determine filename
+        if filename:
+            config_name = filename
+        elif args.get('output'):
+            config_name = args['output']
+        else:
+            # Generate filename from arguments
+            name_parts = [args.get('protocol', 'http')]
+            if args.get('token'):
+                name_parts.append("token")
+            if args.get('roles'):
+                name_parts.append("roles")
+            config_name = "_".join(name_parts)
+        
+        config_file = output_dir / f"{config_name}.json"
+        
+        # Save configuration
+        with open(config_file, 'w', encoding='utf-8') as f:
+            json.dump(config, f, indent=2, ensure_ascii=False)
+        
+        # Validate configuration if requested and validation is available
+        if not args.get('no_validate') and VALIDATION_AVAILABLE:
+            print(f"🔍 Validating configuration: {config_file}")
+            validator = ConfigValidator()
+            validator.config_data = config
+            results = validator.validate_config()
+            
+            if results:
+                print("⚠️  Validation issues found:")
+                for result in results:
+                    level_symbol = "❌" if result.level == "error" else "⚠️" if result.level == "warning" else "ℹ️"
+                    print(f"  {level_symbol} {result.message}")
+                    if hasattr(result, 'suggestion') and result.suggestion:
+                        print(f"     Suggestion: {result.suggestion}")
+            else:
+                print("✅ Configuration validation passed!")
+        
+        return config_file
+    
+    def _create_roles_file(self, output_dir: str) -> None:
+        """Create roles.json file for role-based configurations."""
+        roles_config = {
+            "enabled": True,
+            "default_policy": {
+                "deny_by_default": False,
+                "require_role_match": False,
+                "case_sensitive": False,
+                "allow_wildcard": False
+            },
+            "roles": {
+                "admin": ["read", "write", "delete", "admin"],
+                "user": ["read", "write"],
+                "readonly": ["read"],
+                "guest": ["read"],
+                "proxy": ["read", "write"]
+            },
+            "permissions": {
+                "read": ["GET"],
+                "write": ["POST", "PUT", "PATCH"],
+                "delete": ["DELETE"],
+                "admin": ["*"]
+            }
+        }
+        
+        roles_file = Path(output_dir) / "roles.json"
+        with open(roles_file, 'w', encoding='utf-8') as f:
+            json.dump(roles_config, f, indent=2, ensure_ascii=False)
+        print(f"✅ Created roles.json")
+
+

mcp_proxy_adapter/cli/commands/server.py

@@ -0,0 +1,174 @@
+"""
+Server Command
+
+This module implements the server command for starting MCP Proxy Adapter server.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+try:
+    from mcp_proxy_adapter.core.validation.config_validator import ConfigValidator
+    from mcp_proxy_adapter.core.server_adapter import UnifiedServerRunner
+    from mcp_proxy_adapter.api.app import create_app
+    VALIDATION_AVAILABLE = True
+except ImportError:
+    VALIDATION_AVAILABLE = False
+
+
+class ServerCommand:
+    """Command for starting the MCP Proxy Adapter server."""
+    
+    def __init__(self):
+        """Initialize the server command."""
+        pass
+    
+    def execute(self, args: Dict[str, Any]) -> int:
+        """
+        Execute the server command.
+        
+        Args:
+            args: Parsed command arguments
+            
+        Returns:
+            Exit code (0 for success, 1 for error)
+        """
+        config_file = args['config']
+        no_validate = args.get('no_validate', False)
+        
+        try:
+            # Load configuration
+            print(f"🔍 Loading configuration from: {config_file}")
+            with open(config_file, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+            
+            # Validate configuration if not disabled
+            if not no_validate and VALIDATION_AVAILABLE:
+                print("🔍 Validating configuration...")
+                if not self._validate_config(config, config_file):
+                    print("❌ Configuration validation failed. Server not started.")
+                    return 1
+                print("✅ Configuration validation passed!")
+            elif no_validate:
+                print("⚠️  Configuration validation skipped (--no-validate)")
+            else:
+                print("⚠️  Configuration validation not available")
+            
+            # Override configuration with command line arguments
+            if args.get('port'):
+                config['server']['port'] = args['port']
+                print(f"🔧 Overriding port to: {args['port']}")
+            
+            if args.get('host'):
+                config['server']['host'] = args['host']
+                print(f"🔧 Overriding host to: {args['host']}")
+            
+            # Create and start server
+            print("🚀 Starting MCP Proxy Adapter server...")
+            self._start_server(config, args)
+            
+        except FileNotFoundError:
+            print(f"❌ Configuration file not found: {config_file}")
+            return 1
+        except json.JSONDecodeError as e:
+            print(f"❌ Invalid JSON in configuration file: {e}")
+            return 1
+        except Exception as e:
+            print(f"❌ Error starting server: {e}")
+            return 1
+    
+    def _validate_config(self, config: Dict[str, Any], config_file: str) -> bool:
+        """
+        Validate configuration using ConfigValidator.
+        
+        Args:
+            config: Configuration dictionary
+            config_file: Path to configuration file
+            
+        Returns:
+            True if configuration is valid, False otherwise
+        """
+        try:
+            validator = ConfigValidator()
+            validator.config_data = config
+            results = validator.validate_config()
+            
+            # Check for errors
+            errors = [r for r in results if r.level == "error"]
+            warnings = [r for r in results if r.level == "warning"]
+            
+            if errors:
+                print("❌ Configuration validation errors:")
+                for error in errors:
+                    print(f"  • {error.message}")
+                    if hasattr(error, 'suggestion') and error.suggestion:
+                        print(f"    → {error.suggestion}")
+                return False
+            
+            if warnings:
+                print("⚠️  Configuration validation warnings:")
+                for warning in warnings:
+                    print(f"  • {warning.message}")
+                    if hasattr(warning, 'suggestion') and warning.suggestion:
+                        print(f"    → {warning.suggestion}")
+            
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error during configuration validation: {e}")
+            return False
+    
+    def _start_server(self, config: Dict[str, Any], args: Dict[str, Any]) -> None:
+        """
+        Start the MCP Proxy Adapter server.
+        
+        Args:
+            config: Server configuration
+            args: Command line arguments
+        """
+        try:
+            # Create ASGI application
+            app = create_app(config)
+            
+            # Prepare server configuration
+            server_config = {
+                'host': config['server']['host'],
+                'port': config['server']['port'],
+                'log_level': config['server'].get('log_level', 'INFO'),
+                'reload': args.get('reload', False)
+            }
+            
+            # Add SSL configuration if present
+            if 'ssl' in config and config['ssl'].get('enabled'):
+                server_config.update({
+                    'certfile': config['ssl'].get('cert_file'),
+                    'keyfile': config['ssl'].get('key_file'),
+                    'ca_certs': config['ssl'].get('ca_cert'),
+                    'verify_mode': 'CERT_REQUIRED' if config.get('transport', {}).get('verify_client') else 'CERT_NONE'
+                })
+            
+            # Start server
+            print(f"🌐 Server starting on {server_config['host']}:{server_config['port']}")
+            print(f"📋 Protocol: {config['server']['protocol']}")
+            print(f"🔐 Security: {'Enabled' if config.get('security', {}).get('enabled') else 'Disabled'}")
+            print(f"🔑 Authentication: {'Token-based' if config.get('security', {}).get('tokens') else 'Certificate-based' if config['server']['protocol'] == 'mtls' else 'None'}")
+            print(f"👥 Roles: {'Enabled' if config.get('roles', {}).get('enabled') else 'Disabled'}")
+            print("=" * 60)
+            
+            # Use UnifiedServerRunner to start the server
+            runner = UnifiedServerRunner()
+            runner.run_server(app, server_config)
+            
+        except ImportError as e:
+            print(f"❌ Missing required dependencies: {e}")
+            print("💡 Install required packages: pip install hypercorn")
+            raise
+        except Exception as e:
+            print(f"❌ Failed to start server: {e}")
+            raise
+
+

mcp_proxy_adapter/cli/commands/sets.py

@@ -0,0 +1,128 @@
+"""
+Sets Command
+
+This module implements the sets command for generating configurations using predefined sets.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+from mcp_proxy_adapter.core.config.simple_config import (
+    SimpleConfig,
+    SimpleConfigModel,
+    ServerConfig,
+    ProxyClientConfig,
+    AuthConfig,
+)
+
+
+class SetsCommand:
+    """Command for generating configurations using predefined sets."""
+    
+    def __init__(self):
+        """Initialize the sets command."""
+        pass
+    
+    def execute(self, args: Dict[str, Any]) -> int:
+        """
+        Execute the sets command.
+        
+        Args:
+            args: Parsed command arguments
+            
+        Returns:
+            Exit code (0 for success, 1 for error)
+        """
+        set_name = args.get('set_name')
+        
+        if not set_name:
+            print("❌ No set specified. Use: sets {http,https,mtls}")
+            return 1
+        
+        try:
+            # Generate configuration based on set
+            config_path = self._create_config_from_set(set_name, args)
+            
+            print(f"✅ {set_name.upper()} configuration saved to: {config_path}")
+            return 0
+            
+        except Exception as e:
+            print(f"❌ Error generating {set_name} configuration: {e}")
+            return 1
+    
+    def _create_config_from_set(self, set_name: str, args: Dict[str, Any]) -> Path:
+        """
+        Create configuration based on the specified set.
+        
+        Args:
+            set_name: Name of the configuration set
+            args: Command arguments
+            
+        Returns:
+            Path to saved configuration file
+        """
+        host = args.get('host', '127.0.0.1')
+        port = int(args.get('port', 8000))
+        protocol = set_name
+
+        # Build server config compatible with SimpleConfig
+        server = ServerConfig(host=host, port=port, protocol=protocol)
+        cert_dir = Path(args.get('cert_dir') or './certs')
+        key_dir = Path(args.get('key_dir') or './keys')
+        if protocol in ('https', 'mtls'):
+            # Prefer test-server.* filenames if present, otherwise fallback to server.*
+            cert_file = cert_dir / 'test-server.crt'
+            key_file = key_dir / 'test-server.key'
+            if not cert_file.exists():
+                cert_file = cert_dir / 'server.crt'
+            if not key_file.exists():
+                key_file = key_dir / 'server.key'
+            server.cert_file = str(cert_file)
+            server.key_file = str(key_file)
+        if protocol == 'mtls':
+            # CA file path is expected by validator; try ca/ca.crt relative to provided cert_dir
+            ca_candidate = cert_dir.parent / 'ca' / 'ca.crt'
+            if not ca_candidate.exists():
+                ca_candidate = cert_dir / 'ca.crt'
+            server.ca_cert_file = str(ca_candidate)
+
+        # Proxy client (disabled by default here)
+        proxy = ProxyClientConfig(enabled=False)
+
+        # Auth config based on modifiers
+        use_token = 'token' in (args.get('modifiers') or []) or bool(args.get('token'))
+        use_roles = 'roles' in (args.get('modifiers') or []) or bool(args.get('roles'))
+        # If roles are requested, token must be enabled to satisfy validator
+        if use_roles and not use_token:
+            use_token = True
+        tokens = {
+            'admin': ['read', 'write', 'delete', 'admin'],
+        } if use_token else {}
+        roles = {
+            'admin': ['read', 'write', 'delete', 'admin'],
+            'user': ['read', 'write'],
+        } if use_roles else {}
+        auth = AuthConfig(use_token=use_token, use_roles=use_roles, tokens=tokens, roles=roles)
+
+        # Save using SimpleConfig
+        model = SimpleConfigModel(server=server, proxy_client=proxy, auth=auth)
+        out_dir = Path(args.get('output_dir', './configs'))
+        out_dir.mkdir(parents=True, exist_ok=True)
+        name_parts = [set_name]
+        if use_token and set_name in ['http', 'https']:
+            name_parts.append('token')
+        if use_roles:
+            name_parts.append('roles')
+        filename = args.get('output') or "_".join(name_parts)
+        out_path = out_dir / f"{filename}.json"
+
+        cfg = SimpleConfig(str(out_path))
+        cfg.model = model
+        cfg.save()
+        return out_path
+
+