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

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

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

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

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

@@ -631,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",
@@ -1495,6 +1544,103 @@ def build_app(
             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).
@@ -2961,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.334 → code_coordinator-0.5.335}/tests/test_dashboard_api.py

@@ -769,3 +769,192 @@ class TestMachinesAPI:
         assert m["assignments"]["active"][0]["spec"]["issue_number"] == 7
         assert m["assignments"]["active"][0]["spec"]["issue_title"] == "Add logging"
         assert "progress" not in m["assignments"]["active"][0]
+
+
+class TestMachineMetricsAPI:
+    """``GET /api/machines/metrics`` — the dashboard's proxy of #3021's daemon
+    endpoint (#3022). ``coord web``'s own origin is what the browser (and
+    the phone webapp's Machines panel) actually talks to; this handler
+    resolves where the REAL data lives and forwards there.
+
+    The autouse fixture in ``tests/conftest.py`` (``COORD_SERVICE_URL``/
+    ``COORD_TOKEN`` deleted, ``CLIENT_TOML`` pointed at a nonexistent path)
+    means ``coord.client.resolve_board_service()`` returns ``None`` by
+    default in every test here unless a test monkeypatches it itself — i.e.
+    the *daemon-local* (loopback) branch is what an unmodified test hits.
+    """
+
+    _PAYLOAD = {
+        "schema": 1,
+        "generated_at": 1234.5,
+        "since": None,
+        "resolution": None,
+        "machines": {"laptop": [{"timestamp": 1234.5, "cpu_percent": 12.0}]},
+    }
+
+    @staticmethod
+    def _fake_get(payload, calls, *, status_code=200):
+        def fake_get(url, **kw):
+            calls.append((url, kw.get("params"), kw.get("headers")))
+
+            class _Resp:
+                def __init__(self):
+                    self.status_code = status_code
+
+                def raise_for_status(self):
+                    if self.status_code >= 400:
+                        import httpx
+
+                        raise httpx.HTTPStatusError(
+                            "boom", request=None, response=self
+                        )
+
+                def json(self):
+                    return payload
+
+            return _Resp()
+
+        return fake_get
+
+    def test_daemon_remote_resolution_proxies_to_the_configured_board_service(
+        self, monkeypatch
+    ) -> None:
+        """``board_service`` configured (thin-client dashboard) -> the request
+        goes to THAT daemon's URL over Tailscale, not a local loopback."""
+        import coord.client as cc
+
+        monkeypatch.setattr(
+            cc, "resolve_board_service",
+            lambda *a, **k: cc.ServiceConfig("http://daemon:7435"),
+        )
+        calls = []
+        monkeypatch.setattr(cc.httpx, "get", self._fake_get(self._PAYLOAD, calls))
+
+        client = _client()
+        r = client.get("/api/machines/metrics")
+
+        assert r.status_code == 200
+        assert r.json() == self._PAYLOAD
+        assert len(calls) == 1
+        url, params, _headers = calls[0]
+        assert url == "http://daemon:7435/machines/metrics"
+
+    def test_daemon_local_resolution_hits_the_loopback_daemon_not_itself(
+        self, monkeypatch
+    ) -> None:
+        """No ``board_service`` configured (dashboard co-located with the
+        daemon host) -> a loopback call to the daemon's OWN port
+        (``coord.serve_app.SERVE_PORT``, #3020/#3021's home), carrying its
+        bearer-token convention -- never a recursive call back into this
+        same dashboard process's own port."""
+        import coord.client as cc
+        from coord.serve_app import SERVE_PORT
+
+        monkeypatch.setattr(
+            "coord.serve_app.resolve_serve_token", lambda *a, **k: "secret-tok"
+        )
+        calls = []
+        monkeypatch.setattr(cc.httpx, "get", self._fake_get(self._PAYLOAD, calls))
+
+        client = _client()
+        r = client.get("/api/machines/metrics")
+
+        assert r.status_code == 200
+        assert r.json() == self._PAYLOAD
+        assert len(calls) == 1
+        url, params, headers = calls[0]
+        assert url == f"http://127.0.0.1:{SERVE_PORT}/machines/metrics"
+        assert headers["Authorization"] == "Bearer secret-tok"
+
+    def test_since_resolution_machine_query_params_are_forwarded_verbatim(
+        self, monkeypatch
+    ) -> None:
+        import coord.client as cc
+
+        calls = []
+        monkeypatch.setattr(cc.httpx, "get", self._fake_get(self._PAYLOAD, calls))
+
+        client = _client()
+        r = client.get(
+            "/api/machines/metrics",
+            params={"since": "6h", "resolution": "50", "machine": "laptop"},
+        )
+
+        assert r.status_code == 200
+        assert len(calls) == 1
+        _url, params, _headers = calls[0]
+        assert params == {"since": "6h", "resolution": "50", "machine": "laptop"}
+
+    def test_unreachable_daemon_degrades_to_an_explicit_error_not_an_empty_series(
+        self, monkeypatch
+    ) -> None:
+        """A daemon that can't be reached must come back as an explicit
+        error the UI can render as "no data" -- NEVER a 200 with an empty
+        (or missing) ``machines`` series, which would read as "fleet quiet,
+        all healthy" rather than "we don't know"."""
+        import httpx
+
+        import coord.client as cc
+
+        def raising_get(url, **kw):
+            raise httpx.ConnectError("connection refused")
+
+        monkeypatch.setattr(cc.httpx, "get", raising_get)
+
+        client = _client()
+        r = client.get("/api/machines/metrics")
+
+        assert r.status_code == 503
+        body = r.json()
+        assert body["reachable"] is False
+        assert "error" in body
+        assert "machines" not in body
+
+    def test_daemon_5xx_also_degrades_rather_than_forwarding_a_500(
+        self, monkeypatch
+    ) -> None:
+        import coord.client as cc
+
+        calls = []
+        monkeypatch.setattr(
+            cc.httpx, "get", self._fake_get({}, calls, status_code=500)
+        )
+
+        client = _client()
+        r = client.get("/api/machines/metrics")
+
+        assert r.status_code == 503
+        assert r.json()["reachable"] is False
+
+    def test_daemon_400_is_forwarded_as_a_caller_error_not_folded_into_unreachable(
+        self, monkeypatch
+    ) -> None:
+        """A malformed ``since``/``resolution`` is the CALLER's bad input --
+        the daemon said so via a 400 -- and must stay a 400, distinct from
+        "the daemon didn't answer" (503)."""
+        import coord.client as cc
+
+        calls = []
+        monkeypatch.setattr(
+            cc.httpx,
+            "get",
+            self._fake_get({"error": "bad since='not-a-time'"}, calls, status_code=400),
+        )
+
+        client = _client()
+        r = client.get("/api/machines/metrics", params={"since": "not-a-time"})
+
+        assert r.status_code == 400
+        assert "reachable" not in r.json()
+
+    def test_fixture_mode_reports_unreachable_rather_than_faking_a_series(self) -> None:
+        """``coord web --fixture`` has no live sampler to simulate -- it must
+        say so honestly rather than returning a canned "healthy" series."""
+        from coord.dashboard.fixture import FixtureServer
+
+        client = TestClient(build_app(_config(), fixture=FixtureServer()))
+
+        r = client.get("/api/machines/metrics")
+
+        assert r.status_code == 503
+        assert r.json()["reachable"] is False