mcp-proxy-adapter 6.2.24__py3-none-any.whl → 6.2.26__py3-none-any.whl

mcp_proxy_adapter/examples/generate_test_configs.py

@@ -9,7 +9,7 @@ import json
 import os
 import argparse
 from typing import Dict, Any
-def generate_http_simple_config(port: int = 20000, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_http_simple_config(port: int = 20000, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
     """Generate HTTP configuration without authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
@@ -29,7 +29,7 @@ def generate_http_simple_config(port: int = 20000, certs_dir: str = "./certs", k
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http"]}
     }
-def generate_http_token_config(port: int = 20001, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_http_token_config(port: int = 20001, certs_dir: str = "certs", keys_dir: str = "keys", roles_file: str = "configs/roles.json") -> Dict[str, Any]:
     """Generate HTTP configuration with token authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
@@ -48,7 +48,7 @@ def generate_http_token_config(port: int = 20001, certs_dir: str = "./certs", ke
                     "proxy-token-123": "proxy"
                 }
             },
-            "permissions": {"enabled": True, "roles_file": "./roles.json"}
+            "permissions": {"enabled": True, "roles_file": roles_file}
         },
         "registration": {
             "enabled": True,
@@ -61,14 +61,14 @@ def generate_http_token_config(port: int = 20001, certs_dir: str = "./certs", ke
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http"]}
     }
-def generate_https_simple_config(port: int = 20002, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_https_simple_config(port: int = 20002, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
     """Generate HTTPS configuration without client certificate verification and authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
-            "cert_file": "./certs/localhost_server.crt", 
-            "key_file": "./keys/localhost_server.key"
+            "cert_file": f"{certs_dir}/localhost_server.crt",
+            "key_file": f"{keys_dir}/localhost_server.key"
         },
         "security": {"enabled": False},
         "registration": {
@@ -82,14 +82,14 @@ def generate_https_simple_config(port: int = 20002, certs_dir: str = "./certs",
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http", "https"]}
     }
-def generate_https_token_config(port: int = 20003, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_https_token_config(port: int = 20003, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
     """Generate HTTPS configuration without client certificate verification with token authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
-            "cert_file": "./certs/localhost_server.crt", 
-            "key_file": "./keys/localhost_server.key"
+            "cert_file": f"{certs_dir}/localhost_server.crt",
+            "key_file": f"{keys_dir}/localhost_server.key"
         },
         "security": {
             "enabled": True,
@@ -104,7 +104,7 @@ def generate_https_token_config(port: int = 20003, certs_dir: str = "./certs", k
                     "proxy-token-123": "proxy"
                 }
             },
-            "permissions": {"enabled": True, "roles_file": "./roles.json"}
+            "permissions": {"enabled": True, "roles_file": "./configs/roles.json"}
         },
         "registration": {
             "enabled": True,
@@ -117,33 +117,33 @@ def generate_https_token_config(port: int = 20003, certs_dir: str = "./certs", k
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http", "https"]}
     }
-def generate_mtls_no_roles_config(port: int = 20004, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_mtls_no_roles_config(port: int = 20004, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
     """Generate mTLS configuration without roles."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
-            "cert_file": "./certs/localhost_server.crt", 
-            "key_file": "./keys/localhost_server.key",
-            "ca_cert": "./certs/mcp_proxy_adapter_ca_ca.crt",
+            "cert_file": f"{certs_dir}/localhost_server.crt",
+            "key_file": f"{keys_dir}/localhost_server.key",
+            "ca_cert": f"{certs_dir}/mcp_proxy_adapter_ca_ca.crt",
             "verify_client": True
         },
         "security": {
             "enabled": True,
             "auth": {"enabled": True, "methods": ["certificate"]},
-            "permissions": {"enabled": True, "roles_file": "./roles.json"}
+            "permissions": {"enabled": False}
         },
         "protocols": {"enabled": True, "allowed_protocols": ["https", "mtls"]}
     }
-def generate_mtls_with_roles_config(port: int = 20005, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
+def generate_mtls_with_roles_config(port: int = 20005, certs_dir: str = "certs", keys_dir: str = "keys", roles_file: str = "configs/roles.json") -> Dict[str, Any]:
     """Generate mTLS configuration with roles."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
-            "cert_file": "./certs/localhost_server.crt", 
-            "key_file": "./keys/localhost_server.key",
-            "ca_cert": "./certs/mcp_proxy_adapter_ca_ca.crt",
+            "cert_file": f"{certs_dir}/localhost_server.crt",
+            "key_file": f"{keys_dir}/localhost_server.key",
+            "ca_cert": f"{certs_dir}/mcp_proxy_adapter_ca_ca.crt",
             "verify_client": True
         },
         "registration": {
@@ -161,7 +161,7 @@ def generate_mtls_with_roles_config(port: int = 20005, certs_dir: str = "./certs
         "security": {
             "enabled": True,
             "auth": {"enabled": True, "methods": ["certificate"]},
-            "permissions": {"enabled": True, "roles_file": "./roles.json"}
+            "permissions": {"enabled": True, "roles_file": roles_file}
         },
         "protocols": {"enabled": True, "allowed_protocols": ["https", "mtls"]}
     }
@@ -222,15 +222,18 @@ def generate_roles_config() -> Dict[str, Any]:
             "tokens": ["proxy-token-123"]
         }
     }
-def generate_all_configs(output_dir: str, certs_dir: str = "./certs", keys_dir: str = "./keys") -> None:
+def generate_all_configs(output_dir: str, certs_dir: str = "certs", keys_dir: str = "keys", roles_file: str = "configs/roles.json") -> None:
     """Generate all 6 configuration types and save them to files."""
+    # Ensure output directory exists first
+    os.makedirs(output_dir, exist_ok=True)
+
     configs = {
         "http_simple": generate_http_simple_config(20000, certs_dir, keys_dir),
-        "http_token": generate_http_token_config(20001, certs_dir, keys_dir),
+        "http_token": generate_http_token_config(20001, certs_dir, keys_dir, roles_file),
         "https_simple": generate_https_simple_config(20002, certs_dir, keys_dir),
         "https_token": generate_https_token_config(20003, certs_dir, keys_dir),
         "mtls_no_roles": generate_mtls_no_roles_config(20004, certs_dir, keys_dir),
-        "mtls_with_roles": generate_mtls_with_roles_config(20005, certs_dir, keys_dir)
+        "mtls_with_roles": generate_mtls_with_roles_config(20005, certs_dir, keys_dir, roles_file)
     }
     # Ensure output directory exists
     os.makedirs(output_dir, exist_ok=True)
@@ -242,17 +245,36 @@ def generate_all_configs(output_dir: str, certs_dir: str = "./certs", keys_dir:
         print(f"Generated: {filename}")
     # Generate roles configuration
     roles_config = generate_roles_config()
+    
+    # Create roles.json in the root directory (test environment root) for compatibility
+    # When running as module, we need to create roles.json in the current working directory
+    # This is the directory where the user is running the command from
+    try:
+        # Get the current working directory where the user is running the command
+        current_dir = os.getcwd()
+        root_roles_filename = os.path.join(current_dir, "roles.json")
+        
+        # Create roles.json in the current working directory
+        with open(root_roles_filename, 'w', encoding='utf-8') as f:
+            json.dump(roles_config, f, indent=2, ensure_ascii=False)
+        print(f"Generated: {root_roles_filename}")
+        
+        # Also create a copy in the output directory for reference
+        backup_roles_filename = os.path.join(output_dir, "roles_backup.json")
+        with open(backup_roles_filename, 'w', encoding='utf-8') as f:
+            json.dump(roles_config, f, indent=2, ensure_ascii=False)
+        print(f"Generated backup: {backup_roles_filename}")
+        
+    except Exception as e:
+        print(f"Warning: Could not create roles.json in current directory: {e}")
+        print(f"Current working directory: {os.getcwd()}")
+        print(f"Script directory: {os.path.dirname(os.path.abspath(__file__))}")
+    
+    # Also create roles.json in configs directory for reference
     roles_filename = os.path.join(output_dir, "roles.json")
     with open(roles_filename, 'w', encoding='utf-8') as f:
         json.dump(roles_config, f, indent=2, ensure_ascii=False)
     print(f"Generated: {roles_filename}")
-    # Also create roles.json in certs directory for compatibility
-    certs_dir = os.path.join(os.path.dirname(output_dir), "certs")
-    if os.path.exists(certs_dir):
-        certs_roles_filename = os.path.join(certs_dir, "roles.json")
-        with open(certs_roles_filename, 'w', encoding='utf-8') as f:
-            json.dump(roles_config, f, indent=2, ensure_ascii=False)
-        print(f"Generated: {certs_roles_filename}")
     print(f"\nGenerated {len(configs)} configuration files and roles.json in {output_dir}")
     
     print("\n" + "=" * 60)
@@ -273,12 +295,27 @@ def main():
     )
     parser.add_argument(
         "--output-dir",
-        default="./configs",
-        help="Output directory for configuration files (default: ./configs)"
+        default="configs",
+        help="Output directory for configuration files (default: configs)"
+    )
+    parser.add_argument(
+        "--certs-dir",
+        default="certs",
+        help="Certificates directory (default: certs)"
+    )
+    parser.add_argument(
+        "--keys-dir",
+        default="keys",
+        help="Keys directory (default: keys)"
+    )
+    parser.add_argument(
+        "--roles-file",
+        default="configs/roles.json",
+        help="Roles file path (default: configs/roles.json)"
     )
     args = parser.parse_args()
     try:
-        generate_all_configs(args.output_dir)
+        generate_all_configs(args.output_dir, args.certs_dir, args.keys_dir, args.roles_file)
         print("Configuration generation completed successfully!")
     except Exception as e:
         print(f"\n❌ CONFIGURATION GENERATION FAILED: {e}")

mcp_proxy_adapter/examples/run_full_test_suite.py

@@ -1,125 +1,318 @@
 #!/usr/bin/env python3
 """
-Full Test Suite Runner for MCP Proxy Adapter
-This script automatically runs the complete test suite:
-1. Setup test environment
-2. Generate configurations
-3. Create certificates
-4. Run security tests
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
+Full test suite runner for MCP Proxy Adapter.
+Automates the complete testing workflow.
 """
+import os
 import sys
 import subprocess
-import os
+import time
 from pathlib import Path
+from typing import List, Dict, Optional
 
-
-def run_command(cmd: list, description: str) -> bool:
-    """Run a command and return success status."""
-    try:
-        print(f"\n🚀 {description}")
-        print("=" * 60)
-
-        # Change to script directory if running from package
-        script_dir = Path(__file__).parent
-        if script_dir.name == "examples":
-            os.chdir(script_dir)
-
-        result = subprocess.run(
-            cmd,
-            capture_output=False,
-            text=True,
-            check=True,
-            cwd=script_dir
-        )
-        print(f"✅ {description} completed successfully")
-        return True
-    except subprocess.CalledProcessError as e:
-        print(f"❌ {description} failed:")
-        print(f"   Command: {' '.join(cmd)}")
-        print(f"   Error: {e.stderr}")
-        return False
-    except Exception as e:
-        print(f"❌ {description} failed: {e}")
-        return False
-
-
-def main():
-    """Run the complete test suite."""
-    print("🧪 MCP Proxy Adapter - Full Test Suite")
-    print("=" * 60)
-
-    # Check if we're in the right directory
-    current_dir = Path.cwd()
-    if not (current_dir / "setup_test_environment.py").exists():
-        print("❌ Please run this script from the examples directory")
-        return 1
-
-    success = True
-
-    # 1. Setup test environment
-    if not run_command([
-        sys.executable, "-m", "mcp_proxy_adapter.examples.setup_test_environment",
-        "--output-dir", "."
-    ], "Setting up test environment"):
-        success = False
-
-    # 2. Generate configurations
-    if success and not run_command([
-        sys.executable, "-m", "mcp_proxy_adapter.examples.generate_test_configs",
-        "--output-dir", "configs"
-    ], "Generating test configurations"):
-        success = False
-
-    # 3. Create certificates
-    if success and not run_command([
-        sys.executable, "-m", "mcp_proxy_adapter.examples.create_certificates_simple"
-    ], "Creating certificates"):
-        success = False
-
-    # 4. Copy roles.json to root directory
-    if success:
-        import shutil
-        from pathlib import Path
-        roles_file = Path("configs/roles.json")
-        if roles_file.exists():
-            shutil.copy2(roles_file, "roles.json")
-            print("✅ Copied roles.json to root directory")
+class FullTestSuiteRunner:
+    """Comprehensive test suite runner that automates the entire testing process."""
+    
+    def __init__(self):
+        """Initialize the test suite runner."""
+        self.working_dir = Path.cwd()
+        self.configs_dir = self.working_dir / "configs"
+        self.certs_dir = self.working_dir / "certs"
+        self.keys_dir = self.working_dir / "keys"
+        self.roles_file = self.working_dir / "configs" / "roles.json"
+        
+    def print_step(self, step: str, description: str):
+        """Print a formatted step header."""
+        print(f"\n{'='*60}")
+        print(f"🔧 STEP {step}: {description}")
+        print(f"{'='*60}")
+    
+    def print_success(self, message: str):
+        """Print a success message."""
+        print(f"✅ {message}")
+    
+    def print_error(self, message: str):
+        """Print an error message."""
+        print(f"❌ {message}")
+    
+    def print_info(self, message: str):
+        """Print an info message."""
+        print(f"ℹ️  {message}")
+    
+    def check_environment(self) -> bool:
+        """Check if the environment is properly set up."""
+        self.print_step("1", "Environment Validation")
+        
+        # Check if we're in a virtual environment
+        if not hasattr(sys, 'real_prefix') and not (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
+            self.print_error("Not running in a virtual environment!")
+            self.print_info("Please activate your virtual environment first:")
+            self.print_info("  source venv/bin/activate  # or .venv/bin/activate")
+            return False
+        
+        self.print_success("Virtual environment is active")
+        
+        # Check if mcp_proxy_adapter is installed
+        try:
+            import mcp_proxy_adapter
+            self.print_success(f"mcp_proxy_adapter is installed (version: {mcp_proxy_adapter.__version__})")
+        except ImportError:
+            self.print_error("mcp_proxy_adapter is not installed!")
+            self.print_info("Please install it first:")
+            self.print_info("  pip install mcp_proxy_adapter")
+            return False
+        
+        # Check Python version
+        python_version = sys.version_info
+        if python_version.major >= 3 and python_version.minor >= 8:
+            self.print_success(f"Python version: {python_version.major}.{python_version.minor}.{python_version.micro}")
         else:
-            success = False
-            print("❌ roles.json not found in configs directory")
+            self.print_error(f"Python {python_version.major}.{python_version.minor} is not supported. Need Python 3.8+")
+            return False
+        
+        return True
+    
+    def create_directories(self) -> bool:
+        """Create necessary directories for testing."""
+        self.print_step("2", "Directory Creation")
+        
+        try:
+            # Create configs directory
+            self.configs_dir.mkdir(exist_ok=True)
+            self.print_success(f"Created/verified configs directory: {self.configs_dir}")
+            
+            # Create certs directory
+            self.certs_dir.mkdir(exist_ok=True)
+            self.print_success(f"Created/verified certs directory: {self.certs_dir}")
+            
+            # Create keys directory
+            self.keys_dir.mkdir(exist_ok=True)
+            self.print_success(f"Created/verified keys directory: {self.keys_dir}")
+            
+            return True
+            
+        except Exception as e:
+            self.print_error(f"Failed to create directories: {e}")
+            return False
+    
+    def generate_certificates(self) -> bool:
+        """Generate SSL certificates for testing."""
+        self.print_step("3", "Certificate Generation")
+        
+        try:
+            # Run certificate generation script
+            cmd = [sys.executable, "-m", "mcp_proxy_adapter.examples.create_certificates_simple"]
+            self.print_info("Running certificate generation script...")
+            
+            result = subprocess.run(cmd, capture_output=True, text=True, cwd=self.working_dir)
+            
+            if result.returncode == 0:
+                self.print_success("Certificates generated successfully")
+                if result.stdout:
+                    print(result.stdout)
+                return True
+            else:
+                self.print_error("Certificate generation failed!")
+                if result.stderr:
+                    print("Error output:")
+                    print(result.stderr)
+                return False
+                
+        except Exception as e:
+            self.print_error(f"Failed to generate certificates: {e}")
+            return False
+    
+    def generate_configurations(self) -> bool:
+        """Generate test configurations."""
+        self.print_step("4", "Configuration Generation")
+        
+        try:
+            # Run configuration generation script
+            cmd = [sys.executable, "-m", "mcp_proxy_adapter.examples.generate_test_configs"]
+            self.print_info("Running configuration generation script...")
+            
+            result = subprocess.run(cmd, capture_output=True, text=True, cwd=self.working_dir)
+            
+            if result.returncode == 0:
+                self.print_success("Configurations generated successfully")
+                if result.stdout:
+                    print(result.stdout)
+                return True
+            else:
+                self.print_error("Configuration generation failed!")
+                if result.stderr:
+                    print("Error output:")
+                    print(result.stderr)
+                return False
+                
+        except Exception as e:
+            self.print_error(f"Failed to generate configurations: {e}")
+            return False
+    
+    def run_security_tests(self) -> bool:
+        """Run the security test suite."""
+        self.print_step("5", "Security Testing")
+        
+        try:
+            # Run security tests
+            cmd = [sys.executable, "-m", "mcp_proxy_adapter.examples.run_security_tests", "--verbose"]
+            self.print_info("Running security tests...")
+            
+            # Debug: show current working directory and check files
+            self.print_info(f"DEBUG: Current working directory: {os.getcwd()}")
+            self.print_info(f"DEBUG: Working directory from class: {self.working_dir}")
+            
+            # Check if certificates exist before running tests
+            localhost_cert = self.certs_dir / "localhost_server.crt"
+            self.print_info(f"DEBUG: localhost_server.crt exists: {localhost_cert.exists()}")
+            if localhost_cert.exists():
+                self.print_info(f"DEBUG: localhost_server.crt is symlink: {localhost_cert.is_symlink()}")
+                if localhost_cert.is_symlink():
+                    self.print_info(f"DEBUG: localhost_server.crt symlink target: {localhost_cert.readlink()}")
+            
+            # List all files in certs directory
+            self.print_info("DEBUG: Files in certs directory:")
+            for file in self.certs_dir.iterdir():
+                self.print_info(f"DEBUG:   {file.name} -> {file}")
+            
+            result = subprocess.run(cmd, capture_output=True, text=True, cwd=self.working_dir)
+            
+            if result.returncode == 0:
+                self.print_success("Security tests completed successfully!")
+                if result.stdout:
+                    print(result.stdout)
+                return True
+            else:
+                self.print_error("Security tests failed!")
+                if result.stdout:
+                    print("Test output:")
+                    print(result.stdout)
+                if result.stderr:
+                    print("Error output:")
+                    print(result.stderr)
+                return False
+                
+        except Exception as e:
+            self.print_error(f"Failed to run security tests: {e}")
+            return False
+    
+    def cleanup(self):
+        """Clean up temporary files and processes."""
+        self.print_info("Cleaning up...")
+        
+        # Simple cleanup - just print success message
+        # Process cleanup is handled by the test scripts themselves
+        print("✅ Cleanup completed")
+    
 
-    # 5. Run security tests
-    if success and not run_command([
-        sys.executable, "-m", "mcp_proxy_adapter.examples.run_security_tests"
-    ], "Running security tests"):
-        success = False
 
-    # Final result
-    print("\n" + "=" * 60)
-    if success:
-        print("🎉 FULL TEST SUITE COMPLETED SUCCESSFULLY!")
-        print("=" * 60)
-        print("\n📋 SUMMARY:")
-        print("✅ Test environment setup")
-        print("✅ Configuration generation")
-        print("✅ Certificate creation")
-        print("✅ Roles configuration")
-        print("✅ Security testing")
-        print("\n🚀 All systems are working correctly!")
-        return 0
-    else:
-        print("❌ FULL TEST SUITE FAILED!")
+    def cleanup_directories(self) -> bool:
+        """Clean up existing test directories before starting."""
+        self.print_info("Cleaning up existing test directories...")
+        
+        try:
+            import shutil
+            
+            # Directories to clean
+            dirs_to_clean = [self.configs_dir, self.certs_dir, self.keys_dir]
+            files_to_clean = [self.working_dir / "roles.json"]
+            
+            # Remove directories
+            for dir_path in dirs_to_clean:
+                if dir_path.exists():
+                    shutil.rmtree(dir_path)
+                    print(f"🗑️  Removed directory: {dir_path}")
+            
+            # Remove files
+            for file_path in files_to_clean:
+                if file_path.exists():
+                    file_path.unlink()
+                    print(f"🗑️  Removed file: {file_path}")
+            
+            self.print_success("Directory cleanup completed")
+            return True
+            
+        except Exception as e:
+            self.print_error(f"Failed to cleanup directories: {e}")
+            return False
+    
+    def run_full_suite(self) -> bool:
+        """Run the complete test suite."""
+        print("🚀 MCP Proxy Adapter - Full Test Suite")
         print("=" * 60)
-        print("\n🔧 TROUBLESHOOTING:")
-        print("1. Check the error messages above")
-        print("2. Ensure you have write permissions")
-        print("3. Make sure ports 20000-20010 are free")
-        print("4. Check if mcp_security_framework is installed")
-        return 1
+        print(f"Working directory: {self.working_dir}")
+        print(f"Python executable: {sys.executable}")
+        
+        try:
+            # Step 0: Clean up existing directories
+            if not self.cleanup_directories():
+                return False
+            
+            # Step 1: Environment validation
+            if not self.check_environment():
+                return False
+            
+            # Step 2: Directory creation
+            if not self.create_directories():
+                return False
+            
+            # Step 3: Certificate generation
+            if not self.generate_certificates():
+                return False
+            
+            # Step 4: Configuration generation
+            if not self.generate_configurations():
+                return False
+            
+            # Step 5: Security testing
+            if not self.run_security_tests():
+                return False
+            
+            # All steps completed successfully
+            print(f"\n{'='*60}")
+            print("🎉 FULL TEST SUITE COMPLETED SUCCESSFULLY!")
+            print("="*60)
+            print("✅ Environment validated")
+            print("✅ Directories cleaned")
+            print("✅ Directories created")
+            print("✅ Certificates generated")
+            print("✅ Configurations generated")
+            print("✅ Security tests passed")
+            print(f"\n📁 Test artifacts created in: {self.working_dir}")
+            print(f"📁 Configurations: {self.configs_dir}")
+            print(f"📁 Certificates: {self.certs_dir}")
+            print(f"📁 Keys: {self.keys_dir}")
+            
+            return True
+            
+        except KeyboardInterrupt:
+            print("\n\n⚠️  Test suite interrupted by user")
+            return False
+        except Exception as e:
+            self.print_error(f"Unexpected error during test suite execution: {e}")
+            return False
+        finally:
+            try:
+                self.print_info("Starting cleanup in finally block...")
+                self.cleanup()
+                self.print_info("Cleanup in finally block completed")
+            except Exception as e:
+                self.print_error(f"Cleanup failed in finally block: {e}")
+                import traceback
+                traceback.print_exc()
 
+def main():
+    """Main entry point."""
+    runner = FullTestSuiteRunner()
+    
+    try:
+        success = runner.run_full_suite()
+        sys.exit(0 if success else 1)
+    except Exception as e:
+        print(f"❌ Fatal error: {e}")
+        sys.exit(1)
 
 if __name__ == "__main__":
-    exit(main())
+    main()