code-coordinator 0.5.451__tar.gz → 0.5.452__tar.gz

{code_coordinator-0.5.451 → code_coordinator-0.5.452}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.451
+Version: 0.5.452
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.451 → code_coordinator-0.5.452}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.451
+Version: 0.5.452
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.451 → code_coordinator-0.5.452}/code_coordinator.egg-info/SOURCES.txt

@@ -539,6 +539,7 @@ tests/test_cli_test_plan.py
 tests/test_cli_track.py
 tests/test_cli_tui_update.py
 tests/test_cli_wait.py
+tests/test_client.py
 tests/test_client_base_install.py
 tests/test_client_config_cache_atomic_3052.py
 tests/test_client_resource_migration_1946.py
@@ -570,6 +571,7 @@ tests/test_dao.py
 tests/test_dashboard.py
 tests/test_dashboard_api.py
 tests/test_dashboard_fixture.py
+tests/test_dashboard_server.py
 tests/test_dashboard_terminal.py
 tests/test_dashboard_terminal_live.py
 tests/test_db.py

{code_coordinator-0.5.451 → code_coordinator-0.5.452}/code_coordinator.egg-info/scm_file_list.json

@@ -565,6 +565,7 @@
     "tests/test_cli_track.py",
     "tests/test_cli_tui_update.py",
     "tests/test_cli_wait.py",
+    "tests/test_client.py",
     "tests/test_client_base_install.py",
     "tests/test_client_config_cache_atomic_3052.py",
     "tests/test_client_resource_migration_1946.py",
@@ -596,6 +597,7 @@
     "tests/test_dashboard.py",
     "tests/test_dashboard_api.py",
     "tests/test_dashboard_fixture.py",
+    "tests/test_dashboard_server.py",
     "tests/test_dashboard_terminal.py",
     "tests/test_dashboard_terminal_live.py",
     "tests/test_db.py",

{code_coordinator-0.5.451 → code_coordinator-0.5.452}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.451",
+  "tag": "0.5.452",
   "distance": 0,
-  "node": "g75985b1122962fa0ccd6b97ab453eabdc7a1b5e9",
+  "node": "g69efb323ff5ace2c8783a4e3eb8deb0b37b5aff0",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-11"

{code_coordinator-0.5.451 → code_coordinator-0.5.452}/coord/client.py

@@ -88,11 +88,62 @@ def _headers(svc: ServiceConfig) -> dict[str, str]:
     return headers
 
 
+# #3295: per-service-URL ETag cache for `GET /board`, so a thin client that
+# calls `fetch_board_payload()` repeatedly in a short window (dashboard
+# panels each doing their own read, drive-queue polling, ...) gets a
+# bodyless 304 back and reuses the last body instead of re-shipping and
+# re-parsing the full board (measured at 3.5MB) on every call. The daemon
+# has served `ETag` / honoured `If-None-Match` on `GET /board` since #1336;
+# nothing on the server changes here, only this client now uses it.
+# Process-local and never persisted — like `board_service._RESOURCE_ROUTE_SUPPORT`
+# — so a fresh process (or a test) starts with an empty cache and the very
+# next call is an unconditional GET.
+_board_payload_cache: dict[str, tuple[str, dict]] = {}
+
+
+def reset_board_payload_cache() -> None:
+    """Forget every cached ``(etag, body)`` pair (tests; #3295)."""
+    _board_payload_cache.clear()
+
+
 def fetch_board_payload(svc: ServiceConfig, *, timeout: float = _DEFAULT_TIMEOUT) -> dict:
-    """GET /board → the raw projection dict (also carries machines/merge_queue/…)."""
-    resp = httpx.get(f"{svc.url}/board", headers=_headers(svc), timeout=timeout)
+    """GET /board → the raw projection dict (also carries machines/merge_queue/…).
+
+    #3295: sends ``If-None-Match`` with the ETag from this *svc.url*'s last
+    successful fetch, if any. A ``304`` means the daemon is telling us the
+    board hasn't changed since that ETag was minted — the cached body from
+    that fetch is still exactly correct, so it's returned as-is with no
+    re-parse. A ``200`` (first call for this URL, or the board really did
+    change) refreshes the cache with the new ``ETag``/body pair; a response
+    carrying no ``ETag`` at all clears any stale entry rather than caching
+    something we can't validate next time.
+    """
+    headers = _headers(svc)
+    cached = _board_payload_cache.get(svc.url)
+    if cached is not None:
+        headers["If-None-Match"] = cached[0]
+    resp = httpx.get(f"{svc.url}/board", headers=headers, timeout=timeout)
+    if resp.status_code == 304:
+        if cached is not None:
+            return cached[1]
+        # Should never happen — we only ever send `If-None-Match` when
+        # *cached* is set, so a 304 here means the daemon answered a
+        # conditional response to an unconditional request. Surfacing this
+        # loudly beats silently returning `None`/an empty board that looks
+        # like a real (if suspiciously quiet) fleet.
+        raise RuntimeError(
+            f"GET {svc.url}/board answered 304 but this client sent no "
+            "If-None-Match (no cached ETag for this service) — refusing to "
+            "guess at a board"
+        )
     resp.raise_for_status()
-    return resp.json()
+    body = resp.json()
+    etag = resp.headers.get("ETag")
+    if etag:
+        _board_payload_cache[svc.url] = (etag, body)
+    else:
+        _board_payload_cache.pop(svc.url, None)
+    return body
 
 
 def fetch_healthz(svc: ServiceConfig, *, timeout: float = _DEFAULT_TIMEOUT) -> dict:

{code_coordinator-0.5.451 → code_coordinator-0.5.452}/coord/dashboard/server.py

@@ -2378,22 +2378,90 @@ def build_app(
         # would take those down to protest a missing frontend.
         logger.warning("coord web: %s", webapp_bundle_missing_message(webapp_dist))
 
+    # #3295: per-process board memo. Before this, EVERY `/api/*` request on
+    # the daemon host (no `board_service` configured — the deployment
+    # actually in use) fell through to `read_board()`: open sqlite, run the
+    # query, walk every row through `assemble_board()`. A single screen load
+    # (a few panels each polling their own endpoint) or one background
+    # `_background_poller()` tick fanned that out into 2-5 independent
+    # builds of the SAME board. In thin-client mode (`board_service`
+    # configured) the equivalent waste was `_read_board_and_machine_health()`
+    # and `_read_fleet_health()` each firing their OWN `fetch_board_payload()`
+    # round trip for the same daemon snapshot.
+    #
+    # `_board_memo` is local to this `build_app()` closure — like
+    # `_seen_terminal`/`_orphaned_since` below — never a module global, so
+    # each dashboard process (and each test's own `build_app()`) gets an
+    # independent memo that can never bleed into another's.
+    _BOARD_MEMO_TTL_S = 2.0
+    _board_memo: dict[str, Any] = {"at": 0.0, "board": None, "payload": None}
+
+    def _fetch_board_and_payload():  # -> tuple[Board, dict | None]
+        """Uncached ``(board, payload)`` build — what the memo below wraps.
+
+        ``payload`` is the raw ``/board`` projection dict when this process
+        is a thin client (``board_service`` configured) — it carries sibling
+        keys (``fleet_health``, ...) a bare :class:`Board` does not — and
+        ``None`` when reading the local DB/daemon-host path directly, since
+        there is no daemon payload to share in that mode.
+        """
+        from coord import board_service  # noqa: PLC0415
+
+        svc = board_service.resolve()
+        if svc is not None:
+            from coord.client import board_from_payload, fetch_board_payload  # noqa: PLC0415
+
+            payload = fetch_board_payload(svc)
+            return board_from_payload(payload), payload
+        return read_board(), None
+
+    def _memoized_board_and_payload():  # -> tuple[Board, dict | None]
+        """``(board, payload)``, rebuilt at most once per ``_BOARD_MEMO_TTL_S``.
+
+        The ONE read every board-shaped handler below goes through —
+        ``_read_board()``, ``_read_board_and_machine_health()`` and
+        ``_read_fleet_health()`` all call this rather than each doing their
+        own ``read_board()``/``fetch_board_payload()`` (#3295: "one question,
+        one answer" applies to *how the data is obtained*, not just what it
+        says). A short TTL rather than invalidate-on-write: long enough to
+        collapse a burst of requests (one screen load, one SSE tick) into a
+        single build, short enough that no panel is ever more than ~2s
+        behind the DB/daemon.
+        """
+        now = time.monotonic()
+        if _board_memo["board"] is not None and (now - _board_memo["at"]) < _BOARD_MEMO_TTL_S:
+            return _board_memo["board"], _board_memo["payload"]
+        board, payload = _fetch_board_and_payload()
+        _board_memo.update(at=now, board=board, payload=payload)
+        return board, payload
+
     def _read_board():
-        """The board for this request — seeded fixture or the live DB/daemon.
+        """The board for this request — seeded fixture or the memoized live DB/daemon.
 
         Fixture mode rebuilds the Board from the raw payload on every call, so
         a handler that mutates what it is handed (``unstick`` →
-        ``mark_failed_by_id``) can't leak that into the next request.
+        ``mark_failed_by_id``) can't leak that into the next request. Live
+        mode goes through :func:`_memoized_board_and_payload` (#3295).
         """
         if _fixture is not None:
             return _fixture.board()
-        return read_board()
+        board, _payload = _memoized_board_and_payload()
+        return board
 
     def _write_board(board) -> None:  # noqa: ANN001
-        """Persist *board* — a no-op in fixture mode (writes never execute)."""
+        """Persist *board* — a no-op in fixture mode (writes never execute).
+
+        Invalidates the #3295 board memo rather than repopulating it with
+        *board*: in thin-client mode the write only carries the mutated
+        `Board`, not a fresh daemon payload (`fleet_health` et al.), so
+        keeping a stale/partial cache entry around risks a subsequent
+        `_read_fleet_health()`/`_read_board_and_machine_health()` call
+        serving an empty block instead of paying for one more real read.
+        """
         if _fixture is not None:
             return
         write_board(board)
+        _board_memo.update(at=0.0, board=None, payload=None)
 
     def _read_board_and_machine_health() -> tuple:  # -> tuple[Board, dict[str, dict]]
         """The board plus every configured machine's latest daemon-tick-
@@ -2423,16 +2491,19 @@ def build_app(
         install, or nothing has ticked the health refresher yet) — callers
         must treat that the same as an ``unknown`` state, never as healthy
         (#1485's failure mode).
+
+        #3295: the thin-client branch now reads through
+        :func:`_memoized_board_and_payload` instead of calling
+        ``fetch_board_payload`` itself — sharing the SAME daemon round trip
+        ``_read_fleet_health()`` (and ``_read_board()``) make within the
+        memo window, rather than each paying for its own.
         """
         from coord import board_service  # noqa: PLC0415
 
         svc = board_service.resolve()
         if svc is not None:
-            from coord.client import board_from_payload, fetch_board_payload  # noqa: PLC0415
-
-            payload = fetch_board_payload(svc)
-            board = board_from_payload(payload)
-            rows = (payload.get("fleet_health") or {}).get("machine_health") or []
+            board, payload = _memoized_board_and_payload()
+            rows = ((payload or {}).get("fleet_health") or {}).get("machine_health") or []
             return board, {row["machine"]: row for row in rows}
 
         from coord.health.fleet_snapshot import machine_health_rows  # noqa: PLC0415
@@ -2494,15 +2565,19 @@ def build_app(
         ``coord status``. Per-machine severities still come from the same
         row-assembly the thin-client path rides (``machine_health_rows``), so
         the two modes can't drift on that half.
+
+        #3295: the thin-client branch reads through
+        :func:`_memoized_board_and_payload` — the same memo
+        ``_read_board_and_machine_health()`` reads through — instead of
+        issuing its own ``fetch_board_payload`` call, so the two no longer
+        double the daemon I/O a single request burst costs.
         """
         from coord import board_service  # noqa: PLC0415
 
         svc = board_service.resolve()
         if svc is not None:
-            from coord.client import fetch_board_payload  # noqa: PLC0415
-
-            payload = fetch_board_payload(svc)
-            return payload.get("fleet_health") or dict(_EMPTY_FLEET_HEALTH_BLOCK)
+            _board, payload = _memoized_board_and_payload()
+            return (payload or {}).get("fleet_health") or dict(_EMPTY_FLEET_HEALTH_BLOCK)
 
         from coord.health.aggregate import local_fleet_health_block  # noqa: PLC0415
 
@@ -2746,12 +2821,21 @@ def build_app(
     _sessions_offline_since: dict[str, float] = {}
 
     async def _background_poller() -> None:
-        """Runs forever; polls agents every _POLL_INTERVAL seconds."""
+        """Runs forever; polls agents every _POLL_INTERVAL seconds.
+
+        #3295: passes its own board read through the shared
+        ``_read_board()``/memo rather than letting ``_poll_once`` fall back
+        to its own bare ``read_board()`` — a tick landing inside a client's
+        own ``/api/board`` poll window reuses that build instead of paying
+        for a second one, and the tick's own build is then what the very
+        next client poll reuses.
+        """
         await asyncio.sleep(10)  # Short initial delay so the server is ready
         while True:
             try:
                 possibly_stuck = await _poll_once(
                     config, event_source, _seen_terminal, _orphaned_since,
+                    board=_read_board(),
                     needs_attention_seen=_needs_attention_seen,
                 )
                 event_source.publish(BOARD_UPDATED, {

{code_coordinator-0.5.451 → code_coordinator-0.5.452}/tests/conftest.py

@@ -139,6 +139,26 @@ def _fresh_resource_route_support():
     board_service.reset_resource_route_support()
 
 
+@pytest.fixture(autouse=True)
+def _fresh_board_payload_cache():
+    """#3295: forget every cached ``GET /board`` ETag/body between tests.
+
+    ``coord.client.fetch_board_payload`` now memoizes ``(etag, body)`` per
+    service URL so a thin client sending a repeat ``If-None-Match`` can reuse
+    the daemon's 304. That memo is module-level — same shape as
+    ``_fresh_resource_route_support`` above — so without a reset a test that
+    populates it for a fake ``http://daemon:7435`` (a URL string reused
+    across dozens of unrelated tests) would leak a stale ``If-None-Match``
+    header, and a stale cached body, into the next test that happens to
+    reuse it.
+    """
+    from coord import client as _cc
+
+    _cc.reset_board_payload_cache()
+    yield
+    _cc.reset_board_payload_cache()
+
+
 @pytest.fixture(autouse=True)
 def _no_real_webapp_bundle(monkeypatch, tmp_path):
     """#2009: never let the HOST's live webapp bundle change a test's answer.

code_coordinator-0.5.452/tests/test_client.py

@@ -0,0 +1,206 @@
+"""Tests for #3295's client-side conditional GET.
+
+``coord.client.fetch_board_payload`` now keeps a ``(etag, body)`` pair per
+service URL and sends ``If-None-Match`` on every subsequent call, reusing the
+cached body on a ``304`` instead of re-shipping/re-parsing the full board
+(measured at 3.5MB) every time a thin-client dashboard reads it. The daemon
+side of this (``ETag`` on ``GET /board``, honouring ``If-None-Match``) has
+existed since #1336 — nothing server-side changes here, only this client now
+uses it.
+
+See ``tests/test_dashboard_server.py`` for #3295's other, independent half:
+the per-process board memo in ``coord/dashboard/server.py`` that fixes the
+non-thin-client (daemon-host) deployment.
+"""
+
+from __future__ import annotations
+
+import httpx
+import pytest
+
+import coord.client as cc
+
+
+@pytest.fixture(autouse=True)
+def _clean_board_payload_cache():
+    """Isolate each test from every other's cached ETag/body.
+
+    Not relying solely on the (already autouse, repo-wide) conftest fixture
+    of the same shape — this module's own tests are the direct spec for the
+    cache, so they assert their pre/post state explicitly rather than
+    trusting a fixture defined elsewhere.
+    """
+    cc.reset_board_payload_cache()
+    yield
+    cc.reset_board_payload_cache()
+
+
+class _FakeResponse:
+    """Minimal stand-in for ``httpx.Response`` — just what
+    ``fetch_board_payload`` reads: ``status_code``, ``headers``,
+    ``raise_for_status()``, ``json()``.
+    """
+
+    def __init__(self, *, status_code: int = 200, json_body=None, etag: str | None = None):
+        self.status_code = status_code
+        self._json_body = json_body
+        self.headers: dict[str, str] = {"ETag": etag} if etag else {}
+
+    def raise_for_status(self) -> None:
+        if self.status_code >= 400:
+            raise httpx.HTTPStatusError("boom", request=None, response=self)
+
+    def json(self):
+        return self._json_body
+
+
+def _svc(url: str = "http://daemon:7435") -> cc.ServiceConfig:
+    return cc.ServiceConfig(url=url)
+
+
+class TestFetchBoardPayloadConditionalGet:
+    def test_first_call_for_a_url_sends_no_if_none_match(self, monkeypatch) -> None:
+        captured: dict = {}
+
+        def fake_get(url, *, headers=None, **kw):
+            captured["headers"] = headers
+            return _FakeResponse(json_body={"round_number": 1}, etag='"v1"')
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        body = cc.fetch_board_payload(_svc())
+
+        assert body == {"round_number": 1}
+        assert "If-None-Match" not in captured["headers"]
+
+    def test_second_call_sends_the_etag_cached_from_the_first(self, monkeypatch) -> None:
+        headers_sent: list[dict] = []
+
+        def fake_get(url, *, headers=None, **kw):
+            headers_sent.append(headers)
+            return _FakeResponse(json_body={"round_number": 1}, etag='"v1"')
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+        svc = _svc()
+
+        cc.fetch_board_payload(svc)
+        cc.fetch_board_payload(svc)
+
+        assert len(headers_sent) == 2
+        assert "If-None-Match" not in headers_sent[0]
+        assert headers_sent[1]["If-None-Match"] == '"v1"'
+
+    def test_304_reuses_the_cached_body_and_never_touches_json(self, monkeypatch) -> None:
+        """The whole point: a validated-unchanged response must not pay for
+        parsing a (potentially multi-MB) body it doesn't have."""
+        headers_sent: list[dict] = []
+        first_body = {"round_number": 1, "assignments": ["x"] * 50}
+
+        def fake_get(url, *, headers=None, **kw):
+            headers_sent.append(headers)
+            if len(headers_sent) == 1:
+                return _FakeResponse(json_body=first_body, etag='"v1"')
+
+            def _must_not_be_called():
+                raise AssertionError("json() called on a 304 — body was refetched")
+
+            resp = _FakeResponse(status_code=304)
+            resp.json = _must_not_be_called
+            return resp
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+        svc = _svc()
+
+        first = cc.fetch_board_payload(svc)
+        second = cc.fetch_board_payload(svc)
+
+        assert first == first_body
+        assert second == first_body
+        assert headers_sent[1]["If-None-Match"] == '"v1"'
+
+    def test_a_new_etag_on_200_replaces_the_cached_one(self, monkeypatch) -> None:
+        responses = [
+            _FakeResponse(json_body={"round_number": 1}, etag='"v1"'),
+            _FakeResponse(json_body={"round_number": 2}, etag='"v2"'),
+        ]
+        headers_sent: list[dict] = []
+
+        def fake_get(url, *, headers=None, **kw):
+            headers_sent.append(headers)
+            return responses.pop(0)
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+        svc = _svc()
+
+        first = cc.fetch_board_payload(svc)
+        second = cc.fetch_board_payload(svc)
+
+        assert first == {"round_number": 1}
+        assert second == {"round_number": 2}
+        assert headers_sent[1]["If-None-Match"] == '"v1"'
+
+        # A third call must send the NEW etag ("v2"), never the stale "v1" —
+        # proves the cache was actually replaced, not just appended to.
+        def fake_get_third(url, *, headers=None, **kw):
+            headers_sent.append(headers)
+            return _FakeResponse(json_body={"round_number": 2}, etag='"v2"')
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get_third)
+        cc.fetch_board_payload(svc)
+        assert headers_sent[2]["If-None-Match"] == '"v2"'
+
+    def test_cache_is_scoped_per_service_url(self, monkeypatch) -> None:
+        """Two different daemons (or a test's two fake ones) must never
+        share a cache entry, or a client pointed at daemon B could send
+        daemon A's ETag and silently trust a body that was never daemon B's."""
+
+        def fake_get(url, *, headers=None, **kw):
+            etag = '"a-1"' if url.startswith("http://a:") else '"b-1"'
+            return _FakeResponse(json_body={"url": url}, etag=etag)
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        cc.fetch_board_payload(_svc("http://a:7435"))
+        cc.fetch_board_payload(_svc("http://b:7435"))
+
+        assert cc._board_payload_cache["http://a:7435"][0] == '"a-1"'
+        assert cc._board_payload_cache["http://b:7435"][0] == '"b-1"'
+
+    def test_response_without_an_etag_is_not_cached(self, monkeypatch) -> None:
+        def fake_get(url, *, headers=None, **kw):
+            return _FakeResponse(json_body={"round_number": 1})  # no ETag
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        cc.fetch_board_payload(_svc())
+
+        assert "http://daemon:7435" not in cc._board_payload_cache
+
+    def test_a_304_with_no_prior_cache_raises_instead_of_guessing(self, monkeypatch) -> None:
+        """A #2096 "gate can fail" check on the cache itself: without this
+        guard, an unconditional GET answered 304 (a daemon bug — this client
+        never sends `If-None-Match` with nothing cached) would fall through
+        to `resp.json()` on a bodyless response and silently return `None`
+        — indistinguishable from "board successfully fetched, contents:
+        nothing". Refusing outright is the honest failure."""
+
+        def fake_get(url, *, headers=None, **kw):
+            assert "If-None-Match" not in (headers or {})
+            return _FakeResponse(status_code=304)
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        with pytest.raises(RuntimeError):
+            cc.fetch_board_payload(_svc())
+
+    def test_reset_board_payload_cache_clears_every_entry(self, monkeypatch) -> None:
+        def fake_get(url, *, headers=None, **kw):
+            return _FakeResponse(json_body={"round_number": 1}, etag='"v1"')
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+        cc.fetch_board_payload(_svc())
+        assert cc._board_payload_cache
+
+        cc.reset_board_payload_cache()
+
+        assert cc._board_payload_cache == {}

{code_coordinator-0.5.451 → code_coordinator-0.5.452}/tests/test_dashboard_api.py

@@ -697,6 +697,11 @@ class TestMachinesAPI:
 
             class _Resp:
                 status_code = 200
+                # #3295: fetch_board_payload now reads the ETag off a real
+                # response's `.headers` to decide whether to cache the body
+                # for a future `If-None-Match` — an empty mapping here means
+                # "no ETag returned", which is a valid (if uncacheable) 200.
+                headers: dict = {}
 
                 def raise_for_status(self):
                     return None
@@ -1129,6 +1134,10 @@ class TestMachinesHealthAPI:
 
             class _Resp:
                 status_code = 200
+                # #3295: see the identical comment in
+                # TestMachinesAPI.test_thin_client_reads_the_daemons_published_fleet_health_block
+                # — fetch_board_payload now reads `.headers` for an ETag.
+                headers: dict = {}
 
                 def raise_for_status(self):
                     return None