mcp-proxy-adapter 6.4.36__py3-none-any.whl → 6.4.39__py3-none-any.whl

mcp_proxy_adapter/examples/create_test_configs.py

@@ -175,7 +175,8 @@ class TestConfigGenerator:
             "security.auth.methods": ["certificate"],
             "security.permissions.enabled": False,
             "proxy_registration.enabled": False,
-            "protocols.allowed_protocols": ["https", "mtls"]
+            "protocols.allowed_protocols": ["https", "mtls"],
+            "protocols.default_protocol": "mtls"
         })
         
         # 7. mTLS with Proxy Registration
@@ -196,37 +197,11 @@ class TestConfigGenerator:
             "protocols.allowed_protocols": ["https", "mtls"]
         })
         
-        # 8. HTTP with Token Auth (for security tests)
-        self.create_config("http_token", {
-            "server.port": 8010,
-            "ssl.enabled": False,
-            "security.enabled": True,
-            "security.auth.enabled": True,
-            "security.auth.methods": ["api_key"],
-            "security.auth.api_keys": {
-                "admin": "admin-secret-key",
-                "user": "user-secret-key"
-            },
-            "proxy_registration.enabled": False,
-            "protocols.allowed_protocols": ["http"]
-        })
+        # 8. HTTP with Token Auth (for security tests) - REMOVED DUPLICATE
+        # This is already created above with correct port 20021
         
-        # 9. HTTPS with Token Auth (for security tests)
-        self.create_config("https_token", {
-            "server.port": 8011,
-            "ssl.enabled": True,
-            "ssl.cert_file": "certs/localhost_server.crt",
-            "ssl.key_file": "keys/localhost_server.key",
-            "security.enabled": True,
-            "security.auth.enabled": True,
-            "security.auth.methods": ["api_key"],
-            "security.auth.api_keys": {
-                "admin": "admin-secret-key",
-                "user": "user-secret-key"
-            },
-            "proxy_registration.enabled": False,
-            "protocols.allowed_protocols": ["https"]
-        })
+        # 9. HTTPS with Token Auth (for security tests) - REMOVED DUPLICATE  
+        # This is already created above with correct port 20023
         
         # 10. Full Featured (everything enabled)
         self.create_config("full_featured", {

mcp_proxy_adapter/examples/run_full_test_suite.py

@@ -8,9 +8,7 @@ Automates the complete testing workflow.
 import os
 import sys
 import subprocess
-import time
 from pathlib import Path
-from typing import List, Dict, Optional
 
 
 class FullTestSuiteRunner:
@@ -26,9 +24,9 @@ class FullTestSuiteRunner:
 
     def print_step(self, step: str, description: str):
         """Print a formatted step header."""
-        print(f"\n{'='*60}")
+        print(f"\n{'=' * 60}")
         print(f"🔧 STEP {step}: {description}")
-        print(f"{'='*60}")
+        print(f"{'=' * 60}")
 
     def print_success(self, message: str):
         """Print a success message."""
@@ -114,8 +112,19 @@ class FullTestSuiteRunner:
         self.print_step("3", "Certificate Generation")
 
         try:
+            # Check if certificate generation script exists
+            cert_script = self.working_dir / "scripts" / "create_certificates_simple.py"
+            if not cert_script.exists():
+                # Try alternative path
+                cert_script = self.working_dir / "create_certificates_simple.py"
+                if not cert_script.exists():
+                    self.print_error(
+                        f"Certificate generation script not found: {cert_script}"
+                    )
+                    return False
+
             # Run certificate generation script
-            cmd = [sys.executable, "scripts/create_certificates_simple.py"]
+            cmd = [sys.executable, str(cert_script)]
             self.print_info("Running certificate generation script...")
 
             result = subprocess.run(
@@ -152,18 +161,29 @@ class FullTestSuiteRunner:
             # Check if comprehensive_config.json exists
             comprehensive_config = self.working_dir / "comprehensive_config.json"
             if not comprehensive_config.exists():
-                self.print_error(f"Comprehensive config not found: {comprehensive_config}")
+                self.print_error(
+                    f"Comprehensive config not found: {comprehensive_config}"
+                )
                 return False
 
-            self.print_info("Generating test configurations from comprehensive config...")
+            self.print_info(
+                "Generating test configurations from comprehensive config..."
+            )
             self.print_info("This will create:")
             self.print_info("  - HTTP configurations (simple and with auth)")
             self.print_info("  - HTTPS configurations (simple and with auth)")
-            self.print_info("  - mTLS configurations (simple, with roles, with proxy registration)")
+            self.print_info(
+                "  - mTLS configurations (simple, with roles, with proxy registration)"
+            )
             self.print_info("  - Full featured configuration (everything enabled)")
 
             # Run the configuration generator
-            cmd = [sys.executable, "create_test_configs.py", "--comprehensive-config", "comprehensive_config.json"]
+            cmd = [
+                sys.executable,
+                "create_test_configs.py",
+                "--comprehensive-config",
+                "comprehensive_config.json",
+            ]
             result = subprocess.run(
                 cmd, capture_output=True, text=True, cwd=self.working_dir
             )
@@ -173,36 +193,37 @@ class FullTestSuiteRunner:
                 if result.stdout:
                     print("Generator output:")
                     print(result.stdout)
-                
+
                 # Create roles.json file
                 self.print_info("Creating roles.json file...")
                 roles_content = {
                     "roles": {
                         "admin": {
                             "permissions": ["*"],
-                            "description": "Full administrative access"
+                            "description": "Full administrative access",
                         },
                         "user": {
                             "permissions": ["read", "write"],
-                            "description": "Standard user access"
+                            "description": "Standard user access",
                         },
                         "readonly": {
                             "permissions": ["read"],
-                            "description": "Read-only access"
+                            "description": "Read-only access",
                         },
                         "guest": {
                             "permissions": ["read"],
-                            "description": "Limited guest access"
-                        }
+                            "description": "Limited guest access",
+                        },
                     }
                 }
-                
+
                 roles_file = self.configs_dir / "roles.json"
                 import json
-                with open(roles_file, 'w', encoding='utf-8') as f:
+
+                with open(roles_file, "w", encoding="utf-8") as f:
                     json.dump(roles_content, f, indent=2, ensure_ascii=False)
                 self.print_success(f"Created roles.json: {roles_file}")
-                
+
                 return True
             else:
                 self.print_error("Configuration generation failed!")
@@ -287,29 +308,28 @@ class FullTestSuiteRunner:
             # Create test_proxy_registration.json config if it doesn't exist
             test_config = self.configs_dir / "test_proxy_registration.json"
             if not test_config.exists():
-                self.print_info("Creating test_proxy_registration.json configuration...")
+                self.print_info(
+                    "Creating test_proxy_registration.json configuration..."
+                )
                 test_config_content = {
                     "uuid": "550e8400-e29b-41d4-a716-446655440001",
-                    "server": {
-                        "host": "127.0.0.1",
-                        "port": 20005
-                    },
+                    "server": {"host": "127.0.0.1", "port": 20006},
                     "ssl": {
                         "enabled": True,
                         "cert_file": "certs/localhost_server.crt",
-                        "key_file": "keys/localhost_server.key",
+                        "key_file": "keys/server_key.pem",
                         "ca_cert": "certs/mcp_proxy_adapter_ca_ca.crt",
                         "client_cert_file": "certs/admin_cert.pem",
                         "client_key_file": "certs/admin_key.pem",
-                        "verify_client": True
+                        "verify_client": True,
                     },
                     "registration": {
                         "enabled": True,
                         "auth_method": "token",
-                        "server_url": "http://127.0.0.1:3006/proxy",
+                        "server_url": "https://127.0.0.1:20005/proxy",
                         "token": {
                             "enabled": True,
-                            "token": "proxy_registration_token_123"
+                            "token": "proxy_registration_token_123",
                         },
                         "proxy_info": {
                             "name": "mcp_test_server",
@@ -317,50 +337,42 @@ class FullTestSuiteRunner:
                                 "jsonrpc",
                                 "rest",
                                 "security",
-                                "proxy_registration"
+                                "proxy_registration",
                             ],
                             "endpoints": {
                                 "jsonrpc": "/api/jsonrpc",
                                 "rest": "/cmd",
-                                "health": "/health"
-                            }
+                                "health": "/health",
+                            },
                         },
-                        "heartbeat": {
-                            "enabled": True,
-                            "interval": 30
-                        }
+                        "heartbeat": {"enabled": True, "interval": 30},
                     },
                     "security": {
                         "enabled": True,
-                        "auth": {
-                            "enabled": True,
-                            "methods": [
-                                "certificate"
-                            ]
-                        },
+                        "auth": {"enabled": True, "methods": ["certificate"]},
                         "permissions": {
                             "enabled": True,
-                            "roles_file": "configs/roles.json"
-                        }
+                            "roles_file": "configs/roles.json",
+                        },
                     },
                     "protocols": {
                         "enabled": True,
                         "default_protocol": "mtls",
-                        "allowed_protocols": [
-                            "https",
-                            "mtls"
-                        ]
-                    }
+                        "allowed_protocols": ["https", "mtls"],
+                    },
                 }
-                
+
                 import json
-                with open(test_config, 'w', encoding='utf-8') as f:
+
+                with open(test_config, "w", encoding="utf-8") as f:
                     json.dump(test_config_content, f, indent=2)
                 self.print_success(f"Created test configuration: {test_config}")
 
             self.print_info("Running mTLS proxy registration test...")
             self.print_info("This test verifies:")
-            self.print_info("  - mTLS server startup with client certificate verification")
+            self.print_info(
+                "  - mTLS server startup with client certificate verification"
+            )
             self.print_info("  - Proxy registration functionality")
             self.print_info("  - SSL configuration validation")
 
@@ -371,7 +383,9 @@ class FullTestSuiteRunner:
             )
 
             if result.returncode == 0:
-                self.print_success("mTLS proxy registration test completed successfully!")
+                self.print_success(
+                    "mTLS proxy registration test completed successfully!"
+                )
                 if result.stdout:
                     print("Test output:")
                     print(result.stdout)
@@ -461,7 +475,7 @@ class FullTestSuiteRunner:
                 return False
 
             # All steps completed successfully
-            print(f"\n{'='*60}")
+            print(f"\n{'=' * 60}")
             print("🎉 FULL TEST SUITE COMPLETED SUCCESSFULLY!")
             print("=" * 60)
             print("✅ Environment validated")

mcp_proxy_adapter/examples/run_security_tests.py

@@ -25,10 +25,19 @@ import psutil
 import requests
 
 # Import security test client with proper module path
-from mcp_proxy_adapter.examples.security_test_client import (
-    SecurityTestClient,
-    TestResult,
-)
+try:
+    from mcp_proxy_adapter.examples.security_test_client import (
+        SecurityTestClient,
+        TestResult,
+    )
+except ImportError:
+    # Fallback to local import if package import fails
+    current_dir = Path(__file__).parent
+    sys.path.insert(0, str(current_dir))
+    from security_test_client import (
+        SecurityTestClient,
+        TestResult,
+    )
 
 
 class SecurityTestRunner:
@@ -49,31 +58,31 @@ class SecurityTestRunner:
             "basic_http": {
                 "config": "configs/http_simple.json",
                 "port": 20020,  # Dedicated port
-                "url": f"http://127.0.0.1:20020",
+                "url": "http://127.0.0.1:20020",
                 "auth": "none",
             },
             "http_token": {
                 "config": "configs/http_token.json",
                 "port": 20021,  # Dedicated port
-                "url": f"http://127.0.0.1:20021",
+                "url": "http://127.0.0.1:20021",
                 "auth": "api_key",
             },
             "https": {
                 "config": "configs/https_simple.json",
                 "port": 20022,  # Dedicated port
-                "url": f"https://127.0.0.1:20022",
+                "url": "https://127.0.0.1:20022",
                 "auth": "none",
             },
             "https_token": {
                 "config": "configs/https_token.json",
                 "port": 20023,  # Dedicated port
-                "url": f"https://127.0.0.1:20023",
+                "url": "https://127.0.0.1:20023",
                 "auth": "api_key",
             },
             "mtls": {
                 "config": "configs/mtls_no_roles.json",
                 "port": 20024,  # Dedicated port
-                "url": f"https://127.0.0.1:20024",
+                "url": "https://127.0.0.1:20024",
                 "auth": "certificate",
             },
         }
@@ -146,6 +155,17 @@ class SecurityTestRunner:
             ports.append(cfg["port"])
         return list(sorted(set(ports)))
 
+    def check_ports_available(self, ports: List[int]) -> Tuple[bool, List[int]]:
+        """
+        Check if all ports in the list are available.
+        Returns (True, []) if all ports are free, (False, occupied_ports) otherwise.
+        """
+        occupied_ports = []
+        for port in ports:
+            if self._port_in_use(port):
+                occupied_ports.append(port)
+        return len(occupied_ports) == 0, occupied_ports
+
     def _validate_file(self, base: Path, path_value: Optional[str]) -> Tuple[bool, str]:
         if not path_value:
             return True, ""
@@ -229,13 +249,20 @@ class SecurityTestRunner:
         """Start a server in background."""
         try:
             print(f"🚀 Starting {name} server on port {port}...")
-            
-            # Check if port is still available (should be, since we checked at start)
+
+            # Always ensure port is free before starting server
             if self._port_in_use(port):
-                print(f"❌ Port {port} is unexpectedly in use, cannot start {name}")
-                print("💡 This should not happen - ports were checked at startup")
-                return None
-                
+                print(f"🧹 Port {port} is in use, freeing it...")
+                self.ensure_ports_free([port])
+                time.sleep(1)  # Give time for port to be freed
+
+                # Check again after freeing
+                if self._port_in_use(port):
+                    print(
+                        f"❌ Port {port} still in use after cleanup, cannot start {name}"
+                    )
+                    return None
+
             # Start server in background
             logs_dir = Path("logs")
             logs_dir.mkdir(exist_ok=True)
@@ -293,11 +320,25 @@ class SecurityTestRunner:
         """Start the proxy server for server registration."""
         try:
             print("🚀 Starting proxy server...")
+
+            # Ensure proxy port is free
+            if self._port_in_use(self.proxy_port):
+                print(f"🧹 Proxy port {self.proxy_port} is in use, freeing it...")
+                self.ensure_ports_free([self.proxy_port])
+                time.sleep(1)
+
+                if self._port_in_use(self.proxy_port):
+                    print(f"❌ Proxy port {self.proxy_port} still in use after cleanup")
+                    return False
+
             # Find the proxy server script
             proxy_script = Path(__file__).parent / "run_proxy_server.py"
             if not proxy_script.exists():
-                print("❌ Proxy server script not found")
-                return False
+                # Try alternative path
+                proxy_script = Path.cwd() / "run_proxy_server.py"
+                if not proxy_script.exists():
+                    print("❌ Proxy server script not found")
+                    return False
 
             # Start proxy server
             cmd = [
@@ -372,13 +413,27 @@ class SecurityTestRunner:
             # Override SSL context for mTLS
             client.create_ssl_context = client.create_ssl_context_for_mtls
             async with client as client_session:
-                results = await client_session.run_security_tests(
-                    config["url"], config["auth"]
-                )
+                # Pass correct token for api_key authentication
+                if config["auth"] == "api_key":
+                    results = await client_session.run_security_tests(
+                        config["url"], config["auth"], token="admin-secret-key"
+                    )
+                else:
+                    results = await client_session.run_security_tests(
+                        config["url"], config["auth"]
+                    )
         else:
             # For other auth types, use default SSL context
             async with SecurityTestClient(config["url"]) as client:
-                results = await client.run_security_tests(config["url"], config["auth"])
+                # Pass correct token for api_key authentication
+                if config["auth"] == "api_key":
+                    results = await client.run_security_tests(
+                        config["url"], config["auth"], token="admin-secret-key"
+                    )
+                else:
+                    results = await client.run_security_tests(
+                        config["url"], config["auth"]
+                    )
         # Print summary for this server
         passed = sum(1 for r in results if r.success)
         total = len(results)
@@ -521,13 +576,13 @@ class SecurityTestRunner:
             print("\n🔍 STEP 1: Complete Port Availability Check")
             all_ports = self.get_all_ports()
             print(f"📋 Required ports: {all_ports}")
-            
+
             # Check if ALL ports are available
             ports_available, occupied_ports = self.check_ports_available(all_ports)
             if not ports_available:
                 print(f"❌ CRITICAL: Ports are occupied: {occupied_ports}")
                 print("🧹 Attempting to free occupied ports...")
-                
+
                 if not self.ensure_ports_free(all_ports):
                     print("❌ FAILED: Could not free occupied ports. Aborting tests.")
                     print("💡 Manual cleanup required:")
@@ -584,7 +639,7 @@ def main():
         "--no-cleanup", action="store_true", help="Don't cleanup servers after tests"
     )
     parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
-    args = parser.parse_args()
+    parser.parse_args()
 
     # Determine the correct configs directory
     current_dir = Path.cwd()

mcp_proxy_adapter/examples/security_test_client.py

@@ -11,28 +11,26 @@ Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
 import asyncio
-import json
 import os
 import ssl
 import sys
 import time
 from pathlib import Path
-from typing import Dict, List, Optional, Any
+from typing import Dict, List, Optional
 from dataclasses import dataclass
-import aiohttp
 from aiohttp import ClientSession, ClientTimeout, TCPConnector
 
 # Add project root to path for imports
-project_root = Path(__file__).parent.parent.parent
 current_dir = Path(__file__).parent
 parent_dir = current_dir.parent
-sys.path.insert(0, str(project_root))
+# Only add paths that are likely to exist and be useful
+if parent_dir.exists():
+    sys.path.insert(0, str(parent_dir))
 sys.path.insert(0, str(current_dir))
-sys.path.insert(0, str(parent_dir))
 
 # Import mcp_security_framework components
 try:
-    from mcp_security_framework import SSLManager, CertificateManager
+    from mcp_security_framework import SSLManager
     from mcp_security_framework.schemas.config import SSLConfig
 
     _MCP_SECURITY_AVAILABLE = True
@@ -43,9 +41,6 @@ except ImportError:
 
 # Import cryptography components
 try:
-    from cryptography import x509
-    from cryptography.hazmat.primitives import serialization
-
     _CRYPTOGRAPHY_AVAILABLE = True
     print("✅ cryptography available")
 except ImportError:
@@ -111,19 +106,19 @@ class SecurityTestClient:
             "proxy": "proxy-token-123",
             "invalid": "invalid-token-999",
         }
-        # Test certificates
+        # Test certificates - use relative paths
         self.test_certificates = {
             "admin": {
-                "cert": "mcp_proxy_adapter/examples/certs/admin_cert.pem",
-                "key": "mcp_proxy_adapter/examples/certs/admin_key.pem",
+                "cert": "certs/admin_cert.pem",
+                "key": "certs/admin_key.pem",
             },
             "user": {
-                "cert": "mcp_proxy_adapter/examples/certs/user_cert.pem",
-                "key": "mcp_proxy_adapter/examples/certs/user_key.pem",
+                "cert": "certs/user_cert.pem",
+                "key": "certs/user_key.pem",
             },
             "readonly": {
-                "cert": "mcp_proxy_adapter/examples/certs/readonly_cert.pem",
-                "key": "mcp_proxy_adapter/examples/certs/readonly_key.pem",
+                "cert": "certs/readonly_cert.pem",
+                "key": "certs/readonly_key.pem",
             },
         }
 
@@ -227,6 +222,7 @@ class SecurityTestClient:
         headers = {"Content-Type": "application/json"}
         if auth_type == "api_key":
             token = kwargs.get("token", "test-token-123")
+            print(f"🔍 DEBUG: Using token: {token}")
             # Provide both common header styles to maximize compatibility
             headers["X-API-Key"] = token
             headers["Authorization"] = f"Bearer {token}"
@@ -430,9 +426,7 @@ class SecurityTestClient:
         try:
             if auth_type == "certificate":
                 # For mTLS, test with invalid/expired certificate or no certificate
-                import aiohttp
                 from aiohttp import ClientTimeout, TCPConnector
-                import ssl
 
                 # Create SSL context with wrong certificate (should be rejected)
                 ssl_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
@@ -450,6 +444,8 @@ class SecurityTestClient:
                 timeout = ClientTimeout(total=10)  # Shorter timeout
 
                 try:
+                    import aiohttp
+
                     async with aiohttp.ClientSession(
                         timeout=timeout, connector=connector
                     ) as temp_session:
@@ -474,11 +470,7 @@ class SecurityTestClient:
                                 error_message=f"SECURITY ISSUE: mTLS server accepted connection without client certificate (status: {response.status})",
                                 duration=duration,
                             )
-                except (
-                    aiohttp.ClientError,
-                    aiohttp.ServerDisconnectedError,
-                    asyncio.TimeoutError,
-                ) as e:
+                except (Exception,) as e:
                     # This is expected - server should reject connections without proper certificate
                     duration = time.time() - start_time
                     return TestResult(
@@ -797,7 +789,7 @@ class SecurityTestClient:
         print(f"Total Tests: {total_tests}")
         print(f"Passed: {passed_tests} ✅")
         print(f"Failed: {failed_tests} ❌")
-        print(f"Success Rate: {(passed_tests/total_tests*100):.1f}%")
+        print(f"Success Rate: {(passed_tests / total_tests * 100):.1f}%")
         if failed_tests > 0:
             print("\n❌ Failed Tests:")
             for result in self.test_results:

mcp_proxy_adapter/examples/setup_test_environment.py

@@ -25,7 +25,7 @@ import sys
 import argparse
 import json
 from pathlib import Path
-from typing import Dict, List, Any, Optional, Tuple
+from typing import Dict, List, Any, Tuple
 
 # Import mcp_security_framework
 try:
@@ -191,8 +191,10 @@ def _get_package_paths() -> tuple[Path, Path]:
     # 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
-    
+    utils_path = (
+        pkg_root / "examples" / "scripts"
+    )  # utils scripts are in examples/scripts in the package
+
     return examples_path, utils_path
 
 
@@ -440,12 +442,12 @@ async def register_server(request: Request):
     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={
@@ -489,14 +491,14 @@ async def main():
     print("   POST /register - Register 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.certfile = "certs/localhost_server.crt"
     config.keyfile = "keys/server_key.pem"
     config.loglevel = "info"
-    
+
     # Run server with mTLS using Hypercorn
     await hypercorn.asyncio.serve(app, config)
 
@@ -532,7 +534,7 @@ def test_proxy_registration():
     """Test proxy registration with SSL configuration."""
     print("🧪 Testing Proxy Registration SSL Configuration Fix")
     print("=" * 60)
-    
+
     # Kill any existing process on port 20005
     print("🧹 Killing any existing process on port 20005...")
     try:
@@ -540,21 +542,27 @@ def test_proxy_registration():
     except FileNotFoundError:
         # fuser not available, try with lsof
         try:
-            subprocess.run(["lsof", "-ti:20005", "|", "xargs", "kill", "-9"], shell=True, check=False, capture_output=True)
+            # 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
         print("🔍 Testing proxy server health...")
         try:
@@ -571,19 +579,19 @@ def test_proxy_registration():
         except Exception as e:
             print(f"❌ Failed to connect to proxy server: {e}")
             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")
@@ -592,13 +600,13 @@ def test_proxy_registration():
             else:
                 print("❌ mTLS server failed to start")
                 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:
@@ -609,7 +617,7 @@ def test_proxy_registration():
 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
@@ -647,30 +655,23 @@ def generate_enhanced_configurations(output_dir: Path) -> None:
                 "debug": False,
                 "log_level": "INFO",
                 "workers": 1,
-                "reload": False
-            },
-            "ssl": {
-                "enabled": False
+                "reload": False,
             },
+            "ssl": {"enabled": False},
             "security": {
                 "enabled": True,
                 "auth": {
                     "enabled": True,
-                    "methods": [
-                        "api_key"
-                    ],
+                    "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"
-                    }
+                        "proxy-token-def": "proxy",
+                    },
                 },
-                "permissions": {
-                    "enabled": True,
-                    "roles_file": "configs/roles.json"
-                }
+                "permissions": {"enabled": True, "roles_file": "configs/roles.json"},
             },
             "registration": {
                 "enabled": True,
@@ -681,21 +682,13 @@ def generate_enhanced_configurations(output_dir: Path) -> None:
                     "token_auth",
                     "roles",
                     "registration",
-                    "heartbeat"
+                    "heartbeat",
                 ],
                 "retry_count": 3,
                 "retry_delay": 5,
-                "heartbeat": {
-                    "enabled": True,
-                    "interval": 30
-                }
+                "heartbeat": {"enabled": True, "interval": 30},
             },
-            "protocols": {
-                "enabled": True,
-                "allowed_protocols": [
-                    "http"
-                ]
-            }
+            "protocols": {"enabled": True, "allowed_protocols": ["http"]},
         }
     }
 
@@ -886,30 +879,27 @@ def setup_test_environment(output_dir: Path) -> None:
     test_files = [
         "create_test_configs.py",
         "run_security_tests.py",
-        "run_proxy_server.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
-            },
+            "server": {"host": "127.0.0.1", "port": 20001},
             "ssl": {
                 "enabled": False,
                 "cert_file": "certs/localhost_server.crt",
                 "key_file": "keys/localhost_server.key",
                 "ca_cert": "certs/mcp_proxy_adapter_ca_ca.crt",
-                "verify_client": False
+                "verify_client": False,
             },
             "security": {
                 "enabled": True,
@@ -919,22 +909,19 @@ def setup_test_environment(output_dir: Path) -> None:
                     "api_keys": {
                         "admin-token-123": "admin",
                         "user-token-456": "user",
-                        "readonly-token-789": "readonly"
-                    }
+                        "readonly-token-789": "readonly",
+                    },
                 },
-                "permissions": {
-                    "enabled": True,
-                    "roles_file": "roles.json"
-                }
+                "permissions": {"enabled": True, "roles_file": "roles.json"},
             },
             "protocols": {
                 "enabled": True,
                 "default_protocol": "http",
-                "allowed_protocols": ["http"]
-            }
+                "allowed_protocols": ["http"],
+            },
         }
-        
-        with open(comprehensive_config_dst, 'w', encoding='utf-8') as f:
+
+        with open(comprehensive_config_dst, "w", encoding="utf-8") as f:
             json.dump(comprehensive_config, f, indent=2)
         print("✅ Created comprehensive_config.json")
     else:
@@ -951,21 +938,21 @@ def setup_test_environment(output_dir: Path) -> None:
             "roles": {
                 "admin": {
                     "permissions": ["*"],
-                    "description": "Full access to all commands"
+                    "description": "Full access to all commands",
                 },
                 "user": {
                     "permissions": ["echo", "health", "help"],
-                    "description": "Basic user permissions"
+                    "description": "Basic user permissions",
                 },
                 "readonly": {
                     "permissions": ["health", "help"],
-                    "description": "Read-only access"
-                }
+                    "description": "Read-only access",
+                },
             }
         }
-        
+
         roles_dst = output_dir / "roles.json"
-        with open(roles_dst, 'w', encoding='utf-8') as f:
+        with open(roles_dst, "w", encoding="utf-8") as f:
             json.dump(roles_config, f, indent=2)
         print("✅ Created roles.json in root directory")
 
@@ -1102,10 +1089,10 @@ def generate_certificates_with_framework(output_dir: Path) -> bool:
                 roles=roles,
                 permissions=permissions,
                 ca_cert_path=cert_pair.certificate_path,
-                ca_key_path=ca_key_path,
+                ca_key_path=cert_pair.private_key_path,
             )
-            cert_pair = cert_manager.create_client_certificate(client_config)
-            if not cert_pair or not cert_pair.certificate_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 {}: "
@@ -1134,33 +1121,36 @@ def run_full_test_suite(target_root: Path) -> bool:
     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
-        
+        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
@@ -1175,21 +1165,21 @@ def run_full_test_suite(target_root: Path) -> bool:
 def validate_output_directory(output_dir: Path) -> bool:
     """
     Validate output directory for test environment setup.
-    
+
     Args:
         output_dir: Path to the target directory
-        
+
     Returns:
         True if directory is valid for setup, False otherwise
     """
     output_dir = output_dir.resolve()
-    
+
     # 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}")
             return False
-            
+
         # Check if directory is empty
         try:
             contents = list(output_dir.iterdir())
@@ -1216,7 +1206,7 @@ def validate_output_directory(output_dir: Path) -> bool:
         except Exception as e:
             print(f"❌ Failed to create directory {output_dir}: {e}")
             return False
-    
+
     return True
 
 
@@ -1226,7 +1216,7 @@ def check_ports_available() -> bool:
     Returns True if all ports are free, False otherwise.
     """
     import socket
-    
+
     # Ports used by the test suite - UPDATED with dedicated ports
     test_ports = [
         20010,  # proxy_port
@@ -1238,17 +1228,17 @@ def check_ports_available() -> bool:
         20025,  # mtls_simple
         20026,  # mtls_with_roles
         20005,  # test_proxy_server
-        3006,   # proxy registration
+        3006,  # proxy registration
     ]
-    
+
     occupied_ports = []
-    
+
     print("🔍 Checking port availability...")
     for port in test_ports:
         try:
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
                 sock.settimeout(1)
-                result = sock.connect_ex(('127.0.0.1', port))
+                result = sock.connect_ex(("127.0.0.1", port))
                 if result == 0:
                     occupied_ports.append(port)
                     print(f"   ❌ Port {port} is occupied")
@@ -1257,9 +1247,11 @@ def check_ports_available() -> bool:
         except Exception as e:
             print(f"   ⚠️ Could not check port {port}: {e}")
             occupied_ports.append(port)
-    
+
     if occupied_ports:
-        print(f"\n❌ CRITICAL: {len(occupied_ports)} ports are occupied: {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")
@@ -1267,7 +1259,7 @@ def check_ports_available() -> bool:
         for port in occupied_ports:
             print(f"   fuser -k {port}/tcp")
         return False
-    
+
     print(f"✅ All {len(test_ports)} required ports are available")
     return True
 
@@ -1294,32 +1286,33 @@ def main() -> int:
         "--skip-tests", action="store_true", help="Skip running the full test suite"
     )
     args = parser.parse_args()
-    
+
     # FIRST: Check port availability - if this fails, don't proceed
     print("🔍 STEP 1: Port Availability Check")
     if not check_ports_available():
         print("\n❌ FAILED: Required ports are occupied. Aborting setup.")
         print("💡 Please free the occupied ports and try again.")
         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.")
             return 1
-        
+
         print(f"✅ Directory validation passed: {target_root}")
         setup_test_environment(target_root)
 
@@ -1333,7 +1326,7 @@ def main() -> int:
                 "⚠️ Skipping certificate generation (mcp_security_framework "
                 "not available)"
             )
-            
+
         # Run full test suite if not skipped
         if not args.skip_tests:
             test_success = run_full_test_suite(target_root)
@@ -1342,7 +1335,7 @@ def main() -> int:
                 return 1
         else:
             print("⚠️ Skipping test suite execution (--skip-tests specified)")
-            
+
     except Exception as e:
         print(
             "❌ Error setting up test environment: {}".format(e),
@@ -1357,7 +1350,7 @@ def main() -> int:
     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:
@@ -1376,7 +1369,7 @@ def main() -> int:
         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
 

mcp_proxy_adapter/version.py

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

{mcp_proxy_adapter-6.4.36.dist-info → mcp_proxy_adapter-6.4.39.dist-info}/METADATA

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

{mcp_proxy_adapter-6.4.36.dist-info → mcp_proxy_adapter-6.4.39.dist-info}/RECORD

@@ -4,7 +4,7 @@ mcp_proxy_adapter/config.py,sha256=-7iVS0mUWWKNeao7nqTAFlUD6FcMwRlDkchN7OwYsr0,2
 mcp_proxy_adapter/custom_openapi.py,sha256=yLle4CntYK9wpivgn9NflZyJhy-YNrmWjJzt0ai5nP0,14672
 mcp_proxy_adapter/main.py,sha256=idp3KUR7CT7kTXLVPvvclJlNnt8d_HYl8_jY98uknmo,4677
 mcp_proxy_adapter/openapi.py,sha256=2UZOI09ZDRJuBYBjKbMyb2U4uASszoCMD5o_4ktRpvg,13480
-mcp_proxy_adapter/version.py,sha256=0-LJHNTlgIHjMygnw5NBVzN35NC108daY2MZA3wdTjA,75
+mcp_proxy_adapter/version.py,sha256=fEv9yyAT-nidoRbv5rOSNSK2TPzzpGMl5e_rgcDUiWQ,75
 mcp_proxy_adapter/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_proxy_adapter/api/app.py,sha256=UQ7_m-LbUzKuuPJPxS_69ahANUQ5rnPwoddQ2MMXNkg,33941
 mcp_proxy_adapter/api/handlers.py,sha256=iyFGoEuUS1wxbV1ELA0zmaxIyQR7j4zw-4MrD-uIO6E,8294
@@ -84,7 +84,7 @@ mcp_proxy_adapter/core/unified_config_adapter.py,sha256=zBGYdLDZ3G8f3Y9tmtm0Ne0U
 mcp_proxy_adapter/core/utils.py,sha256=wBdDYBDWQ6zbwrnl9tykHjo0FjJVsLT_x8Bjk1lZX60,3270
 mcp_proxy_adapter/examples/__init__.py,sha256=k1F-EotAFbJ3JvK_rNgiH4bUztmxIWtYn0AfbAZ1ZGs,450
 mcp_proxy_adapter/examples/create_certificates_simple.py,sha256=xoa4VtKzb9y7Mn8VqcK-uH2q7Bf89vrWG6G3LQmhJng,27086
-mcp_proxy_adapter/examples/create_test_configs.py,sha256=GRCmGM9xXTEz3iB7cq3yH-tJCQHuVxrqu0uHuuSSark,12140
+mcp_proxy_adapter/examples/create_test_configs.py,sha256=k7-GycHP96CZFry7EXwkQCViPlr_7jq-f18I9kVWN6c,11253
 mcp_proxy_adapter/examples/debug_request_state.py,sha256=Z3Gy2-fWtu7KIV9OkzGDLVz7TpL_h9V_99ica40uQBU,4489
 mcp_proxy_adapter/examples/debug_role_chain.py,sha256=GLVXC2fJUwP8UJnXHchd1t-H53cjWLJI3RqTPrKmaak,8750
 mcp_proxy_adapter/examples/demo_client.py,sha256=en2Rtb70B1sQmhL-vdQ4PDpKNNl_mfll2YCFT_jFCAg,10191
@@ -94,12 +94,12 @@ mcp_proxy_adapter/examples/generate_certificates_and_tokens.py,sha256=hUCoJH3fy5
 mcp_proxy_adapter/examples/generate_test_configs.py,sha256=FWg_QFJAWinI1lw05RccX4_VbhsCBEKPpZA6I9v6KAs,14379
 mcp_proxy_adapter/examples/proxy_registration_example.py,sha256=vemRhftnjbiOBCJkmtDGqlWQ8syTG0a8755GCOnaQsg,12503
 mcp_proxy_adapter/examples/run_example.py,sha256=yp-a6HIrSk3ddQmbn0KkuKwErId0aNfj028TE6U-zmY,2626
-mcp_proxy_adapter/examples/run_full_test_suite.py,sha256=HuiNTOey2zwk4KSSgh7l3JZlymMHv2yPTCvX0XNAxCY,19827
+mcp_proxy_adapter/examples/run_full_test_suite.py,sha256=QI4a7vTDovHTVd8BDeRAWsCNZp5aTtrlp7NE2LZU5bA,20143
 mcp_proxy_adapter/examples/run_proxy_server.py,sha256=SBLSSY2F_VEBQD3MsCE_Pa9xFE6Sszr3vHdE9QOEN4Y,5242
-mcp_proxy_adapter/examples/run_security_tests.py,sha256=ePekKblBbrfz5-Xe5hgs5OLL4rSd9QiIUlnm9dER8Bo,24082
+mcp_proxy_adapter/examples/run_security_tests.py,sha256=3mgp6fbPknI2fljpuedvtwoY1DzT_-UlOR45fHrkO0A,26215
 mcp_proxy_adapter/examples/run_security_tests_fixed.py,sha256=2BKMT0_-FhmcZA73hdQOt2XR7Cgb9Sq8qBI88BkwAAA,10934
-mcp_proxy_adapter/examples/security_test_client.py,sha256=K5gEVat1SJS2pBVxqLl5c9-uiiG12k8UT3ULQDXZ2Uc,35713
-mcp_proxy_adapter/examples/setup_test_environment.py,sha256=_ecdyHvWq8yx5WMm7JJ25Z9mHVgnvQ7xcSCdsXI2fv4,45563
+mcp_proxy_adapter/examples/security_test_client.py,sha256=o4XhXCDZPaGVNjOSc0qm8onouj_ZenACz9aSEkvzbRc,35313
+mcp_proxy_adapter/examples/setup_test_environment.py,sha256=gXo_ZIjmZC6WLQG0deng4w-vLfaSLmHTk29b5dEBiAw,45334
 mcp_proxy_adapter/examples/test_config.py,sha256=ekEoUZe9q484vU_0IxOVhQdNMVJXG3IpmQpP--VmuDI,6491
 mcp_proxy_adapter/examples/test_config_generator.py,sha256=PBXk1V_awJ-iBlbE66Pme5sQwu6CJDxkmqgm8uPtM58,4091
 mcp_proxy_adapter/examples/test_examples.py,sha256=CYlVatdHUVC_rwv4NsvxFG3GXiKIyxPDUH43BOJHjrU,12330
@@ -121,8 +121,8 @@ mcp_proxy_adapter/examples/full_application/hooks/builtin_command_hooks.py,sha25
 mcp_proxy_adapter/examples/scripts/config_generator.py,sha256=SKFlRRCE_pEHGbfjDuzfKpvV2DMwG6lRfK90uJwRlJM,33410
 mcp_proxy_adapter/examples/scripts/create_certificates_simple.py,sha256=yCWdUIhMSDPwoPhuLR9rhPdf7jLN5hCjzNfYYgVyHnw,27769
 mcp_proxy_adapter/examples/scripts/generate_certificates_and_tokens.py,sha256=hUCoJH3fy5WeR_YMHj-_W0mR0ZKUWqewH4FVN3yWyrM,17972
-mcp_proxy_adapter-6.4.36.dist-info/METADATA,sha256=moNhmhs_hqlfAVMLMXLdmLYsD-gN_fCTskeX4V-g8rc,6087
-mcp_proxy_adapter-6.4.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_proxy_adapter-6.4.36.dist-info/entry_points.txt,sha256=J3eV6ID0lt_VSp4lIdIgBFTqLCThgObNNxRCbyfiMHw,70
-mcp_proxy_adapter-6.4.36.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
-mcp_proxy_adapter-6.4.36.dist-info/RECORD,,
+mcp_proxy_adapter-6.4.39.dist-info/METADATA,sha256=M2i7654bHp6n3l5nQOCgZPZ8Cje5mMSGWedtUek1bvs,6087
+mcp_proxy_adapter-6.4.39.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_proxy_adapter-6.4.39.dist-info/entry_points.txt,sha256=J3eV6ID0lt_VSp4lIdIgBFTqLCThgObNNxRCbyfiMHw,70
+mcp_proxy_adapter-6.4.39.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
+mcp_proxy_adapter-6.4.39.dist-info/RECORD,,