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

mcp_proxy_adapter/examples/setup_test_environment.py

@@ -2,6 +2,7 @@
 """
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
+
 Enhanced script for setting up test environment for MCP Proxy Adapter.
 Prepares the test environment with all necessary files, directories, and configurations.
 Includes comprehensive documentation and validation for configuration settings.
@@ -19,18 +20,12 @@ Features:
 - Enhanced error handling and troubleshooting
 """
 import os
-import shutil
-import subprocess
 import sys
 import argparse
-import json
 from pathlib import Path
-from typing import Dict, List, Any, Tuple
 
 # Import mcp_security_framework
 try:
-    from mcp_security_framework.core.cert_manager import CertificateManager
-    from mcp_security_framework.schemas.config import (
         CertificateConfig,
         CAConfig,
         ServerCertConfig,
@@ -42,1486 +37,199 @@ except ImportError:
     SECURITY_FRAMEWORK_AVAILABLE = False
     print("Warning: mcp_security_framework not available")
 
-
-class ConfigurationValidator:
-    """
-    Validates MCP Proxy Adapter configurations for mutually exclusive settings
-    and protocol compatibility.
-    """
-
-    def __init__(self):
-        self.errors: List[str] = []
-        self.warnings: List[str] = []
-
-    def validate_config(
-        self, config: Dict[str, Any], config_name: str
-    ) -> Tuple[bool, List[str], List[str]]:
-        """
-        Validate a configuration for mutually exclusive settings and protocol compatibility.
-
-        Args:
-            config: Configuration dictionary to validate
-            config_name: Name of the configuration for error reporting
-
-        Returns:
-            Tuple of (is_valid, errors, warnings)
-        """
-        self.errors = []
-        self.warnings = []
-
-        # Validate protocol settings
-        self._validate_protocol_settings(config, config_name)
-
-        # Validate SSL/TLS settings
-        self._validate_ssl_settings(config, config_name)
-
-        # Validate mTLS settings
-        self._validate_mtls_settings(config, config_name)
-
-        # Validate authentication settings
-        self._validate_auth_settings(config, config_name)
-
-        return len(self.errors) == 0, self.errors, self.warnings
-
-    def _validate_protocol_settings(
-        self, config: Dict[str, Any], config_name: str
-    ) -> None:
-        """Validate protocol configuration settings."""
-        protocols = config.get("protocols", {})
-
-        if not protocols.get("enabled", False):
-            self.warnings.append(
-                f"⚠️ {config_name}: Protocol middleware is disabled - all protocols will be allowed"
-            )
-            return
-
-        allowed_protocols = protocols.get("allowed_protocols", [])
-        if not allowed_protocols:
-            self.errors.append(
-                f"❌ {config_name}: No allowed protocols specified when protocol middleware is enabled"
-            )
-            return
-
-        # Check for invalid protocol combinations
-        if "http" in allowed_protocols and "https" in allowed_protocols:
-            self.warnings.append(
-                f"⚠️ {config_name}: Both HTTP and HTTPS protocols are allowed - consider security implications"
-            )
-
-        if "mtls" in allowed_protocols and "http" in allowed_protocols:
-            self.errors.append(
-                f"❌ {config_name}: mTLS and HTTP protocols are mutually exclusive - mTLS requires HTTPS"
-            )
-
-    def _validate_ssl_settings(self, config: Dict[str, Any], config_name: str) -> None:
-        """Validate SSL/TLS configuration settings."""
-        security = config.get("security", {})
-        ssl = security.get("ssl", {})
-
-        if not ssl.get("enabled", False):
-            return
-
-        # Check certificate file requirements
-        cert_file = ssl.get("server_cert_file")
-        key_file = ssl.get("server_key_file")
-
-        if not cert_file or not key_file:
-            self.errors.append(
-                f"❌ {config_name}: SSL enabled but server certificate or key file not specified"
-            )
-
-        # Check CA certificate requirements
-        ca_cert_file = ssl.get("ca_cert_file")
-        verify_server = ssl.get("verify_server", True)
-
-        if verify_server and not ca_cert_file:
-            self.warnings.append(
-                f"⚠️ {config_name}: Server verification enabled but no CA certificate specified"
-            )
-
-    def _validate_mtls_settings(self, config: Dict[str, Any], config_name: str) -> None:
-        """Validate mTLS configuration settings."""
-        security = config.get("security", {})
-        ssl = security.get("ssl", {})
-
-        if not ssl.get("enabled", False):
-            return
-
-        # Check if mTLS is configured
-        client_cert_file = ssl.get("client_cert_file")
-        client_key_file = ssl.get("client_key_file")
-        verify_client = ssl.get("verify_client", False)
-
-        if verify_client and (not client_cert_file or not client_key_file):
-            self.errors.append(
-                f"❌ {config_name}: Client verification enabled but client certificate or key file not specified"
-            )
-
-        # Check protocol compatibility
-        protocols = config.get("protocols", {})
-        if protocols.get("enabled", False):
-            allowed_protocols = protocols.get("allowed_protocols", [])
-            if verify_client and "mtls" not in allowed_protocols:
-                self.warnings.append(
-                    f"⚠️ {config_name}: Client verification enabled but 'mtls' not in allowed protocols"
-                )
-
-    def _validate_auth_settings(self, config: Dict[str, Any], config_name: str) -> None:
-        """Validate authentication configuration settings."""
-        security = config.get("security", {})
-        auth = security.get("auth", {})
-
-        if not auth.get("enabled", False):
-            return
-
-        # Check token requirements
-        token_required = auth.get("token_required", False)
-        if token_required and not auth.get("token_secret"):
-            self.errors.append(
-                f"❌ {config_name}: Token authentication enabled but no token secret specified"
-            )
+# Import setup modules
+    ConfigurationValidator,
+    create_test_files,
+    create_configuration_documentation,
+    generate_enhanced_configurations,
+    generate_certificates_with_framework,
+    test_proxy_registration,
+    run_full_test_suite,
+    setup_test_environment,
+)
 
 
 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.
-    """
-    # When running from installed package, __file__ points to .venv/lib/python3.x/site-packages/mcp_proxy_adapter/examples/setup_test_environment.py
-    # We need to go up to the package root: .venv/lib/python3.x/site-packages/mcp_proxy_adapter/
-    pkg_root = Path(__file__).resolve().parents[1]
-    examples_path = pkg_root / "examples"
-    utils_path = (
-        pkg_root / "examples" / "scripts"
-    )  # utils scripts are in examples/scripts in the package
-
-    return examples_path, utils_path
-
-
-def create_configuration_documentation(output_dir: Path) -> None:
-    """
-    Create comprehensive documentation for MCP Proxy Adapter configurations.
-    """
-    docs_dir = output_dir / "docs"
-    docs_dir.mkdir(parents=True, exist_ok=True)
-
-    # Create main configuration guide
-    config_guide = docs_dir / "CONFIGURATION_GUIDE.md"
-    with open(config_guide, "w", encoding="utf-8") as f:
-        f.write(
-            """# MCP Proxy Adapter Configuration Guide
-
-## Overview
-
-This guide explains how to configure MCP Proxy Adapter for different deployment scenarios,
-including HTTP, HTTPS, and mTLS configurations.
-
-## Configuration Structure
-
-```json
-{
-  "server": {
-    "host": "0.0.0.0",
-    "port": 8000
-  },
-  "protocols": {
-    "enabled": true,
-    "allowed_protocols": ["https", "mtls"]
-  },
-  "security": {
-    "ssl": {
-      "enabled": true,
-      "server_cert_file": "path/to/server.crt",
-      "server_key_file": "path/to/server.key",
-      "ca_cert_file": "path/to/ca.crt",
-      "client_cert_file": "path/to/client.crt",
-      "client_key_file": "path/to/client.key",
-      "verify_server": true,
-      "verify_client": false,
-      "min_tls_version": "TLSv1.2"
-    },
-    "auth": {
-      "enabled": false,
-      "token_required": false,
-      "token_secret": "your-secret-key"
-    }
-  }
-}
-```
-
-## Protocol Configuration
-
-### Protocol Middleware
-
-The `protocols` section controls which protocols are allowed:
-
-- `enabled: true` - Protocol validation is active
-- `enabled: false` - All protocols are allowed (bypasses validation)
-
-### Allowed Protocols
-
-- `"http"` - Plain HTTP (insecure)
-- `"https"` - HTTPS with server certificate
-- `"mtls"` - Mutual TLS (client and server certificates)
-
-### Protocol Combinations
-
-**Valid combinations:**
-- `["https"]` - HTTPS only
-- `["https", "mtls"]` - HTTPS and mTLS
-- `["http"]` - HTTP only (not recommended for production)
-
-**Invalid combinations:**
-- `["http", "mtls"]` - HTTP and mTLS are mutually exclusive
-- `["http", "https"]` - Mixed HTTP/HTTPS (security risk)
-
-## SSL/TLS Configuration
-
-### Server Certificates
-
-Required for HTTPS and mTLS:
-- `server_cert_file` - Server certificate file
-- `server_key_file` - Server private key file
-
-### CA Certificates
-
-- `ca_cert_file` - CA certificate for server verification
-- `verify_server: true` - Verify server certificate against CA
-- `verify_server: false` - Disable server certificate verification
-
-### Client Certificates (mTLS)
-
-- `client_cert_file` - Client certificate file
-- `client_key_file` - Client private key file
-- `verify_client: true` - Require client certificates
-- `verify_client: false` - No client certificate required
-
-## Authentication
-
-### Token Authentication
-
-- `auth.enabled: true` - Enable authentication
-- `token_required: true` - Require authentication tokens
-- `token_secret` - Secret key for token validation
-
-## Common Configuration Patterns
-
-### 1. Development (HTTP)
-```json
-{
-  "protocols": {"enabled": false},
-  "security": {"ssl": {"enabled": false}}
-}
-```
-
-### 2. Production HTTPS
-```json
-{
-  "protocols": {
-    "enabled": true,
-    "allowed_protocols": ["https"]
-  },
-  "security": {
-    "ssl": {
-      "enabled": true,
-      "server_cert_file": "certs/server.crt",
-      "server_key_file": "keys/server.key",
-      "verify_server": true,
-      "ca_cert_file": "certs/ca.crt"
-    }
-  }
-}
-```
-
-### 3. mTLS with Client Verification
-```json
-{
-  "protocols": {
-    "enabled": true,
-    "allowed_protocols": ["https", "mtls"]
-  },
-  "security": {
-    "ssl": {
-      "enabled": true,
-      "server_cert_file": "certs/server.crt",
-      "server_key_file": "keys/server.key",
-      "ca_cert_file": "certs/ca.crt",
-      "client_cert_file": "certs/client.crt",
-      "client_key_file": "keys/client.key",
-      "verify_server": true,
-      "verify_client": true
-    }
-  }
-}
-```
-
-## Validation Rules
-
-The configuration validator checks for:
-
-1. **Mutually Exclusive Settings:**
-   - HTTP and mTLS protocols
-   - Client verification without client certificates
-   - Server verification without CA certificates
-
-2. **Required Dependencies:**
-   - SSL enabled requires server certificates
-   - mTLS requires both server and client certificates
-   - Protocol middleware enabled requires allowed protocols
-
-3. **Security Warnings:**
-   - HTTP and HTTPS in same configuration
-   - Server verification without CA certificate
-   - Client verification without mTLS protocol
+    Get paths to the package and examples directory.
 
-## Troubleshooting
-
-### Common Issues
-
-1. **"Protocol not allowed" errors:**
-   - Check `protocols.allowed_protocols` includes required protocol
-   - Ensure `protocols.enabled: true` for validation
-
-2. **SSL certificate errors:**
-   - Verify certificate file paths are correct
-   - Check certificate validity and format
-   - Ensure CA certificate matches server certificate
-
-3. **mTLS connection failures:**
-   - Verify client certificates are valid
-   - Check `verify_client: true` is set
-   - Ensure "mtls" is in allowed protocols
-
-### Debug Mode
-
-Enable debug logging to troubleshoot issues:
-
-```json
-{
-  "logging": {
-    "level": "DEBUG",
-    "handlers": ["console", "file"]
-  }
-}
-```
-"""
-        )
-
-    print(f"✅ Created configuration documentation: {config_guide}")
-
-
-def create_test_files(output_dir: Path) -> None:
-    """
-    Create additional test files for proxy registration testing.
+    Returns:
+        Tuple of (package_path, examples_path)
     """
-    # Create test proxy server script
-    test_proxy_server = output_dir / "test_proxy_server.py"
-    with open(test_proxy_server, "w", encoding="utf-8") as f:
-        f.write(
-            '''#!/usr/bin/env python3
-"""
-Author: Vasiliy Zdanovskiy
-email: vasilyvz@gmail.com
-
-Simple mTLS proxy server for testing proxy registration SSL fix.
-"""
-import asyncio
-import os
-import ssl
-from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
-import hypercorn.asyncio
-import hypercorn.config
-
-
-app = FastAPI(title="Test mTLS Proxy Server", version="1.0.0")
-
-
-@app.post("/register")
-async def register_server(request: Request):
-    """Register server endpoint."""
-    try:
-        data = await request.json()
-        print(f"✅ Received registration request: {data}")
-
-        # Check if client certificate is present
-        client_cert = request.client
-        if client_cert:
-            print(f"✅ Client certificate verified: {client_cert}")
-
-        return JSONResponse(
-            status_code=200,
-            content={
-                "success": True,
-                "server_key": f"{data.get('server_id', 'unknown')}_1",
-                "message": "Server registered successfully"
-            }
-        )
-    except Exception as e:
-        print(f"❌ Registration error: {e}")
-        return JSONResponse(
-            status_code=500,
-            content={
-                "success": False,
-                "error": {
-                    "message": str(e),
-                    "code": "REGISTRATION_ERROR"
-                }
-            }
-        )
-
-
-@app.post("/unregister")
-async def unregister_server(request: Request):
-    """Unregister server endpoint."""
-    try:
-        data = await request.json()
-        print(f"✅ Received unregistration request: {data}")
-
-        # Check if client certificate is present
-        client_cert = request.client
-        if client_cert:
-            print(f"✅ Client certificate verified for unregistration: {client_cert}")
-
-        return JSONResponse(
-            status_code=200,
-            content={
-                "success": True,
-                "message": "Server unregistered successfully"
-            }
-        )
-    except Exception as e:
-        print(f"❌ Unregistration error: {e}")
-        return JSONResponse(
-            status_code=500,
-            content={
-                "success": False,
-                "error": {
-                    "message": str(e),
-                    "code": "UNREGISTRATION_ERROR"
-                }
-            }
-        )
-
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint."""
-    return JSONResponse(
-        status_code=200,
-        content={
-            "status": "healthy",
-            "message": "mTLS Proxy Server is running"
-        }
-    )
-
-
-async def main():
-    """Run the mTLS proxy server."""
-    print("🚀 Starting Test mTLS Proxy Server...")
-    print("📡 Server URL: https://127.0.0.1:20005")
-    print("🔐 mTLS enabled with client certificate verification")
-    print("📋 Available endpoints:")
-    print("   POST /register   - Register server")
-    print("   POST /unregister - Unregister server")
-    print("   GET  /health     - Health check")
-    print("⚡ Press Ctrl+C to stop\\n")
-
-    # Configure Hypercorn
-    config = hypercorn.config.Config()
-    config.bind = ["127.0.0.1:20005"]
-    config.loglevel = "info"
+    # Get the directory containing this script
+    script_dir = Path(__file__).parent.absolute()
     
-    # Check if certificates exist, if not run without SSL
-    cert_file = "certs/localhost_server.crt"
-    key_file = "keys/server_key.pem"
+    # Package path is the parent of examples
+    package_path = script_dir.parent
     
-    if os.path.exists(cert_file) and os.path.exists(key_file):
-        print("🔐 Using SSL certificates for mTLS")
-        config.certfile = cert_file
-        config.keyfile = key_file
-    else:
-        print("⚠️ SSL certificates not found, running without SSL")
-        # Run on HTTP instead of HTTPS
-        config.bind = ["127.0.0.1:20005"]
-
-    # Run server with Hypercorn
-    await hypercorn.asyncio.serve(app, config)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
-'''
-        )
-
-    # Make it executable
-    test_proxy_server.chmod(0o755)
-    print(f"✅ Created test proxy server: {test_proxy_server}")
-
-    # Create test script for proxy registration
-    test_script = output_dir / "test_proxy_registration.py"
-    with open(test_script, "w", encoding="utf-8") as f:
-        f.write(
-            '''#!/usr/bin/env python3
-"""
-Author: Vasiliy Zdanovskiy
-email: vasilyvz@gmail.com
-
-Test script to verify proxy registration SSL configuration fix.
-"""
-import sys
-import subprocess
-import time
-import requests
-from pathlib import Path
-
-
-def test_proxy_registration():
-    """Test proxy registration with SSL configuration."""
-    print("🧪 Testing Proxy Registration SSL Configuration Fix")
-    print("=" * 60)
+    # Examples path
+    examples_path = script_dir
     
-    # Error tracking
-    error_count = 0
-    errors = []
-
-    # Kill any existing process on port 20005
-    print("🧹 Killing any existing process on port 20005...")
-    try:
-        subprocess.run(["fuser", "-k", "20005/tcp"], check=False, capture_output=True)
-    except FileNotFoundError:
-        # fuser not available, try with lsof
-        try:
-            # Get PIDs using lsof
-            result = subprocess.run(["lsof", "-ti:20005"], capture_output=True, text=True, check=False)
-            if result.returncode == 0 and result.stdout.strip():
-                pids = result.stdout.strip().split('\\n')
-                for pid in pids:
-                    if pid.strip():
-                        subprocess.run(["kill", "-9", pid.strip()], check=False, capture_output=True)
-        except:
-            pass
-
-    # Start proxy server
-    print("🚀 Starting test proxy server...")
-    proxy_process = subprocess.Popen([
-        sys.executable, "test_proxy_server.py"
-    ], cwd=Path(__file__).parent)
-
-    try:
-        # Wait for server to start
-        print("⏳ Waiting for proxy server to start...")
-        time.sleep(5)
-
-        # Test proxy server health - try both HTTP and HTTPS
-        print("🔍 Testing proxy server health...")
-        proxy_working = False
-        
-        # Try HTTP first
-        try:
-            print("🔍 Trying HTTP connection...")
-            response = requests.get(
-                "http://127.0.0.1:20005/health",
-                timeout=10
-            )
-            if response.status_code == 200:
-                print("✅ Proxy server is running on HTTP")
-                proxy_working = True
-            else:
-                print(f"⚠️ HTTP health check failed: {response.status_code}")
-        except Exception as e:
-            print(f"⚠️ HTTP connection failed: {e}")
-        
-        # Try HTTPS if HTTP failed
-        if not proxy_working:
-            try:
-                print("🔍 Trying HTTPS connection...")
-                response = requests.get(
-                    "https://127.0.0.1:20005/health",
-                    verify=False,
-                    timeout=10
-                )
-                if response.status_code == 200:
-                    print("✅ Proxy server is running on HTTPS")
-                    proxy_working = True
-                else:
-                    print(f"⚠️ HTTPS health check failed: {response.status_code}")
-            except Exception as e:
-                print(f"⚠️ HTTPS connection failed: {e}")
-        
-        if not proxy_working:
-            error_count += 1
-            errors.append("Failed to connect to proxy server on both HTTP and HTTPS")
-            print("❌ Failed to connect to proxy server on both HTTP and HTTPS")
-            return False
-
-        # Test mTLS server with registration
-        print("🚀 Starting mTLS server with proxy registration...")
-        server_process = subprocess.Popen([
-            sys.executable, "-m", "mcp_proxy_adapter",
-            "--config", "configs/test_proxy_registration.json"
-        ], cwd=Path(__file__).parent)
-
-        try:
-            # Wait for server to start and attempt registration
-            print("⏳ Waiting for server to start and register...")
-            time.sleep(10)
-
-            # Check if server is running
-            if server_process.poll() is None:
-                print("✅ mTLS server started successfully")
-                
-                # Check if registration was successful by querying the proxy server
-                print("⏳ Checking registration status...")
-                time.sleep(5)  # Give more time for registration attempt
-                
-                if server_process.poll() is None:
-                    print("✅ Server is running - checking registration status...")
-                    
-                    # Try to check if server is registered by querying proxy server
-                    try:
-                        # Check if we can get server list from proxy (if it has such endpoint)
-                        # For now, we'll assume registration is successful if server is still running
-                        # and no error messages were shown in the logs
-                        print("✅ Server is running and appears to be registered successfully")
-                        print("✅ Proxy registration test PASSED")
-                        return True
-                    except Exception as e:
-                        error_count += 1
-                        errors.append(f"Failed to verify registration: {e}")
-                        print(f"❌ Failed to verify registration: {e}")
-                        print(f"📊 Error count: {error_count}")
-                        print(f"📋 Errors: {errors}")
-                        return False
-                else:
-                    error_count += 1
-                    errors.append("Server stopped unexpectedly")
-                    print("❌ Server stopped unexpectedly")
-                    print(f"📊 Error count: {error_count}")
-                    print(f"📋 Errors: {errors}")
-                    return False
-            else:
-                error_count += 1
-                errors.append("mTLS server failed to start")
-                print("❌ mTLS server failed to start")
-                print(f"📊 Error count: {error_count}")
-                print(f"📋 Errors: {errors}")
-                return False
-
-        finally:
-            # Clean up server process
-            if server_process.poll() is None:
-                server_process.terminate()
-                server_process.wait()
-
-    finally:
-        # Clean up proxy process
-        if proxy_process.poll() is None:
-            proxy_process.terminate()
-            proxy_process.wait()
-
-
-def main():
-    """Run the test."""
-    success = test_proxy_registration()
-
-    if success:
-        print("\\n🎉 All tests passed! Proxy registration SSL fix is working correctly.")
-        return 0
-    else:
-        print("\\n❌ Tests failed. Check the logs above for details.")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())
-'''
-        )
-
-    # Make it executable
-    test_script.chmod(0o755)
-    print(f"✅ Created test script: {test_script}")
-
-
-def generate_enhanced_configurations(output_dir: Path) -> None:
-    """
-    Generate enhanced configurations with proper protocol settings and validation.
-    """
-    configs_dir = output_dir / "configs"
-    configs_dir.mkdir(parents=True, exist_ok=True)
-
-    validator = ConfigurationValidator()
-
-    # Single comprehensive HTTP configuration with all features
-    configs = {
-        "comprehensive_http.json": {
-            "uuid": "550e8400-e29b-41d4-a716-446655440000",
-            "server": {
-                "host": "127.0.0.1",
-                "port": 20001,
-                "debug": False,
-                "log_level": "INFO",
-                "workers": 1,
-                "reload": False,
-            },
-            "ssl": {"enabled": False},
-            "security": {
-                "enabled": True,
-                "auth": {
-                    "enabled": True,
-                    "methods": ["api_key"],
-                    "api_keys": {
-                        "admin-token-123": "admin",
-                        "user-token-456": "user",
-                        "readonly-token-789": "readonly",
-                        "guest-token-abc": "guest",
-                        "proxy-token-def": "proxy",
-                    },
-                },
-                "permissions": {"enabled": True, "roles_file": "configs/roles.json"},
-            },
-            "registration": {
-                "enabled": True,
-                "url": "http://127.0.0.1:3004/proxy",
-                "name": "comprehensive_http_adapter",
-                "capabilities": [
-                    "http",
-                    "token_auth",
-                    "roles",
-                    "registration",
-                    "heartbeat",
-                ],
-                "retry_count": 3,
-                "retry_delay": 5,
-                "heartbeat": {"enabled": True, "interval": 30},
-            },
-            "protocols": {"enabled": True, "allowed_protocols": ["http"]},
-        }
-    }
-
-    # Generate and validate configurations
-    for config_name, config_data in configs.items():
-        config_path = configs_dir / config_name
-
-        # Validate configuration
-        is_valid, errors, warnings = validator.validate_config(config_data, config_name)
-
-        if not is_valid:
-            print(f"❌ Configuration {config_name} has errors:")
-            for error in errors:
-                print(f"   {error}")
-            continue
-
-        if warnings:
-            print(f"⚠️ Configuration {config_name} has warnings:")
-            for warning in warnings:
-                print(f"   {warning}")
-
-        # Write configuration file
-        with open(config_path, "w", encoding="utf-8") as f:
-            json.dump(config_data, f, indent=2)
-
-        print(f"✅ Generated configuration: {config_path}")
-
-    # Create configuration index
-    index_path = configs_dir / "README.md"
-    with open(index_path, "w", encoding="utf-8") as f:
-        f.write(
-            """# Comprehensive HTTP Configuration
-
-This directory contains a single comprehensive HTTP configuration with all features enabled.
-
-## Available Configuration
-
-### Comprehensive HTTP
-- `comprehensive_http.json` - Complete HTTP server with all features
-
-## Features
-
-### Security
-- **Token Authentication**: API key-based access control with 5 predefined tokens
-- **Role-based Permissions**: Granular access control with 5 roles
-- **Roles**: admin, user, readonly, guest, proxy
-
-### Authentication Tokens
-- `admin-token-123` → admin role (full access)
-- `user-token-456` → user role (read, write, execute)
-- `readonly-token-789` → readonly role (read only)
-- `guest-token-abc` → guest role (limited access)
-- `proxy-token-def` → proxy role (registration, heartbeat)
-
-### Registration & Monitoring
-- **Proxy Registration**: Automatic service discovery
-- **Heartbeat**: 30-second health monitoring
-- **Retry Logic**: 3 attempts with 5-second delay
-
-### Protocols
-- **HTTP**: Standard web protocol (port 20001)
-
-## Usage
-
-### Starting the Server
-```bash
-# Start comprehensive HTTP server
-python -m mcp_proxy_adapter --config configs/comprehensive_http.json
-```
-
-### Testing Authentication
-```bash
-# Test with admin token
-curl -H "Authorization: Bearer admin-token-123" http://localhost:20001/health
-
-# Test with user token
-curl -H "Authorization: Bearer user-token-456" http://localhost:20001/health
-
-# Test with readonly token
-curl -H "Authorization: Bearer readonly-token-789" http://localhost:20001/health
-```
-
-## Configuration Details
-
-- **Server**: 127.0.0.1:20001
-- **SSL**: Disabled (HTTP only)
-- **Authentication**: Token-based with roles
-- **Registration**: Enabled with proxy server
-- **Heartbeat**: 30-second interval
-- **Protocols**: HTTP only
-
-## Customization
-
-Edit `comprehensive_http.json` to:
-- Change server host/port
-- Add/modify authentication tokens
-- Update role permissions
-- Modify registration settings
-- Adjust heartbeat interval
-
-## Troubleshooting
-
-1. **Port Conflicts**: Ensure port 20001 is not in use
-2. **Token Issues**: Verify token format and role mapping
-3. **Registration Issues**: Check proxy server availability
-4. **Permission Errors**: Verify roles.json file exists
-"""
-        )
-
-    print(f"✅ Created configuration index: {index_path}")
-
-
-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 enhanced 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",
-        "docs",
-    ]
-    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 from examples/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 from examples/scripts
-    create_certs_src = utils_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 = utils_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 test suite runner from examples
-    test_suite_src = examples_src_root / "run_full_test_suite.py"
-    if test_suite_src.exists():
-        shutil.copy2(test_suite_src, output_dir)
-        print("✅ Copied run_full_test_suite.py")
-
-    # Copy other required test files from examples
-    test_files = [
-        "create_test_configs.py",
-        "run_security_tests.py",
-        "run_proxy_server.py",
-    ]
-    for test_file in test_files:
-        test_file_src = examples_src_root / test_file
-        if test_file_src.exists():
-            shutil.copy2(test_file_src, output_dir)
-            print(f"✅ Copied {test_file}")
-
-    # Create comprehensive_config.json if it doesn't exist
-    comprehensive_config_dst = output_dir / "comprehensive_config.json"
-    if not comprehensive_config_dst.exists():
-        # Create a basic comprehensive config
-        comprehensive_config = {
-            "uuid": "79db1fa0-ff4e-4695-8c94-1d5ac470b613",
-            "server": {"host": "127.0.0.1", "port": 20001},
-            "ssl": {
-                "enabled": False,
-                "cert_file": "certs/localhost_server.crt",
-                "key_file": "keys/server_key.pem",
-                "ca_cert": "certs/mcp_proxy_adapter_ca_ca.crt",
-                "verify_client": False,
-            },
-            "security": {
-                "enabled": True,
-                "auth": {
-                    "enabled": True,
-                    "methods": ["token"],
-                    "api_keys": {
-                        "admin-token-123": "admin",
-                        "user-token-456": "user",
-                        "readonly-token-789": "readonly",
-                    },
-                },
-                "permissions": {"enabled": True, "roles_file": "roles.json"},
-            },
-            "protocols": {
-                "enabled": True,
-                "default_protocol": "http",
-                "allowed_protocols": ["http"],
-            },
-        }
-
-        with open(comprehensive_config_dst, "w", encoding="utf-8") as f:
-            json.dump(comprehensive_config, f, indent=2)
-        print("✅ Created comprehensive_config.json")
-    else:
-        print("✅ comprehensive_config.json already exists")
-
-    # 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")
-    else:
-        # Create a basic roles.json if it doesn't exist
-        roles_config = {
-            "roles": {
-                "admin": {
-                    "permissions": ["*"],
-                    "description": "Full access to all commands",
-                },
-                "user": {
-                    "permissions": ["echo", "health", "help"],
-                    "description": "Basic user permissions",
-                },
-                "readonly": {
-                    "permissions": ["health", "help"],
-                    "description": "Read-only access",
-                },
-            }
-        }
-
-        roles_dst = output_dir / "roles.json"
-        with open(roles_dst, "w", encoding="utf-8") as f:
-            json.dump(roles_config, f, indent=2)
-        print("✅ Created roles.json in 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")
-
-    # Create configuration documentation
-    create_configuration_documentation(output_dir)
-
-    # Generate enhanced configurations
-    generate_enhanced_configurations(output_dir)
-
-    # Create test files
-    create_test_files(output_dir)
-
-    print(
-        "🎉 Enhanced 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 (localhost_server.crt)
-        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 additional server certificate (mcp_proxy_adapter_server.crt) for HTTPS configs
-        server_config2 = ServerCertConfig(
-            common_name="mcp_proxy_adapter_server",
-            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",
-                "mcp_proxy_adapter_server",
-            ],
-            ca_cert_path=cert_pair.certificate_path,
-            ca_key_path=cert_pair.private_key_path,
-        )
-        cert_pair2 = cert_manager.create_server_certificate(server_config2)
-        if not cert_pair2 or not cert_pair2.certificate_path:
-            print("❌ Failed to create mcp_proxy_adapter_server certificate: Invalid certificate " "pair")
-            return False
-        print("✅ mcp_proxy_adapter_server certificate created successfully")
-        
-        # Create symlinks with the expected names for HTTPS configs
-        import shutil
-        certs_dir = output_dir / "certs"
-        keys_dir = output_dir / "keys"
-        
-        # Create symlink for mcp_proxy_adapter_server.crt
-        expected_cert_path = certs_dir / "mcp_proxy_adapter_server.crt"
-        if not expected_cert_path.exists():
-            shutil.copy2(cert_pair2.certificate_path, expected_cert_path)
-            print(f"✅ Created mcp_proxy_adapter_server.crt: {expected_cert_path}")
-        
-        # Create symlink for mcp_proxy_adapter_server.key
-        expected_key_path = certs_dir / "mcp_proxy_adapter_server.key"
-        if not expected_key_path.exists():
-            shutil.copy2(cert_pair2.private_key_path, expected_key_path)
-            print(f"✅ Created mcp_proxy_adapter_server.key: {expected_key_path}")
-        # 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=cert_pair.private_key_path,
-            )
-            client_cert_pair = cert_manager.create_client_certificate(client_config)
-            if not client_cert_pair or not client_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 run_full_test_suite(target_root: Path) -> bool:
-    """Run the full test suite after environment setup."""
-    print("\n" + "=" * 60)
-    print("🚀 AUTOMATICALLY RUNNING FULL TEST SUITE")
-    print("=" * 60)
-
-    try:
-        # Change to target directory
-        original_cwd = Path.cwd()
-        os.chdir(target_root)
-
-        # Run the full test suite
-        result = subprocess.run(
-            [sys.executable, "run_full_test_suite.py"],
-            capture_output=True,
-            text=True,
-            timeout=300,
-        )  # 5 minute timeout
-
-        # Print output
-        if result.stdout:
-            print("📋 Test Suite Output:")
-            print(result.stdout)
-
-        if result.stderr:
-            print("⚠️ Test Suite Warnings/Errors:")
-            print(result.stderr)
-
-        if result.returncode == 0:
-            print("🎉 FULL TEST SUITE COMPLETED SUCCESSFULLY!")
-            return True
-        else:
-            print(f"❌ FULL TEST SUITE FAILED (exit code: {result.returncode})")
-            return False
-
-    except subprocess.TimeoutExpired:
-        print("⏰ Test suite timed out after 5 minutes")
-        return False
-    except Exception as e:
-        print(f"❌ Error running test suite: {e}")
-        return False
-    finally:
-        # Restore original working directory
-        os.chdir(original_cwd)
+    return package_path, examples_path
 
 
 def validate_output_directory(output_dir: Path) -> bool:
     """
-    Validate output directory for test environment setup.
+    Validate that the output directory is suitable for setup.
 
     Args:
-        output_dir: Path to the target directory
+        output_dir: Directory to validate
 
     Returns:
-        True if directory is valid for setup, False otherwise
+        True if valid, False otherwise
     """
-    output_dir = output_dir.resolve()
+    try:
+        # Check if directory exists
+        if not output_dir.exists():
+            print(f"📁 Creating output directory: {output_dir}")
+            output_dir.mkdir(parents=True, exist_ok=True)
+            return True
 
-    # Check if directory exists
-    if output_dir.exists():
-        if not output_dir.is_dir():
-            print(f"❌ Path exists but is not a directory: {output_dir}")
+        # Check if directory is writable
+        if not os.access(output_dir, os.W_OK):
+            print(f"❌ Error: Directory {output_dir} is not writable")
             return False
 
-        # Check if directory is empty
-        try:
-            contents = list(output_dir.iterdir())
-            if contents:
-                print(f"❌ Directory is not empty: {output_dir}")
-                print(f"   Found {len(contents)} items:")
-                for item in contents[:5]:  # Show first 5 items
-                    print(f"   - {item.name}")
-                if len(contents) > 5:
-                    print(f"   ... and {len(contents) - 5} more items")
-                print("\n💡 Please use an empty directory or specify a different path.")
+        # Check if directory is empty (optional warning)
+        contents = list(output_dir.iterdir())
+        if contents:
+            print(f"⚠️ Warning: Directory {output_dir} is not empty")
+            print(f"   Found {len(contents)} items")
+            response = input("   Continue anyway? (y/N): ").strip().lower()
+            if response not in ['y', 'yes']:
+                print("   Setup cancelled")
                 return False
-        except PermissionError:
-            print(f"❌ Permission denied accessing directory: {output_dir}")
-            return False
-    else:
-        # Directory doesn't exist, try to create it
-        try:
-            output_dir.mkdir(parents=True, exist_ok=True)
-            print(f"✅ Created directory: {output_dir}")
-        except PermissionError:
-            print(f"❌ Permission denied creating directory: {output_dir}")
-            return False
-        except Exception as e:
-            print(f"❌ Failed to create directory {output_dir}: {e}")
-            return False
 
-    return True
+        return True
+
+    except Exception as e:
+        print(f"❌ Error validating output directory: {e}")
+        return False
 
 
 def check_ports_available() -> bool:
     """
-    Check if all required test ports are available.
-    Returns True if all ports are free, False otherwise.
+    Check if required ports are available.
+
+    Returns:
+        True if ports are available, False otherwise
     """
     import socket
 
-    # Ports used by the test suite - UPDATED with dedicated ports
-    test_ports = [
-        20010,  # proxy_port
-        20020,  # basic_http (http_simple)
-        20021,  # http_token
-        20022,  # https_simple
-        20023,  # https_token
-        20024,  # mtls_no_roles
-        20025,  # mtls_simple
-        20026,  # mtls_with_roles
-        20005,  # test_proxy_server
-        3006,  # proxy registration
-    ]
+    ports_to_check = [8080, 8443, 20005, 3005]
+    unavailable_ports = []
 
-    occupied_ports = []
-
-    print("🔍 Checking port availability...")
-    for port in test_ports:
+    for port in ports_to_check:
         try:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-                sock.settimeout(1)
-                result = sock.connect_ex(("127.0.0.1", port))
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(1)
+                result = s.connect_ex(('localhost', port))
                 if result == 0:
-                    occupied_ports.append(port)
-                    print(f"   ❌ Port {port} is occupied")
-                else:
-                    print(f"   ✅ Port {port} is available")
-        except Exception as e:
-            print(f"   ⚠️ Could not check port {port}: {e}")
-            occupied_ports.append(port)
+                    unavailable_ports.append(port)
+        except Exception:
+            # If we can't check, assume it's available
+            pass
 
-    if occupied_ports:
-        print(
-            f"\n❌ CRITICAL: {len(occupied_ports)} ports are occupied: {occupied_ports}"
-        )
-        print("💡 Please free these ports before running the test suite:")
-        for port in occupied_ports:
-            print(f"   - Port {port}: kill processes using this port")
-        print("\n🔧 You can use these commands to free ports:")
-        for port in occupied_ports:
-            print(f"   fuser -k {port}/tcp")
-        return False
+    if unavailable_ports:
+        print(f"⚠️ Warning: The following ports are in use: {unavailable_ports}")
+        print("   This may cause issues when running the examples")
+        response = input("   Continue anyway? (y/N): ").strip().lower()
+        return response in ['y', 'yes']
 
-    print(f"✅ All {len(test_ports)} required ports are available")
     return True
 
 
 def main() -> int:
-    """Main function for command line execution."""
+    """
+    Main function to set up the test environment.
+
+    Returns:
+        Exit code (0 for success, 1 for failure)
+    """
     parser = argparse.ArgumentParser(
-        description="Setup enhanced test environment for MCP Proxy Adapter and run full test suite"
+        description="Set up test environment for MCP Proxy Adapter",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python setup_test_environment.py                    # Setup in current directory
+  python setup_test_environment.py -o /path/to/test  # Setup in specific directory
+  python setup_test_environment.py --no-certs        # Skip certificate generation
+  python setup_test_environment.py --run-tests       # Run tests after setup
+        """
+    )
+
+    parser.add_argument(
+        "-o", "--output-dir",
+        type=Path,
+        default=Path.cwd(),
+        help="Output directory for test environment (default: current directory)"
     )
+
     parser.add_argument(
-        "output_dir",
-        nargs="?",
-        type=str,
-        default=None,
-        help=(
-            "Target directory to create the test environment "
-            "(default: auto-generated directory in /tmp)"
-        ),
+        "--no-certs",
+        action="store_true",
+        help="Skip certificate generation"
     )
+
     parser.add_argument(
-        "--skip-certs", action="store_true", help="Skip certificate generation"
+        "--run-tests",
+        action="store_true",
+        help="Run tests after setup"
     )
+
     parser.add_argument(
-        "--skip-tests", action="store_true", help="Skip running the full test suite"
+        "--verbose",
+        action="store_true",
+        help="Enable verbose output"
     )
+
     args = parser.parse_args()
 
-    # FIRST: Check port availability - if this fails, don't proceed
-    print("🔍 STEP 1: Port Availability Check")
+    print("🚀 MCP Proxy Adapter Test Environment Setup")
+    print("=" * 50)
+
+    # Validate output directory
+    if not validate_output_directory(args.output_dir):
+        print("❌ Setup failed: Invalid output directory")
+        return 1
+
+    # Check ports
     if not check_ports_available():
-        print("\n❌ FAILED: Required ports are occupied. Aborting setup.")
-        print("💡 Please free the occupied ports and try again.")
+        print("❌ Setup cancelled: Port conflicts detected")
         return 1
 
     try:
-        # Determine target directory
-        if args.output_dir is None:
-            # Create auto-generated directory in /tmp
-            import tempfile
-            import time
-
-            timestamp = int(time.time())
-            target_root = Path(tempfile.gettempdir()) / f"mcp_test_env_{timestamp}"
-            print(f"🔧 Auto-generating test environment directory: {target_root}")
-        else:
-            target_root = Path(args.output_dir)
-
-        # Validate output directory
-        print(f"🔍 Validating output directory: {target_root}")
-        if not validate_output_directory(target_root):
-            print("\n❌ Directory validation failed. Exiting.")
+        # Run setup
+        success = setup_test_environment(args.output_dir)
+        
+        if not success:
+            print("❌ Setup failed")
             return 1
 
-        print(f"✅ Directory validation passed: {target_root}")
-        setup_test_environment(target_root)
-
-        # Generate certificates if framework is available and not skipped
-        if not args.skip_certs and SECURITY_FRAMEWORK_AVAILABLE:
-            generate_certificates_with_framework(target_root)
-        elif args.skip_certs:
-            print("⚠️ Skipping certificate generation (--skip-certs specified)")
-        else:
-            print(
-                "⚠️ Skipping certificate generation (mcp_security_framework "
-                "not available)"
-            )
+        print("✅ Test environment setup completed successfully!")
+        print(f"📁 Output directory: {args.output_dir.absolute()}")
 
-        # Run full test suite if not skipped
-        if not args.skip_tests:
-            test_success = run_full_test_suite(target_root)
+        # Run tests if requested
+        if args.run_tests:
+            print("\\n🧪 Running tests...")
+            test_success = run_full_test_suite(args.output_dir)
             if not test_success:
-                print("\n❌ TEST SUITE FAILED - Check the output above for details")
+                print("⚠️ Some tests failed, but setup completed")
                 return 1
-        else:
-            print("⚠️ Skipping test suite execution (--skip-tests specified)")
 
+        print("\\n🎉 Setup complete! You can now run the examples.")
+        return 0
+
+    except KeyboardInterrupt:
+        print("\\n⚠️ Setup interrupted by user")
+        return 1
     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")
+        print(f"\\n❌ Setup failed with error: {e}")
+        if args.verbose:
+            import traceback
+            traceback.print_exc()
         return 1
 
-    print("\n" + "=" * 60)
-    print("✅ ENHANCED TEST ENVIRONMENT SETUP COMPLETED SUCCESSFULLY")
-    print("=" * 60)
-
-    if not args.skip_tests:
-        print("\n🎉 ALL TESTS PASSED - Environment is ready for use!")
-    else:
-        print("\n📋 NEXT STEPS:")
-        print("1. Review configuration documentation:")
-        print("   cat docs/CONFIGURATION_GUIDE.md")
-        print("\n2. Check available configurations:")
-        print("   ls -la configs/")
-        print("\n3. Run the full test suite:")
-        print("   python run_full_test_suite.py")
-        print("\n4. Test proxy registration SSL fix:")
-        print("   python test_proxy_registration.py")
-        print("\n5. Start server with a specific configuration:")
-        print("   python -m mcp_proxy_adapter --config configs/production_https.json")
-        print("\n6. Run security tests:")
-        print("   python -m mcp_proxy_adapter.examples.run_security_tests")
-        print("\n7. Generate additional certificates (if needed):")
-        print("   python scripts/create_certificates_simple.py")
-
-    print("=" * 60)
-    return 0
-
 
 if __name__ == "__main__":
-    exit(main())
+    sys.exit(main())