code-coordinator 0.5.533__tar.gz → 0.5.534__tar.gz

{code_coordinator-0.5.533 → code_coordinator-0.5.534}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.533",
+  "tag": "0.5.534",
   "distance": 0,
-  "node": "g3ea458dbd41140d5bf4dca2f931046590f1b3fb0",
+  "node": "ga57e6a4b749192d9ac4e31c24b5ad4b9fa5a2e13",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-30"

{code_coordinator-0.5.533 → code_coordinator-0.5.534}/coord/client.py

@@ -763,18 +763,44 @@ def fetch_drive_escalations(
     return entries if isinstance(entries, list) else []
 
 
-def fetch_drive_queue(
+@dataclass(frozen=True)
+class DriveQueueRead:
+    """Result of one drive-queue read attempt (#2992).
+
+    Distinguishes "the daemon could not be read" from "the daemon answered
+    and the queue is genuinely empty" — a distinction :func:`fetch_drive_queue`
+    itself collapses on purpose (see its docstring), because most callers only
+    want best-effort rows. ``coord drive-queue list`` is the one caller that
+    must NOT collapse it: reporting "queue is empty" for a daemon that never
+    actually answered is exactly the false "nothing to see here" #2992 was
+    filed over.
+
+    ``ok=True`` — the daemon answered; ``entries`` is the real list, ``[]``
+    included for a genuinely drained queue.
+    ``ok=False`` — the read failed (network error, non-2xx, malformed JSON);
+    ``entries`` is always ``[]`` here too (never meaningful) and ``error``
+    carries a short human-readable reason.
+    """
+
+    ok: bool
+    entries: list[dict]
+    error: str | None = None
+
+
+def fetch_drive_queue_result(
     svc: ServiceConfig,
     repo_name: str | None = None,
     *,
     timeout: float = _DEFAULT_TIMEOUT,
-) -> list[dict]:
-    """GET the drive queue in run order, optionally filtered to one repo (#1753).
-
-    ``[]`` on ANY failure (404 from a daemon predating this route, network
-    error, bad JSON, or a genuinely empty queue) — fail-soft, mirrors
-    :func:`fetch_drive_escalations`. ``after_json`` arrives already decoded to
-    a list; this helper does not re-parse it.
+) -> DriveQueueRead:
+    """GET the drive queue — same request as :func:`fetch_drive_queue` — but
+    returning a :class:`DriveQueueRead` that keeps "could not read" and
+    "read fine, zero rows" apart (#2992).
+
+    This is the one place that decides what counts as a successful
+    drive-queue read; :func:`fetch_drive_queue` is now a thin fail-soft
+    wrapper around it, so there is exactly one answer to "did this read
+    succeed" rather than two implementations that could drift apart.
     """
     try:
         params = {"repo_name": repo_name} if repo_name else {}
@@ -786,10 +812,42 @@ def fetch_drive_queue(
         )
         resp.raise_for_status()
         data = resp.json()
-    except Exception:  # noqa: BLE001
-        return []
+    except httpx.HTTPStatusError as exc:
+        status = exc.response.status_code if exc.response is not None else "?"
+        return DriveQueueRead(
+            ok=False, entries=[], error=f"HTTP {status} from {svc.url}/drive-queue"
+        )
+    except Exception as exc:  # noqa: BLE001 — transport/JSON failure; reported, not swallowed
+        return DriveQueueRead(ok=False, entries=[], error=f"{type(exc).__name__}: {exc}")
     entries = data.get("entries") if isinstance(data, dict) else None
-    return entries if isinstance(entries, list) else []
+    if not isinstance(entries, list):
+        return DriveQueueRead(
+            ok=False, entries=[], error="malformed response (no 'entries' list)"
+        )
+    return DriveQueueRead(ok=True, entries=entries)
+
+
+def fetch_drive_queue(
+    svc: ServiceConfig,
+    repo_name: str | None = None,
+    *,
+    timeout: float = _DEFAULT_TIMEOUT,
+) -> list[dict]:
+    """GET the drive queue in run order, optionally filtered to one repo (#1753).
+
+    ``[]`` on ANY failure (404 from a daemon predating this route, network
+    error, bad JSON, or a genuinely empty queue) — fail-soft, mirrors
+    :func:`fetch_drive_escalations`. ``after_json`` arrives already decoded to
+    a list; this helper does not re-parse it.
+
+    Deliberately still collapses "failed" and "genuinely empty" to the same
+    ``[]`` — most callers (``coord.state.list_drive_queue``'s daemon route,
+    the auto-loop tick) only want best-effort rows and must keep degrading
+    quietly. A caller that needs to tell the two apart — ``coord
+    drive-queue list`` (#2992) — should call :func:`fetch_drive_queue_result`
+    instead, of which this is now a thin wrapper.
+    """
+    return fetch_drive_queue_result(svc, repo_name, timeout=timeout).entries
 
 
 def fetch_leg_counts(

{code_coordinator-0.5.533 → code_coordinator-0.5.534}/coord/commands/drive_queue.py

@@ -132,6 +132,7 @@ from coord.overlap_predict import (
 )
 
 if TYPE_CHECKING:  # pragma: no cover — typing only
+    from coord.client import DriveQueueRead
     from coord.config import Config
     from coord.merge_queue import QueuedMerge
 
@@ -1460,15 +1461,64 @@ def _board_for_list_diagnosis() -> BoardView | None:
         return None
 
 
+def _drive_queue_list_read(
+    repo: str | None,
+) -> tuple[list[dict], DriveQueueRead | None, str | None]:
+    """Fetch the rows `list` renders, distinguishing "daemon unreachable"
+    from "genuinely empty" on a thin client (#2992).
+
+    Returns ``(rows, failure, service_url)`` — ``failure`` is ``None`` on a
+    successful read (rows may still be ``[]``, a genuinely drained queue)
+    and a :class:`coord.client.DriveQueueRead` with ``ok=False`` when the
+    daemon could not be read at all; ``service_url`` names the daemon the
+    failed read targeted (``None`` in host mode). Host mode (no
+    ``board_service`` configured) has no daemon to fail against, so it
+    always reads the local DB and never returns a failure here — out of
+    scope per #2992's own issue body (``coord/state.py``'s local-DB
+    fallback is a separate seam).
+    """
+    from coord.client import fetch_drive_queue_result, resolve_board_service  # noqa: PLC0415
+    from coord.state import list_drive_queue  # noqa: PLC0415
+
+    svc = resolve_board_service()
+    if svc is None:
+        return list_drive_queue(repo), None, None
+    result = fetch_drive_queue_result(svc, repo)
+    if not result.ok:
+        return [], result, svc.url
+    return result.entries, None, svc.url
+
+
+def _drive_queue_list_failure_text(service_url: str, error: str | None) -> str:
+    """The `list` failure line — must read as unmistakably NOT "empty"
+    (#2992's acceptance bar: never contains the words "queue is empty")."""
+    return (
+        f"(drive queue UNREADABLE — could not reach board daemon at "
+        f"{service_url}: {error})"
+    )
+
+
+def _drive_queue_list_failure_json(service_url: str, error: str | None) -> str:
+    """The `--json` failure payload — never a bare `[]` a caller could
+    mistake for zero entries (#2992)."""
+    return _json.dumps({"error": error, "service_url": service_url, "ok": False})
+
+
 @drive_queue_group.command("list")
 @click.option("--repo", "repo", default=None, help="Restrict to one repo (default: every repo).")
 @click.option("--json", "output_json", is_flag=True, default=False, help="Emit the raw rows as JSON.")
 @_CONFIG_OPTION
 def drive_queue_list(repo: str | None, output_json: bool, config_path: Path) -> None:
     """Show the queue in run order."""
-    from coord.state import list_drive_queue  # noqa: PLC0415
+    rows, failure, service_url = _drive_queue_list_read(repo)
+    if failure is not None:
+        import sys as _sys  # noqa: PLC0415
 
-    rows = list_drive_queue(repo)
+        if output_json:
+            click.echo(_drive_queue_list_failure_json(service_url, failure.error))
+        else:
+            click.echo(_drive_queue_list_failure_text(service_url, failure.error))
+        _sys.exit(1)
     if output_json:
         click.echo(_json.dumps(rows))
         return

{code_coordinator-0.5.533 → code_coordinator-0.5.534}/tests/test_client.py

@@ -204,3 +204,125 @@ class TestFetchBoardPayloadConditionalGet:
         cc.reset_board_payload_cache()
 
         assert cc._board_payload_cache == {}
+
+
+class TestFetchDriveQueueResult:
+    """#2992: a daemon read failure must be distinguishable from a
+    genuinely empty queue — ``fetch_drive_queue_result`` is the function
+    that carries that distinction; ``fetch_drive_queue`` stays a fail-soft
+    wrapper around it for callers that don't want it (unchanged contract).
+    """
+
+    def test_populated_queue_is_ok_with_the_real_rows(self, monkeypatch) -> None:
+        rows = [{"repo_name": "cc", "issue_number": 1}, {"repo_name": "cc", "issue_number": 2}]
+
+        def fake_get(url, *, headers=None, params=None, **kw):
+            return _FakeResponse(json_body={"entries": rows})
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        result = cc.fetch_drive_queue_result(_svc())
+
+        assert result.ok is True
+        assert result.entries == rows
+        assert result.error is None
+
+    def test_genuinely_empty_queue_is_ok_with_zero_rows(self, monkeypatch) -> None:
+        def fake_get(url, *, headers=None, params=None, **kw):
+            return _FakeResponse(json_body={"entries": []})
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        result = cc.fetch_drive_queue_result(_svc())
+
+        assert result.ok is True
+        assert result.entries == []
+        assert result.error is None
+
+    def test_transport_error_is_not_ok_and_names_the_reason(self, monkeypatch) -> None:
+        def fake_get(url, *, headers=None, params=None, **kw):
+            raise httpx.ConnectError("connection refused")
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        result = cc.fetch_drive_queue_result(_svc())
+
+        assert result.ok is False
+        assert result.entries == []
+        assert result.error is not None
+        assert "refused" in result.error or "ConnectError" in result.error
+
+    def test_5xx_is_not_ok_and_names_the_status(self, monkeypatch) -> None:
+        def fake_get(url, *, headers=None, params=None, **kw):
+            return _FakeResponse(status_code=503)
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        result = cc.fetch_drive_queue_result(_svc())
+
+        assert result.ok is False
+        assert result.entries == []
+        assert "503" in result.error
+
+    def test_malformed_json_is_not_ok(self, monkeypatch) -> None:
+        def fake_get(url, *, headers=None, params=None, **kw):
+            return _FakeResponse(json_body={"not_entries_at_all": True})
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        result = cc.fetch_drive_queue_result(_svc())
+
+        assert result.ok is False
+        assert result.entries == []
+        assert result.error
+
+    def test_the_three_shapes_are_mutually_distinguishable(self, monkeypatch) -> None:
+        """Empty / transport-error / populated must never collapse to the
+        same result — the whole point of #2992."""
+
+        def get_for(shape: str):
+            def fake_get(url, *, headers=None, params=None, **kw):
+                if shape == "populated":
+                    return _FakeResponse(json_body={"entries": [{"issue_number": 1}]})
+                if shape == "empty":
+                    return _FakeResponse(json_body={"entries": []})
+                raise httpx.ConnectError("refused")
+
+            return fake_get
+
+        monkeypatch.setattr(cc.httpx, "get", get_for("populated"))
+        populated = cc.fetch_drive_queue_result(_svc())
+        monkeypatch.setattr(cc.httpx, "get", get_for("empty"))
+        empty = cc.fetch_drive_queue_result(_svc())
+        monkeypatch.setattr(cc.httpx, "get", get_for("error"))
+        errored = cc.fetch_drive_queue_result(_svc())
+
+        assert (populated.ok, empty.ok, errored.ok) == (True, True, False)
+        assert populated.entries != empty.entries
+        assert errored.error is not None
+        assert populated.error is None
+        assert empty.error is None
+
+    def test_fetch_drive_queue_stays_fail_soft_to_empty_list_on_failure(
+        self, monkeypatch
+    ) -> None:
+        """The pre-existing, unchanged contract: `fetch_drive_queue` itself
+        never raises and never exposes the failure — only
+        `fetch_drive_queue_result` does."""
+
+        def fake_get(url, *, headers=None, params=None, **kw):
+            raise httpx.ConnectError("refused")
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        assert cc.fetch_drive_queue(_svc()) == []
+
+    def test_fetch_drive_queue_returns_the_real_rows_on_success(self, monkeypatch) -> None:
+        rows = [{"repo_name": "cc", "issue_number": 7}]
+
+        def fake_get(url, *, headers=None, params=None, **kw):
+            return _FakeResponse(json_body={"entries": rows})
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        assert cc.fetch_drive_queue(_svc()) == rows

{code_coordinator-0.5.533 → code_coordinator-0.5.534}/tests/test_drive_queue.py

@@ -7160,3 +7160,217 @@ def test_merge_gate_remedy_command_is_the_safe_inspect_fallback_for_none_and_non
     ordinary = "no candidate machine available for claude-coordinator#1650"
     assert is_merge_gate_block_reason(ordinary) is False
     assert merge_gate_remedy_command(ordinary, REPO, 1650) == merge_plan_inspect_command(REPO)
+
+
+class TestDriveQueueListReadDistinguishesFailureFromEmpty:
+    """#2992: `coord drive-queue list` must not report a daemon it could
+    not read as "the queue is empty" — those are two different facts and
+    the CLI collapsed them to the same rendering.
+
+    Unlike the rest of this file, these exercise `coord/commands/
+    drive_queue.py` (the CLI shell, imported directly rather than through
+    `CliRunner` for most cases — plus one end-to-end pair at the bottom for
+    the exact rendered text) — scoped here per the #2992 briefing's own
+    file list rather than `tests/test_cli_drive_queue.py`, which is the
+    CLI black-box suite for everything else in this command group.
+    """
+
+    @staticmethod
+    def _svc():
+        import coord.client as cc
+
+        return cc.ServiceConfig(url="http://daemon:7435")
+
+    def test_host_mode_has_no_daemon_to_fail_against(self, monkeypatch):
+        """No `board_service` configured (the suite-wide default, #584/#590)
+        — #2992 is scoped to the thin-client path, so host mode must keep
+        reading the local DB exactly as before and never report a
+        `failure`."""
+        import coord.state as state
+        from coord.commands import drive_queue as dq
+
+        monkeypatch.setattr(state, "list_drive_queue", lambda repo=None: [{"issue_number": 1}])
+
+        rows, failure, service_url = dq._drive_queue_list_read(None)
+
+        assert rows == [{"issue_number": 1}]
+        assert failure is None
+        assert service_url is None
+
+    def test_thin_client_daemon_failure_is_reported_not_collapsed_to_empty(self, monkeypatch):
+        import coord.client as cc
+        from coord.commands import drive_queue as dq
+
+        svc = self._svc()
+        monkeypatch.setattr(cc, "resolve_board_service", lambda: svc)
+        monkeypatch.setattr(
+            cc,
+            "fetch_drive_queue_result",
+            lambda svc, repo=None, **kw: cc.DriveQueueRead(ok=False, entries=[], error="boom"),
+        )
+
+        rows, failure, service_url = dq._drive_queue_list_read(None)
+
+        assert rows == []
+        assert failure is not None
+        assert failure.ok is False
+        assert failure.error == "boom"
+        assert service_url == svc.url
+
+    def test_thin_client_genuinely_empty_queue_reads_as_success(self, monkeypatch):
+        import coord.client as cc
+        from coord.commands import drive_queue as dq
+
+        svc = self._svc()
+        monkeypatch.setattr(cc, "resolve_board_service", lambda: svc)
+        monkeypatch.setattr(
+            cc,
+            "fetch_drive_queue_result",
+            lambda svc, repo=None, **kw: cc.DriveQueueRead(ok=True, entries=[]),
+        )
+
+        rows, failure, service_url = dq._drive_queue_list_read(None)
+
+        assert rows == []
+        assert failure is None
+        assert service_url == svc.url
+
+    def test_thin_client_populated_queue_passes_the_real_rows_through(self, monkeypatch):
+        import coord.client as cc
+        from coord.commands import drive_queue as dq
+
+        svc = self._svc()
+        real_rows = [{"issue_number": 1}, {"issue_number": 2}]
+        monkeypatch.setattr(cc, "resolve_board_service", lambda: svc)
+        monkeypatch.setattr(
+            cc,
+            "fetch_drive_queue_result",
+            lambda svc, repo=None, **kw: cc.DriveQueueRead(ok=True, entries=real_rows),
+        )
+
+        rows, failure, service_url = dq._drive_queue_list_read(None)
+
+        assert rows == real_rows
+        assert failure is None
+        assert service_url == svc.url
+
+    def test_the_three_read_outcomes_are_mutually_distinguishable(self, monkeypatch):
+        """Empty / transport-failure / populated must never produce the
+        same `(rows, failure, service_url)` shape — the issue's own
+        acceptance bar, at the routing layer."""
+        import coord.client as cc
+        from coord.commands import drive_queue as dq
+
+        svc = self._svc()
+        monkeypatch.setattr(cc, "resolve_board_service", lambda: svc)
+
+        monkeypatch.setattr(
+            cc,
+            "fetch_drive_queue_result",
+            lambda svc, repo=None, **kw: cc.DriveQueueRead(ok=True, entries=[{"issue_number": 1}]),
+        )
+        populated = dq._drive_queue_list_read(None)
+
+        monkeypatch.setattr(
+            cc, "fetch_drive_queue_result",
+            lambda svc, repo=None, **kw: cc.DriveQueueRead(ok=True, entries=[]),
+        )
+        empty = dq._drive_queue_list_read(None)
+
+        monkeypatch.setattr(
+            cc, "fetch_drive_queue_result",
+            lambda svc, repo=None, **kw: cc.DriveQueueRead(ok=False, entries=[], error="503"),
+        )
+        errored = dq._drive_queue_list_read(None)
+
+        assert populated != empty
+        assert empty != errored
+        assert populated != errored
+        assert empty[1] is None and errored[1] is not None
+
+    def test_failure_text_never_says_queue_is_empty_and_names_the_daemon(self):
+        from coord.commands import drive_queue as dq
+
+        text = dq._drive_queue_list_failure_text(
+            "http://daemon:7435", "HTTP 503 from http://daemon:7435/drive-queue"
+        )
+
+        assert "queue is empty" not in text
+        assert "http://daemon:7435" in text
+        assert "503" in text
+
+    def test_failure_json_is_never_a_bare_empty_list(self):
+        import json
+
+        from coord.commands import drive_queue as dq
+
+        payload = dq._drive_queue_list_failure_json("http://daemon:7435", "boom")
+
+        assert payload != "[]"
+        decoded = json.loads(payload)
+        assert decoded["ok"] is False
+        assert decoded["service_url"] == "http://daemon:7435"
+        assert decoded["error"] == "boom"
+
+    def test_cli_end_to_end_reports_daemon_failure_not_empty_queue(self, monkeypatch, tmp_path):
+        """The actual `coord drive-queue list` invocation: a failed read
+        must render neither `(drive queue is empty)` nor a bare `[]`, and
+        must exit non-zero so scripts branching on it notice."""
+        import coord.client as cc
+        from click.testing import CliRunner
+
+        from coord.cli import main
+
+        svc = self._svc()
+        monkeypatch.setattr(cc, "resolve_board_service", lambda: svc)
+        monkeypatch.setattr(
+            cc,
+            "fetch_drive_queue_result",
+            lambda svc, repo=None, **kw: cc.DriveQueueRead(
+                ok=False, entries=[], error="HTTP 503 from http://daemon:7435/drive-queue"
+            ),
+        )
+        config_path = tmp_path / "coordinator.yml"
+        config_path.write_text("repos: []\nmachines: []\n")
+
+        result = CliRunner().invoke(
+            main, ["drive-queue", "list", "--config", str(config_path)]
+        )
+
+        assert result.exit_code != 0
+        assert "queue is empty" not in result.output
+        assert "http://daemon:7435" in result.output
+
+        json_result = CliRunner().invoke(
+            main, ["drive-queue", "list", "--json", "--config", str(config_path)]
+        )
+        assert json_result.exit_code != 0
+        assert json_result.output.strip() != "[]"
+
+    def test_cli_end_to_end_reports_a_genuinely_empty_queue_unchanged(
+        self, monkeypatch, tmp_path
+    ):
+        """The other half of the pair above: a real empty queue must keep
+        printing exactly today's message, on the exact same thin-client
+        code path a failed read now diverges from."""
+        import coord.client as cc
+        from click.testing import CliRunner
+
+        from coord.cli import main
+
+        svc = self._svc()
+        monkeypatch.setattr(cc, "resolve_board_service", lambda: svc)
+        monkeypatch.setattr(
+            cc,
+            "fetch_drive_queue_result",
+            lambda svc, repo=None, **kw: cc.DriveQueueRead(ok=True, entries=[]),
+        )
+        config_path = tmp_path / "coordinator.yml"
+        config_path.write_text("repos: []\nmachines: []\n")
+
+        result = CliRunner().invoke(
+            main, ["drive-queue", "list", "--config", str(config_path)]
+        )
+
+        assert result.exit_code == 0
+        assert result.output.strip() == "(drive queue is empty)"