code-coordinator 0.5.333__tar.gz → 0.5.335__tar.gz

{code_coordinator-0.5.333 → code_coordinator-0.5.335}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.333
+Version: 0.5.335
 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.333 → code_coordinator-0.5.335}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.333
+Version: 0.5.335
 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.333 → code_coordinator-0.5.335}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.333",
+  "tag": "0.5.335",
   "distance": 0,
-  "node": "g05e864bdfa3476802900ee1d85295822957907e0",
+  "node": "gb914d712a7d0e11d9f9a30e4f62b05cf9b5e8c5c",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-01"

{code_coordinator-0.5.333 → code_coordinator-0.5.335}/coord/client.py

@@ -1085,3 +1085,39 @@ def fetch_report(
         raise ValueError(detail or f"report request rejected ({resp.status_code})")
     resp.raise_for_status()
     return resp.json()
+
+
+def fetch_machine_metrics(
+    svc: ServiceConfig,
+    params: dict[str, Any] | None = None,
+    *,
+    timeout: float = _DEFAULT_TIMEOUT,
+) -> dict:
+    """GET /machines/metrics from the daemon (#3021's read endpoint).
+
+    *params* (``since``/``resolution``/``machine``) forward straight through —
+    :func:`coord.machine_metrics.resolve_since`/``build_metrics_response`` on the daemon side
+    already own their validation vocabulary; this function does no interpretation of its own.
+
+    Mirrors :func:`fetch_report`'s error posture: a 400 (malformed ``since``/``resolution``) is
+    a caller error, surfaced as :class:`ValueError` with the daemon's own message rather than a
+    generic HTTP status. Everything else (network failure, timeout, 5xx) is left to raise
+    ``httpx.HTTPError`` — the dashboard's ``GET /api/machines/metrics`` handler (#3022) turns
+    that into an explicit "metrics unreachable" response rather than an empty-but-200 series.
+    """
+    resp = httpx.get(
+        f"{svc.url}/machines/metrics",
+        params={k: v for k, v in (params or {}).items() if v not in (None, "")},
+        headers=_headers(svc),
+        timeout=timeout,
+    )
+    if resp.status_code == 400:
+        detail = ""
+        try:
+            body = resp.json()
+            detail = body.get("error") or ""
+        except Exception:  # noqa: BLE001 — non-JSON error body; fall through
+            detail = resp.text.strip()
+        raise ValueError(detail or f"machine metrics request rejected ({resp.status_code})")
+    resp.raise_for_status()
+    return resp.json()

{code_coordinator-0.5.333 → code_coordinator-0.5.335}/coord/dashboard/index.html

@@ -521,12 +521,12 @@ async function loadMachines() {
       const a = m.assignments.active[0];
       const spec = a.spec || {};
       detail = `<div class="meta">${badge('busy', 'busy')} #${spec.issue_number}: ${E(spec.issue_title || '')}</div>`;
-      if (a.progress && a.progress.updates && a.progress.updates.length) {
-        detail += `<div class="meta">latest: ${E(a.progress.updates[a.progress.updates.length-1])}</div>`;
-      }
-      if (a.progress && a.progress.stuck) {
-        detail += `<div class="meta" style="color:#da3633">STUCK: ${E(a.progress.stuck)}</div>`;
-      }
+      // #3023: GET /api/machines no longer carries `a.progress` (live
+      // STATUS:/STUCK: tail of the owning machine's own log file) — that
+      // data only ever existed via a fresh per-agent probe, and serving it
+      // here would reintroduce the exact per-request fleet fan-out this
+      // endpoint was reworked to remove. Use `coord status` / `coord log
+      // <id> -f` for live per-worker progress instead.
     }
     return `
       <div class="card">

{code_coordinator-0.5.333 → code_coordinator-0.5.335}/coord/dashboard/server.py

@@ -51,7 +51,6 @@ from coord.drive_queue import (
     summarize_drive_queue,
 )
 from coord.models import Assignment
-from coord.network import check_all, fetch_status
 from coord.openapi import build_spec, dataclass_schema, openapi_and_docs_routes
 from coord.pipeline import PipelineView
 from coord.state import list_drive_queue, load_proposals
@@ -632,6 +631,55 @@ def openapi_spec() -> dict:
                 "responses": {"200": {"description": "OK"}},
             }
         },
+        "/api/machines/metrics": {
+            "get": {
+                "summary": (
+                    "Proxy of the daemon's GET /machines/metrics (#3021) -- per-machine "
+                    "CPU/mem sample series for the Machines panel (#3022)"
+                ),
+                "parameters": [
+                    {
+                        "name": "since",
+                        "in": "query",
+                        "required": False,
+                        "schema": {"type": "string"},
+                        "description": (
+                            "Epoch number, ISO-8601 timestamp, or duration (e.g. '6h') -- "
+                            "forwarded to the daemon unexamined; see "
+                            "coord.machine_metrics.resolve_since."
+                        ),
+                    },
+                    {
+                        "name": "resolution",
+                        "in": "query",
+                        "required": False,
+                        "schema": {"type": "integer"},
+                        "description": "Max points per machine after server-side downsampling.",
+                    },
+                    {
+                        "name": "machine",
+                        "in": "query",
+                        "required": False,
+                        "schema": {"type": "string"},
+                        "description": "Restrict to one machine's series.",
+                    },
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK -- daemon's versioned metrics payload, verbatim",
+                    },
+                    "400": {
+                        "description": "The daemon rejected since/resolution as malformed",
+                    },
+                    "503": {
+                        "description": (
+                            "The daemon is unreachable -- an explicit "
+                            "{error, reachable: false} body, never an empty series"
+                        ),
+                    },
+                },
+            }
+        },
         "/api/proposals": {
             "get": {
                 "summary": "Pending brain proposals awaiting approve/reject",
@@ -1142,6 +1190,94 @@ def build_app(
             return
         write_board(board)
 
+    def _read_board_and_machine_health() -> tuple:  # -> tuple[Board, dict[str, dict]]
+        """The board plus every configured machine's latest daemon-tick-
+        refreshed health row, keyed by machine name (#3023).
+
+        Backs ``GET /api/machines``. Fetches both in ONE daemon round trip
+        when this dashboard is a thin client (``board_service`` configured)
+        instead of two independent ``GET /board`` calls — the review found
+        that ``_read_machine_health()`` fetching its own payload and then
+        ``_active_assignments_by_machine(_read_board())`` fetching a SECOND
+        one doubled this endpoint's daemon I/O per client poll, which is
+        exactly the per-request amplification #3023 exists to eliminate
+        (just at a smaller scale than the fan-out it replaced). A thin
+        client reads the daemon-published payload's
+        ``fleet_health.machine_health`` sibling key — the tick-refreshed
+        output of ``coord.health.fleet_snapshot.FleetHealthRefresher``
+        (#1630) a board poll already carries — never a fresh per-request
+        probe of the fleet. A dashboard co-located with the daemon (no
+        ``board_service``) has no network cost to share in the first place:
+        it reads the board from the local DB and the health rows straight
+        out of the same local DB via ``coord.state.load_machine_health`` +
+        ``coord.health.fleet_snapshot.machine_health_rows`` (the public
+        wrapper ``FleetHealthRefresher.refresh()`` itself calls right after
+        persisting) — so the two modes can't drift.
+
+        A machine absent from the health dict was never polled (fresh
+        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).
+        """
+        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 []
+            return board, {row["machine"]: row for row in rows}
+
+        from coord.health.fleet_snapshot import machine_health_rows  # noqa: PLC0415
+        from coord.state import load_machine_health  # noqa: PLC0415
+
+        board = _read_board()
+        raw = load_machine_health()
+        machine_names = [m.name for m in config.machines]
+        rows = machine_health_rows(machine_names, raw, now=time.time())
+        return board, {row["machine"]: row for row in rows}
+
+    def _active_assignments_by_machine(board) -> dict[str, list[dict]]:  # noqa: ANN001
+        """Group *board*'s RUNNING active assignments by machine (#3023).
+
+        Backs the legacy dashboard's per-machine "busy" card
+        (``coord/dashboard/index.html``'s ``loadMachines()``), which used
+        to come from a live per-agent ``GET /status`` probe. The board
+        already carries the same fact — which issue a machine is currently
+        running — from the normal board read path, so grouping it here
+        costs no extra daemon I/O beyond what ``_read_board_and_machine_health()``
+        already fetches.
+
+        Filters to ``status == "running"`` exactly like
+        ``Board.idle_machines()`` and ``Board.active_files_by_repo()`` in
+        ``coord/models.py`` do before treating an active-list entry as real,
+        in-progress work — an unfiltered read of ``board.active`` would be a
+        second, independent answer to "is this machine busy" that could
+        diverge from those two (epic #2096 "one question, one answer").
+        Every ``board.active.append()`` call site happens to set
+        ``status="running"`` at append time today, and reconcile removes
+        non-running entries the same tick it retags them, so this filter is
+        currently a no-op in practice — which is exactly why the existing
+        code defends against it twice already rather than trusting that
+        invariant to hold forever.
+        """
+        out: dict[str, list[dict]] = {}
+        for a in board.active:
+            if a.status != "running":
+                continue
+            out.setdefault(a.machine_name, []).append({
+                "assignment_id": a.assignment_id,
+                "status": a.status,
+                "spec": {
+                    "issue_number": a.issue_number,
+                    "issue_title": a.issue_title,
+                    "repo_name": a.repo_name,
+                },
+            })
+        return out
+
     def _read_drive_queue() -> list[dict]:
         """Every drive-queue row — seeded fixture or the daemon/local DB (#2428).
 
@@ -1350,30 +1486,161 @@ def build_app(
         })
 
     async def api_machines(request: Request) -> JSONResponse:
+        """GET /api/machines — the fleet panel, from daemon-refreshed state (#3023).
+
+        Used to do a synchronous fan-out probe on every request: ``GET
+        /health`` against every configured machine, then ``GET /status``
+        against every one that answered — seconds of worst-case latency,
+        multiplied by every connected client polling this panel live. Now
+        serves the SAME state the board daemon's tick loop already
+        refreshes on its own cadence, plus the board this dashboard reads
+        for every other panel anyway, both from ONE combined read
+        (``_read_board_and_machine_health()``) — zero per-request network
+        fan-out to the fleet, whether this dashboard is co-located with the
+        daemon or a thin client of it.
+
+        Design decision (#3023 review): each active assignment's ``spec``
+        (issue/repo) is included, but the live ``STATUS:``/``STUCK:``
+        per-worker progress tail (``a.progress.updates`` / ``a.progress.stuck``
+        in the pre-#3023 shape) is NOT. That data only ever existed as a
+        fresh tail-read of the OWNING machine's own log file — see
+        ``AgentServer.progress()``/``list_assignments()`` in ``coord/agent.py``
+        ("only this machine can see its own log file — the coordinator
+        cannot stat a remote path") — so serving it here would mean putting
+        the exact per-request fan-out probe this endpoint exists to remove
+        right back in, just hidden one level down. ``coord/dashboard/index.html``
+        no longer reads those two keys; live per-worker progress is still
+        available via ``coord status`` / ``coord log <id> -f``, which DO pay
+        for a targeted probe of the one machine in question rather than
+        every machine on every dashboard poll.
+        """
         if _fixture is not None:
             # Seeded reachability — never probe the fleet in fixture mode.
             return JSONResponse(_fixture.machines())
-        statuses = check_all(config.machines, timeout=3.0)
+        board, health_by_name = _read_board_and_machine_health()
+        assignments_by_machine = _active_assignments_by_machine(board)
         result = []
-        for s in statuses:
+        for m in config.machines:
+            row = health_by_name.get(m.name) or {}
             machine_data = {
-                "name": s.machine.name,
-                "host": s.machine.host,
-                "repos": s.machine.repos,
-                "state": s.state,
-                "reason": s.reason,
-                "latency_ms": s.latency_ms,
+                "name": m.name,
+                "host": m.host,
+                "repos": m.repos,
+                "state": row.get("state", "unknown"),
+                "reason": row.get("reason", ""),
+                "latency_ms": row.get("latency_ms"),
+                # #3023: agent's own running version — compared against
+                # this coordinator's local version by consumers (coord-tui's
+                # `machine_detail_list` shows it red on a mismatch) — and
+                # total on-disk size of this agent's git worktrees. Both
+                # ride the same tick-refreshed health blob as everything
+                # else here; see `coord.health.fleet_snapshot.refresh`.
+                "agent_version": row.get("agent_runtime_version"),
+                "worktree_bytes": row.get("worktree_bytes"),
             }
-            if s.is_online:
-                status_result = fetch_status(s.machine, timeout=3.0)
-                if status_result.ok:
-                    machine_data["assignments"] = status_result.data
-                else:
-                    machine_data["assignments"] = None
-                    machine_data["status_error"] = status_result.error
+            active = assignments_by_machine.get(m.name)
+            if active:
+                machine_data["assignments"] = {"active": active}
             result.append(machine_data)
         return JSONResponse(result)
 
+    def _machine_metrics_daemon_target():  # -> coord.client.ServiceConfig
+        """Where ``GET /api/machines/metrics`` actually reaches for data (#3022).
+
+        Resolves daemon-vs-local exactly like ``_read_board()``/
+        ``_read_drive_queue()``: ``board_service.resolve()`` first, so a
+        thin-client dashboard reaches the fleet's real daemon over Tailscale.
+
+        Unlike the board or the drive queue, though, there is no on-disk
+        local fallback here. The metrics ring buffer
+        (``coord.machine_metrics.MachineMetricsSampler``, #3020) lives ONLY
+        in the ``coord serve`` process's memory, by design (see that
+        module's "No persistence" note) — the identical "introspection of a
+        running interpreter" situation
+        ``coord.release_verify._default_board_fetch`` already solved for
+        reading the daemon's own version off the daemon host. So "local"
+        here still costs one HTTP hop, just a loopback one to THIS host's
+        own daemon (``127.0.0.1:SERVE_PORT``, same
+        ``resolve_serve_token()`` bearer-token convention) rather than a
+        Tailscale round trip to a configured ``board_service`` URL — never
+        a recursive call back into this same dashboard process.
+        """
+        from coord import board_service  # noqa: PLC0415
+        from coord.client import ServiceConfig  # noqa: PLC0415
+
+        svc = board_service.resolve()
+        if svc is not None:
+            return svc
+        from coord.serve_app import SERVE_PORT, resolve_serve_token  # noqa: PLC0415
+
+        return ServiceConfig(
+            url=f"http://127.0.0.1:{SERVE_PORT}", token=resolve_serve_token()
+        )
+
+    async def api_machine_metrics(request: Request) -> JSONResponse:
+        """GET /api/machines/metrics — proxy the daemon's GET /machines/metrics
+        (#3021) so the Machines panel's own origin (``coord web``, port 7434)
+        can chart it without the browser needing to reach the daemon's
+        separate port 7435 directly (#3022).
+
+        Forwards ``since``/``resolution``/``machine`` straight through,
+        unexamined — the daemon
+        (``coord.machine_metrics.resolve_since``/``build_metrics_response``)
+        already owns their validation vocabulary and this handler must not
+        duplicate or drift from it. See ``_machine_metrics_daemon_target()``
+        for how daemon-vs-local is resolved.
+
+        Fixture mode has no live sampler to simulate at all, so it always
+        reports the same explicit-unreachable shape a real unreachable
+        daemon would (below) rather than pretending to have live data —
+        mirrors ``api_machines``' "never probe the fleet in fixture mode",
+        just with nothing to seed instead of a canned reachable answer.
+
+        Degrades honestly (#3022): a daemon that is unreachable (down,
+        network partition, wrong token) comes back as an explicit
+        ``{"error": ..., "reachable": false}`` body with a 503 — never a 200
+        with an empty/short series a renderer could mistake for "fleet
+        quiet, all healthy". That is the same failure mode
+        ``coord.machine_metrics`` already guards against for a single
+        unresponsive agent (its ``status="unknown"`` samples), just
+        extended here to "the whole daemon didn't answer". A 400 the daemon
+        itself raised for a malformed ``since``/``resolution`` is forwarded
+        as a 400, not folded into the unreachable state — that's the
+        caller's bad input, not a daemon health problem.
+        """
+        if _fixture is not None:
+            return JSONResponse(
+                {
+                    "error": "machine metrics have no fixture source",
+                    "reachable": False,
+                },
+                status_code=503,
+            )
+
+        from coord.client import fetch_machine_metrics  # noqa: PLC0415
+
+        svc = _machine_metrics_daemon_target()
+        qp = request.query_params
+        params = {
+            "since": qp.get("since"),
+            "resolution": qp.get("resolution"),
+            "machine": qp.get("machine"),
+        }
+        try:
+            result = fetch_machine_metrics(svc, params)
+        except ValueError as e:
+            return JSONResponse({"error": str(e)}, status_code=400)
+        except Exception as e:  # noqa: BLE001 — network failure/timeout/daemon 5xx: all "unreachable"
+            return JSONResponse(
+                {
+                    "error": "machine metrics daemon unreachable",
+                    "detail": str(e),
+                    "reachable": False,
+                },
+                status_code=503,
+            )
+        return JSONResponse(result)
+
     async def api_sessions(request: Request) -> JSONResponse:
         """GET /api/sessions — live coord-* interactive sessions the phone can
         attach to via GET /ws/terminal/{session_id} (#1066).
@@ -2840,6 +3107,7 @@ def build_app(
         Route("/", index, methods=["GET"]),
         Route("/api/board", api_board, methods=["GET"]),
         Route("/api/machines", api_machines, methods=["GET"]),
+        Route("/api/machines/metrics", api_machine_metrics, methods=["GET"]),
         Route("/api/sessions", api_sessions, methods=["GET"]),
         Route("/api/proposals", api_proposals, methods=["GET"]),
         Route("/api/drive-queue", api_drive_queue, methods=["GET"]),

{code_coordinator-0.5.333 → code_coordinator-0.5.335}/coord/health/fleet_snapshot.py

@@ -209,6 +209,19 @@ def _effective_severity(entry: dict, *, now: float) -> tuple[str, bool]:
     return (severity or "unknown"), stale
 
 
+def machine_health_rows(machine_names: list[str], raw: dict, *, now: float) -> list[dict]:
+    """Public wrapper around :func:`_machine_health_rows` (#3023).
+
+    ``coord.dashboard.server`` reads this from outside the module (the
+    local-mode half of ``GET /api/machines``, mirroring the thin-client half
+    that reads the daemon-published ``fleet_health.machine_health`` block
+    ``FleetHealthRefresher.refresh()`` builds from this same function) —
+    exposed as a real entry point instead of reaching across the module
+    boundary for the underscore-prefixed helper below.
+    """
+    return _machine_health_rows(machine_names, raw, now=now)
+
+
 def _machine_health_rows(machine_names: list[str], raw: dict, *, now: float) -> list[dict]:
     rows: list[dict] = []
     for name in machine_names:
@@ -234,6 +247,11 @@ def _machine_health_rows(machine_names: list[str], raw: dict, *, now: float) ->
                 "severity": severity,
                 "checked_at": checks.get("checked_at"),
                 "results": checks.get("results", []),
+                # #3023: sibling facts `refresh()` stashes on the same
+                # persisted `health` blob — see its docstring comment for
+                # why they live here instead of inside `results`.
+                "worktree_bytes": checks.get("worktree_bytes"),
+                "agent_runtime_version": checks.get("agent_runtime_version"),
             }
         )
     return rows
@@ -310,6 +328,36 @@ class FleetHealthRefresher:
             health_block = (
                 status.health.get("health") if status.health else None
             ) or last_known_health
+            # #3023: the coord-web Machines panel (GET /api/machines) needs
+            # two more whole-payload facts that live OUTSIDE the H-1
+            # check-registry block above — the agent's own running
+            # `version` (compared against the coordinator's local version to
+            # flag skew) and `worktree_bytes` (total on-disk size of this
+            # agent's git worktrees). Both are real facts about the agent
+            # PROCESS, not a health check result, so they ride as sibling
+            # keys on the same persisted `health` blob rather than a schema
+            # change — advisory only, same as everything else in this
+            # module (see the module docstring). Freshly measured whenever
+            # this poll actually reached the agent; carried forward from the
+            # last successful poll otherwise, same "last-known, not
+            # blanked" posture as the H-1 `results` above, so a machine
+            # that's merely offline for one tick doesn't flash to "no data"
+            # in the panel. Named `agent_runtime_version` (not
+            # `agent_version`) to avoid colliding with the unrelated
+            # `agent_version` H-1 *check* already inside `results`, which
+            # measures installed-vs-latest-on-PyPI skew, not this.
+            if status.health is not None:
+                worktree_bytes = status.health.get("worktree_bytes")
+                agent_runtime_version = status.health.get("version")
+            else:
+                worktree_bytes = (last_known_health or {}).get("worktree_bytes")
+                agent_runtime_version = (last_known_health or {}).get("agent_runtime_version")
+            if health_block is not None:
+                health_block = {
+                    **health_block,
+                    "worktree_bytes": worktree_bytes,
+                    "agent_runtime_version": agent_runtime_version,
+                }
             state.save_machine_health(
                 machine.name,
                 state=status.state,

{code_coordinator-0.5.333 → code_coordinator-0.5.335}/tests/test_dashboard.py

@@ -125,23 +125,30 @@ class TestBoardAPI:
 
 
 class TestMachinesAPI:
-    @patch("coord.dashboard.server.fetch_status")
-    @patch("coord.dashboard.server.check_all")
-    def test_returns_machine_list(
-        self, mock_check: MagicMock, mock_fetch: MagicMock,
-    ) -> None:
-        mock_status = MagicMock()
-        mock_status.machine = Machine(name="laptop", host="laptop.tailnet", repos=["api"])
-        mock_status.state = "online"
-        mock_status.reason = ""
-        mock_status.latency_ms = 5.0
-        mock_status.is_online = True
-        mock_check.return_value = [mock_status]
-        from coord.network import StatusResult
-        mock_fetch.return_value = StatusResult(data={"active": [], "completed": []})
-
-        client = _client()
-        r = client.get("/api/machines")
+    """#3023: served from the daemon's already-refreshed health snapshot,
+    never a per-request fan-out probe of the fleet — see
+    ``tests/test_dashboard_api.py::TestMachinesAPI`` for the fuller
+    shape/no-probe/legacy-consumer coverage this issue asks for. This class
+    keeps the smoke-level "does the route wire up" check colocated with the
+    rest of this file's board/sessions API tests.
+    """
+
+    def test_returns_machine_list(self) -> None:
+        health = {
+            "laptop": {
+                "state": "online",
+                "reason": "",
+                "latency_ms": 5.0,
+                "received_at": time.time(),
+                "health": {"schema": 1, "checked_at": time.time(), "results": []},
+            },
+        }
+        client = _client()
+        with (
+            patch("coord.state.load_machine_health", return_value=health),
+            patch("coord.dashboard.server.read_board", return_value=Board()),
+        ):
+            r = client.get("/api/machines")
         assert r.status_code == 200
         data = r.json()
         assert len(data) == 1