code-coordinator 0.5.334__tar.gz → 0.5.336__tar.gz

{code_coordinator-0.5.334 → code_coordinator-0.5.336}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.334",
+  "tag": "0.5.336",
   "distance": 0,
-  "node": "ga8ed02fdc4995b6f8f25c6915f46e94404a5ef85",
+  "node": "g40054efb9557131858aa5684627e8e9e93b9f6ff",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-01"

{code_coordinator-0.5.334 → code_coordinator-0.5.336}/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.334 → code_coordinator-0.5.336}/coord/dashboard/server.py

@@ -631,6 +631,78 @@ def openapi_spec() -> dict:
                 "responses": {"200": {"description": "OK"}},
             }
         },
+        "/api/machines/health": {
+            "get": {
+                "summary": (
+                    "Fleet-wide health snapshot (#3024): per-machine severity/"
+                    "stale/checked_at/results plus fleet-scope checks, verbatim "
+                    "off coord.health.fleet_snapshot.FleetHealthSnapshot"
+                ),
+                "responses": {
+                    "200": {
+                        "description": (
+                            "OK -- {schema, refreshed_at, machine_health: [...], "
+                            "fleet_checks: [...], truncated}, unchanged"
+                        ),
+                    },
+                    "503": {
+                        "description": (
+                            "The daemon is unreachable -- an explicit "
+                            "{error, reachable: false} body, never a stale-looking 200"
+                        ),
+                    },
+                },
+            }
+        },
+        "/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",
@@ -1190,6 +1262,72 @@ def build_app(
         rows = machine_health_rows(machine_names, raw, now=time.time())
         return board, {row["machine"]: row for row in rows}
 
+    _EMPTY_FLEET_HEALTH_BLOCK = {
+        "schema": 1,
+        "refreshed_at": None,
+        "machine_health": [],
+        "fleet_checks": [],
+        "truncated": False,
+    }
+
+    def _read_fleet_health() -> dict:
+        """The full ``FleetHealthSnapshot``-shaped block backing ``GET
+        /api/machines/health`` (#3024).
+
+        Deliberately a SEPARATE read from ``_read_board_and_machine_health()``
+        rather than folding this into it: that helper's ``health_by_name``
+        already carries every field this returns per machine (``severity``,
+        ``stale``, ``checked_at``, ``results``) — see
+        ``coord.health.fleet_snapshot.machine_health_rows`` — but ``GET
+        /api/machines`` deliberately narrows to the small reachability
+        subset the fleet panel renders on every poll, the same way ``GET
+        /api/machines/metrics`` was split out from ``GET /api/machines``
+        (#3021/#3022) instead of inflating it: the per-check ``results``
+        arrays (headroom strings, values, detail) are exactly the
+        bytes-heavy, low-poll-frequency payload that split precedent argues
+        for keeping out of the panel's steady-state response.
+
+        Returns the block **verbatim** — never re-derives, re-ranks, or
+        collapses a severity here. Per #1630/#3023's honesty contract,
+        ``_effective_severity`` (upstream, in ``coord.health.fleet_snapshot``)
+        has already made the one call that matters: ``unknown``, never a
+        carried-forward ``ok``, whenever the daemon can't currently vouch for
+        a machine, while still keeping that machine's last-known
+        ``results``/``checked_at`` so a renderer can distinguish "OK" from
+        "last measured OK, a while ago".
+
+        Thin client (``board_service`` configured): the daemon's own
+        ``fleet_health`` sibling key off ``GET /board`` —
+        ``FleetHealthSnapshot.to_dict()`` (``schema``/``refreshed_at``/
+        ``machine_health``/``fleet_checks``/``truncated``) — forwarded
+        unexamined. Raises on an unreachable daemon; callers degrade
+        explicitly (mirrors ``api_machine_metrics``, #3022).
+
+        Co-located (no ``board_service``): ``fleet_checks`` is always ``[]``
+        here — those probes (board latency, phantom-running rows, deploy-lane
+        skew, …) only exist inside a live ``coord serve`` process's in-memory
+        ``FleetHealthRefresher``; a separate dashboard process has no way to
+        reach into that process's memory, same restriction
+        ``coord.health.aggregate.local_fleet_health_block`` documents for
+        ``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.
+        """
+        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)
+
+        from coord.health.aggregate import local_fleet_health_block  # noqa: PLC0415
+
+        machine_names = [m.name for m in config.machines]
+        block = local_fleet_health_block(machine_names)
+        return {**_EMPTY_FLEET_HEALTH_BLOCK, **block}
+
     def _active_assignments_by_machine(board) -> dict[str, list[dict]]:  # noqa: ANN001
         """Group *board*'s RUNNING active assignments by machine (#3023).
 
@@ -1495,6 +1633,163 @@ def build_app(
             result.append(machine_data)
         return JSONResponse(result)
 
+    async def api_machines_health(request: Request) -> JSONResponse:
+        """GET /api/machines/health — the fleet-wide health snapshot (#3024).
+
+        The richest per-machine data the coordinator has, already computed
+        and already refreshed by the daemon's health-poll tick
+        (``coord.health.fleet_snapshot.FleetHealthRefresher``, #1630) and
+        already served on the board daemon's own ``/board`` for coord-tui —
+        this is what makes it reachable from ``coord web`` too, which
+        previously had no view of it at all.
+
+        Kept as its own endpoint rather than folded into ``GET
+        /api/machines``: see ``_read_fleet_health()``'s docstring for why —
+        in short, the same split ``GET /api/machines/metrics`` already made
+        from ``GET /api/machines`` (#3021/#3022), because the per-check
+        ``results`` this carries (headroom strings, values, detail, one row
+        per check per machine) are meaningfully heavier than the small
+        reachability summary the fleet panel polls on every tick.
+
+        Body shape mirrors ``/board``'s own ``fleet_health`` key exactly
+        (``coord.health.fleet_snapshot.FleetHealthSnapshot.to_dict()``):
+        ``{schema, refreshed_at, machine_health: [...], fleet_checks: [...],
+        truncated}``. Every ``machine_health`` row carries ``severity``,
+        ``stale``, ``checked_at`` and ``results`` verbatim from
+        ``_effective_severity``/``machine_health_rows`` — never re-derived,
+        re-ranked, or collapsed at this layer (#1630's honesty contract: a
+        stale/offline/never-polled machine reads ``unknown``, never a
+        carried-forward ``ok``, while its last-known ``results``/
+        ``checked_at`` are retained so a renderer can still tell "OK" apart
+        from "last measured OK, a while ago").
+
+        Degrades honestly on an unreachable daemon (thin-client mode only —
+        same failure mode ``api_machine_metrics`` already guards against,
+        #3022): an explicit ``{error, reachable: false}`` 503, never a 200
+        with an empty/last-known block a renderer could mistake for "fleet
+        quiet, all healthy".
+
+        Fixture mode has no live health poll to simulate, so it serves
+        whatever ``fleet_health`` block (if any) was captured alongside the
+        seeded ``/board`` payload — the same "golden /board capture drops in
+        unchanged" posture ``FixtureServer.board()`` and friends already
+        have — falling back to the same all-empty shape a fresh install with
+        no health data yet would report, rather than fabricating severities.
+        """
+        if _fixture is not None:
+            block = _fixture.board_payload.get("fleet_health")
+            return JSONResponse(block if block else dict(_EMPTY_FLEET_HEALTH_BLOCK))
+
+        try:
+            block = _read_fleet_health()
+        except Exception as e:  # noqa: BLE001 — network failure/timeout/daemon 5xx: all "unreachable"
+            return JSONResponse(
+                {
+                    "error": "fleet health daemon unreachable",
+                    "detail": str(e),
+                    "reachable": False,
+                },
+                status_code=503,
+            )
+        return JSONResponse(block)
+
+    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).
@@ -2961,6 +3256,8 @@ def build_app(
         Route("/", index, methods=["GET"]),
         Route("/api/board", api_board, methods=["GET"]),
         Route("/api/machines", api_machines, methods=["GET"]),
+        Route("/api/machines/health", api_machines_health, 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"]),