Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
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.pyindex 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 annotationsimport asyncioimport contextlibimport os+import weakreffrom contextlib import asynccontextmanagerfrom 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.pynew file mode 100644index 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