code-coordinator 0.5.337__tar.gz → 0.5.339__tar.gz

{code_coordinator-0.5.337 → code_coordinator-0.5.339}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.337",
+  "tag": "0.5.339",
   "distance": 0,
-  "node": "gd62241bfb0c96bba0b64ac55588d7a44b20a4ed6",
+  "node": "g9385deb1f400cff71b39039be094c1078708bd9c",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-01"

{code_coordinator-0.5.337 → code_coordinator-0.5.339}/coord/dashboard/fixture.py

@@ -29,11 +29,19 @@ Fixture schema (every key optional except ``board``)::
         "round_number": 7,
         "assignments": [ {...assignment row...} ],
         "plans": {},                # assignment_id -> plan object
-        "notifications": []         # [{"assignment_id": ...}]
+        "notifications": [],        # [{"assignment_id": ...}]
+        "fleet_health": {           # GET /api/machines/health's block, verbatim (#3026)
+          "schema": 1, "refreshed_at": 1750000000.0,
+          "machine_health": [ {...coord.health.fleet_snapshot row shape...} ],
+          "fleet_checks": [], "truncated": false
+        }
       },
       "merge_queue":     [ {...coord.merge_queue.QueuedMerge fields...} ],
       "proposals":       [ {...coord.models.Proposal fields...} ],
       "machines":        [ {...GET /api/machines entry...} ],
+      "machine_metrics": {         # GET /api/machines/metrics source series (#3026)
+        "precision": [ {...coord.machine_metrics.MetricsSample.to_dict()...} ]
+      },
       "sessions":        [ {...GET /api/sessions entry...} ],
       "drive_queue":     [ {...coord.state._decode_drive_queue_row shape...} ],
       "report_catalogue": {"reports": [ {...coord.reports.ReportDef.to_dict()...} ]},
@@ -55,7 +63,17 @@ client is subscribed (a late subscriber can still catch up via
 ``board`` may also be spelled at the top level (``assignments`` /
 ``round_number`` as siblings of ``merge_queue``), which is exactly what
 ``scripts/gen_board_fixture.py`` emits — so a golden ``/board`` capture drops
-in unchanged.
+in unchanged. ``fleet_health`` rides along as a sibling of ``assignments`` in
+either spelling, for the identical reason: it is already a sibling key on the
+real daemon's ``/board`` payload (``FleetHealthSnapshot.to_dict()``), so a
+golden capture carries it for free.
+
+``GET /api/machines/stats`` (#3026) needs no dedicated fixture key at all —
+it is derived purely from ``board`` (completed/active assignments) and
+``config.machines`` (for the concurrency ceiling), exactly like the live
+handler, so seeding a realistic spread of completed/failed/running
+assignments per machine in ``board.assignments`` is all a fixture needs to
+exercise it.
 """
 
 from __future__ import annotations
@@ -157,6 +175,9 @@ class FixtureServer:
     merge_queue_raw: list = field(default_factory=list)
     proposals_raw: list = field(default_factory=list)
     machines_raw: list = field(default_factory=list)
+    #: #3026: seeded `GET /api/machines/metrics` source series, keyed by
+    #: machine name — see `machine_metrics_series()`.
+    machine_metrics_raw: dict = field(default_factory=dict)
     sessions_raw: list = field(default_factory=list)
     drive_queue_raw: list = field(default_factory=list)
     #: #2492 RPT-1: `GET /api/report`'s catalogue. `None` (the default) falls
@@ -202,6 +223,20 @@ class FixtureServer:
     def machines(self) -> list[dict]:
         return copy.deepcopy(self.machines_raw)
 
+    def machine_metrics_series(self) -> dict[str, list[dict]]:
+        """Seeded per-machine metrics ring-buffer contents (#3026).
+
+        Same shape ``coord.machine_metrics.MachineMetricsSampler.all_series()``
+        returns live — machine name to an oldest-first list of
+        ``MetricsSample``-shaped dicts — so ``api_machine_metrics`` can run
+        it through the real ``resolve_since``/``build_metrics_response``
+        pipeline unchanged (no parallel fake filtering/downsampling path);
+        only the series *source* differs from the live daemon-proxy path.
+        A machine absent here comes back ``[]``, same as the live sampler's
+        "never polled yet" case.
+        """
+        return copy.deepcopy(self.machine_metrics_raw)
+
     def sessions(self) -> list[dict]:
         return copy.deepcopy(self.sessions_raw)
 
@@ -387,6 +422,17 @@ def parse_fixture(raw: Any, *, path: Path | None = None) -> FixtureServer:
         "plans": _as_dict(board_raw.get("plans"), "board.plans"),
         "notifications": _as_list(board_raw.get("notifications"), "board.notifications"),
     }
+    # #3026: `fleet_health` rides along as a sibling of `assignments` on the
+    # real daemon's `/board` payload (`FleetHealthSnapshot.to_dict()`) — carry
+    # it through verbatim so `api_machines_health`'s fixture branch (which
+    # reads `board_payload.get("fleet_health")`) has something to serve.
+    # Absent entirely (the common case for a fixture that doesn't care about
+    # machine health) leaves the key out, matching `_EMPTY_FLEET_HEALTH_BLOCK`
+    # already being the handler's own fallback.
+    if board_raw.get("fleet_health") is not None:
+        board_payload["fleet_health"] = _as_dict(
+            board_raw.get("fleet_health"), "board.fleet_health"
+        )
 
     now = raw.get("now")
     if now is not None:
@@ -418,11 +464,20 @@ def parse_fixture(raw: Any, *, path: Path | None = None) -> FixtureServer:
             "fixture 'report_results' values must be mappings (ReportResult wire shape)"
         )
 
+    machine_metrics_raw = _as_dict(raw.get("machine_metrics"), "machine_metrics")
+    for name, series in machine_metrics_raw.items():
+        if not isinstance(series, list):
+            raise FixtureError(
+                f"fixture 'machine_metrics[{name!r}]' must be a list, "
+                f"got {type(series).__name__}"
+            )
+
     server = FixtureServer(
         board_payload=board_payload,
         merge_queue_raw=_as_list(raw.get("merge_queue"), "merge_queue"),
         proposals_raw=_as_list(raw.get("proposals"), "proposals"),
         machines_raw=_as_list(raw.get("machines"), "machines"),
+        machine_metrics_raw=machine_metrics_raw,
         sessions_raw=_as_list(raw.get("sessions"), "sessions"),
         drive_queue_raw=_as_list(raw.get("drive_queue"), "drive_queue"),
         report_catalogue_raw=report_catalogue_raw,

{code_coordinator-0.5.337 → code_coordinator-0.5.339}/coord/dashboard/server.py

@@ -607,6 +607,229 @@ def openapi_spec() -> dict:
         },
         "required": ["submission_id", "question_revision", "question"],
     }
+    # #3027: the four `/api/machines*` endpoints (#3021-#3026) went out
+    # carrying a bare `{"200": {"description": "OK"}}` stub — every other
+    # surface here has a real `content` schema, this milestone's own
+    # deliverable is closing that gap. Hand-built (not `dataclass_schema`),
+    # matching the same "mirror the handler's actual dict field-for-field"
+    # convention `report_result_ref`/`portal_ledger_entry` above already
+    # use, because none of these four responses is a plain
+    # `dataclasses.asdict()` of a single dataclass.
+    components["MachineAssignmentSpec"] = {
+        "type": "object",
+        "properties": {
+            "issue_number": {"type": "integer"},
+            "issue_title": {"type": "string"},
+            "repo_name": {"type": "string"},
+        },
+    }
+    machine_assignment_spec_ref = {"$ref": "#/components/schemas/MachineAssignmentSpec"}
+    components["MachineActiveAssignment"] = {
+        "type": "object",
+        "properties": {
+            "assignment_id": {"type": "string"},
+            "status": {"type": "string"},
+            "spec": machine_assignment_spec_ref,
+        },
+    }
+    machine_active_assignment_ref = {
+        "$ref": "#/components/schemas/MachineActiveAssignment"
+    }
+    components["MachineActiveAssignments"] = {
+        "type": "object",
+        "properties": {
+            "active": {"type": "array", "items": machine_active_assignment_ref}
+        },
+        "required": ["active"],
+    }
+    machine_active_assignments_ref = {
+        "$ref": "#/components/schemas/MachineActiveAssignments"
+    }
+    components["MachineRow"] = {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "host": {"type": "string"},
+            "repos": {"type": "array", "items": {"type": "string"}},
+            "state": {"type": "string", "description": "unknown|online|offline|..."},
+            "reason": {"type": "string"},
+            "latency_ms": {"type": "number", "nullable": True},
+            "agent_version": {"type": "string", "nullable": True},
+            "worktree_bytes": {"type": "number", "nullable": True},
+            "assignments": {
+                **machine_active_assignments_ref,
+                "nullable": True,
+                "description": "present only when this machine has running work",
+            },
+        },
+        "required": ["name", "host", "repos", "state", "reason"],
+    }
+    machine_row_ref = {"$ref": "#/components/schemas/MachineRow"}
+    machines_response = {"type": "array", "items": machine_row_ref}
+    # `coord.health.models.CheckResult.to_dict()` verbatim — shared by
+    # `MachineHealthRow.results` and `FleetHealthResponse.fleet_checks`,
+    # since both are that same to_dict() shape (see fleet_snapshot.py's
+    # `_machine_health_rows`/`FleetHealthRefresher.refresh`).
+    components["HealthCheckResult"] = {
+        "type": "object",
+        "properties": {
+            "key": {"type": "string"},
+            "check_id": {"type": "string"},
+            "scope": {"type": "string"},
+            "subject": {"type": "string", "nullable": True},
+            "title": {"type": "string"},
+            "label": {"type": "string"},
+            "severity": {"type": "string", "description": "ok|warn|crit|unknown"},
+            "headroom": {"type": "string"},
+            "threshold": {"type": "string"},
+            "detail": {"type": "string"},
+            "trend": {"type": "string", "nullable": True},
+            "values": {"type": "object"},
+            "error": {"type": "string", "nullable": True},
+        },
+        "required": ["key", "check_id", "scope", "title", "label", "severity", "headroom"],
+    }
+    health_check_result_ref = {"$ref": "#/components/schemas/HealthCheckResult"}
+    components["MachineHealthRow"] = {
+        "type": "object",
+        "properties": {
+            "machine": {"type": "string"},
+            "state": {"type": "string"},
+            "reason": {"type": "string"},
+            "latency_ms": {"type": "number", "nullable": True},
+            "received_at": {"type": "number", "nullable": True},
+            "stale": {"type": "boolean"},
+            "severity": {"type": "string", "description": "ok|warn|crit|unknown"},
+            "checked_at": {"type": "number", "nullable": True},
+            "results": {"type": "array", "items": health_check_result_ref},
+            "worktree_bytes": {"type": "number", "nullable": True},
+            "agent_runtime_version": {"type": "string", "nullable": True},
+        },
+        "required": ["machine", "state", "reason", "stale", "severity", "results"],
+    }
+    machine_health_row_ref = {"$ref": "#/components/schemas/MachineHealthRow"}
+    # Mirrors `coord.health.fleet_snapshot.FleetHealthSnapshot.to_dict()`
+    # exactly (`{schema, refreshed_at, machine_health, fleet_checks,
+    # truncated}`) -- the same body `/board`'s own `fleet_health` key
+    # carries, per this endpoint's docstring.
+    components["FleetHealthResponse"] = {
+        "type": "object",
+        "properties": {
+            "schema": {"type": "integer"},
+            "refreshed_at": {"type": "number", "nullable": True},
+            "machine_health": {"type": "array", "items": machine_health_row_ref},
+            "fleet_checks": {"type": "array", "items": health_check_result_ref},
+            "truncated": {"type": "boolean"},
+        },
+        "required": ["schema", "machine_health", "fleet_checks", "truncated"],
+    }
+    fleet_health_response_ref = {"$ref": "#/components/schemas/FleetHealthResponse"}
+    # Shared by `/api/machines/health` and `/api/machines/metrics` (#3024/
+    # #3021/#3022 both degrade an unreachable thin-client daemon the same
+    # way): an explicit `{error, detail, reachable: false}` 503 body, never
+    # a stale-looking 200.
+    components["DaemonUnreachableError"] = {
+        "type": "object",
+        "properties": {
+            "error": {"type": "string"},
+            "detail": {"type": "string"},
+            "reachable": {"type": "boolean"},
+        },
+        "required": ["error", "reachable"],
+    }
+    daemon_unreachable_ref = {"$ref": "#/components/schemas/DaemonUnreachableError"}
+    components["BadRequestError"] = {
+        "type": "object",
+        "properties": {"error": {"type": "string"}},
+        "required": ["error"],
+    }
+    bad_request_ref = {"$ref": "#/components/schemas/BadRequestError"}
+    # `coord.machine_metrics.MetricsSample.to_dict()` verbatim.
+    components["MachineMetricsSample"] = {
+        "type": "object",
+        "properties": {
+            "timestamp": {"type": "number"},
+            "status": {"type": "string", "description": "ok|unknown"},
+            "cpu_percent": {"type": "number", "nullable": True},
+            "mem_percent": {"type": "number", "nullable": True},
+            "mem_used_mb": {"type": "number", "nullable": True},
+            "mem_total_mb": {"type": "number", "nullable": True},
+            "reason": {"type": "string"},
+        },
+        "required": ["timestamp", "status", "reason"],
+    }
+    machine_metrics_sample_ref = {"$ref": "#/components/schemas/MachineMetricsSample"}
+    # `coord.machine_metrics.build_metrics_response()`'s body verbatim.
+    components["MachineMetricsResponse"] = {
+        "type": "object",
+        "properties": {
+            "schema": {"type": "integer"},
+            "generated_at": {"type": "number"},
+            "since": {"type": "number", "nullable": True},
+            "resolution": {"type": "integer", "nullable": True},
+            "machines": {
+                "type": "object",
+                "additionalProperties": {
+                    "type": "array",
+                    "items": machine_metrics_sample_ref,
+                },
+                "description": "machine name -> oldest-first sample series",
+            },
+        },
+        "required": ["schema", "generated_at", "machines"],
+    }
+    machine_metrics_response_ref = {"$ref": "#/components/schemas/MachineMetricsResponse"}
+    # `api_machines_stats`'s per-machine dict verbatim (#3025).
+    components["MachineStatsJobHistoryEntry"] = {
+        "type": "object",
+        "properties": {
+            "assignment_id": {"type": "string"},
+            "repo_name": {"type": "string"},
+            "issue_number": {"type": "integer", "nullable": True},
+            "issue_title": {"type": "string", "nullable": True},
+            "type": {"type": "string"},
+            "status": {"type": "string"},
+            "dispatched_at": {"type": "number", "nullable": True},
+            "finished_at": {"type": "number", "nullable": True},
+        },
+        "required": ["assignment_id", "repo_name", "type", "status"],
+    }
+    machine_stats_job_history_entry_ref = {
+        "$ref": "#/components/schemas/MachineStatsJobHistoryEntry"
+    }
+    components["MachineCapacity"] = {
+        "type": "object",
+        "properties": {
+            "active": {"type": "integer"},
+            "max": {"type": "integer"},
+        },
+        "required": ["active", "max"],
+    }
+    machine_capacity_ref = {"$ref": "#/components/schemas/MachineCapacity"}
+    components["MachineJobCounts"] = {
+        "type": "object",
+        "properties": {
+            "completed": {"type": "integer"},
+            "failed": {"type": "integer"},
+        },
+        "required": ["completed", "failed"],
+    }
+    machine_job_counts_ref = {"$ref": "#/components/schemas/MachineJobCounts"}
+    components["MachineStatsRow"] = {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "capacity": machine_capacity_ref,
+            "counts": machine_job_counts_ref,
+            "job_history": {
+                "type": "array",
+                "items": machine_stats_job_history_entry_ref,
+            },
+        },
+        "required": ["name", "capacity", "counts", "job_history"],
+    }
+    machine_stats_row_ref = {"$ref": "#/components/schemas/MachineStatsRow"}
+    machines_stats_response = {"type": "array", "items": machine_stats_row_ref}
     paths = {
         "/": {
             "get": {
@@ -628,7 +851,12 @@ def openapi_spec() -> dict:
         "/api/machines": {
             "get": {
                 "summary": "Machine reachability + live agent /status per machine",
-                "responses": {"200": {"description": "OK"}},
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "content": {"application/json": {"schema": machines_response}},
+                    }
+                },
             }
         },
         "/api/machines/health": {
@@ -644,12 +872,18 @@ def openapi_spec() -> dict:
                             "OK -- {schema, refreshed_at, machine_health: [...], "
                             "fleet_checks: [...], truncated}, unchanged"
                         ),
+                        "content": {
+                            "application/json": {"schema": fleet_health_response_ref}
+                        },
                     },
                     "503": {
                         "description": (
                             "The daemon is unreachable -- an explicit "
                             "{error, reachable: false} body, never a stale-looking 200"
                         ),
+                        "content": {
+                            "application/json": {"schema": daemon_unreachable_ref}
+                        },
                     },
                 },
             }
@@ -690,15 +924,22 @@ def openapi_spec() -> dict:
                 "responses": {
                     "200": {
                         "description": "OK -- daemon's versioned metrics payload, verbatim",
+                        "content": {
+                            "application/json": {"schema": machine_metrics_response_ref}
+                        },
                     },
                     "400": {
                         "description": "The daemon rejected since/resolution as malformed",
+                        "content": {"application/json": {"schema": bad_request_ref}},
                     },
                     "503": {
                         "description": (
                             "The daemon is unreachable -- an explicit "
                             "{error, reachable: false} body, never an empty series"
                         ),
+                        "content": {
+                            "application/json": {"schema": daemon_unreachable_ref}
+                        },
                     },
                 },
             }
@@ -710,7 +951,14 @@ def openapi_spec() -> dict:
                     "active vs configured concurrency, completed/failed counts "
                     "over the retention window, and recent (last 20) job history"
                 ),
-                "responses": {"200": {"description": "OK"}},
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "content": {
+                            "application/json": {"schema": machines_stats_response}
+                        },
+                    }
+                },
             }
         },
         "/api/proposals": {
@@ -1749,11 +1997,14 @@ def build_app(
         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.
+        Fixture mode (#3026) has no live sampler to simulate, so it runs the
+        seeded per-machine series (``FixtureServer.machine_metrics_series()``)
+        through the exact same ``resolve_since``/``build_metrics_response``
+        pipeline the daemon's own ``GET /machines/metrics`` handler
+        (``coord.serve_app.get_machine_metrics``) uses — only the series
+        *source* differs, so ``since``/``resolution``/``machine`` and a bad
+        value's 400 all behave identically to live mode. Never probes the
+        fleet, mirroring ``api_machines``' fixture branch.
 
         Degrades honestly (#3022): a daemon that is unreachable (down,
         network partition, wrong token) comes back as an explicit
@@ -1768,14 +2019,34 @@ def build_app(
         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.machine_metrics import (  # noqa: PLC0415
+                build_metrics_response,
+                resolve_since,
             )
 
+            qp = request.query_params
+            resolution_raw = qp.get("resolution")
+            try:
+                resolution = int(resolution_raw) if resolution_raw else None
+                if resolution is not None and resolution <= 0:
+                    raise ValueError("resolution must be a positive integer")
+            except ValueError as e:
+                return JSONResponse(
+                    {"error": f"bad resolution={resolution_raw!r}: {e}"}, status_code=400
+                )
+            try:
+                since = resolve_since(qp.get("since"), now=_fixture.now)
+            except ValueError as e:
+                return JSONResponse({"error": str(e)}, status_code=400)
+            result = build_metrics_response(
+                _fixture.machine_metrics_series(),
+                machine=qp.get("machine") or None,
+                since=since,
+                resolution=resolution,
+                now=_fixture.now,
+            )
+            return JSONResponse(result)
+
         from coord.client import fetch_machine_metrics  # noqa: PLC0415
 
         svc = _machine_metrics_daemon_target()
@@ -1852,6 +2123,13 @@ def build_app(
         coord-tui's ``machine_detail_list``), newest first by ``finished_at``
         (falling back to ``dispatched_at`` for a row that somehow has no
         ``finished_at``).
+
+        Fixture mode (#3026) needs no dedicated branch here at all: ``_read_board()``
+        already returns the seeded board and ``config`` is already the fixture's
+        own ``config`` block (or the caller-supplied fallback) — this handler
+        reads both exactly like live mode, so a fixture with a realistic spread
+        of completed/failed/running assignments per machine exercises it for
+        free.
         """
         from coord.reconcile import _machine_capacity, _running_by_machine  # noqa: PLC0415