mcp-proxy-adapter 6.6.3__tar.gz → 6.6.5__tar.gz

{mcp_proxy_adapter-6.6.3 → mcp_proxy_adapter-6.6.5}/PKG-INFO

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

@@ -65,11 +65,8 @@ def create_lifespan(config_path: Optional[str] = None):
             initialize_proxy_registration,
         )
 
-        # Initialize proxy registration manager early
-        try:
-            initialize_proxy_registration(config.get_all())
-        except Exception as e:
-            logger.error(f"Failed to initialize proxy registration: {e}")
+        # Proxy registration manager will be initialized in registry.reload_system()
+        # after all commands are loaded to ensure complete command schema
 
         # Compute server_url EARLY and inject into registration manager so
         # that reload_system (which may perform registration) uses the correct
@@ -89,10 +86,20 @@ def create_lifespan(config_path: Optional[str] = None):
         public_port = reg_cfg.get("public_port")
 
         # Check SSL configuration from new structure
-        protocol = config.get("server.protocol", "http")
-        verify_client = config.get("transport.verify_client", False)
-        ssl_enabled = protocol in ["https", "mtls"] or verify_client
-        protocol = "https" if ssl_enabled else "http"
+        # Priority: registration.protocol > server.protocol > fallback to http
+        reg_cfg = config.get("registration", {})
+        registration_protocol = reg_cfg.get("protocol")
+        server_protocol = config.get("server.protocol", "http")
+        
+        if registration_protocol:
+            # Use protocol from registration configuration
+            # Convert mtls to https for URL construction (mTLS is still HTTPS)
+            protocol = "https" if registration_protocol == "mtls" else registration_protocol
+        else:
+            # Fallback to server protocol
+            verify_client = config.get("transport.verify_client", False)
+            ssl_enabled = server_protocol in ["https", "mtls"] or verify_client
+            protocol = "https" if ssl_enabled else "http"
 
         import os
         docker_host_addr = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
@@ -124,11 +131,7 @@ def create_lifespan(config_path: Optional[str] = None):
         )
         logger.info(f"System initialization result: {init_result}")
 
-        # Initialize proxy registration manager with current config
-        try:
-            initialize_proxy_registration(config.get_all())
-        except Exception as e:
-            logger.error(f"Failed to initialize proxy registration: {e}")
+        # Proxy registration manager is already initialized in registry.reload_system()
 
         # Recompute registration URL AFTER config reload using final config
         try:
@@ -141,11 +144,21 @@ def create_lifespan(config_path: Optional[str] = None):
             public_host = reg_cfg.get("public_host")
             public_port = reg_cfg.get("public_port")
 
-            security_config = final_config.get("security", {})
-            ssl_cfg = security_config.get("ssl", {})
-            if not ssl_cfg.get("enabled", False):
-                ssl_cfg = final_config.get("ssl", {})
-            protocol = "https" if ssl_cfg.get("enabled", False) else "http"
+            # Determine protocol using the new configuration structure
+            # Priority: registration.protocol > server.protocol > fallback to http
+            reg_cfg = final_config.get("registration", final_config.get("proxy_registration", {}))
+            registration_protocol = reg_cfg.get("protocol")
+            server_protocol = final_config.get("server", {}).get("protocol", "http")
+            
+            if registration_protocol:
+                # Use protocol from registration configuration
+                # Convert mtls to https for URL construction (mTLS is still HTTPS)
+                protocol = "https" if registration_protocol == "mtls" else registration_protocol
+            else:
+                # Fallback to server protocol
+                verify_client_cfg = final_config.get("transport", {}).get("verify_client", False)
+                ssl_enabled_final = server_protocol in ["https", "mtls"] or verify_client_cfg
+                protocol = "https" if ssl_enabled_final else "http"
 
             import os
             docker_host_addr = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
@@ -184,19 +197,26 @@ def create_lifespan(config_path: Optional[str] = None):
             logger.error(f"Failed to recompute registration URL: {e}")
             server_url = early_server_url
 
-        # Attempt proxy registration in background with small delay
-        async def _delayed_register():
+        # Proxy registration is now handled in registry.reload_system() 
+        # after all commands are loaded, ensuring complete command schema
+        logger.info("ℹ️ Proxy registration will be handled after command loading completes")
+        
+        # Add delayed registration task to allow server to fully start
+        async def delayed_registration():
+            """Delayed registration to ensure server is fully started."""
+            await asyncio.sleep(2)  # Wait for server to start listening
+            logger.info("🔄 Attempting delayed proxy registration after server startup")
             try:
-                await asyncio.sleep(0.5)
+                from mcp_proxy_adapter.core.proxy_registration import register_with_proxy
                 success = await register_with_proxy(server_url)
                 if success:
-                    logger.info("✅ Proxy registration completed successfully")
+                    logger.info("✅ Delayed proxy registration successful")
                 else:
-                    logger.info("ℹ️ Proxy registration is disabled or failed")
+                    logger.warning("⚠️ Delayed proxy registration failed")
             except Exception as e:
-                logger.error(f"Proxy registration failed: {e}")
-
-        asyncio.create_task(_delayed_register())
+                logger.error(f"❌ Delayed proxy registration error: {e}")
+        
+        asyncio.create_task(delayed_registration())
 
         yield  # Application is running
 
@@ -237,16 +257,20 @@ def create_ssl_context(
         return None
 
     # Get certificate paths from configuration
-    cert_file = current_config.get("ssl", {}).get("cert_file")
-    key_file = current_config.get("ssl", {}).get("key_file")
+    cert_file = current_config.get("transport", {}).get("cert_file")
+    key_file = current_config.get("transport", {}).get("key_file")
+    ca_cert = current_config.get("transport", {}).get("ca_cert")
     
-    # If not found in ssl section, use default paths
-    if not cert_file:
+    # Convert relative paths to absolute paths
+    if cert_file and not Path(cert_file).is_absolute():
+        project_root = Path(__file__).parent.parent.parent
+        cert_file = str(project_root / cert_file)
+    if key_file and not Path(key_file).is_absolute():
         project_root = Path(__file__).parent.parent.parent
-        cert_file = str(project_root / "certs" / "server.crt")
-    if not key_file:
+        key_file = str(project_root / key_file)
+    if ca_cert and not Path(ca_cert).is_absolute():
         project_root = Path(__file__).parent.parent.parent
-        key_file = str(project_root / "certs" / "server.key")
+        ca_cert = str(project_root / ca_cert)
 
     if not cert_file or not key_file:
         logger.warning("SSL enabled but certificate or key file not specified")
@@ -257,15 +281,15 @@ def create_ssl_context(
         ssl_context = SSLUtils.create_ssl_context(
             cert_file=cert_file,
             key_file=key_file,
-            ca_cert=ssl_config.get("ca_cert"),
-            verify_client=ssl_config.get("verify_client", False),
-            cipher_suites=ssl_config.get("cipher_suites", []),
-            min_tls_version=ssl_config.get("min_tls_version", "1.2"),
-            max_tls_version=ssl_config.get("max_tls_version", "1.3"),
+            ca_cert=ca_cert,
+            verify_client=current_config.get("transport", {}).get("verify_client", False),
+            cipher_suites=[],
+            min_tls_version="1.2",
+            max_tls_version="1.3",
         )
 
         logger.info(
-            f"SSL context created successfully for mode: {ssl_config.get('mode', 'https_only')}"
+            f"SSL context created successfully for mode: https_only"
         )
         return ssl_context
 

{mcp_proxy_adapter-6.6.3 → mcp_proxy_adapter-6.6.5}/mcp_proxy_adapter/commands/command_registry.py

@@ -786,23 +786,37 @@ class CommandRegistry:
             # Initialize proxy registration manager with current config
             initialize_proxy_registration(config.get_all())
 
-            # Get server configuration
+            # Get server configuration with proper URL resolution logic
             server_config = config.get("server", {})
             server_host = server_config.get("host", "0.0.0.0")
             server_port = server_config.get("port", 8000)
 
-            # Determine server URL based on SSL configuration
-            ssl_config = config.get("ssl", {})
-            if ssl_config.get("enabled", False):
-                protocol = "https"
-            else:
-                protocol = "http"
-
-            # Use localhost for external access if host is 0.0.0.0
-            if server_host == "0.0.0.0":
-                server_host = "localhost"
-
-            server_url = f"{protocol}://{server_host}:{server_port}"
+            # Get registration configuration for public host/port overrides
+            # First check server config, then registration config
+            public_host = config.get("server.public_host")
+            public_port = config.get("server.public_port")
+            
+            # Fallback to registration config if not found in server
+            if not public_host or not public_port:
+                reg_cfg = config.get("registration", config.get("proxy_registration", {}))
+                public_host = public_host or reg_cfg.get("public_host")
+                public_port = public_port or reg_cfg.get("public_port")
+
+            # Determine protocol based on new configuration structure
+            protocol = config.get("server.protocol", "http")
+            verify_client = config.get("transport.verify_client", False)
+            ssl_enabled = protocol in ["https", "mtls"] or verify_client
+            protocol = "https" if ssl_enabled else "http"
+
+            # Resolve host and port (same logic as in app.py)
+            import os
+            docker_host_addr = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
+            resolved_host = public_host or (docker_host_addr if server_host == "0.0.0.0" else server_host)
+            resolved_port = public_port or server_port
+
+            server_url = f"{protocol}://{resolved_host}:{resolved_port}"
+            
+            logger.info(f"🔍 Proxy registration URL resolved: {server_url}")
 
             # Attempt proxy registration
             proxy_registration_success = await register_with_proxy(server_url)

{mcp_proxy_adapter-6.6.3 → mcp_proxy_adapter-6.6.5}/mcp_proxy_adapter/config.py

@@ -84,7 +84,7 @@ class Config:
             "transport": {
                 "type": "http",
                 "port": None,
-                "verify_client": False,
+                    "verify_client": False,
                 "chk_hostname": False,  # Default to False for HTTP
             },
             "proxy_registration": {

{mcp_proxy_adapter-6.6.3 → mcp_proxy_adapter-6.6.5}/mcp_proxy_adapter/core/proxy_registration.py

@@ -13,6 +13,7 @@ email: vasilyvz@gmail.com
 import asyncio
 import time
 import ssl
+import traceback
 from typing import Dict, Any, Optional, Tuple
 from pathlib import Path
 from urllib.parse import urljoin
@@ -248,10 +249,15 @@ class ProxyRegistrationManager:
         """
         logger.debug("_create_ssl_context called")
         
-        # Check if we're in HTTP mode - if so, don't create SSL context
-        server_config = self.config.get("server", {})
-        if server_config.get("protocol", "http").lower() == "http":
-            logger.debug("HTTP mode detected, skipping SSL context creation")
+        # Decide SSL strictly by proxy URL scheme: use SSL only for https proxy URLs
+        try:
+            from urllib.parse import urlparse as _urlparse
+            scheme = _urlparse(self.proxy_url).scheme if self.proxy_url else "http"
+            if scheme.lower() != "https":
+                logger.debug("Proxy URL is HTTP, skipping SSL context creation for registration")
+                return None
+        except Exception:
+            logger.debug("Failed to parse proxy_url, assuming HTTP and skipping SSL context")
             return None
             
         if not self.client_security:
@@ -440,7 +446,11 @@ class ProxyRegistrationManager:
 
                 if success:
                     self.registered = True
-                    self.server_key = result.get("server_key")
+                    # Safely extract server_key from result
+                    if isinstance(result, dict):
+                        self.server_key = result.get("server_key")
+                    else:
+                        self.server_key = None
                     logger.info(
                         f"✅ Successfully registered with proxy. Server key: {self.server_key}"
                     )
@@ -455,8 +465,65 @@ class ProxyRegistrationManager:
                 else:
                     # Be robust if result is not a dict
                     error_msg = None
+                    logger.error(f"DEBUG: result type = {type(result)}, result = {result}")
                     if isinstance(result, dict):
-                        error_msg = result.get("error", {}).get("message", "Unknown error")
+                        logger.error(f"DEBUG: result is dict, getting error field")
+                        error_field = result.get("error", {})
+                        logger.error(f"DEBUG: error_field type = {type(error_field)}, error_field = {error_field}")
+                        if isinstance(error_field, dict):
+                            error_msg = error_field.get("message", "Unknown error")
+                        elif isinstance(error_field, str):
+                            error_msg = error_field
+                        else:
+                            error_msg = str(error_field)
+
+                        # Auto-recovery: already registered case → force unregistration then retry once
+                        error_code = result.get("error_code") or (result.get("error", {}).get("code") if isinstance(result.get("error"), dict) else None)
+                        already_registered = False
+                        existing_server_key = None
+                        # Prefer structured detail if provided
+                        if isinstance(result.get("details"), dict):
+                            existing_server_key = result.get("details", {}).get("existing_server_key")
+                        # Fallback: parse from error message text
+                        if not existing_server_key and isinstance(error_msg, str) and "already registered as" in error_msg:
+                            try:
+                                # Expecting: "... already registered as <server_id>_<copy_number>"
+                                tail = error_msg.split("already registered as", 1)[1].strip()
+                                existing_server_key = tail.split()[0]
+                            except Exception:
+                                existing_server_key = None
+
+                        if (error_code in ("DUPLICATE_SERVER_URL", "REGISTRATION_ERROR") or already_registered) and existing_server_key:
+                            try:
+                                logger.info(f"Attempting auto-unregistration of existing instance: {existing_server_key}")
+                                # Build unregistration payload using parsed server_key
+                                try:
+                                    copy_number = int(existing_server_key.split("_")[-1])
+                                except Exception:
+                                    copy_number = 1
+                                unregistration_data = {"server_id": self.server_id, "copy_number": copy_number}
+                                # Reuse secure unregistration request directly
+                                unreg_success, _unreg_result = await self._make_secure_unregistration_request(unregistration_data)
+                                if unreg_success:
+                                    logger.info("Auto-unregistration succeeded, retrying registration once...")
+                                    # Retry registration once immediately
+                                    retry_success, retry_result = await self._make_secure_registration_request(registration_data)
+                                    if retry_success:
+                                        self.registered = True
+                                        if isinstance(retry_result, dict):
+                                            self.server_key = retry_result.get("server_key")
+                                        else:
+                                            self.server_key = None
+                                        logger.info(f"✅ Successfully registered after auto-unregistration. Server key: {self.server_key}")
+                                        if self.registration_config.get("heartbeat", {}).get("enabled", True):
+                                            await self._start_heartbeat()
+                                        return True
+                                    else:
+                                        logger.warning(f"Retry registration failed after auto-unregistration: {retry_result}")
+                                else:
+                                    logger.warning(f"Auto-unregistration failed: {_unreg_result}")
+                            except Exception as _auto_e:
+                                logger.warning(f"Auto-unregistration/registration flow error: {_auto_e}")
                     else:
                         error_msg = str(result)
                     logger.warning(
@@ -467,6 +534,7 @@ class ProxyRegistrationManager:
                 logger.error(
                     f"❌ Registration attempt {attempt + 1} failed with exception: {e}"
                 )
+                logger.error(f"Full traceback: {traceback.format_exc()}")
 
         logger.error(
             f"❌ Failed to register with proxy after {self.retry_attempts} attempts"
@@ -562,8 +630,10 @@ class ProxyRegistrationManager:
                 ) as response:
                     try:
                         result = await response.json()
-                    except Exception:
+                        logger.debug(f"Response JSON parsed successfully: {type(result)} - {result}")
+                    except Exception as e:
                         text_body = await response.text()
+                        logger.debug(f"JSON parsing failed: {e}, text_body: {text_body}")
                         result = {"success": False, "error": {"code": "NON_JSON_RESPONSE", "message": text_body}}
 
                     # Validate response headers if security framework available
@@ -604,6 +674,9 @@ class ProxyRegistrationManager:
                         logger.warning(
                             f"Registration failed with HTTP status: {response.status}"
                         )
+                        # Ensure result is a dict for consistent error handling
+                        if isinstance(result, str):
+                            result = {"success": False, "error": {"code": "HTTP_ERROR", "message": result}}
                         return False, result
         finally:
             if connector:

{mcp_proxy_adapter-6.6.3 → mcp_proxy_adapter-6.6.5}/mcp_proxy_adapter/examples/config_builder.py

@@ -76,7 +76,7 @@ class ConfigBuilder:
             },
             "transport": {
                 "type": "http",
-                "port": None,
+                        "port": None,
                 "verify_client": False,
                 "chk_hostname": False
             }
@@ -231,7 +231,7 @@ class ConfigFactory:
                 .set_auth(AuthMethod.TOKEN)
                 .set_server(port=port)
                 .build())
-    
+
     @staticmethod
     def create_mtls_token_roles_config(port: int = 8008) -> Dict[str, Any]:
         """Create mTLS with token and roles configuration."""

{mcp_proxy_adapter-6.6.3 → mcp_proxy_adapter-6.6.5}/mcp_proxy_adapter/main.py

@@ -73,11 +73,19 @@ def main():
     ssl_ca_cert = None
     
     if ssl_enabled:
-        # Configure SSL certificates - use absolute paths
+        # Configure SSL certificates from configuration
+        ssl_cert_file = config.get("transport.cert_file")
+        ssl_key_file = config.get("transport.key_file")
+        ssl_ca_cert = config.get("transport.ca_cert")
+        
+        # Convert relative paths to absolute paths
         project_root = Path(__file__).parent.parent
-        ssl_cert_file = str(project_root / "certs" / "server_cert.pem")
-        ssl_key_file = str(project_root / "keys" / "server_key.pem")
-        ssl_ca_cert = str(project_root / "certs" / "localhost_server.crt")
+        if ssl_cert_file and not Path(ssl_cert_file).is_absolute():
+            ssl_cert_file = str(project_root / ssl_cert_file)
+        if ssl_key_file and not Path(ssl_key_file).is_absolute():
+            ssl_key_file = str(project_root / ssl_key_file)
+        if ssl_ca_cert and not Path(ssl_ca_cert).is_absolute():
+            ssl_ca_cert = str(project_root / ssl_ca_cert)
 
     print("🔍 Debug config:")
     print(f"   protocol: {protocol}")

{mcp_proxy_adapter-6.6.3 → mcp_proxy_adapter-6.6.5}/mcp_proxy_adapter/version.py

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

{mcp_proxy_adapter-6.6.3 → mcp_proxy_adapter-6.6.5}/mcp_proxy_adapter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.6.3
+Version: 6.6.5
 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.6.3 → mcp_proxy_adapter-6.6.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcp-proxy-adapter"
-version = "6.6.3"
+version = "6.6.5"
 description = "Powerful JSON-RPC microservices framework with built-in security, authentication, and proxy registration"
 readme = "README.md"
 license = {text = "MIT"}