Extract HTTP bind settings from MCP server construction.

Author: diego-ferrand

config/runtime.py

@@ -1,4 +1,5 @@
 """Process-level runtime wiring shared by all tool registrations."""
+import os
 from dataclasses import dataclass
 from typing import Any, Literal, Optional
 
@@ -12,6 +13,42 @@
 
 Transport = Literal["stdio", "streamable-http"]
 
+DEFAULT_HTTP_HOST = "127.0.0.1"
+DEFAULT_HTTP_PORT = 8000
+DEFAULT_HTTP_PATH = "/mcp"
+
+
+@dataclass(frozen=True)
+class HttpBindSettings:
+    """Listen settings used only by the streamable-http transport."""
+
+    host: str = DEFAULT_HTTP_HOST
+    port: int = DEFAULT_HTTP_PORT
+    streamable_http_path: str = DEFAULT_HTTP_PATH
+
+
+def resolve_http_bind_settings() -> HttpBindSettings:
+    """
+    Resolve FastMCP bind settings from the environment.
+
+    Cloud Run injects PORT; prefer FASTMCP_PORT when set, else PORT, else 8000.
+    """
+    host = os.getenv("FASTMCP_HOST", DEFAULT_HTTP_HOST).strip() or DEFAULT_HTTP_HOST
+    port_raw = (
+        os.getenv("FASTMCP_PORT")
+        or os.getenv("PORT")
+        or str(DEFAULT_HTTP_PORT)
+    ).strip() or str(DEFAULT_HTTP_PORT)
+    streamable_http_path = (
+        os.getenv("FASTMCP_STREAMABLE_HTTP_PATH", DEFAULT_HTTP_PATH).strip()
+        or DEFAULT_HTTP_PATH
+    )
+    return HttpBindSettings(
+        host=host,
+        port=int(port_raw),
+        streamable_http_path=streamable_http_path,
+    )
+
 
 @dataclass(frozen=True)
 class AppRuntime:

main.py

@@ -10,7 +10,7 @@
 from config.auth import run_streamable_http
 from config.perfecto import SECURITY_TOKEN_FILE_ENV_NAME, SECURITY_TOKEN_ENV_NAME, PERFECTO_CLOUD_NAME_ENV_NAME, \
     GITHUB
-from config.runtime import build_runtime
+from config.runtime import build_runtime, resolve_http_bind_settings
 from config.token import PerfectoToken, PerfectoTokenError
 from config.version import __version__, __executable__, __bundle__, __uvx__, get_version
 from server import register_tools
@@ -112,20 +112,6 @@ def build_mcp_server(
     transport name (``stdio`` or ``streamable-http``).
     """
     init_telemetry("perfecto-mcp", __version__)
-    host = "127.0.0.1"
-    port = 8000
-    streamable_http_path = "/mcp"
-    if transport == "http":
-        host = os.getenv("FASTMCP_HOST", "127.0.0.1").strip() or "127.0.0.1"
-        # Cloud Run injects PORT; prefer FASTMCP_PORT when set, else PORT, else 8000.
-        port_raw = (
-            os.getenv("FASTMCP_PORT")
-            or os.getenv("PORT")
-            or "8000"
-        ).strip() or "8000"
-        port = int(port_raw)
-        streamable_http_path = os.getenv("FASTMCP_STREAMABLE_HTTP_PATH", "/mcp").strip() or "/mcp"
-
     # docker and stdio share process-lifetime credentials; http uses Bearer per request.
     wire_transport = to_wire_transport(transport)
     app_runtime = build_runtime(
@@ -136,15 +122,19 @@ def build_mcp_server(
 # Perfecto MCP Server
 
 """
-    mcp = FastMCP(
-        "perfecto-mcp",
-        instructions=instructions,
-        log_level=cast(LOG_LEVELS, log_level),
-        host=host,
-        port=port,
-        streamable_http_path=streamable_http_path,
-        stateless_http=False,
-    )
+    mcp_kwargs: dict = {
+        "instructions": instructions,
+        "log_level": cast(LOG_LEVELS, log_level),
+    }
+    if transport == "http":
+        bind = resolve_http_bind_settings()
+        mcp_kwargs.update(
+            host=bind.host,
+            port=bind.port,
+            streamable_http_path=bind.streamable_http_path,
+            stateless_http=False,
+        )
+    mcp = FastMCP("perfecto-mcp", **mcp_kwargs)
     register_tools(mcp, app_runtime)
     return mcp, wire_transport
 

tests/test_main_transport.py

@@ -2,7 +2,7 @@
 
 import main
 from config.auth import HttpAuthProvider, StdioAuthProvider
-from config.runtime import AppRuntime
+from config.runtime import AppRuntime, resolve_http_bind_settings
 
 
 class _DummyFastMCP:
@@ -47,6 +47,38 @@ def test_maps_logical_transports(self):
         assert main.to_wire_transport("docker") == "stdio"
 
 
+class TestResolveHttpBindSettings:
+    def test_defaults(self, monkeypatch):
+        monkeypatch.delenv("FASTMCP_HOST", raising=False)
+        monkeypatch.delenv("FASTMCP_PORT", raising=False)
+        monkeypatch.delenv("PORT", raising=False)
+        monkeypatch.delenv("FASTMCP_STREAMABLE_HTTP_PATH", raising=False)
+
+        bind = resolve_http_bind_settings()
+
+        assert bind.host == "127.0.0.1"
+        assert bind.port == 8000
+        assert bind.streamable_http_path == "/mcp"
+
+    def test_env_overrides_and_cloud_run_port_fallback(self, monkeypatch):
+        monkeypatch.setenv("FASTMCP_HOST", "0.0.0.0")
+        monkeypatch.setenv("FASTMCP_STREAMABLE_HTTP_PATH", "/custom-mcp")
+        monkeypatch.delenv("FASTMCP_PORT", raising=False)
+        monkeypatch.setenv("PORT", "8080")
+
+        bind = resolve_http_bind_settings()
+
+        assert bind.host == "0.0.0.0"
+        assert bind.port == 8080
+        assert bind.streamable_http_path == "/custom-mcp"
+
+    def test_fastmcp_port_wins_over_port(self, monkeypatch):
+        monkeypatch.setenv("FASTMCP_PORT", "8012")
+        monkeypatch.setenv("PORT", "8080")
+
+        assert resolve_http_bind_settings().port == 8012
+
+
 class TestBuildMcpServerHttp:
     def test_http_uses_env_settings_and_stateful_http(self, monkeypatch):
         _patch_mcp_server_dependencies(monkeypatch)
@@ -73,6 +105,21 @@ def test_http_falls_back_to_cloud_run_port(self, monkeypatch):
 
         assert mcp.kwargs["port"] == 8080
 
+    def test_stdio_and_docker_omit_http_bind_kwargs(self, monkeypatch):
+        _patch_mcp_server_dependencies(monkeypatch)
+        monkeypatch.setenv("FASTMCP_HOST", "0.0.0.0")
+        monkeypatch.setenv("FASTMCP_PORT", "8012")
+        monkeypatch.setenv("FASTMCP_STREAMABLE_HTTP_PATH", "/custom-mcp")
+
+        mcp_stdio, _ = main.build_mcp_server(transport="stdio")
+        mcp_docker, _ = main.build_mcp_server(transport="docker")
+
+        for mcp in (mcp_stdio, mcp_docker):
+            assert "host" not in mcp.kwargs
+            assert "port" not in mcp.kwargs
+            assert "streamable_http_path" not in mcp.kwargs
+            assert "stateless_http" not in mcp.kwargs
+
 
 class TestBuildMcpServerTransportMapping:
     def test_transport_mapping_keeps_docker_stdio_and_http_streamable(self, monkeypatch):