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

mcp_proxy_adapter/examples/setup_test_environment.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+Script for setting up test environment for MCP Proxy Adapter.
+Prepares the test environment with all necessary files and directories.
+Uses mcp_security_framework for certificate generation.
+"""
+import os
+import shutil
+import sys
+from pathlib import Path
+# Import mcp_security_framework
+try:
+    from mcp_security_framework.core.cert_manager import CertificateManager
+    from mcp_security_framework.schemas.config import CertificateConfig, CAConfig, ServerCertConfig, ClientCertConfig
+    from mcp_security_framework.schemas.models import CertificateType
+    SECURITY_FRAMEWORK_AVAILABLE = True
+except ImportError:
+    SECURITY_FRAMEWORK_AVAILABLE = False
+    print("Warning: mcp_security_framework not available")
+def setup_test_environment():
+    """
+    Setup test environment with all necessary files and directories.
+    """
+    print("🔧 Setting up test environment...")
+    # Create test environment directory structure
+    directories = [
+        "examples/basic_framework",
+        "examples/full_application",
+        "scripts",
+        "configs",
+        "certs",
+        "keys",
+        "tokens",
+        "logs"
+    ]
+    for directory in directories:
+        os.makedirs(directory, exist_ok=True)
+        print(f"✅ Created directory: {directory}")
+    # Copy example files
+    source_examples = "../mcp_proxy_adapter/examples"
+    if os.path.exists(source_examples):
+        # Copy basic framework
+        basic_framework_src = os.path.join(source_examples, "basic_framework")
+        if os.path.exists(basic_framework_src):
+            shutil.copytree(basic_framework_src, "examples/basic_framework", dirs_exist_ok=True)
+            print("✅ Copied basic_framework examples")
+        # Copy full application
+        full_application_src = os.path.join(source_examples, "full_application")
+        if os.path.exists(full_application_src):
+            shutil.copytree(full_application_src, "examples/full_application", dirs_exist_ok=True)
+            print("✅ Copied full_application examples")
+    # Copy utility scripts
+    source_utils = "../mcp_proxy_adapter/utils"
+    if os.path.exists(source_utils):
+        config_generator_src = os.path.join(source_utils, "config_generator.py")
+        if os.path.exists(config_generator_src):
+            shutil.copy2(config_generator_src, "scripts/")
+            print("✅ Copied config_generator.py")
+    # Copy certificate generation script
+    source_examples = "../mcp_proxy_adapter/examples"
+    if os.path.exists(source_examples):
+        cert_script_src = os.path.join(source_examples, "create_certificates_simple.py")
+        if os.path.exists(cert_script_src):
+            shutil.copy2(cert_script_src, "scripts/")
+            print("✅ Copied create_certificates_simple.py")
+        # Copy new certificate generation script
+        cert_tokens_src = os.path.join(source_examples, "generate_certificates_and_tokens.py")
+        if os.path.exists(cert_tokens_src):
+            shutil.copy2(cert_tokens_src, "scripts/")
+            print("✅ Copied generate_certificates_and_tokens.py")
+    print("🎉 Test environment setup completed successfully!")
+def generate_certificates_with_framework():
+    """
+    Generate certificates using mcp_security_framework.
+    """
+    if not SECURITY_FRAMEWORK_AVAILABLE:
+        print("❌ mcp_security_framework not available for certificate generation")
+        return False
+    try:
+        print("🔐 Generating certificates using mcp_security_framework...")
+        # Configure certificate manager
+        cert_config = CertificateConfig(
+            cert_storage_path="./certs",
+            key_storage_path="./keys",
+            default_validity_days=365,
+            key_size=2048,
+            hash_algorithm="sha256"
+        )
+        cert_manager = CertificateManager(cert_config)
+        # Generate CA certificate
+        ca_config = CAConfig(
+            common_name="MCP Proxy Adapter Test CA",
+            organization="Test Organization",
+            organizational_unit="Certificate Authority",
+            country="US",
+            state="Test State",
+            locality="Test City",
+            validity_years=10,  # Используем validity_years вместо validity_days
+            key_size=2048,
+            hash_algorithm="sha256"
+        )
+        cert_pair = cert_manager.create_root_ca(ca_config)
+        if not cert_pair or not cert_pair.certificate_path:
+            print(f"❌ Failed to create CA certificate: Invalid certificate pair")
+            return False
+        print("✅ CA certificate created successfully")
+        # Find CA key file
+        ca_key_path = cert_pair.private_key_path
+        # Generate server certificate
+        server_config = ServerCertConfig(
+            common_name="localhost",
+            organization="Test Organization",
+            organizational_unit="Server",
+            country="US",
+            state="Test State",
+            locality="Test City",
+            validity_days=365,
+            key_size=2048,
+            hash_algorithm="sha256",
+            subject_alt_names=["localhost", "127.0.0.1"],  # Используем subject_alt_names вместо san_dns
+            ca_cert_path=cert_pair.certificate_path,
+            ca_key_path=ca_key_path
+        )
+        cert_pair = cert_manager.create_server_certificate(server_config)
+        if not cert_pair or not cert_pair.certificate_path:
+            print(f"❌ Failed to create server certificate: Invalid certificate pair")
+            return False
+        print("✅ Server certificate created successfully")
+        # Generate client certificates
+        client_configs = [
+            ("admin", ["admin"], ["read", "write", "execute", "delete", "admin", "register", "unregister", "heartbeat", "discover"]),
+            ("user", ["user"], ["read", "execute", "register", "unregister", "heartbeat", "discover"]),
+            ("readonly", ["readonly"], ["read", "discover"]),
+            ("guest", ["guest"], ["read", "discover"]),
+            ("proxy", ["proxy"], ["register", "unregister", "heartbeat", "discover"])
+        ]
+        for client_name, roles, permissions in client_configs:
+            client_config = ClientCertConfig(
+                common_name=f"{client_name}-client",
+                organization="Test Organization",
+                organizational_unit="Client",
+                country="US",
+                state="Test State",
+                locality="Test City",
+                validity_days=730,
+                key_size=2048,
+                hash_algorithm="sha256",
+                roles=roles,
+                permissions=permissions,
+                ca_cert_path=cert_pair.certificate_path,
+                ca_key_path=ca_key_path
+            )
+            cert_pair = cert_manager.create_client_certificate(client_config)
+            if not cert_pair or not cert_pair.certificate_path:
+                print(f"❌ Failed to create client certificate {client_name}: Invalid certificate pair")
+                return False
+            print(f"✅ Client certificate {client_name} created successfully")
+        print("🎉 All certificates generated successfully using mcp_security_framework!")
+        return True
+    except Exception as e:
+        print(f"❌ Error generating certificates with framework: {e}")
+        return False
+def main():
+    """Main function for command line execution."""
+    try:
+        setup_test_environment()
+        # Generate certificates if framework is available
+        if SECURITY_FRAMEWORK_AVAILABLE:
+            generate_certificates_with_framework()
+        else:
+            print("⚠️ Skipping certificate generation (mcp_security_framework not available)")
+    except Exception as e:
+        print(f"❌ Error setting up test environment: {e}", file=sys.stderr)
+        return 1
+    return 0
+if __name__ == "__main__":
+    exit(main())

mcp_proxy_adapter/examples/test_config.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+Script for testing MCP Proxy Adapter configurations.
+Tests a specific configuration by creating an application and validating it.
+Uses mcp_security_framework for security validation.
+"""
+import json
+import os
+import sys
+import argparse
+import time
+import subprocess
+from pathlib import Path
+from typing import Dict, Any, Optional
+# Import mcp_security_framework
+try:
+    from mcp_security_framework import SecurityManager
+    from mcp_security_framework.schemas.config import SecurityConfig
+    SECURITY_FRAMEWORK_AVAILABLE = True
+except ImportError:
+    SECURITY_FRAMEWORK_AVAILABLE = False
+    print("Warning: mcp_security_framework not available")
+# Add parent directory to path to import mcp_proxy_adapter
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../.."))
+def validate_security_config(config: Dict[str, Any]) -> bool:
+    """
+    Validate security configuration using mcp_security_framework.
+    Args:
+        config: Configuration dictionary
+    Returns:
+        True if validation passed, False otherwise
+    """
+    if not SECURITY_FRAMEWORK_AVAILABLE:
+        print("⚠️ Skipping security validation (mcp_security_framework not available)")
+        return True
+    try:
+        security_section = config.get("security", {})
+        if not security_section.get("enabled", False):
+            print("🔓 Security framework disabled in configuration")
+            return True
+        print("🔒 Validating security configuration with mcp_security_framework...")
+        # Create SecurityConfig from configuration
+        security_config = SecurityConfig(
+            auth=security_section.get("auth", {}),
+            ssl=security_section.get("ssl", {}),
+            permissions=security_section.get("permissions", {}),
+            rate_limit=security_section.get("rate_limit", {})
+        )
+        # Create SecurityManager for validation
+        security_manager = SecurityManager(security_config)
+        # Validate configuration
+        validation_result = security_manager.validate_configuration()
+        if validation_result.is_valid:
+            print("✅ Security configuration validation passed")
+            return True
+        else:
+            print("❌ Security configuration validation failed:")
+            for error in validation_result.errors:
+                print(f"  - {error}")
+            return False
+    except Exception as e:
+        print(f"❌ Error validating security configuration: {e}")
+        return False
+def test_configuration(config_path: str, timeout: int = 30) -> bool:
+    """
+    Test a configuration by creating an application and validating it.
+    Args:
+        config_path: Path to configuration file
+        timeout: Timeout in seconds for server startup
+    Returns:
+        True if test passed, False otherwise
+    """
+    print(f"🧪 Testing configuration: {config_path}")
+    print("=" * 60)
+    try:
+        # Load configuration
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        # Import required modules
+        from mcp_proxy_adapter.core.app_factory import create_application
+        from mcp_proxy_adapter.core.app_runner import ApplicationRunner
+        # Create application
+        print("🔧 Creating application...")
+        app = create_application(config)
+        print("✅ Application created successfully")
+        # Create runner and validate configuration
+        print("🔍 Validating configuration...")
+        runner = ApplicationRunner(app, config)
+        errors = runner.validate_configuration()
+        if errors:
+            print("❌ Configuration validation failed:")
+            for error in errors:
+                print(f"  - {error}")
+            return False
+        print("✅ Configuration validation passed")
+        # Validate security configuration
+        if not validate_security_config(config):
+            return False
+        # Test server startup (without actually starting)
+        print("🚀 Testing server startup...")
+        server_config = config.get("server", {})
+        host = server_config.get("host", "127.0.0.1")
+        port = server_config.get("port", 8000)
+        print(f"✅ Server configuration: {host}:{port}")
+        # Test SSL configuration if enabled
+        ssl_config = config.get("ssl", {})
+        if ssl_config.get("enabled", False):
+            print("🔐 SSL configuration:")
+            print(f"  - Certificate: {ssl_config.get('cert_file', 'N/A')}")
+            print(f"  - Key: {ssl_config.get('key_file', 'N/A')}")
+            print(f"  - Client verification: {ssl_config.get('verify_client', False)}")
+        # Test security configuration if enabled
+        security_config = config.get("security", {})
+        if security_config.get("enabled", False):
+            print("🔒 Security configuration:")
+            auth_config = security_config.get("auth", {})
+            if auth_config.get("enabled", False):
+                methods = auth_config.get("methods", [])
+                print(f"  - Authentication methods: {methods}")
+            permissions_config = security_config.get("permissions", {})
+            if permissions_config.get("enabled", False):
+                print(f"  - Roles file: {permissions_config.get('roles_file', 'N/A')}")
+        # Test protocol configuration
+        protocols_config = config.get("protocols", {})
+        if protocols_config.get("enabled", False):
+            allowed_protocols = protocols_config.get("allowed_protocols", [])
+            print(f"🌐 Allowed protocols: {allowed_protocols}")
+        print("=" * 60)
+        print("✅ Configuration test completed successfully!")
+        return True
+    except Exception as e:
+        print(f"❌ Configuration test failed: {e}")
+        return False
+def main():
+    """Main function for command line execution."""
+    parser = argparse.ArgumentParser(description="Test MCP Proxy Adapter configuration")
+    parser.add_argument("--config", "-c", required=True, help="Path to configuration file")
+    parser.add_argument("--timeout", "-t", type=int, default=30, help="Timeout in seconds")
+    args = parser.parse_args()
+    if not os.path.exists(args.config):
+        print(f"❌ Configuration file not found: {args.config}")
+        return 1
+    success = test_configuration(args.config, args.timeout)
+    return 0 if success else 1
+if __name__ == "__main__":
+    exit(main())

mcp_proxy_adapter/examples/test_config_generator.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""
+Test script for configuration generator utility.
+This script tests the configuration generator to ensure it properly generates
+configurations with the new protocols section and fixes for ProtocolMiddleware issues.
+"""
+import sys
+import json
+from pathlib import Path
+# Add the project root to the path
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+from mcp_proxy_adapter.utils.config_generator import ConfigGenerator
+def test_config_generator():
+    """Test the configuration generator with different types."""
+    generator = ConfigGenerator()
+    # Test configuration types
+    config_types = [
+        "basic_http",
+        "http_token",
+        "https",
+        "https_token",
+        "https_no_protocol_middleware",
+        "mtls",
+        "mtls_no_protocol_middleware"
+    ]
+    print("Testing Configuration Generator")
+    print("=" * 50)
+    for config_type in config_types:
+        print(f"\nTesting {config_type} configuration:")
+        print("-" * 30)
+        try:
+            # Generate configuration
+            config = generator._get_config_by_type(config_type)
+            # Check if protocols section exists
+            if "protocols" in config:
+                protocols = config["protocols"]
+                print(f"✅ Protocols section found:")
+                print(f"   - enabled: {protocols.get('enabled', 'NOT SET')}")
+                print(f"   - allowed_protocols: {protocols.get('allowed_protocols', 'NOT SET')}")
+                print(f"   - default_protocol: {protocols.get('default_protocol', 'NOT SET')}")
+            else:
+                print("❌ Protocols section missing!")
+            # Check SSL configuration
+            ssl_enabled = config.get("ssl", {}).get("enabled", False)
+            security_ssl_enabled = config.get("security", {}).get("ssl", {}).get("enabled", False)
+            print(f"   - legacy ssl.enabled: {ssl_enabled}")
+            print(f"   - security.ssl.enabled: {security_ssl_enabled}")
+            # Check if configuration is valid for its type
+            if config_type == "https_no_protocol_middleware" or config_type == "mtls_no_protocol_middleware":
+                if protocols.get("enabled") == False:
+                    print("✅ ProtocolMiddleware correctly disabled")
+                else:
+                    print("❌ ProtocolMiddleware should be disabled but is enabled")
+            else:
+                if protocols.get("enabled") == True:
+                    print("✅ ProtocolMiddleware correctly enabled")
+                else:
+                    print("❌ ProtocolMiddleware should be enabled but is disabled")
+            # Save configuration to file for inspection
+            output_file = f"test_config_{config_type}.json"
+            with open(output_file, 'w') as f:
+                json.dump(config, f, indent=2)
+            print(f"   - Configuration saved to {output_file}")
+        except Exception as e:
+            print(f"❌ Error generating {config_type} configuration: {e}")
+    print("\n" + "=" * 50)
+    print("Configuration generator test completed!")
+def test_config_with_comments():
+    """Test configuration generation with comments."""
+    generator = ConfigGenerator()
+    print("\nTesting configuration with comments:")
+    print("-" * 40)
+    try:
+        # Generate HTTPS configuration with comments
+        commented_config = generator.generate_config_with_comments("https")
+        print("✅ HTTPS configuration with comments generated successfully")
+        # Save to file
+        with open("test_https_with_comments.json", 'w') as f:
+            f.write(commented_config)
+        print("   - Configuration saved to test_https_with_comments.json")
+    except Exception as e:
+        print(f"❌ Error generating configuration with comments: {e}")
+if __name__ == "__main__":
+    test_config_generator()
+    test_config_with_comments()