mcp-proxy-adapter 6.7.2__tar.gz → 6.8.0__tar.gz

{mcp_proxy_adapter-6.7.2 → mcp_proxy_adapter-6.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.7.2
+Version: 6.8.0
 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.7.2 → mcp_proxy_adapter-6.8.0}/mcp_proxy_adapter/api/app.py

@@ -156,6 +156,20 @@ def create_lifespan(config_path: Optional[str] = None):
         if not server_port:
             raise ValueError("server.port is required")
 
+        # Check port availability BEFORE starting registration manager
+        from mcp_proxy_adapter.core.utils import check_port_availability, handle_port_conflict
+        
+        server_config = config.get("server", {})
+        server_host = server_config.get("host", "0.0.0.0")
+        server_port = server_config.get("port", 8000)
+        
+        print(f"🔍 Checking external server port availability: {server_host}:{server_port}")
+        if not check_port_availability(server_host, server_port):
+            print(f"❌ CRITICAL: External server port {server_port} is occupied")
+            handle_port_conflict(server_host, server_port)
+            return  # Exit the function immediately
+        print(f"✅ External server port {server_port} is available")
+
         # Determine registration URL using unified logic
         early_server_url = _determine_registration_url(config)
         try:

{mcp_proxy_adapter-6.7.2 → mcp_proxy_adapter-6.8.0}/mcp_proxy_adapter/core/app_factory.py

@@ -19,6 +19,11 @@ from mcp_proxy_adapter.config import config
 from mcp_proxy_adapter.commands.builtin_commands import (
     register_builtin_commands,
 )
+from mcp_proxy_adapter.core.utils import (
+    check_port_availability,
+    handle_port_conflict,
+    find_port_for_internal_server,
+)
 
 logger = get_logger("app_factory")
 
@@ -265,6 +270,7 @@ async def create_and_run_server(
     )
     print(f"🔌 Port: {server_port}")
 
+
     server_config = {
         "host": host,
         "port": server_port,
@@ -277,30 +283,6 @@ async def create_and_run_server(
         f"🔍 Debug: app_config keys: {list(app_config.keys()) if app_config else 'None'}"
     )
 
-    # Check for SSL config in root section first (higher priority)
-    if app_config and "ssl" in app_config:
-        print(f"🔍 Debug: SSL config found in root: {app_config['ssl']}")
-        print(
-            f"🔍 Debug: SSL enabled: {app_config['ssl'].get('enabled', False)}"
-        )
-        if app_config["ssl"].get("enabled", False):
-            ssl_config = app_config["ssl"]
-            # Add SSL config directly to server_config for Hypercorn
-            server_config["certfile"] = ssl_config.get("cert_file")
-            server_config["keyfile"] = ssl_config.get("key_file")
-            server_config["ca_certs"] = ssl_config.get(
-                "ca_cert_file", ssl_config.get("ca_cert")
-            )
-            # Set verify_client based on verify_client setting
-            verify_client = ssl_config.get("verify_client", False)
-            server_config["verify_client"] = verify_client
-            print(f"🔒 SSL enabled: {ssl_config.get('cert_file', 'N/A')}")
-            print(
-                f"🔒 SSL enabled: cert={ssl_config.get('cert_file')}, key={ssl_config.get('key_file')}"
-            )
-            print(
-                f"🔒 Server config SSL: certfile={server_config.get('certfile')}, keyfile={server_config.get('keyfile')}, ca_certs={server_config.get('ca_certs')}, verify_mode={server_config.get('verify_mode')}"
-            )
 
     # Check for SSL config in security section (fallback)
     if app_config and "security" in app_config:
@@ -331,28 +313,6 @@ async def create_and_run_server(
                 print(
                     f"🔒 Server config SSL: certfile={server_config.get('certfile')}, keyfile={server_config.get('keyfile')}, ca_certs={server_config.get('ca_certs')}, verify_mode={server_config.get('verify_mode')}"
                 )
-        print(f"🔍 Debug: SSL config found in root: {app_config['ssl']}")
-        print(
-            f"🔍 Debug: SSL enabled: {app_config['ssl'].get('enabled', False)}"
-        )
-        if app_config["ssl"].get("enabled", False):
-            ssl_config = app_config["ssl"]
-            # Add SSL config directly to server_config for Hypercorn
-            server_config["certfile"] = ssl_config.get("cert_file")
-            server_config["keyfile"] = ssl_config.get("key_file")
-            server_config["ca_certs"] = ssl_config.get(
-                "ca_cert_file", ssl_config.get("ca_cert")
-            )
-            # Set verify_client based on verify_client setting
-            verify_client = ssl_config.get("verify_client", False)
-            server_config["verify_client"] = verify_client
-            print(f"🔒 SSL enabled: {ssl_config.get('cert_file', 'N/A')}")
-            print(
-                f"🔒 SSL enabled: cert={ssl_config.get('cert_file')}, key={ssl_config.get('key_file')}"
-            )
-            print(
-                f"🔒 Server config SSL: certfile={server_config.get('certfile')}, keyfile={server_config.get('keyfile')}, ca_certs={server_config.get('ca_certs')}, verify_mode={server_config.get('verify_mode')}"
-            )
 
     # 6. Start mTLS server if needed
     mtls_server = None
@@ -362,18 +322,21 @@ async def create_and_run_server(
         verify_client = ssl_config.get("verify_client", False)
 
         if verify_client:
-            print("🔐 mTLS enabled - starting separate mTLS server...")
+            print("🔐 mTLS enabled - starting internal mTLS server...")
+            print("   External port: mTLS proxy (hypercorn)")
+            print("   Internal port: mTLS server (http.server)")
             from mcp_proxy_adapter.core.mtls_server import (
                 start_mtls_server_thread,
             )
 
-            # Start mTLS server in separate thread
+            # Start internal mTLS server in separate thread
+            # This server will find available port automatically if needed
             mtls_server = start_mtls_server_thread(app_config, main_app=app)
             if mtls_server:
-                print(f"✅ mTLS server started on port {mtls_server.port}")
+                print(f"✅ Internal mTLS server started on port {mtls_server.port}")
             else:
                 print(
-                    "⚠️  Failed to start mTLS server, continuing with regular HTTPS"
+                    "⚠️  Failed to start internal mTLS server, continuing with regular HTTPS"
                 )
         else:
             print("🔓 mTLS disabled - using regular HTTPS")
@@ -387,6 +350,8 @@ async def create_and_run_server(
         print("   Use Ctrl+C to stop the server")
         print("=" * 60)
 
+        # Port availability is already checked in api/app.py before registration manager starts
+
         # Use hypercorn directly
         import hypercorn.asyncio
         import hypercorn.config
@@ -428,13 +393,21 @@ async def create_and_run_server(
         if ssl_enabled:
             if verify_client:
                 print(
-                    f"🔐 Starting HTTPS server with hypercorn (mTLS on separate port)..."
+                    f"🔐 Starting external mTLS proxy with hypercorn (internal server on port {mtls_server.port if mtls_server else 'N/A'})..."
                 )
             else:
                 print(f"🔐 Starting HTTPS server with hypercorn...")
         else:
             print(f"🌐 Starting HTTP server with hypercorn...")
 
+        # Final port check before starting hypercorn
+        print(f"🔍 Final port check before starting hypercorn: {host}:{server_port}")
+        if not check_port_availability(host, server_port):
+            print(f"❌ CRITICAL: Port {server_port} is occupied during final check")
+            handle_port_conflict(host, server_port)
+            return  # Exit immediately
+        print(f"✅ Final port check passed: {host}:{server_port}")
+
         # Run the server
         # hypercorn.asyncio.serve() should be run with asyncio.run(), not awaited
         # The function is designed to be the main entry point, not a coroutine to await
@@ -442,15 +415,28 @@ async def create_and_run_server(
 
     except KeyboardInterrupt:
         print("\n🛑 Server stopped by user")
-        # Stop mTLS server if running
+        # Stop internal mTLS server if running
         if mtls_server:
-            print("🛑 Stopping mTLS server...")
+            print("🛑 Stopping internal mTLS server...")
             mtls_server.stop()
+    except OSError as e:
+        if e.errno == 98:  # Address already in use
+            print(f"\n❌ Port conflict detected: {e}")
+            handle_port_conflict(host, server_port)
+        else:
+            print(f"\n❌ Failed to start server: {e}")
+            # Stop mTLS server if running
+            if mtls_server:
+                print("🛑 Stopping mTLS server...")
+                mtls_server.stop()
+            import traceback
+            traceback.print_exc()
+            sys.exit(1)
     except Exception as e:
         print(f"\n❌ Failed to start server: {e}")
-        # Stop mTLS server if running
+        # Stop internal mTLS server if running
         if mtls_server:
-            print("🛑 Stopping mTLS server...")
+            print("🛑 Stopping internal mTLS server...")
             mtls_server.stop()
         import traceback
 

{mcp_proxy_adapter-6.7.2 → mcp_proxy_adapter-6.8.0}/mcp_proxy_adapter/core/mtls_server.py

@@ -286,7 +286,11 @@ def start_mtls_server_thread(
         # Get server configuration
         server_config = config.get("server", {})
         host = server_config.get("host", "127.0.0.1")
-        port = ssl_config.get("mtls_port", 8443)  # Different port for mTLS
+        preferred_port = ssl_config.get("mtls_port", 8443)  # Different port for mTLS
+        
+        # For internal servers (mTLS), find available port if preferred is occupied
+        from mcp_proxy_adapter.core.utils import find_port_for_internal_server
+        port = find_port_for_internal_server(host, preferred_port)
 
         # Get certificate paths
         cert_file = ssl_config.get("cert_file", "certs/localhost_server.crt")

{mcp_proxy_adapter-6.7.2 → mcp_proxy_adapter-6.8.0}/mcp_proxy_adapter/core/signal_handler.py

@@ -79,10 +79,12 @@ class SignalHandler:
             except Exception as e:
                 logger.error(f"❌ Shutdown callback failed: {e}")
         
-        # If this is SIGINT (Ctrl+C), we might want to exit immediately after a delay
-        if signum == signal.SIGINT:
-            logger.info("⏰ SIGINT received, will exit in 5 seconds if not stopped gracefully...")
-            threading.Timer(5.0, self._force_exit).start()
+        # Force exit immediately to avoid server hang
+        logger.info("🔄 Force exiting to avoid server hang...")
+        import os
+        # Use os._exit for immediate termination
+        logger.warning("⚠️ Using os._exit for immediate termination...")
+        os._exit(0)
     
     def _force_exit(self):
         """Force exit if graceful shutdown takes too long."""

mcp_proxy_adapter-6.8.0/mcp_proxy_adapter/core/utils.py

@@ -0,0 +1,282 @@
+"""
+Module with utility functions for the microservice.
+"""
+
+import hashlib
+import json
+import os
+import socket
+import sys
+import time
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from mcp_proxy_adapter.core.logging import logger
+
+
+def generate_id() -> str:
+    """
+    Generates a unique identifier.
+
+    Returns:
+        String with unique identifier.
+    """
+    return str(uuid.uuid4())
+
+
+def get_timestamp() -> int:
+    """
+    Returns current timestamp in milliseconds.
+
+    Returns:
+        Integer - timestamp in milliseconds.
+    """
+    return int(time.time() * 1000)
+
+
+def format_datetime(
+    dt: Optional[datetime] = None, format_str: str = "%Y-%m-%dT%H:%M:%S.%fZ"
+) -> str:
+    """
+    Formats date and time as string.
+
+    Args:
+        dt: Datetime object to format. If None, current time is used.
+        format_str: Format string for output.
+
+    Returns:
+        Formatted date/time string.
+    """
+    dt = dt or datetime.now(timezone.utc)
+    return dt.strftime(format_str)
+
+
+def parse_datetime(dt_str: str, format_str: str = "%Y-%m-%dT%H:%M:%S.%fZ") -> datetime:
+    """
+    Parses date/time string into datetime object.
+
+    Args:
+        dt_str: Date/time string.
+        format_str: Date/time string format.
+
+    Returns:
+        Datetime object.
+    """
+    return datetime.strptime(dt_str, format_str)
+
+
+def safe_json_loads(s: str, default: Any = None) -> Any:
+    """
+    Safe JSON string loading.
+
+    Args:
+        s: JSON string to load.
+        default: Default value on parsing error.
+
+    Returns:
+        Loaded object or default value on error.
+    """
+    try:
+        return json.loads(s)
+    except Exception as e:
+        logger.error(f"Error parsing JSON: {e}")
+        return default
+
+
+def safe_json_dumps(obj: Any, default: str = "{}", indent: Optional[int] = None) -> str:
+    """
+    Safe object conversion to JSON string.
+
+    Args:
+        obj: Object to convert.
+        default: Default string on serialization error.
+        indent: Indentation for JSON formatting.
+
+    Returns:
+        JSON string or default string on error.
+    """
+    try:
+        return json.dumps(obj, ensure_ascii=False, indent=indent)
+    except Exception as e:
+        logger.error(f"Error serializing to JSON: {e}")
+        return default
+
+
+def calculate_hash(data: Union[str, bytes], algorithm: str = "sha256") -> str:
+    """
+    Calculates hash for data.
+
+    Args:
+        data: Data to hash (string or bytes).
+        algorithm: Hashing algorithm (md5, sha1, sha256, etc.).
+
+    Returns:
+        String with hash in hexadecimal format.
+    """
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+
+    hash_obj = hashlib.new(algorithm)
+    hash_obj.update(data)
+    return hash_obj.hexdigest()
+
+
+def ensure_directory(path: str) -> bool:
+    """
+    Checks directory existence and creates it if necessary.
+
+    Args:
+        path: Path to directory.
+
+    Returns:
+        True if directory exists or was successfully created, otherwise False.
+    """
+    try:
+        if not os.path.exists(path):
+            os.makedirs(path, exist_ok=True)
+        return True
+    except Exception as e:
+        logger.error(f"Error creating directory {path}: {e}")
+        return False
+
+
+def check_port_availability(host: str, port: int, timeout: float = 1.0) -> bool:
+    """
+    Checks if a port is available for binding.
+    
+    Args:
+        host: Host address to check
+        port: Port number to check
+        timeout: Connection timeout in seconds
+        
+    Returns:
+        True if port is available, False if port is in use
+    """
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.settimeout(timeout)
+            result = sock.connect_ex((host, port))
+            return result != 0  # True if connection failed (port is free)
+    except Exception as e:
+        logger.warning(f"Error checking port {port} on {host}: {e}")
+        return True  # Assume port is available if check fails
+
+
+def find_available_port(host: str, start_port: int, max_attempts: int = 100) -> Optional[int]:
+    """
+    Finds an available port starting from the specified port.
+    
+    Args:
+        host: Host address to check
+        start_port: Starting port number
+        max_attempts: Maximum number of ports to check
+        
+    Returns:
+        Available port number or None if no port found
+    """
+    for port in range(start_port, start_port + max_attempts):
+        if check_port_availability(host, port):
+            return port
+    return None
+
+
+def get_port_usage_info(port: int) -> str:
+    """
+    Gets information about what process is using a port.
+    
+    Args:
+        port: Port number to check
+        
+    Returns:
+        String with port usage information
+    """
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["lsof", "-i", f":{port}"], 
+            capture_output=True, 
+            text=True, 
+            timeout=5
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return f"Port {port} is used by:\n{result.stdout.strip()}"
+        else:
+            return f"Port {port} appears to be in use but process info unavailable"
+    except Exception as e:
+        return f"Port {port} is in use (unable to get process info: {e})"
+
+
+def handle_port_conflict(host: str, port: int) -> None:
+    """
+    Handles port conflict with user-friendly error message and suggestions.
+    This is for MAIN server port conflicts - application must exit.
+    
+    Args:
+        host: Host address
+        port: Port number that's in conflict
+    """
+    print(f"❌ ERROR: Port {port} is already in use on {host}")
+    print(f"💡 Suggestions:")
+    print(f"   1. Choose a different port: --port <different_port>")
+    print(f"   2. Stop the conflicting service")
+    print(f"   3. Check what's using the port:")
+    print(f"      lsof -i :{port}")
+    print(f"      netstat -tulpn | grep :{port}")
+    
+    # Try to get more detailed info about port usage
+    usage_info = get_port_usage_info(port)
+    print(f"🔍 Port usage details:")
+    print(f"   {usage_info}")
+    
+    # Try to find an alternative port
+    alt_port = find_available_port(host, port + 1, 10)
+    if alt_port:
+        print(f"💡 Alternative port suggestion: {alt_port}")
+        print(f"   Try: --port {alt_port}")
+    else:
+        print(f"💡 Try ports in range {port + 1}-{port + 20}")
+    
+    print(f"🛑 Application cannot start due to port conflict")
+    sys.exit(1)
+
+
+def find_port_for_internal_server(host: str, preferred_port: int) -> int:
+    """
+    Finds an available port for internal server (mTLS, etc.).
+    If preferred port is occupied, finds any available port.
+    
+    Args:
+        host: Host address
+        preferred_port: Preferred port number
+        
+    Returns:
+        Available port number
+    """
+    # First try the preferred port
+    if check_port_availability(host, preferred_port):
+        print(f"✅ Internal server port {preferred_port} is available")
+        return preferred_port
+    
+    # If preferred port is occupied, find any available port
+    print(f"⚠️  Internal server preferred port {preferred_port} is occupied, searching for alternative...")
+    
+    alt_port = find_available_port(host, preferred_port + 1, 50)
+    if alt_port:
+        print(f"✅ Found alternative port for internal server: {alt_port}")
+        return alt_port
+    
+    # If no port found in range, try from 9000
+    alt_port = find_available_port(host, 9000, 100)
+    if alt_port:
+        print(f"✅ Found alternative port for internal server: {alt_port}")
+        return alt_port
+    
+    # Last resort - try from 10000
+    alt_port = find_available_port(host, 10000, 100)
+    if alt_port:
+        print(f"✅ Found alternative port for internal server: {alt_port}")
+        return alt_port
+    
+    # If still no port found, raise error
+    raise RuntimeError(f"Unable to find available port for internal server on {host}")

{mcp_proxy_adapter-6.7.2 → mcp_proxy_adapter-6.8.0}/mcp_proxy_adapter/examples/basic_framework/main.py

@@ -25,27 +25,26 @@ def main():
     parser.add_argument("--port", type=int, help="Server port")
     parser.add_argument("--debug", action="store_true", help="Enable debug mode")
     args = parser.parse_args()
-    # Override configuration if specified
-    config_overrides = {}
+    print(f"🚀 Starting Basic Framework Example")
+    print(f"📋 Configuration: {args.config}")
     if args.host:
-        config_overrides["host"] = args.host
+        print(f"🌐 Host override: {args.host}")
     if args.port:
-        config_overrides["port"] = args.port
+        print(f"🔌 Port override: {args.port}")
     if args.debug:
-        config_overrides["debug"] = True
-    print(f"🚀 Starting Basic Framework Example")
-    print(f"📋 Configuration: {args.config}")
+        print(f"🔧 Debug mode: enabled")
     print("=" * 50)
-    # Use the factory method to create and run the server
+    
+    # Note: Host and port overrides should be handled in configuration file
+    # or by modifying the configuration before passing to create_and_run_server
     import asyncio
     asyncio.run(create_and_run_server(
         config_path=args.config,
         title="Basic Framework Example",
         description="Basic MCP Proxy Adapter with minimal configuration",
         version="1.0.0",
-        host=config_overrides.get("host"),
-        port=config_overrides.get("port"),
-        debug=config_overrides.get("debug", False),
+        host=args.host or "0.0.0.0",
+        log_level="debug" if args.debug else "info"
     ))
 
 

{mcp_proxy_adapter-6.7.2 → mcp_proxy_adapter-6.8.0}/mcp_proxy_adapter/examples/full_application/main.py

@@ -93,74 +93,24 @@ class FullApplication:
         self.logger.info("✅ Application created successfully")
 
     def run(self, host: str = None, port: int = None, debug: bool = False):
-        """Run the application using the factory method."""
-        # Override configuration if specified
-        config_overrides = {}
-        if host:
-            config_overrides["host"] = host
-        if port:
-            config_overrides["port"] = port
-        if debug:
-            config_overrides["debug"] = True
+        """Run the application using the factory method with port checking."""
         print(f"🚀 Starting Full Application Example")
         print(f"📋 Configuration: {self.config_path}")
         print(
             f"🔧 Features: Built-in commands, Custom commands, Dynamic commands, Hooks, Proxy endpoints"
         )
         print("=" * 60)
-        # Create application with configuration
-        self.create_application()
-        # Get server configuration
-        server_host = self.config.get("server.host", "0.0.0.0")
-        server_port = self.config.get("server.port", 8000)
-        server_debug = self.config.get("server.debug", False)
-        # Get SSL configuration
-        ssl_enabled = self.config.get("ssl.enabled", False)
-        ssl_cert_file = self.config.get("ssl.cert_file")
-        ssl_key_file = self.config.get("ssl.key_file")
-        ssl_ca_cert = self.config.get("ssl.ca_cert")
-        verify_client = self.config.get("ssl.verify_client", False)
-        print(f"🌐 Server: {server_host}:{server_port}")
-        print(f"🔧 Debug: {server_debug}")
-        if ssl_enabled:
-            print(f"🔐 SSL: Enabled")
-            print(f"   Certificate: {ssl_cert_file}")
-            print(f"   Key: {ssl_key_file}")
-            if ssl_ca_cert:
-                print(f"   CA: {ssl_ca_cert}")
-            print(f"   Client verification: {verify_client}")
-        print("=" * 60)
-        # Use hypercorn directly to run the application with proxy endpoints
-        try:
-            import hypercorn.asyncio
-            import hypercorn.config
-            import asyncio
-
-            # Configure hypercorn
-            config_hypercorn = hypercorn.config.Config()
-            config_hypercorn.bind = [f"{server_host}:{server_port}"]
-            config_hypercorn.loglevel = "debug" if server_debug else "info"
-            if ssl_enabled and ssl_cert_file and ssl_key_file:
-                config_hypercorn.certfile = ssl_cert_file
-                config_hypercorn.keyfile = ssl_key_file
-                if ssl_ca_cert:
-                    config_hypercorn.ca_certs = ssl_ca_cert
-                if verify_client:
-                    import ssl
-
-                    config_hypercorn.verify_mode = ssl.CERT_REQUIRED
-                print(f"🔐 Starting HTTPS server with hypercorn...")
-            else:
-                print(f"🌐 Starting HTTP server with hypercorn...")
-            # Run the server
-            asyncio.run(hypercorn.asyncio.serve(self.app, config_hypercorn))
-        except ImportError:
-            print("❌ hypercorn not installed. Installing...")
-            import subprocess
-
-            subprocess.run([sys.executable, "-m", "pip", "install", "hypercorn"])
-            print("✅ hypercorn installed. Please restart the application.")
-            return
+        
+        # Use the factory method to create and run the server with port checking
+        import asyncio
+        asyncio.run(create_and_run_server(
+            config_path=self.config_path,
+            title="Full Application Example",
+            description="Complete MCP Proxy Adapter with all features",
+            version="1.0.0",
+            host=host or "0.0.0.0",
+            log_level="debug" if debug else "info"
+        ))
 
 
 def main():