mcp-proxy-adapter 6.6.0__py3-none-any.whl → 6.6.1__py3-none-any.whl

mcp_proxy_adapter/examples/check_config.py

@@ -0,0 +1,415 @@
+#!/usr/bin/env python3
+"""
+Configuration Checker CLI for MCP Proxy Adapter
+Validates configuration files and checks for common issues.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import argparse
+import json
+import sys
+import os
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+
+# Add the project root to the path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_proxy_adapter.config import Config
+from mcp_proxy_adapter.examples.config_builder import ConfigBuilder, Protocol, AuthMethod
+
+
+class ConfigChecker:
+    """Configuration checker with validation and analysis."""
+    
+    def __init__(self):
+        self.errors: List[str] = []
+        self.warnings: List[str] = []
+        self.info: List[str] = []
+    
+    def check_config_file(self, config_path: str) -> bool:
+        """
+        Check a configuration file for issues.
+        
+        Args:
+            config_path: Path to configuration file
+            
+        Returns:
+            True if config is valid, False otherwise
+        """
+        self.errors.clear()
+        self.warnings.clear()
+        self.info.clear()
+        
+        print(f"🔍 Checking configuration: {config_path}")
+        print("=" * 60)
+        
+        # Check if file exists
+        if not os.path.exists(config_path):
+            self.errors.append(f"Configuration file not found: {config_path}")
+            return False
+        
+        # Check if file is readable
+        if not os.access(config_path, os.R_OK):
+            self.errors.append(f"Configuration file is not readable: {config_path}")
+            return False
+        
+        try:
+            # Load and parse JSON
+            with open(config_path, 'r', encoding='utf-8') as f:
+                config_data = json.load(f)
+        except json.JSONDecodeError as e:
+            self.errors.append(f"Invalid JSON format: {e}")
+            return False
+        except Exception as e:
+            self.errors.append(f"Error reading configuration file: {e}")
+            return False
+        
+        # Load with Config class
+        try:
+            config = Config(config_path)
+        except Exception as e:
+            self.errors.append(f"Error loading configuration with Config class: {e}")
+            return False
+        
+        # Perform checks
+        self._check_basic_structure(config_data)
+        self._check_server_config(config)
+        self._check_security_config(config)
+        self._check_ssl_config(config)
+        self._check_logging_config(config)
+        self._check_file_paths(config_path, config)
+        self._check_port_availability(config)
+        
+        # Print results
+        self._print_results()
+        
+        return len(self.errors) == 0
+    
+    def _check_basic_structure(self, config_data: Dict[str, Any]) -> None:
+        """Check basic configuration structure."""
+        required_sections = ["server", "security", "logging", "transport"]
+        
+        for section in required_sections:
+            if section not in config_data:
+                self.errors.append(f"Missing required section: {section}")
+            else:
+                self.info.append(f"✅ Section '{section}' present")
+    
+    def _check_server_config(self, config: Config) -> None:
+        """Check server configuration."""
+        protocol = config.get("server.protocol")
+        host = config.get("server.host")
+        port = config.get("server.port")
+        
+        if not protocol:
+            self.errors.append("Server protocol not specified")
+        elif protocol not in ["http", "https", "mtls"]:
+            self.errors.append(f"Invalid server protocol: {protocol}")
+        else:
+            self.info.append(f"✅ Server protocol: {protocol}")
+        
+        if not host:
+            self.warnings.append("Server host not specified, using default")
+        else:
+            self.info.append(f"✅ Server host: {host}")
+        
+        if not port:
+            self.errors.append("Server port not specified")
+        elif not isinstance(port, int) or port < 1 or port > 65535:
+            self.errors.append(f"Invalid server port: {port}")
+        else:
+            self.info.append(f"✅ Server port: {port}")
+    
+    def _check_security_config(self, config: Config) -> None:
+        """Check security configuration."""
+        security_enabled = config.get("security.enabled", False)
+        tokens = config.get("security.tokens", {})
+        roles = config.get("security.roles", {})
+        roles_file = config.get("security.roles_file")
+        
+        if security_enabled:
+            self.info.append("✅ Security enabled")
+            
+            if not tokens and not roles and not roles_file:
+                self.warnings.append("Security enabled but no authentication methods configured")
+            else:
+                if tokens:
+                    self.info.append(f"✅ Tokens configured: {len(tokens)} tokens")
+                if roles:
+                    self.info.append(f"✅ Roles configured: {len(roles)} roles")
+                if roles_file:
+                    self.info.append(f"✅ Roles file: {roles_file}")
+        else:
+            self.info.append("ℹ️ Security disabled")
+    
+    def _check_ssl_config(self, config: Config) -> None:
+        """Check SSL configuration."""
+        protocol = config.get("server.protocol")
+        chk_hostname = config.get("transport.ssl.chk_hostname")
+        
+        if protocol in ["https", "mtls"]:
+            self.info.append(f"✅ SSL protocol: {protocol}")
+            
+            if chk_hostname is None:
+                self.warnings.append("chk_hostname not specified for SSL protocol")
+            elif chk_hostname:
+                self.info.append("✅ Hostname checking enabled")
+            else:
+                self.warnings.append("Hostname checking disabled for SSL protocol")
+        else:
+            if chk_hostname:
+                self.warnings.append("Hostname checking enabled for non-SSL protocol")
+            else:
+                self.info.append("✅ Hostname checking disabled for HTTP")
+    
+    def _check_logging_config(self, config: Config) -> None:
+        """Check logging configuration."""
+        log_level = config.get("logging.level")
+        log_file = config.get("logging.file")
+        log_dir = config.get("logging.log_dir")
+        
+        if log_level and log_level.upper() in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
+            self.info.append(f"✅ Log level: {log_level}")
+        else:
+            self.warnings.append(f"Invalid or missing log level: {log_level}")
+        
+        if log_file:
+            self.info.append(f"✅ Log file: {log_file}")
+        
+        if log_dir:
+            self.info.append(f"✅ Log directory: {log_dir}")
+    
+    def _check_file_paths(self, config_path: str, config: Config) -> None:
+        """Check file paths in configuration."""
+        config_dir = Path(config_path).parent
+        
+        # Check roles file
+        roles_file = config.get("security.roles_file")
+        if roles_file:
+            roles_path = config_dir / roles_file
+            if not roles_path.exists():
+                self.warnings.append(f"Roles file not found: {roles_path}")
+            else:
+                self.info.append(f"✅ Roles file exists: {roles_path}")
+        
+        # Check log directory
+        log_dir = config.get("logging.log_dir")
+        if log_dir:
+            log_path = config_dir / log_dir
+            if not log_path.exists():
+                self.warnings.append(f"Log directory not found: {log_path}")
+            else:
+                self.info.append(f"✅ Log directory exists: {log_path}")
+    
+    def _check_port_availability(self, config: Config) -> None:
+        """Check if the configured port is available."""
+        import socket
+        
+        port = config.get("server.port")
+        if not port:
+            return
+        
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.bind(('localhost', port))
+                self.info.append(f"✅ Port {port} is available")
+        except OSError:
+            self.warnings.append(f"Port {port} is already in use")
+    
+    def _print_results(self) -> None:
+        """Print check results."""
+        if self.info:
+            print("\n📋 Information:")
+            for info in self.info:
+                print(f"  {info}")
+        
+        if self.warnings:
+            print("\n⚠️ Warnings:")
+            for warning in self.warnings:
+                print(f"  {warning}")
+        
+        if self.errors:
+            print("\n❌ Errors:")
+            for error in self.errors:
+                print(f"  {error}")
+        
+        print(f"\n📊 Summary:")
+        print(f"  Information: {len(self.info)}")
+        print(f"  Warnings: {len(self.warnings)}")
+        print(f"  Errors: {len(self.errors)}")
+        
+        if self.errors:
+            print(f"  Status: ❌ FAILED")
+        elif self.warnings:
+            print(f"  Status: ⚠️ WARNINGS")
+        else:
+            print(f"  Status: ✅ PASSED")
+
+
+def check_all_configs(config_dir: str = "./configs") -> None:
+    """Check all configuration files in a directory."""
+    config_dir_path = Path(config_dir)
+    
+    if not config_dir_path.exists():
+        print(f"❌ Configuration directory not found: {config_dir}")
+        return
+    
+    config_files = list(config_dir_path.glob("*.json"))
+    
+    if not config_files:
+        print(f"❌ No JSON configuration files found in: {config_dir}")
+        return
+    
+    print(f"🔍 Checking {len(config_files)} configuration files in {config_dir}")
+    print("=" * 80)
+    
+    checker = ConfigChecker()
+    total_checked = 0
+    total_passed = 0
+    
+    for config_file in sorted(config_files):
+        if checker.check_config_file(str(config_file)):
+            total_passed += 1
+        total_checked += 1
+        print("\n" + "-" * 80 + "\n")
+    
+    print(f"📊 Final Summary:")
+    print(f"  Total files checked: {total_checked}")
+    print(f"  Passed: {total_passed}")
+    print(f"  Failed: {total_checked - total_passed}")
+    print(f"  Success rate: {(total_passed / total_checked * 100):.1f}%")
+
+
+def validate_config_syntax(config_path: str) -> bool:
+    """Validate configuration syntax only."""
+    try:
+        with open(config_path, 'r', encoding='utf-8') as f:
+            json.load(f)
+        print(f"✅ Configuration syntax is valid: {config_path}")
+        return True
+    except json.JSONDecodeError as e:
+        print(f"❌ Invalid JSON syntax: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ Error reading file: {e}")
+        return False
+
+
+def compare_configs(config1_path: str, config2_path: str) -> None:
+    """Compare two configuration files."""
+    print(f"🔍 Comparing configurations:")
+    print(f"  Config 1: {config1_path}")
+    print(f"  Config 2: {config2_path}")
+    print("=" * 60)
+    
+    try:
+        with open(config1_path, 'r') as f:
+            config1 = json.load(f)
+        with open(config2_path, 'r') as f:
+            config2 = json.load(f)
+    except Exception as e:
+        print(f"❌ Error loading configurations: {e}")
+        return
+    
+    # Compare key sections
+    sections_to_compare = ["server", "security", "logging", "transport"]
+    
+    for section in sections_to_compare:
+        print(f"\n📋 Section: {section}")
+        
+        if section not in config1 and section not in config2:
+            print("  Both configs missing this section")
+            continue
+        elif section not in config1:
+            print(f"  ❌ Missing in {config1_path}")
+            continue
+        elif section not in config2:
+            print(f"  ❌ Missing in {config2_path}")
+            continue
+        
+        if config1[section] == config2[section]:
+            print("  ✅ Identical")
+        else:
+            print("  ⚠️ Different")
+            # Show differences for key fields
+            if section == "server":
+                for key in ["protocol", "host", "port"]:
+                    val1 = config1[section].get(key)
+                    val2 = config2[section].get(key)
+                    if val1 != val2:
+                        print(f"    {key}: {val1} vs {val2}")
+
+
+def main():
+    """Main CLI function."""
+    parser = argparse.ArgumentParser(
+        description="MCP Proxy Adapter Configuration Checker",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Check a single configuration file
+  python check_config.py configs/http.json
+  
+  # Check all configurations in a directory
+  python check_config.py --all
+  
+  # Validate JSON syntax only
+  python check_config.py --syntax configs/http.json
+  
+  # Compare two configurations
+  python check_config.py --compare configs/http.json configs/https.json
+        """
+    )
+    
+    parser.add_argument(
+        "config_file",
+        nargs="?",
+        help="Configuration file to check"
+    )
+    
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Check all configuration files in ./configs directory"
+    )
+    
+    parser.add_argument(
+        "--syntax",
+        action="store_true",
+        help="Validate JSON syntax only"
+    )
+    
+    parser.add_argument(
+        "--compare",
+        nargs=2,
+        metavar=("CONFIG1", "CONFIG2"),
+        help="Compare two configuration files"
+    )
+    
+    parser.add_argument(
+        "--config-dir",
+        default="./configs",
+        help="Configuration directory (default: ./configs)"
+    )
+    
+    args = parser.parse_args()
+    
+    if args.compare:
+        compare_configs(args.compare[0], args.compare[1])
+    elif args.all:
+        check_all_configs(args.config_dir)
+    elif args.config_file:
+        if args.syntax:
+            validate_config_syntax(args.config_file)
+        else:
+            checker = ConfigChecker()
+            checker.check_config_file(args.config_file)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

mcp_proxy_adapter/examples/generate_config.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+"""
+Configuration Generator CLI for MCP Proxy Adapter
+Generates configurations based on command line flags.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# Add the examples directory to the path to import config_builder
+sys.path.insert(0, str(Path(__file__).parent / "mcp_proxy_adapter" / "examples"))
+
+from config_builder import ConfigBuilder, ConfigFactory, Protocol, AuthMethod
+
+
+def create_config_from_flags(
+    protocol: str,
+    token: bool = False,
+    roles: bool = False,
+    host: str = "127.0.0.1",
+    port: int = 8000,
+    cert_dir: str = "./certs",
+    key_dir: str = "./keys",
+    output_dir: str = "./configs"
+) -> Dict[str, Any]:
+    """
+    Create configuration based on command line flags.
+    
+    Args:
+        protocol: Protocol type (http, https, mtls)
+        token: Enable token authentication
+        roles: Enable role-based access control
+        host: Server host
+        port: Server port
+        cert_dir: Certificate directory
+        key_dir: Key directory
+        output_dir: Output directory for configs
+        
+    Returns:
+        Configuration dictionary
+    """
+    # Use the simplified config builder
+    from config_builder import create_config_from_flags as simple_create_config
+    
+    return simple_create_config(protocol, token, roles, port)
+
+
+def save_config(config: Dict[str, Any], filename: str, output_dir: str) -> Path:
+    """Save configuration to file."""
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+    
+    config_file = output_path / f"{filename}.json"
+    with open(config_file, 'w', encoding='utf-8') as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+    
+    return config_file
+
+
+def create_full_config_with_all_options(host: str = "127.0.0.1", port: int = 20000) -> Dict[str, Any]:
+    """
+    Create a full configuration with all options enabled but set to HTTP base.
+    This allows testing all features by enabling different sections.
+    
+    Args:
+        host: Server host
+        port: Server port
+        
+    Returns:
+        Full configuration dictionary with all options
+    """
+    builder = ConfigBuilder()
+    
+    # Set server configuration
+    builder.set_server(host=host, port=port)
+    
+    # Set to HTTP base (no SSL by default)
+    builder.set_protocol(Protocol.HTTP)
+    
+    # Enable all authentication options but keep them disabled by default
+    api_keys = {
+        "admin": "admin-secret-key",
+        "user": "user-secret-key", 
+        "readonly": "readonly-secret-key"
+    }
+    roles = {
+        "admin": ["read", "write", "delete", "admin"],
+        "user": ["read", "write"],
+        "readonly": ["read"]
+    }
+    
+    # Set up all authentication methods but keep security disabled
+    builder.set_auth(AuthMethod.TOKEN_ROLES, api_keys=api_keys, roles=roles)
+    
+    # Disable security by default (will be enabled in tests)
+    config = builder.build()
+    config["security"]["enabled"] = False
+    
+    # Add protocol variants for easy switching
+    config["protocol_variants"] = {
+        "http": {"server": {"protocol": "http"}},
+        "https": {"server": {"protocol": "https"}},
+        "mtls": {"server": {"protocol": "mtls"}}
+    }
+    
+    # Add authentication configurations for easy switching
+    config["auth_variants"] = {
+        "none": {"security": {"enabled": False}},
+        "token": {
+            "security": {
+                "enabled": True,
+                "tokens": api_keys,
+                "roles": roles,
+                "roles_file": None
+            }
+        },
+        "token_roles": {
+            "security": {
+                "enabled": True,
+                "tokens": api_keys,
+                "roles": roles,
+                "roles_file": "configs/roles.json"
+            }
+        }
+    }
+    
+    return config
+
+
+def generate_all_configs(output_dir: str = "./configs", host: str = "127.0.0.1") -> None:
+    """Generate all standard configurations."""
+    configs = [
+        # HTTP configurations
+        ("http", False, False, 20000),
+        ("http", True, True, 20001),  # token=True always includes roles
+        ("http", True, True, 20002),  # token_roles is same as token now
+        
+        # HTTPS configurations
+        ("https", False, False, 20003),
+        ("https", True, True, 20004),  # token=True always includes roles
+        ("https", True, True, 20005),  # token_roles is same as token now
+        
+        # mTLS configurations
+        ("mtls", False, False, 20006),
+        ("mtls", True, True, 20007),  # token=True always includes roles
+        ("mtls", True, True, 20008),  # token_roles is same as token now
+    ]
+    
+    print("🔧 Generating MCP Proxy Adapter configurations...")
+    print("=" * 60)
+    
+    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)
+        
+        # Generate configuration
+        config = create_config_from_flags(
+            protocol=protocol,
+            token=token,
+            roles=roles,
+            host=host,
+            port=port,
+            output_dir=output_dir
+        )
+        
+        # Save configuration
+        config_file = save_config(config, config_name, output_dir)
+        generated_files.append(config_file)
+        
+        print(f"✅ Created {config_name}.json (port {port})")
+    
+    # Create roles.json file if any role-based configs were generated
+    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")
+    
+    print(f"\n🎉 Generated {len(generated_files)} configurations in {output_dir}/")
+    print("\n📋 Generated configurations:")
+    for config_file in generated_files:
+        print(f"  - {config_file.name}")
+
+
+def main():
+    """Main CLI function."""
+    parser = argparse.ArgumentParser(
+        description="MCP Proxy Adapter Configuration Generator",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Generate all standard configurations
+  python generate_config.py --all
+  
+  # Generate full config with all options (HTTP base)
+  python generate_config.py --full-config
+  
+  # Generate specific configuration
+  python generate_config.py --protocol https --token --roles --port 8080
+  
+  # Generate HTTP configuration with token auth
+  python generate_config.py --protocol http --token
+  
+  # Generate mTLS configuration with roles
+  python generate_config.py --protocol mtls --roles
+        """
+    )
+    
+    # Configuration options
+    parser.add_argument("--protocol", choices=["http", "https", "mtls"], 
+                       help="Protocol type (http, https, mtls)")
+    parser.add_argument("--token", action="store_true", 
+                       help="Enable token authentication")
+    parser.add_argument("--roles", action="store_true", 
+                       help="Enable role-based access control")
+    parser.add_argument("--all", action="store_true", 
+                       help="Generate all standard configurations")
+    parser.add_argument("--full-config", action="store_true", 
+                       help="Generate full config with all options (HTTP base)")
+    
+    # Server configuration
+    parser.add_argument("--host", default="127.0.0.1", 
+                       help="Server host (default: 127.0.0.1)")
+    parser.add_argument("--port", type=int, default=8000, 
+                       help="Server port (default: 8000)")
+    
+    # Paths
+    parser.add_argument("--cert-dir", default="./certs", 
+                       help="Certificate directory (default: ./certs)")
+    parser.add_argument("--key-dir", default="./keys", 
+                       help="Key directory (default: ./keys)")
+    parser.add_argument("--output-dir", default="./configs", 
+                       help="Output directory (default: ./configs)")
+    
+    # Output options
+    parser.add_argument("--output", "-o", 
+                       help="Output filename (without extension)")
+    parser.add_argument("--stdout", action="store_true", 
+                       help="Output to stdout instead of file")
+    
+    args = parser.parse_args()
+    
+    try:
+        if args.all:
+            # Generate all configurations
+            generate_all_configs(
+                output_dir=args.output_dir,
+                host=args.host
+            )
+        elif args.full_config:
+            # Generate full config with all options
+            config = create_full_config_with_all_options(
+                host=args.host,
+                port=args.port
+            )
+            
+            if args.stdout:
+                # Output to stdout
+                print(json.dumps(config, indent=2, ensure_ascii=False))
+            else:
+                # Save to file
+                filename = args.output or "full_config"
+                config_file = save_config(config, filename, args.output_dir)
+                print(f"✅ Full configuration saved to: {config_file}")
+        elif args.protocol:
+            # Generate specific configuration
+            config = create_config_from_flags(
+                protocol=args.protocol,
+                token=args.token,
+                roles=args.roles,
+                host=args.host,
+                port=args.port,
+                cert_dir=args.cert_dir,
+                key_dir=args.key_dir,
+                output_dir=args.output_dir
+            )
+            
+            if args.stdout:
+                # Output to stdout
+                print(json.dumps(config, indent=2, ensure_ascii=False))
+            else:
+                # Save to file
+                if args.output:
+                    filename = args.output
+                else:
+                    # Generate filename from flags
+                    name_parts = [args.protocol]
+                    if args.token:
+                        name_parts.append("token")
+                    if args.roles:
+                        name_parts.append("roles")
+                    filename = "_".join(name_parts)
+                
+                config_file = save_config(config, filename, args.output_dir)
+                print(f"✅ Configuration saved to: {config_file}")
+        else:
+            parser.print_help()
+            return 1
+        
+        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/test_chk_hostname_automated.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""
+Automated tests for chk_hostname functionality in all SSL modes.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+import tempfile
+import os
+from pathlib import Path
+import sys
+
+# Add the project root to the path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_proxy_adapter.config import Config
+from mcp_proxy_adapter.examples.config_builder import ConfigBuilder, Protocol, AuthMethod
+
+
+def test_chk_hostname_default_config():
+    """Test that default config has chk_hostname=False for HTTP."""
+    print("🧪 Testing default config chk_hostname...")
+    
+    config = Config()
+    
+    # Default should be HTTP with chk_hostname=False
+    assert config.get("server.protocol") == "http"
+    assert config.get("transport.ssl.chk_hostname") is False
+    
+    print("✅ Default config: chk_hostname=False for HTTP")
+
+
+def test_chk_hostname_http_config():
+    """Test that HTTP config has chk_hostname=False."""
+    print("🧪 Testing HTTP config chk_hostname...")
+    
+    # Create HTTP config
+    http_config = ConfigBuilder().set_protocol(Protocol.HTTP).build()
+    
+    # Save to temporary file and load with Config
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        json.dump(http_config, f)
+        temp_config_path = f.name
+    
+    try:
+        config = Config(temp_config_path)
+        
+        # HTTP should have chk_hostname=False
+        assert config.get("server.protocol") == "http"
+        assert config.get("transport.ssl.chk_hostname") is False
+        
+        print("✅ HTTP config: chk_hostname=False")
+    finally:
+        os.unlink(temp_config_path)
+
+
+def test_chk_hostname_https_config():
+    """Test that HTTPS config has chk_hostname=True."""
+    print("🧪 Testing HTTPS config chk_hostname...")
+    
+    # Create HTTPS config
+    https_config = ConfigBuilder().set_protocol(Protocol.HTTPS).build()
+    
+    # Save to temporary file and load with Config
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        json.dump(https_config, f)
+        temp_config_path = f.name
+    
+    try:
+        config = Config(temp_config_path)
+        
+        
+        # HTTPS should have chk_hostname=True
+        assert config.get("server.protocol") == "https"
+        assert config.get("transport.ssl.chk_hostname") is True
+        
+        print("✅ HTTPS config: chk_hostname=True")
+    finally:
+        os.unlink(temp_config_path)
+
+
+def test_chk_hostname_mtls_config():
+    """Test that mTLS config has chk_hostname=True."""
+    print("🧪 Testing mTLS config chk_hostname...")
+    
+    # Create mTLS config
+    mtls_config = ConfigBuilder().set_protocol(Protocol.MTLS).build()
+    
+    # Save to temporary file and load with Config
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        json.dump(mtls_config, f)
+        temp_config_path = f.name
+    
+    try:
+        config = Config(temp_config_path)
+        
+        # mTLS should have chk_hostname=True
+        assert config.get("server.protocol") == "mtls"
+        assert config.get("transport.ssl.chk_hostname") is True
+        
+        print("✅ mTLS config: chk_hostname=True")
+    finally:
+        os.unlink(temp_config_path)
+
+
+def test_chk_hostname_override():
+    """Test that chk_hostname can be overridden in config."""
+    print("🧪 Testing chk_hostname override...")
+    
+    # Create HTTPS config with chk_hostname=False override
+    https_config = ConfigBuilder().set_protocol(Protocol.HTTPS).build()
+    # Add transport section if it doesn't exist
+    if "transport" not in https_config:
+        https_config["transport"] = {}
+    if "ssl" not in https_config["transport"]:
+        https_config["transport"]["ssl"] = {}
+    https_config["transport"]["ssl"]["chk_hostname"] = False
+    https_config["transport"]["ssl"]["_chk_hostname_user_set"] = True
+    
+    # Save to temporary file and load with Config
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        json.dump(https_config, f)
+        temp_config_path = f.name
+    
+    try:
+        config = Config(temp_config_path)
+        
+        
+        # Should respect the override
+        assert config.get("server.protocol") == "https"
+        assert config.get("transport.ssl.chk_hostname") is False
+        
+        print("✅ HTTPS config with chk_hostname=False override works")
+    finally:
+        os.unlink(temp_config_path)
+
+
+def test_chk_hostname_all_combinations():
+    """Test chk_hostname for all protocol and auth combinations."""
+    print("🧪 Testing chk_hostname for all combinations...")
+    
+    protocols = [Protocol.HTTP, Protocol.HTTPS, Protocol.MTLS]
+    auth_methods = [AuthMethod.NONE, AuthMethod.TOKEN, AuthMethod.TOKEN_ROLES]
+    
+    for protocol in protocols:
+        for auth_method in auth_methods:
+            # Create config
+            config_data = (ConfigBuilder()
+                          .set_protocol(protocol)
+                          .set_auth(auth_method)
+                          .build())
+            
+            # Save to temporary file and load with Config
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+                json.dump(config_data, f)
+                temp_config_path = f.name
+            
+            try:
+                config = Config(temp_config_path)
+                
+                protocol_name = protocol.value
+                auth_name = auth_method.value
+                
+                # Check chk_hostname based on protocol
+                if protocol_name == "http":
+                    expected_chk_hostname = False
+                else:  # https or mtls
+                    expected_chk_hostname = True
+                
+                actual_chk_hostname = config.get("transport.ssl.chk_hostname")
+                
+                assert actual_chk_hostname == expected_chk_hostname, (
+                    f"Protocol {protocol_name} with auth {auth_name}: "
+                    f"expected chk_hostname={expected_chk_hostname}, "
+                    f"got {actual_chk_hostname}"
+                )
+                
+                print(f"✅ {protocol_name}+{auth_name}: chk_hostname={actual_chk_hostname}")
+                
+            finally:
+                os.unlink(temp_config_path)
+    
+    print("✅ All protocol+auth combinations have correct chk_hostname values")
+
+
+def main():
+    """Run all chk_hostname tests."""
+    print("🧪 Running Automated chk_hostname Tests")
+    print("=" * 50)
+    
+    try:
+        test_chk_hostname_default_config()
+        test_chk_hostname_http_config()
+        test_chk_hostname_https_config()
+        test_chk_hostname_mtls_config()
+        test_chk_hostname_override()
+        test_chk_hostname_all_combinations()
+        
+        print("=" * 50)
+        print("🎉 All chk_hostname tests passed!")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

mcp_proxy_adapter/version.py

@@ -2,4 +2,4 @@
 Version information for MCP Proxy Adapter.
 """
 
-__version__ = "6.6.0"
+__version__ = "6.6.1"

{mcp_proxy_adapter-6.6.0.dist-info → mcp_proxy_adapter-6.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.6.0
+Version: 6.6.1
 Summary: Powerful JSON-RPC microservices framework with built-in security, authentication, and proxy registration
 Home-page: https://github.com/maverikod/mcp-proxy-adapter
 Author: Vasiliy Zdanovskiy

{mcp_proxy_adapter-6.6.0.dist-info → mcp_proxy_adapter-6.6.1.dist-info}/RECORD

@@ -4,7 +4,7 @@ mcp_proxy_adapter/config.py,sha256=NmwYJPfnAFWmGsOlyYkMDfuqA-SeduuvTSjZKJbzbKc,2
 mcp_proxy_adapter/custom_openapi.py,sha256=XRviX-C-ZkSKdBhORhDTdeN_1FWyEfXZADiASft3t9I,28149
 mcp_proxy_adapter/main.py,sha256=I9fYgMD8_RNYuSHn-paeTSr9coAuVlEkfLaWeYbZors,5724
 mcp_proxy_adapter/openapi.py,sha256=2UZOI09ZDRJuBYBjKbMyb2U4uASszoCMD5o_4ktRpvg,13480
-mcp_proxy_adapter/version.py,sha256=3wn4ixEY89A5pJaACrT6Pg-UKLFQTHKOi6F0jL-TyDo,74
+mcp_proxy_adapter/version.py,sha256=Mh_TTmFK-EgbYu8AwRu8Ax1MTsScWluXVsIKkST5imU,74
 mcp_proxy_adapter/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_proxy_adapter/api/app.py,sha256=cxjavhNTtaYg2ea-UeHSDnKh8edKVNQ2NbXUDYbufFU,34183
 mcp_proxy_adapter/api/handlers.py,sha256=X-hcMNVeTAu4yVkKJEChEsj2bFptUS6sLNN-Wysjkow,10011
@@ -85,6 +85,7 @@ mcp_proxy_adapter/core/utils.py,sha256=wBdDYBDWQ6zbwrnl9tykHjo0FjJVsLT_x8Bjk1lZX
 mcp_proxy_adapter/examples/__init__.py,sha256=k1F-EotAFbJ3JvK_rNgiH4bUztmxIWtYn0AfbAZ1ZGs,450
 mcp_proxy_adapter/examples/bugfix_certificate_config.py,sha256=YGBE_SI6wYZUJLWl7-fP1OWXiSH4mHJAZHApgQWvG7s,10529
 mcp_proxy_adapter/examples/cert_manager_bugfix.py,sha256=UWUwItjqHqSnOMHocsz40_3deoZE8-vdROLW9y2fEns,7259
+mcp_proxy_adapter/examples/check_config.py,sha256=W6gS6stP-WfE71YmIemvbmolf04FiR7mvJYSJqDFdzQ,14090
 mcp_proxy_adapter/examples/config_builder.py,sha256=kd3-donlGuDgZwJYsy_rjzrydBg_A1GaaJuJ8jj4VDc,9696
 mcp_proxy_adapter/examples/config_builder_simple.py,sha256=qTG3tIIu8eUW8gb06snaWHOTp0BFRRim38VqKrP2Ezo,9109
 mcp_proxy_adapter/examples/config_cli.py,sha256=ZhVG6XEpTFe5-MzELByVsUh0AD4bHPBZeoXnGWbqifs,11059
@@ -98,6 +99,7 @@ mcp_proxy_adapter/examples/generate_certificates_cli.py,sha256=jb5bdNhoODL6qTWBd
 mcp_proxy_adapter/examples/generate_certificates_fixed.py,sha256=6zJj9xdEuwj-ZO2clMoB7pNj5hW4IgwK-qsLPzuq8VQ,12566
 mcp_proxy_adapter/examples/generate_certificates_framework.py,sha256=TGLyy4AJNI0w-Dd2FUQyX2sOXt05o_q4zkjoapzG1Wc,15017
 mcp_proxy_adapter/examples/generate_certificates_openssl.py,sha256=5V4B8Ys_-FZsDh-CH7BNf1XXkMtpidkm4iecY0XCFuE,16891
+mcp_proxy_adapter/examples/generate_config.py,sha256=4WcyCMuQKqr5qtGekoqy-jrQ-71F-ZYdDYftwLrjJNg,11461
 mcp_proxy_adapter/examples/proxy_registration_example.py,sha256=vemRhftnjbiOBCJkmtDGqlWQ8syTG0a8755GCOnaQsg,12503
 mcp_proxy_adapter/examples/required_certificates.py,sha256=YW9-V78oFiZ-FmHlGP-8FQFS569VdDVyq9hfvCv31pk,7133
 mcp_proxy_adapter/examples/run_example.py,sha256=yp-a6HIrSk3ddQmbn0KkuKwErId0aNfj028TE6U-zmY,2626
@@ -107,6 +109,7 @@ mcp_proxy_adapter/examples/run_security_tests_fixed.py,sha256=aIf57LcAlNUEoroRue
 mcp_proxy_adapter/examples/security_test_client.py,sha256=HL0AhmmHZ9SHlUx6aJ32jTHJonjKmGil74ifLbsGkZA,48660
 mcp_proxy_adapter/examples/setup_test_environment.py,sha256=JkMqLpH5ZmkNKE7-WT52_kYMxEKLFOyQWbtip29TeiU,51629
 mcp_proxy_adapter/examples/simple_protocol_test.py,sha256=BzFUZvK9Fih3aG4IFLQTZPyPe_s6YjpZfB6uZmQ76rw,3969
+mcp_proxy_adapter/examples/test_chk_hostname_automated.py,sha256=9n3V2rk3WdC9yPj40o_3MyRlVRM6jGBBgpyJ5PL2Fd8,7178
 mcp_proxy_adapter/examples/test_config.py,sha256=ekEoUZe9q484vU_0IxOVhQdNMVJXG3IpmQpP--VmuDI,6491
 mcp_proxy_adapter/examples/test_config_builder.py,sha256=SAcWIC54vzO0mrb1L9xZKK2IhNkZuSx7_cMEkC1Lm60,21607
 mcp_proxy_adapter/examples/test_examples.py,sha256=CYlVatdHUVC_rwv4NsvxFG3GXiKIyxPDUH43BOJHjrU,12330
@@ -131,8 +134,8 @@ mcp_proxy_adapter/schemas/base_schema.json,sha256=v9G9cGMd4dRhCZsOQ_FMqOi5VFyVbI
 mcp_proxy_adapter/schemas/openapi_schema.json,sha256=C3yLkwmDsvnLW9B5gnKKdBGl4zxkeU-rEmjTrNVsQU0,8405
 mcp_proxy_adapter/schemas/roles.json,sha256=pgf_ZyqKyXbfGUxvobpiLiSJz9zzxrMuoVWEkEpz3N8,764
 mcp_proxy_adapter/schemas/roles_schema.json,sha256=deHgI7L6GwfBXacOlNtDgDJelDThppClC3Ti4Eh8rJY,5659
-mcp_proxy_adapter-6.6.0.dist-info/METADATA,sha256=WSvtaCv_mkqE20kqYWmmJSt_UkCUqmKi4w7vVSLweeo,8510
-mcp_proxy_adapter-6.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_proxy_adapter-6.6.0.dist-info/entry_points.txt,sha256=Bf-O5Aq80n22Ayu9fI9BgidzWqwzIVaqextAddTuHZw,563
-mcp_proxy_adapter-6.6.0.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
-mcp_proxy_adapter-6.6.0.dist-info/RECORD,,
+mcp_proxy_adapter-6.6.1.dist-info/METADATA,sha256=b7eTkQKOdUxqilzA8AMTgJRr3f6SrnBwrhgRmAzML04,8510
+mcp_proxy_adapter-6.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_proxy_adapter-6.6.1.dist-info/entry_points.txt,sha256=Bf-O5Aq80n22Ayu9fI9BgidzWqwzIVaqextAddTuHZw,563
+mcp_proxy_adapter-6.6.1.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
+mcp_proxy_adapter-6.6.1.dist-info/RECORD,,