mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.29__py3-none-any.whl

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
+
+

mcp_proxy_adapter/cli/commands/testconfig.py

@@ -0,0 +1,177 @@
+"""
+TestConfig Command
+
+This module implements the testconfig command for validating configuration files.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+from typing import Dict, Any
+
+try:
+    from mcp_proxy_adapter.core.config_validator import ConfigValidator
+    VALIDATION_AVAILABLE = True
+except ImportError:
+    VALIDATION_AVAILABLE = False
+
+
+class TestConfigCommand:
+    """Command for testing and validating configuration files."""
+    
+    def __init__(self):
+        """Initialize the testconfig command."""
+        pass
+    
+    def execute(self, args: Dict[str, Any]) -> int:
+        """
+        Execute the testconfig command.
+        
+        Args:
+            args: Parsed command arguments
+            
+        Returns:
+            Exit code (0 for success, 1 for error)
+        """
+        if not VALIDATION_AVAILABLE:
+            print("❌ Configuration validation not available. Install the package to enable validation.")
+            return 1
+        
+        config_file = args['config']
+        verbose = args.get('verbose', False)
+        fix_suggestions = args.get('fix_suggestions', False)
+        json_output = args.get('json', False)
+        
+        try:
+            # Load and validate configuration
+            validator = ConfigValidator(config_file)
+            validator.load_config()
+            results = validator.validate_config()
+            
+            # Get validation summary
+            summary = validator.get_validation_summary()
+            
+            if json_output:
+                # Output results in JSON format
+                self._output_json_results(summary, results, config_file)
+            else:
+                # Output human-readable results
+                self._output_human_results(summary, results, config_file, verbose, fix_suggestions)
+            
+            # Return appropriate exit code
+            return 0 if summary['is_valid'] else 1
+            
+        except Exception as e:
+            print(f"❌ Error testing configuration: {e}")
+            return 1
+    
+    def _output_json_results(self, summary: Dict[str, Any], results: list, config_file: str) -> None:
+        """Output validation results in JSON format."""
+        output = {
+            "config_file": config_file,
+            "summary": summary,
+            "issues": []
+        }
+        
+        for result in results:
+            issue = {
+                "level": result.level,
+                "message": result.message,
+                "section": result.section,
+                "key": result.key if hasattr(result, 'key') else None,
+                "suggestion": result.suggestion if hasattr(result, 'suggestion') else None
+            }
+            output["issues"].append(issue)
+        
+        print(json.dumps(output, indent=2, ensure_ascii=False))
+    
+    def _output_human_results(self, summary: Dict[str, Any], results: list, config_file: str, 
+                            verbose: bool, fix_suggestions: bool) -> None:
+        """Output validation results in human-readable format."""
+        print("=" * 60)
+        print("CONFIGURATION VALIDATION REPORT")
+        print("=" * 60)
+        print(f"Configuration file: {config_file}")
+        print(f"Total issues: {summary['total_issues']}")
+        print(f"Errors: {summary['errors']}")
+        print(f"Warnings: {summary['warnings']}")
+        print(f"Info: {summary['info']}")
+        print(f"Configuration is valid: {'✅ YES' if summary['is_valid'] else '❌ NO'}")
+        print("=" * 60)
+        
+        if results:
+            print("\n📋 DETAILED ISSUES:")
+            print("-" * 40)
+            
+            for i, result in enumerate(results, 1):
+                level_symbol = {
+                    "error": "❌",
+                    "warning": "⚠️",
+                    "info": "ℹ️"
+                }.get(result.level, "❓")
+                
+                print(f"\n{i}. {level_symbol} [{result.level.upper()}]")
+                print(f"   Message: {result.message}")
+                
+                if hasattr(result, 'section') and result.section:
+                    location = f"{result.section}"
+                    if hasattr(result, 'key') and result.key:
+                        location += f".{result.key}"
+                    print(f"   Location: {location}")
+                
+                if hasattr(result, 'suggestion') and result.suggestion:
+                    print(f"   Suggestion: {result.suggestion}")
+                
+                if verbose:
+                    print(f"   Full details: {result}")
+        else:
+            print("\n✅ No issues found in configuration!")
+        
+        if fix_suggestions and results:
+            self._print_fix_suggestions(results)
+    
+    def _print_fix_suggestions(self, results: list) -> None:
+        """Print suggestions for fixing configuration issues."""
+        print("\n🔧 FIX SUGGESTIONS:")
+        print("-" * 40)
+        
+        # Group suggestions by type
+        suggestions = {
+            "missing_files": [],
+            "invalid_values": [],
+            "missing_sections": [],
+            "dependency_issues": [],
+            "other": []
+        }
+        
+        for result in results:
+            if result.level == "error":
+                message = result.message.lower()
+                if "does not exist" in message or "not found" in message:
+                    suggestions["missing_files"].append(result)
+                elif "missing" in message and "section" in message:
+                    suggestions["missing_sections"].append(result)
+                elif "invalid" in message or "wrong type" in message:
+                    suggestions["invalid_values"].append(result)
+                elif "dependency" in message or "requires" in message:
+                    suggestions["dependency_issues"].append(result)
+                else:
+                    suggestions["other"].append(result)
+        
+        # Print suggestions by category
+        for category, issues in suggestions.items():
+            if issues:
+                print(f"\n📁 {category.replace('_', ' ').title()}:")
+                for issue in issues:
+                    print(f"  • {issue.message}")
+                    if hasattr(issue, 'suggestion') and issue.suggestion:
+                        print(f"    → {issue.suggestion}")
+        
+        print("\n💡 GENERAL RECOMMENDATIONS:")
+        print("  • Use the configuration generator: mcp-proxy-adapter generate --help")
+        print("  • Check the documentation: docs/EN/ALL_CONFIG_SETTINGS.md")
+        print("  • Validate certificates and file paths")
+        print("  • Ensure all required sections are present")
+
+

mcp_proxy_adapter/cli/examples/__init__.py

@@ -0,0 +1,8 @@
+"""
+CLI Examples Module
+
+This module contains example scripts demonstrating CLI usage.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""

mcp_proxy_adapter/cli/examples/http_basic.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""
+HTTP Basic Configuration Example
+
+This example demonstrates how to generate and use a basic HTTP configuration.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import subprocess
+import sys
+import json
+from pathlib import Path
+
+
+def main():
+    """Generate and test HTTP basic configuration."""
+    print("🔧 HTTP Basic Configuration Example")
+    print("=" * 50)
+    
+    # Generate HTTP configuration
+    print("1. Generating HTTP configuration...")
+    result = subprocess.run([
+        sys.executable, "-m", "mcp_proxy_adapter.cli.main",
+        "sets", "http",
+        "--port", "8080",
+        "--output-dir", "./examples_configs"
+    ], capture_output=True, text=True)
+    
+    if result.returncode != 0:
+        print(f"❌ Error generating configuration: {result.stderr}")
+        return 1
+    
+    print("✅ HTTP configuration generated")
+    
+    # Find the generated config file
+    config_dir = Path("./examples_configs")
+    config_files = list(config_dir.glob("http*.json"))
+    
+    if not config_files:
+        print("❌ No configuration files found")
+        return 1
+    
+    config_file = config_files[0]
+    print(f"📁 Configuration file: {config_file}")
+    
+    # Test the configuration
+    print("\n2. Testing configuration...")
+    result = subprocess.run([
+        sys.executable, "-m", "mcp_proxy_adapter.cli.main",
+        "testconfig",
+        "--config", str(config_file),
+        "--verbose"
+    ], capture_output=True, text=True)
+    
+    if result.returncode != 0:
+        print(f"❌ Configuration validation failed: {result.stderr}")
+        return 1
+    
+    print("✅ Configuration validation passed")
+    
+    # Show configuration content
+    print("\n3. Configuration content:")
+    with open(config_file, 'r') as f:
+        config = json.load(f)
+    
+    print(f"   Protocol: {config['server']['protocol']}")
+    print(f"   Host: {config['server']['host']}")
+    print(f"   Port: {config['server']['port']}")
+    print(f"   Security: {'Enabled' if config.get('security', {}).get('enabled') else 'Disabled'}")
+    
+    print("\n🎉 HTTP basic configuration example completed!")
+    print(f"📁 Configuration saved to: {config_file}")
+    print("\n💡 To start the server:")
+    print(f"   mcp-proxy-adapter server --config {config_file}")
+    
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_proxy_adapter/cli/examples/https_token.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""
+HTTPS Token Configuration Example
+
+This example demonstrates how to generate and use an HTTPS configuration with token authentication.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import subprocess
+import sys
+import json
+from pathlib import Path
+
+
+def main():
+    """Generate and test HTTPS token configuration."""
+    print("🔧 HTTPS Token Configuration Example")
+    print("=" * 50)
+    
+    # Generate HTTPS configuration with token authentication
+    print("1. Generating HTTPS configuration with token authentication...")
+    result = subprocess.run([
+        sys.executable, "-m", "mcp_proxy_adapter.cli.main",
+        "sets", "https",
+        "--token",
+        "--roles",
+        "--port", "8443",
+        "--output-dir", "./examples_configs"
+    ], capture_output=True, text=True)
+    
+    if result.returncode != 0:
+        print(f"❌ Error generating configuration: {result.stderr}")
+        return 1
+    
+    print("✅ HTTPS configuration with token authentication generated")
+    
+    # Find the generated config file
+    config_dir = Path("./examples_configs")
+    config_files = list(config_dir.glob("https_token_roles*.json"))
+    
+    if not config_files:
+        print("❌ No configuration files found")
+        return 1
+    
+    config_file = config_files[0]
+    print(f"📁 Configuration file: {config_file}")
+    
+    # Test the configuration
+    print("\n2. Testing configuration...")
+    result = subprocess.run([
+        sys.executable, "-m", "mcp_proxy_adapter.cli.main",
+        "testconfig",
+        "--config", str(config_file),
+        "--verbose"
+    ], capture_output=True, text=True)
+    
+    if result.returncode != 0:
+        print(f"❌ Configuration validation failed: {result.stderr}")
+        return 1
+    
+    print("✅ Configuration validation passed")
+    
+    # Show configuration content
+    print("\n3. Configuration content:")
+    with open(config_file, 'r') as f:
+        config = json.load(f)
+    
+    print(f"   Protocol: {config['server']['protocol']}")
+    print(f"   Host: {config['server']['host']}")
+    print(f"   Port: {config['server']['port']}")
+    print(f"   SSL: {'Enabled' if config.get('ssl', {}).get('enabled') else 'Disabled'}")
+    print(f"   Security: {'Enabled' if config.get('security', {}).get('enabled') else 'Disabled'}")
+    print(f"   Token Auth: {'Enabled' if config.get('security', {}).get('tokens') else 'Disabled'}")
+    print(f"   Roles: {'Enabled' if config.get('roles', {}).get('enabled') else 'Disabled'}")
+    
+    # Show available tokens
+    if config.get('security', {}).get('tokens'):
+        print("\n4. Available authentication tokens:")
+        for role, token in config['security']['tokens'].items():
+            print(f"   {role}: {token}")
+    
+    print("\n🎉 HTTPS token configuration example completed!")
+    print(f"📁 Configuration saved to: {config_file}")
+    print("\n💡 To start the server:")
+    print(f"   mcp-proxy-adapter server --config {config_file}")
+    print("\n💡 To test with curl:")
+    print(f"   curl -k https://localhost:8443/health")
+    print(f"   curl -k -H 'X-API-Key: admin-secret-key' https://localhost:8443/api/jsonrpc -d '{{\"jsonrpc\":\"2.0\",\"method\":\"echo\",\"params\":{{\"message\":\"Hello\"}},\"id\":1}}'")
+    
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_proxy_adapter/cli/examples/mtls_roles.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+mTLS Roles Configuration Example
+
+This example demonstrates how to generate and use an mTLS configuration with role-based access control.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import subprocess
+import sys
+import json
+from pathlib import Path
+
+
+def main():
+    """Generate and test mTLS roles configuration."""
+    print("🔧 mTLS Roles Configuration Example")
+    print("=" * 50)
+    
+    # Generate mTLS configuration with roles
+    print("1. Generating mTLS configuration with roles...")
+    result = subprocess.run([
+        sys.executable, "-m", "mcp_proxy_adapter.cli.main",
+        "sets", "mtls",
+        "--roles",
+        "--port", "8443",
+        "--output-dir", "./examples_configs"
+    ], capture_output=True, text=True)
+    
+    if result.returncode != 0:
+        print(f"❌ Error generating configuration: {result.stderr}")
+        return 1
+    
+    print("✅ mTLS configuration with roles generated")
+    
+    # Find the generated config file
+    config_dir = Path("./examples_configs")
+    config_files = list(config_dir.glob("mtls_roles*.json"))
+    
+    if not config_files:
+        print("❌ No configuration files found")
+        return 1
+    
+    config_file = config_files[0]
+    print(f"📁 Configuration file: {config_file}")
+    
+    # Test the configuration
+    print("\n2. Testing configuration...")
+    result = subprocess.run([
+        sys.executable, "-m", "mcp_proxy_adapter.cli.main",
+        "testconfig",
+        "--config", str(config_file),
+        "--verbose"
+    ], capture_output=True, text=True)
+    
+    if result.returncode != 0:
+        print(f"❌ Configuration validation failed: {result.stderr}")
+        return 1
+    
+    print("✅ Configuration validation passed")
+    
+    # Show configuration content
+    print("\n3. Configuration content:")
+    with open(config_file, 'r') as f:
+        config = json.load(f)
+    
+    print(f"   Protocol: {config['server']['protocol']}")
+    print(f"   Host: {config['server']['host']}")
+    print(f"   Port: {config['server']['port']}")
+    print(f"   SSL: {'Enabled' if config.get('ssl', {}).get('enabled') else 'Disabled'}")
+    print(f"   Client Verification: {'Enabled' if config.get('transport', {}).get('verify_client') else 'Disabled'}")
+    print(f"   Roles: {'Enabled' if config.get('roles', {}).get('enabled') else 'Disabled'}")
+    
+    # Show SSL configuration
+    if config.get('ssl'):
+        ssl_config = config['ssl']
+        print(f"\n4. SSL Configuration:")
+        print(f"   Certificate: {ssl_config.get('cert_file', 'Not set')}")
+        print(f"   Private Key: {ssl_config.get('key_file', 'Not set')}")
+        print(f"   CA Certificate: {ssl_config.get('ca_cert', 'Not set')}")
+    
+    # Show roles configuration
+    if config.get('roles', {}).get('enabled'):
+        print(f"\n5. Roles Configuration:")
+        print(f"   Config File: {config['roles'].get('config_file', 'Not set')}")
+        print(f"   Auto Load: {config['roles'].get('auto_load', False)}")
+        print(f"   Validation: {'Enabled' if config['roles'].get('validation_enabled') else 'Disabled'}")
+    
+    print("\n🎉 mTLS roles configuration example completed!")
+    print(f"📁 Configuration saved to: {config_file}")
+    print("\n💡 To start the server:")
+    print(f"   mcp-proxy-adapter server --config {config_file}")
+    print("\n💡 To test with curl (requires client certificates):")
+    print(f"   curl -k --cert client.crt --key client.key https://localhost:8443/health")
+    print(f"   curl -k --cert client.crt --key client.key https://localhost:8443/api/jsonrpc -d '{{\"jsonrpc\":\"2.0\",\"method\":\"echo\",\"params\":{{\"message\":\"Hello mTLS\"}},\"id\":1}}'")
+    
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_proxy_adapter/cli/main.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""
+MCP Proxy Adapter CLI Application
+Comprehensive command-line interface with multi-level help and configuration management
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from mcp_proxy_adapter.cli.parser import create_main_parser  # noqa: E402
+
+
+def main():
+    """Main CLI entry point"""
+    parser = create_main_parser()
+    args = parser.parse_args()
+
+    try:
+        if args.command == 'generate':
+            from mcp_proxy_adapter.cli.commands.generate import GenerateCommand
+            return GenerateCommand().execute(vars(args))
+        elif args.command == 'testconfig':
+            from mcp_proxy_adapter.cli.commands.testconfig import TestConfigCommand
+            return TestConfigCommand().execute(vars(args))
+        elif args.command == 'sets':
+            from mcp_proxy_adapter.cli.commands.sets import SetsCommand
+            return SetsCommand().execute(vars(args))
+        elif args.command == 'server':
+            from mcp_proxy_adapter.cli.commands.server import ServerCommand
+            return ServerCommand().execute(vars(args))
+        elif args.command == 'config':
+            if args.config_command == 'generate':
+                from mcp_proxy_adapter.cli.commands.config_generate import config_generate_command
+                return config_generate_command(args)
+            if args.config_command == 'validate':
+                from mcp_proxy_adapter.cli.commands.config_validate import config_validate_command
+                return config_validate_command(args)
+            print('Available: config generate|validate')
+            return 1
+        elif args.command == 'client':
+            from mcp_proxy_adapter.cli.commands.client import client_command
+            return client_command(args)
+        else:
+            parser.print_help()
+            return 1
+
+    except KeyboardInterrupt:
+        print("\n❌ Operation cancelled by user")
+        return 1
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())