mcp-proxy-adapter 4.1.1__py3-none-any.whl → 6.0.1__py3-none-any.whl

mcp_proxy_adapter/examples/setup_test_environment.py

@@ -0,0 +1,328 @@
+#!/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.
+
+This script accepts an output directory and copies required example files
+and helper scripts into that directory, creating a ready-to-use workspace.
+By default, the current working directory is used, so end-users can run
+it in their project root after installing this framework in a virtual
+environment.
+"""
+import shutil
+import sys
+import argparse
+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,
+    )
+    SECURITY_FRAMEWORK_AVAILABLE = True
+except ImportError:
+    SECURITY_FRAMEWORK_AVAILABLE = False
+    print("Warning: mcp_security_framework not available")
+
+
+def _get_package_paths() -> tuple[Path, Path]:
+    """
+    Resolve source paths for examples and utils relative to this file
+    to avoid importing the package during setup.
+    """
+    pkg_root = Path(__file__).resolve().parents[1]
+    return pkg_root / "examples", pkg_root / "utils"
+
+
+def setup_test_environment(output_dir: Path) -> None:
+    """
+    Setup test environment under output_dir with required files
+    and directories.
+
+    All created directories and copied files are rooted at output_dir
+    so users can run scripts relative to that directory.
+    """
+    print("🔧 Setting up test environment...")
+    output_dir = output_dir.resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+    # Create test environment directory structure
+    directories = [
+        "examples/basic_framework",
+        "examples/full_application",
+        "scripts",
+        "configs",
+        "certs",
+        "keys",
+        "tokens",
+        "logs"
+    ]
+    for directory in directories:
+        target_dir = output_dir / directory
+        target_dir.mkdir(parents=True, exist_ok=True)
+        print(f"✅ Created directory: {target_dir}")
+    # Resolve package paths
+    examples_src_root, utils_src_root = _get_package_paths()
+    # Copy example files
+    basic_framework_src = examples_src_root / "basic_framework"
+    if basic_framework_src.exists():
+        shutil.copytree(
+            basic_framework_src,
+            output_dir / "examples/basic_framework",
+            dirs_exist_ok=True,
+        )
+        print("✅ Copied basic_framework examples")
+    full_application_src = examples_src_root / "full_application"
+    if full_application_src.exists():
+        shutil.copytree(
+            full_application_src,
+            output_dir / "examples/full_application",
+            dirs_exist_ok=True,
+        )
+        print("✅ Copied full_application examples")
+    # Copy utility scripts
+    config_generator_src = utils_src_root / "config_generator.py"
+    if config_generator_src.exists():
+        shutil.copy2(config_generator_src, output_dir / "scripts/")
+        print("✅ Copied config_generator.py")
+    # Copy certificate generation scripts
+    create_certs_src = examples_src_root / "create_certificates_simple.py"
+    if create_certs_src.exists():
+        shutil.copy2(create_certs_src, output_dir / "scripts/")
+        print("✅ Copied create_certificates_simple.py")
+    cert_tokens_src = examples_src_root / "generate_certificates_and_tokens.py"
+    if cert_tokens_src.exists():
+        shutil.copy2(cert_tokens_src, output_dir / "scripts/")
+        print("✅ Copied generate_certificates_and_tokens.py")
+
+    # Copy roles.json to the root directory for compatibility
+    roles_src = examples_src_root / "roles.json"
+    if roles_src.exists():
+        shutil.copy2(roles_src, output_dir)
+        print("✅ Copied roles.json to root directory")
+
+    # Also copy from configs directory if it exists
+    roles_configs_src = output_dir / "configs" / "roles.json"
+    if roles_configs_src.exists():
+        shutil.copy2(roles_configs_src, output_dir / "roles.json")
+        print("✅ Updated roles.json from configs directory")
+    print(
+        "🎉 Test environment setup completed successfully at: {}".format(
+            output_dir
+        )
+    )
+
+
+def generate_certificates_with_framework(output_dir: Path) -> bool:
+    """
+    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=str((output_dir / "certs").resolve()),
+            key_storage_path=str((output_dir / "keys").resolve()),
+            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,  # Use validity_years instead of 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(
+                "❌ 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",
+            ],
+            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(
+                "❌ 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(
+                    (
+                        "❌ Failed to create client certificate {}: "
+                        "Invalid certificate pair"
+                    ).format(client_name)
+                )
+                return False
+            print(
+                "✅ Client certificate {} created successfully".format(
+                    client_name
+                )
+            )
+        print(
+            "🎉 All certificates generated successfully using "
+            "mcp_security_framework!"
+        )
+        return True
+    except Exception as e:
+        print("❌ Error generating certificates with framework: {}".format(e))
+        print("\n🔧 TROUBLESHOOTING:")
+        print("1. Check if mcp_security_framework is installed:")
+        print("   pip install mcp_security_framework")
+        print("\n2. Verify write permissions in output directory")
+        print("\n3. Check if certs/ and keys/ directories exist")
+        return False
+
+
+def main() -> int:
+    """Main function for command line execution."""
+    parser = argparse.ArgumentParser(
+        description="Setup test environment for MCP Proxy Adapter"
+    )
+    parser.add_argument(
+        "--output-dir",
+        "-o",
+        type=str,
+        default=".",
+        help=(
+            "Target directory to create the test environment "
+            "(default: current directory)"
+        ),
+    )
+    args = parser.parse_args()
+    try:
+        target_root = Path(args.output_dir)
+        setup_test_environment(target_root)
+        # Generate certificates if framework is available
+        if SECURITY_FRAMEWORK_AVAILABLE:
+            generate_certificates_with_framework(target_root)
+        else:
+            print(
+                "⚠️ Skipping certificate generation (mcp_security_framework "
+                "not available)"
+            )
+    except Exception as e:
+        print(
+            "❌ Error setting up test environment: {}".format(e),
+            file=sys.stderr,
+        )
+        print("\n🔧 TROUBLESHOOTING:")
+        print("1. Check if output directory is writable")
+        print("2. Verify mcp_security_framework installation")
+        print("3. Check available disk space")
+        return 1
+    
+    print("\n" + "=" * 60)
+    print("✅ TEST ENVIRONMENT SETUP COMPLETED SUCCESSFULLY")
+    print("=" * 60)
+    print("\n📋 NEXT STEPS:")
+    print("1. Generate test configurations:")
+    print("   python -m mcp_proxy_adapter.examples.generate_test_configs --output-dir configs")
+    print("\n2. Generate additional certificates (if needed):")
+    print("   python -m mcp_proxy_adapter.examples.generate_certificates")
+    print("\n3. Run security tests:")
+    print("   python -m mcp_proxy_adapter.examples.run_security_tests")
+    print("\n4. Start basic framework example:")
+    print("   python -m mcp_proxy_adapter.examples.basic_framework.main --config configs/https_simple.json")
+    print("=" * 60)
+    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()