Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

fix(mcp): share lifespan across HTTP sessions (#4398)

ZhangDT1ddf926ffe10
diff --git a/packages/server/src/repowise/server/mcp_server/_server.py b/packages/server/src/repowise/server/mcp_server/_server.py
index 0777ab783..116ccb744 100644
--- a/packages/server/src/repowise/server/mcp_server/_server.py
+++ b/packages/server/src/repowise/server/mcp_server/_server.py
@@ -5,6 +5,7 @@ from __future__ import annotations
import asyncio
import contextlib
import os
+import weakref
from contextlib import asynccontextmanager
from typing import Any, NoReturn
@@ -199,6 +200,64 @@ def _query_embedder():
_RELEASE_RECHECK_S = 6 * 3600
+def _share_lifespan(server: Any) -> None:
+ """Keep process-scoped MCP resources alive while any session is active.
+
+ Streamable HTTP enters the low-level server lifespan once per session,
+ while the state it publishes is process-wide. Share one underlying
+ lifespan per event loop so one session cannot tear down another's state.
+ """
+ original = server.lifespan
+ managers: weakref.WeakKeyDictionary[Any, dict[str, Any]] = weakref.WeakKeyDictionary()
+
+ @asynccontextmanager
+ async def shared(app: Any):
+ loop = asyncio.get_running_loop()
+ manager = managers.get(loop)
+ if manager is None:
+ manager = {"lock": asyncio.Lock(), "active": 0, "context": None, "state": None}
+ managers[loop] = manager
+
+ async with manager["lock"]:
+ if manager["active"] == 0:
+ context = original(app)
+ try:
+ state = await context.__aenter__()
+ except BaseException:
+ manager["context"] = None
+ manager["state"] = None
+ raise
+ manager["context"] = context
+ manager["state"] = state
+ manager["active"] += 1
+ state = manager["state"]
+
+ error: BaseException | None = None
+ try:
+ yield state
+ except BaseException as exc:
+ error = exc
+ raise
+ finally:
+ async with manager["lock"]:
+ manager["active"] -= 1
+ if manager["active"] == 0:
+ context = manager["context"]
+ manager["context"] = None
+ manager["state"] = None
+ if context is not None:
+ teardown_error = (
+ None if isinstance(error, asyncio.CancelledError) else error
+ )
+ await context.__aexit__(
+ type(teardown_error) if teardown_error is not None else None,
+ teardown_error,
+ teardown_error.__traceback__ if teardown_error is not None else None,
+ )
+
+ server.lifespan = shared
+
+
async def _poll_release_check() -> None:
"""Keep ``_state._release_check`` current for the life of the server.
@@ -692,6 +751,7 @@ mcp = _RepowiseMCP(
),
lifespan=_lifespan,
)
+_share_lifespan(mcp._mcp_server)
# FastMCP takes no version argument, and without one the handshake's
# serverInfo.version reports the installed ``mcp`` SDK's version.
mcp._mcp_server.version = __version__
diff --git a/tests/unit/server/test_mcp_http_lifespan.py b/tests/unit/server/test_mcp_http_lifespan.py
new file mode 100644
index 000000000..dd82fb312
--- /dev/null
+++ b/tests/unit/server/test_mcp_http_lifespan.py
@@ -0,0 +1,191 @@
+"""Regression tests for shared state across Streamable HTTP MCP sessions."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from types import SimpleNamespace
+from typing import ClassVar
+
+import pytest
+
+import repowise.server.mcp_server as mcp_mod
+from repowise.server.mcp_server import _server
+from repowise.server.mcp_server._helpers import _resolve_repo_context
+
+
[email protected](autouse=True)
+def restore_mcp_state():
+ saved = (
+ mcp_mod._registry,
+ mcp_mod._workspace_root,
+ mcp_mod._cross_repo_enricher,
+ mcp_mod._session_factory,
+ mcp_mod._fts,
+ mcp_mod._vector_store,
+ _server._state._decision_store,
+ _server._state._repo_path,
+ _server._state._lancedb_ready,
+ _server._state._vector_store_ready,
+ )
+ yield
+ (
+ mcp_mod._registry,
+ mcp_mod._workspace_root,
+ mcp_mod._cross_repo_enricher,
+ mcp_mod._session_factory,
+ mcp_mod._fts,
+ mcp_mod._vector_store,
+ _server._state._decision_store,
+ _server._state._repo_path,
+ _server._state._lancedb_ready,
+ _server._state._vector_store_ready,
+ ) = saved
+
+
+def _install_workspace(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ *,
+ fail_first_start: bool = False,
+) -> SimpleNamespace:
+ contexts = {
+ alias: SimpleNamespace(
+ alias=alias,
+ session_factory=object(),
+ fts=object(),
+ vector_store=object(),
+ decision_store=object(),
+ vector_store_ready=asyncio.Event(),
+ )
+ for alias in ("boot", "gateway")
+ }
+ registries = []
+ cancelled_tasks = []
+
+ class WorkspaceConfig:
+ repos: ClassVar[list[SimpleNamespace]] = [
+ SimpleNamespace(alias="boot"),
+ SimpleNamespace(alias="gateway"),
+ ]
+ default_repo = "boot"
+
+ def get_repo(self, alias: str):
+ return next((repo for repo in self.repos if repo.alias == alias), None)
+
+ class Registry:
+ def __init__(self, **_kwargs) -> None:
+ self.closed = False
+ registries.append(self)
+
+ async def get_default(self):
+ await asyncio.sleep(0)
+ if fail_first_start and len(registries) == 1:
+ raise RuntimeError("workspace startup failed")
+ return contexts["boot"]
+
+ def get_all_aliases(self):
+ return list(contexts)
+
+ def get_default_alias(self):
+ return "boot"
+
+ def resolve_repo_param(self, alias):
+ return alias
+
+ async def get(self, alias):
+ return contexts[alias]
+
+ async def close(self):
+ self.closed = True
+
+ async def idle_task() -> None:
+ try:
+ await asyncio.Event().wait()
+ finally:
+ cancelled_tasks.append(True)
+
+ monkeypatch.setattr(_server, "_detect_workspace", lambda _path: (tmp_path, WorkspaceConfig(), None))
+ monkeypatch.setattr(_server, "_warm_lancedb", idle_task)
+ monkeypatch.setattr(_server, "_poll_release_check", idle_task)
+ monkeypatch.setattr("repowise.core.workspace.registry.RepoRegistry", Registry)
+ return SimpleNamespace(registries=registries, cancelled_tasks=cancelled_tasks)
+
+
+async def test_overlapping_sessions_share_lifespan_and_reenter_after_cleanup(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ workspace = _install_workspace(tmp_path, monkeypatch)
+
+ session_a = _server.mcp._mcp_server.lifespan(_server.mcp._mcp_server)
+ session_b = _server.mcp._mcp_server.lifespan(_server.mcp._mcp_server)
+ await asyncio.gather(session_a.__aenter__(), session_b.__aenter__())
+ try:
+ assert len(workspace.registries) == 1
+ registry = workspace.registries[0]
+ assert (await _resolve_repo_context("gateway")).alias == "gateway"
+
+ await session_b.__aexit__(None, None, None)
+ assert not registry.closed
+ assert mcp_mod._registry is not None
+ assert (await _resolve_repo_context("gateway")).alias == "gateway"
+
+ finally:
+ await session_a.__aexit__(None, None, None)
+
+ assert registry.closed
+ assert mcp_mod._registry is None
+ assert mcp_mod._workspace_root is None
+ assert len(workspace.cancelled_tasks) == 2
+
+ new_session = _server.mcp._mcp_server.lifespan(_server.mcp._mcp_server)
+ await new_session.__aenter__()
+ try:
+ assert len(workspace.registries) == 2
+ assert (await _resolve_repo_context("gateway")).alias == "gateway"
+ finally:
+ await new_session.__aexit__(None, None, None)
+ assert workspace.registries[1].closed
+ assert len(workspace.cancelled_tasks) == 4
+
+
+async def test_failed_startup_can_be_retried(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ workspace = _install_workspace(tmp_path, monkeypatch, fail_first_start=True)
+ failed_session = _server.mcp._mcp_server.lifespan(_server.mcp._mcp_server)
+
+ with pytest.raises(RuntimeError, match="workspace startup failed"):
+ await failed_session.__aenter__()
+
+ assert mcp_mod._registry is None
+ assert _server._state._lancedb_ready is None
+ assert len(workspace.cancelled_tasks) == 2
+
+ retry_session = _server.mcp._mcp_server.lifespan(_server.mcp._mcp_server)
+ await retry_session.__aenter__()
+ try:
+ assert len(workspace.registries) == 2
+ assert (await _resolve_repo_context("gateway")).alias == "gateway"
+ finally:
+ await retry_session.__aexit__(None, None, None)
+
+ assert workspace.registries[1].closed
+ assert len(workspace.cancelled_tasks) == 4
+
+
+async def test_cancelled_last_session_still_cleans_up_lifespan(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ workspace = _install_workspace(tmp_path, monkeypatch)
+ session = _server.mcp._mcp_server.lifespan(_server.mcp._mcp_server)
+ await session.__aenter__()
+ registry = workspace.registries[0]
+
+ await session.__aexit__(asyncio.CancelledError, asyncio.CancelledError(), None)
+
+ assert registry.closed
+ assert mcp_mod._registry is None
+ assert mcp_mod._workspace_root is None
+ assert len(workspace.cancelled_tasks) == 2