mcp-proxy-adapter 6.2.21__py3-none-any.whl → 6.2.23__py3-none-any.whl

mcp_proxy_adapter/examples/generate_test_configs.py

@@ -9,14 +9,14 @@ import json
 import os
 import argparse
 from typing import Dict, Any
-def generate_http_simple_config(port: int = 8000) -> 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},
         "ssl": {"enabled": False},
         "security": {"enabled": False},
         "registration": {
-            "enabled": True,
+            "enabled": False,
             "auth_method": "token",
             "server_url": "http://127.0.0.1:3004/proxy",
             "token": {"enabled": True, "token": "proxy_registration_token_123"},
@@ -29,14 +29,25 @@ def generate_http_simple_config(port: int = 8000) -> Dict[str, Any]:
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http"]}
     }
-def generate_http_token_config(port: int = 8001) -> Dict[str, Any]:
+def generate_http_token_config(port: int = 20001, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
     """Generate HTTP configuration with token authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {"enabled": False},
         "security": {
             "enabled": True,
-            "auth": {"enabled": True, "methods": ["api_key"]},
+            "auth": {
+                "enabled": True,
+                "methods": ["api_key"],
+                # Map API tokens to roles for testing
+                "api_keys": {
+                    "test-token-123": "admin",
+                    "user-token-456": "user",
+                    "readonly-token-123": "readonly",
+                    "guest-token-123": "guest",
+                    "proxy-token-123": "proxy"
+                }
+            },
             "permissions": {"enabled": True, "roles_file": "./roles.json"}
         },
         "registration": {
@@ -50,7 +61,7 @@ def generate_http_token_config(port: int = 8001) -> Dict[str, Any]:
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http"]}
     }
-def generate_https_simple_config(port: int = 8002) -> 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},
@@ -71,7 +82,7 @@ def generate_https_simple_config(port: int = 8002) -> Dict[str, Any]:
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http", "https"]}
     }
-def generate_https_token_config(port: int = 8003) -> 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},
@@ -82,7 +93,17 @@ def generate_https_token_config(port: int = 8003) -> Dict[str, Any]:
         },
         "security": {
             "enabled": True,
-            "auth": {"enabled": True, "methods": ["api_key"]},
+            "auth": {
+                "enabled": True,
+                "methods": ["api_key"],
+                "api_keys": {
+                    "test-token-123": "admin",
+                    "user-token-456": "user",
+                    "readonly-token-123": "readonly",
+                    "guest-token-123": "guest",
+                    "proxy-token-123": "proxy"
+                }
+            },
             "permissions": {"enabled": True, "roles_file": "./roles.json"}
         },
         "registration": {
@@ -96,7 +117,7 @@ def generate_https_token_config(port: int = 8003) -> Dict[str, Any]:
         },
         "protocols": {"enabled": True, "allowed_protocols": ["http", "https"]}
     }
-def generate_mtls_no_roles_config(port: int = 8004) -> 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},
@@ -104,7 +125,7 @@ def generate_mtls_no_roles_config(port: int = 8004) -> Dict[str, Any]:
             "enabled": True,
             "cert_file": "./certs/localhost_server.crt", 
             "key_file": "./keys/localhost_server.key",
-            "ca_cert": "./certs/mcp_proxy_adapter_test_ca_ca.crt",
+            "ca_cert": "./certs/mcp_proxy_adapter_ca_ca.crt",
             "verify_client": True
         },
         "security": {
@@ -114,7 +135,7 @@ def generate_mtls_no_roles_config(port: int = 8004) -> Dict[str, Any]:
         },
         "protocols": {"enabled": True, "allowed_protocols": ["https", "mtls"]}
     }
-def generate_mtls_with_roles_config(port: int = 8005) -> Dict[str, Any]:
+def generate_mtls_with_roles_config(port: int = 20005, certs_dir: str = "./certs", keys_dir: str = "./keys") -> Dict[str, Any]:
     """Generate mTLS configuration with roles."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
@@ -122,7 +143,7 @@ def generate_mtls_with_roles_config(port: int = 8005) -> Dict[str, Any]:
             "enabled": True,
             "cert_file": "./certs/localhost_server.crt", 
             "key_file": "./keys/localhost_server.key",
-            "ca_cert": "./certs/mcp_proxy_adapter_test_ca_ca.crt",
+            "ca_cert": "./certs/mcp_proxy_adapter_ca_ca.crt",
             "verify_client": True
         },
         "registration": {
@@ -160,7 +181,7 @@ def generate_roles_config() -> Dict[str, Any]:
                 "heartbeat",
                 "discover"
             ],
-            "tokens": []
+            "tokens": ["test-token-123"]
         },
         "user": {
             "description": "User role with limited access",
@@ -172,7 +193,7 @@ def generate_roles_config() -> Dict[str, Any]:
                 "heartbeat",
                 "discover"
             ],
-            "tokens": []
+            "tokens": ["user-token-456"]
         },
         "readonly": {
             "description": "Read-only role",
@@ -180,7 +201,7 @@ def generate_roles_config() -> Dict[str, Any]:
                 "read",
                 "discover"
             ],
-            "tokens": []
+            "tokens": ["readonly-token-123"]
         },
         "guest": {
             "description": "Guest role with read-only access",
@@ -188,7 +209,7 @@ def generate_roles_config() -> Dict[str, Any]:
                 "read",
                 "discover"
             ],
-            "tokens": []
+            "tokens": ["guest-token-123"]
         },
         "proxy": {
             "description": "Proxy role for registration",
@@ -198,18 +219,18 @@ def generate_roles_config() -> Dict[str, Any]:
                 "heartbeat",
                 "discover"
             ],
-            "tokens": []
+            "tokens": ["proxy-token-123"]
         }
     }
-def generate_all_configs(output_dir: str) -> None:
+def generate_all_configs(output_dir: str, certs_dir: str = "./certs", keys_dir: str = "./keys") -> None:
     """Generate all 6 configuration types and save them to files."""
     configs = {
-        "http_simple": generate_http_simple_config(8000),
-        "http_token": generate_http_token_config(8001),
-        "https_simple": generate_https_simple_config(8002),
-        "https_token": generate_https_token_config(8003),
-        "mtls_no_roles": generate_mtls_no_roles_config(8004),
-        "mtls_with_roles": generate_mtls_with_roles_config(8005)
+        "http_simple": generate_http_simple_config(20000, certs_dir, keys_dir),
+        "http_token": generate_http_token_config(20001, certs_dir, keys_dir),
+        "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)
     }
     # Ensure output directory exists
     os.makedirs(output_dir, exist_ok=True)

mcp_proxy_adapter/examples/run_full_test_suite.py

@@ -0,0 +1,125 @@
+#!/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
+"""
+import sys
+import subprocess
+import os
+from pathlib import Path
+
+
+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")
+        else:
+            success = False
+            print("❌ roles.json not found in configs directory")
+
+    # 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!")
+        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
+
+
+if __name__ == "__main__":
+    exit(main())

mcp_proxy_adapter/examples/run_proxy_server.py

@@ -19,7 +19,7 @@ from datetime import datetime, timedelta
 
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-import uvicorn
+from mcp_proxy_adapter.core.server_adapter import UnifiedServerRunner
 
 
 # Simple in-memory storage for registered adapters
@@ -130,13 +130,15 @@ def main() -> None:
     print("   POST /proxy/heartbeat   - Heartbeat from adapter")
     print("⚡ Press Ctrl+C to stop\n")
 
-    # Run server
-    uvicorn.run(
+    # Run server via unified runner (hypercorn under the hood)
+    runner = UnifiedServerRunner()
+    runner.run_server(
         app,
-        host=args.host,
-        port=args.port,
-        log_level=args.log_level,
-        access_log=True
+        {
+            "host": args.host,
+            "port": args.port,
+            "log_level": args.log_level,
+        },
     )
 
 

mcp_proxy_adapter/examples/run_security_tests.py

@@ -14,11 +14,15 @@ import asyncio
 import json
 import os
 import signal
+import socket
 import subprocess
 import sys
 import time
 from pathlib import Path
-from typing import Dict, List, Optional, Any
+from typing import Dict, List, Optional, Any, Tuple
+
+import psutil
+import requests
 # Import security test client with proper module path
 from mcp_proxy_adapter.examples.security_test_client import SecurityTestClient, TestResult
 class SecurityTestRunner:
@@ -27,39 +31,149 @@ class SecurityTestRunner:
         """Initialize test runner."""
         self.servers = {}
         self.proxy_server = None
+        self.server_logs = {}
+        self.proxy_log = None
         self.test_results = {}
+        # Base and proxy ports
+        self.base_port = 20000
+        self.proxy_port = 20010
+        # Server configurations with ports starting from 20000
         self.configs = {
             "basic_http": {
                 "config": "configs/http_simple.json",
-                "port": 8000,
-                "url": "http://localhost:8000",
+                "port": self.base_port + 0,
+                "url": f"http://localhost:{self.base_port + 0}",
                 "auth": "none"
             },
             "http_token": {
                 "config": "configs/http_token.json",
-                "port": 8001,
-                "url": "http://localhost:8001",
+                "port": self.base_port + 1,
+                "url": f"http://localhost:{self.base_port + 1}",
                 "auth": "api_key"
             },
             "https": {
                 "config": "configs/https_simple.json",
-                "port": 8002,
-                "url": "https://localhost:8002",
+                "port": self.base_port + 2,
+                "url": f"https://localhost:{self.base_port + 2}",
                 "auth": "none"
             },
             "https_token": {
                 "config": "configs/https_token.json",
-                "port": 8003,
-                "url": "https://localhost:8003",
+                "port": self.base_port + 3,
+                "url": f"https://localhost:{self.base_port + 3}",
                 "auth": "api_key"
             },
             "mtls": {
                 "config": "configs/mtls_no_roles.json",
-                "port": 8004,
-                "url": "https://localhost:8004",
+                "port": self.base_port + 4,
+                "url": f"https://localhost:{self.base_port + 4}",
                 "auth": "certificate"
             }
         }
+
+    def _port_in_use(self, port: int, host: str = "127.0.0.1") -> bool:
+        try:
+            with socket.create_connection((host, port), timeout=0.5):
+                return True
+        except Exception:
+            return False
+
+    def _pids_on_port(self, port: int) -> List[int]:
+        pids: List[int] = []
+        try:
+            for proc in psutil.process_iter(attrs=["pid", "connections"]):
+                for c in proc.connections(kind="inet"):
+                    if c.laddr and c.laddr.port == port:
+                        pids.append(proc.pid)
+                        break
+        except Exception:
+            pass
+        return list(set(pids))
+
+    def ensure_ports_free(self, ports: List[int]) -> None:
+        for port in ports:
+            pids = self._pids_on_port(port)
+            for pid in pids:
+                try:
+                    psutil.Process(pid).terminate()
+                except Exception:
+                    pass
+            time.sleep(0.3)
+            for pid in pids:
+                try:
+                    if psutil.pid_exists(pid):
+                        psutil.Process(pid).kill()
+                except Exception:
+                    pass
+
+    def wait_for_http(self, url: str, timeout_sec: float = 8.0) -> bool:
+        end = time.time() + timeout_sec
+        candidates = ["/health", "/proxy/health"]
+        while time.time() < end:
+            for path in candidates:
+                health_url = url.rstrip("/") + path
+                try:
+                    resp = requests.get(health_url, timeout=1.0, verify=False)
+                    if resp.status_code == 200:
+                        return True
+                except Exception:
+                    pass
+            time.sleep(0.2)
+        return False
+
+    def wait_for_port(self, port: int, timeout_sec: float = 8.0) -> bool:
+        end = time.time() + timeout_sec
+        while time.time() < end:
+            if self._port_in_use(port):
+                return True
+            time.sleep(0.2)
+        return False
+
+    def get_all_ports(self) -> List[int]:
+        ports = [self.proxy_port]
+        for cfg in self.configs.values():
+            ports.append(cfg["port"])
+        return list(sorted(set(ports)))
+
+    def _validate_file(self, base: Path, path_value: Optional[str]) -> Tuple[bool, str]:
+        if not path_value:
+            return True, ""
+        p = Path(path_value)
+        if not p.is_absolute():
+            p = base / p
+        return p.exists(), str(p)
+
+    def validate_config_files(self) -> bool:
+        ok = True
+        base = Path.cwd()
+        missing: List[str] = []
+        for name, cfg in self.configs.items():
+            cfg_path = Path(cfg["config"]).resolve()
+            try:
+                with open(cfg_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                ssl = data.get("ssl", {})
+                for key in ("cert_file", "key_file", "ca_cert"):
+                    exists, abs_path = self._validate_file(base, ssl.get(key))
+                    if ssl.get("enabled") and key in ("cert_file", "key_file") and not exists:
+                        ok = False
+                        missing.append(f"{name}:{key} -> {abs_path}")
+                sec = data.get("security", {})
+                perms = sec.get("permissions", {})
+                exists, abs_path = self._validate_file(base, perms.get("roles_file"))
+                if sec.get("enabled") and perms.get("enabled") and not exists:
+                    ok = False
+                    missing.append(f"{name}:roles_file -> {abs_path}")
+            except Exception as e:
+                ok = False
+                missing.append(f"{name}: cannot read {cfg_path} ({e})")
+        if not ok:
+            print("❌ CONFIG VALIDATION FAILED. Missing files:")
+            for m in missing:
+                print("   -", m)
+        else:
+            print("✅ Configuration file paths validated")
+        return ok
     def check_prerequisites(self) -> bool:
         """Check if all prerequisites are met."""
         print("🔍 Checking prerequisites...")
@@ -69,7 +183,7 @@ class SecurityTestRunner:
             return False
         # Check if certificates exist
         cert_files = [
-            "certs/mcp_proxy_adapter_test_ca_ca.crt",
+             "certs/mcp_proxy_adapter_ca_ca.crt",
             "certs/localhost_server.crt",
             "keys/localhost_server.key"
         ]
@@ -87,11 +201,26 @@ class SecurityTestRunner:
         """Start a server in background."""
         try:
             print(f"🚀 Starting {name} server on port {port}...")
+            # Ensure the port is free just before starting
+            self.ensure_ports_free([port])
+            if self._port_in_use(port):
+                print(f"⚠️ Port {port} still busy, waiting...")
+                if not self.wait_for_port(port, timeout_sec=1.5):
+                    # After wait_for_port True means busy; we invert logic here
+                    pass
+            # If still busy after attempts, abort this server start
+            if self._port_in_use(port):
+                print(f"❌ Port {port} is in use, cannot start {name}")
+                return None
             # Start server in background
+            logs_dir = Path("logs"); logs_dir.mkdir(exist_ok=True)
+            log_path = logs_dir / f"{name}.log"
+            log_file = open(log_path, "wb")
+            self.server_logs[name] = log_file
             process = subprocess.Popen([
                 sys.executable, "-m", "mcp_proxy_adapter.main",
                 "--config", config_path
-            ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            ], stdout=log_file, stderr=subprocess.STDOUT)
             # Wait a bit for server to start
             time.sleep(3)
             # Check if process is still running
@@ -99,10 +228,7 @@ class SecurityTestRunner:
                 print(f"✅ {name} server started (PID: {process.pid})")
                 return process
             else:
-                stdout, stderr = process.communicate()
-                print(f"❌ Failed to start {name} server:")
-                print(f"STDOUT: {stdout.decode()}")
-                print(f"STDERR: {stderr.decode()}")
+                print(f"❌ Failed to start {name} server (see logs/{name}.log)")
                 return None
         except Exception as e:
             print(f"❌ Error starting {name} server: {e}")
@@ -122,6 +248,13 @@ class SecurityTestRunner:
                 process.wait()
         except Exception as e:
             print(f"❌ Error stopping {name} server: {e}")
+        finally:
+            try:
+                lf = self.server_logs.pop(name, None)
+                if lf:
+                    lf.close()
+            except Exception:
+                pass
 
     def start_proxy_server(self) -> bool:
         """Start the proxy server for server registration."""
@@ -134,27 +267,24 @@ class SecurityTestRunner:
                 return False
 
             # Start proxy server
-            cmd = [sys.executable, str(proxy_script), "--host", "127.0.0.1", "--port", "3004"]
+            cmd = [sys.executable, str(proxy_script), "--host", "127.0.0.1", "--port", str(self.proxy_port)]
+            logs_dir = Path("logs"); logs_dir.mkdir(exist_ok=True)
+            proxy_log_path = logs_dir / "proxy_server.log"
+            self.proxy_log = open(proxy_log_path, "wb")
             process = subprocess.Popen(
                 cmd,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
+                stdout=self.proxy_log,
+                stderr=subprocess.STDOUT,
                 cwd=Path.cwd()
             )
 
-            # Wait a bit for server to start
-            time.sleep(2)
-
-            # Check if process is still running
-            if process.poll() is None:
+            # Check readiness
+            if process.poll() is None and self.wait_for_http(f"http://127.0.0.1:{self.proxy_port}"):
                 self.proxy_server = process
                 print("✅ Proxy server started successfully (PID: {})".format(process.pid))
                 return True
             else:
-                stdout, stderr = process.communicate()
-                print("❌ Failed to start proxy server:")
-                print("STDOUT:", stdout.decode())
-                print("STDERR:", stderr.decode())
+                print("❌ Failed to start proxy server (see logs/proxy_server.log)")
                 return False
 
         except Exception as e:
@@ -178,6 +308,12 @@ class SecurityTestRunner:
                 print(f"❌ Error stopping proxy server: {e}")
             finally:
                 self.proxy_server = None
+                try:
+                    if self.proxy_log:
+                        self.proxy_log.close()
+                        self.proxy_log = None
+                except Exception:
+                    pass
     async def test_server(self, name: str, config: Dict[str, Any]) -> List[TestResult]:
         """Test a specific server configuration."""
         print(f"\n🧪 Testing {name} server...")
@@ -209,16 +345,23 @@ class SecurityTestRunner:
         """Run tests against all server configurations."""
         print("🚀 Starting comprehensive security testing")
         print("=" * 60)
-        # Start all servers
+        # Start all servers with verification and abort on failure
         for name, config in self.configs.items():
             process = self.start_server(name, config["config"], config["port"])
-            if process:
-                self.servers[name] = process
+            if not process:
+                print(f"❌ {name} failed to start. Aborting.")
+                return {}
+            url = config["url"]
+            ready = False
+            if name == "mtls":
+                ready = self.wait_for_port(config["port"], timeout_sec=8.0)
             else:
-                print(f"⚠️ Skipping tests for {name} due to startup failure")
-        # Wait for all servers to be ready
-        print("\n⏳ Waiting for servers to be ready...")
-        time.sleep(5)
+                ready = self.wait_for_http(url, timeout_sec=8.0)
+            if not ready:
+                print(f"❌ {name} did not become ready. Aborting.")
+                return {}
+            self.servers[name] = process
+        print("\n✅ All servers started and verified. Proceeding to client tests...")
         # Test each server
         all_results = {}
         for name, config in self.configs.items():
@@ -320,6 +463,14 @@ class SecurityTestRunner:
             if not self.check_prerequisites():
                 return False
 
+            # Free ports before run
+            print("\n🧹 Freeing ports before startup...")
+            self.ensure_ports_free(self.get_all_ports())
+
+            # Validate config file paths
+            if not self.validate_config_files():
+                return False
+
             # Start proxy server first
             print("\n🚀 Starting proxy server for server registration...")
             if not self.start_proxy_server():