mcp-proxy-adapter 6.3.28__py3-none-any.whl → 6.3.29__py3-none-any.whl

mcp_proxy_adapter/api/app.py

@@ -65,16 +65,49 @@ def create_lifespan(config_path: Optional[str] = None):
             initialize_proxy_registration,
         )
 
-        # Initialize proxy registration manager WITH CURRENT CONFIG before reload_system
-        # so that registration inside reload_system can work
+        # 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}")
 
-        # Initialize system using unified logic
-        # This will load config, register custom commands, and discover auto-commands
-        # Only reload config if not already loaded from the same path
+        # Compute server_url EARLY and inject into registration manager so
+        # that reload_system (which may perform registration) uses the correct
+        # externally reachable address.
+        server_config = config.get("server", {})
+        server_host = server_config.get("host", "0.0.0.0")
+        server_port = server_config.get("port", 8000)
+
+        reg_cfg = config.get("registration", {})
+        public_host = reg_cfg.get("public_host")
+        public_port = reg_cfg.get("public_port")
+
+        security_config = config.get("security", {})
+        ssl_config = security_config.get("ssl", {})
+        if not ssl_config.get("enabled", False):
+            ssl_config = config.get("ssl", {})
+        protocol = "https" if ssl_config.get("enabled", False) else "http"
+
+        import os
+        docker_host_addr = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
+        target_host = public_host or (docker_host_addr if server_host == "0.0.0.0" else server_host)
+        target_port = public_port or server_port
+        early_server_url = f"{protocol}://{target_host}:{target_port}"
+        try:
+            from mcp_proxy_adapter.core.proxy_registration import (
+                proxy_registration_manager,
+            )
+
+            if proxy_registration_manager is not None:
+                proxy_registration_manager.set_server_url(early_server_url)
+                logger.info(
+                    "🔍 Early injection of server_url for registration: %s",
+                    early_server_url,
+                )
+        except Exception as e:
+            logger.error(f"Failed to inject early server_url: {e}")
+
+        # Initialize system using unified logic (may perform registration)
         if config_path:
             init_result = await registry.reload_system(config_path=config_path)
         else:
@@ -91,30 +124,59 @@ def create_lifespan(config_path: Optional[str] = None):
         except Exception as e:
             logger.error(f"Failed to initialize proxy registration: {e}")
 
-        # Register with proxy if enabled (run slightly delayed to ensure server is accepting connections)
-        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
-        # Try security framework SSL config first
-        security_config = config.get("security", {})
-        ssl_config = security_config.get("ssl", {})
+        # Recompute registration URL AFTER config reload using final config
+        try:
+            final_config = config.get_all()
+            server_config = final_config.get("server", {})
+            server_host = server_config.get("host", "0.0.0.0")
+            server_port = server_config.get("port", 8000)
 
-        # Fallback to legacy SSL config
-        if not ssl_config.get("enabled", False):
-            ssl_config = config.get("ssl", {})
+            reg_cfg = final_config.get("registration", final_config.get("proxy_registration", {}))
+            public_host = reg_cfg.get("public_host")
+            public_port = reg_cfg.get("public_port")
 
-        if ssl_config.get("enabled", False):
-            protocol = "https"
-        else:
-            protocol = "http"
+            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"
 
-        # Use localhost for external access if host is 0.0.0.0
-        if server_host == "0.0.0.0":
-            server_host = "localhost"
+            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(
+                "🔍 Registration URL selection: server_host=%s, server_port=%s, public_host=%s, public_port=%s, protocol=%s",
+                server_host,
+                server_port,
+                public_host,
+                public_port,
+                protocol,
+            )
+            try:
+                print(
+                    "🔍 Registration URL selection (print):",
+                    {
+                        "server_host": server_host,
+                        "server_port": server_port,
+                        "public_host": public_host,
+                        "public_port": public_port,
+                        "protocol": protocol,
+                    },
+                )
+            except Exception:
+                pass
 
-        server_url = f"{protocol}://{server_host}:{server_port}"
+            logger.info("🔍 Registration server_url resolved to: %s", server_url)
+            try:
+                print("🔍 Registration server_url resolved to (print):", server_url)
+            except Exception:
+                pass
+        except Exception as e:
+            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():
@@ -256,7 +318,26 @@ def create_app(
     else:
         print("🔍 Debug: create_app received no app_config, using global config")
 
-    # Security check: Validate all authentication configurations before startup
+    # Security check: Validate configuration strictly at startup (fail-fast)
+    try:
+        from mcp_proxy_adapter.core.config_validator import ConfigValidator
+
+        try:
+            _validator = ConfigValidator()
+        except TypeError:
+            _validator = ConfigValidator(current_config)
+        _validation = _validator.validate(current_config)
+        if not _validation.is_valid:
+            logger.critical("CRITICAL CONFIG ERROR: Invalid configuration at startup:")
+            for _e in _validation.errors:
+                logger.critical(f"  - {_e}")
+            raise SystemExit(1)
+        for _w in _validation.warnings:
+            logger.warning(f"Config warning: {_w}")
+    except Exception as _ex:
+        logger.error(f"Failed to run startup configuration validation: {_ex}")
+
+    # Security check: Validate all authentication configurations before startup (legacy checks kept for compatibility)
     security_errors = []
 
     print(f"🔍 Debug: current_config keys: {list(current_config.keys())}")
@@ -426,11 +507,11 @@ def create_app(
     # Add request logging middleware for debugging
     @app.middleware("http")
     async def debug_request_middleware(request: Request, call_next):
-        logger.debug(f"🔍 FastAPI Request START: {request.method} {request.url.path}")
-        logger.debug(f"🔍 FastAPI Request Headers: {dict(request.headers)}")
+        logger.info(f"🔍 FastAPI Request START: {request.method} {request.url.path}")
+        logger.info(f"🔍 FastAPI Request Headers: {dict(request.headers)}")
         try:
             response = await call_next(request)
-            logger.debug(f"🔍 FastAPI Request COMPLETED: {response.status_code}")
+            logger.info(f"🔍 FastAPI Request COMPLETED: {response.status_code}")
             return response
         except Exception as e:
             logger.error(f"🔍 FastAPI Request ERROR: {e}", exc_info=True)
@@ -440,14 +521,14 @@ def create_app(
     setup_middleware(app, current_config)
     
     # Add request logging middleware
-    @app.middleware("http")
-    async def log_requests(request: Request, call_next):
-        logger.info(f"🔍 REQUEST LOG: {request.method} {request.url.path}")
-        logger.info(f"🔍 REQUEST LOG: Headers: {dict(request.headers)}")
-        logger.info(f"🔍 REQUEST LOG: Client: {request.client}")
-        response = await call_next(request)
-        logger.info(f"🔍 RESPONSE LOG: Status: {response.status_code}")
-        return response
+    # @app.middleware("http")
+    # async def log_requests(request: Request, call_next):
+    #     logger.info(f"🔍 REQUEST LOG: {request.method} {request.url.path}")
+    #     logger.info(f"🔍 REQUEST LOG: Headers: {dict(request.headers)}")
+    #     logger.info(f"🔍 REQUEST LOG: Client: {request.client}")
+    #     response = await call_next(request)
+    #     logger.info(f"🔍 RESPONSE LOG: Status: {response.status_code}")
+    #     return response
 
     # Use custom OpenAPI schema
     app.openapi = lambda: custom_openapi_with_fallback(app)

mcp_proxy_adapter/commands/command_registry.py

@@ -674,7 +674,8 @@ class CommandRegistry:
             f"🔄 Starting system reload with config: {config_path or 'default'}"
         )
 
-        # Step 1: Load configuration
+        # Step 1: Load configuration (preserve previous config for soft-fail)
+        previous_config = config.get_all()
         try:
             if config_path:
                 config.load_from_file(config_path)
@@ -688,6 +689,28 @@ class CommandRegistry:
             logger.error(f"❌ Failed to load configuration: {e}")
             config_reloaded = False
 
+        # Step 1.1: Validate configuration (soft-fail on reload)
+        try:
+            from mcp_proxy_adapter.core.config_validator import ConfigValidator
+
+            validator = ConfigValidator()
+            validation = validator.validate(config.get_all())
+            if not validation.is_valid:
+                logger.error("⚠️ Configuration validation failed during reload:")
+                for err in validation.errors:
+                    logger.error(f"  - {err}")
+                # Do NOT exit on reload; restore previous configuration
+                try:
+                    config.config_data = previous_config
+                    config_reloaded = False
+                    logger.error("ℹ️ Restored previous configuration due to validation errors")
+                except Exception as restore_ex:
+                    logger.error(f"❌ Failed to restore previous configuration: {restore_ex}")
+            for warn in validation.warnings:
+                logger.warning(f"Config warning: {warn}")
+        except Exception as e:
+            logger.error(f"❌ Failed to validate configuration: {e}")
+
         # Step 2: Initialize logging with configuration
         try:
             from mcp_proxy_adapter.core.logging import setup_logging