claude-dev-env 8.45.1 → 8.46.1

package/docs/account-broker.md

@@ -27,6 +27,7 @@ The broker stores cached meters, spent marks, and Claude session bindings in one
 | `0` | `choose` or `check` found an account, or the job exited successfully. |
 | `3` | No account clears its floor. The decision includes `resets_at`. |
 | `4` | A Claude job stopped with `advisor_blocked`. |
+| `127` | A Codex job timed out, or its command could not start while no Codex roster is configured. |
 | Other command code | `run` returns the command's exit code after a served response. |
 
 `run` writes a JSON report with `product`, `command`, `events`, and `final_decision`. A wait report has `final_decision.action` equal to `wait` and a UTC `final_decision.resets_at`.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.45.1",
+    "version": "8.46.1",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/scripts/account_broker.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import Mapping, Sequence
 
 import account_broker_support as support
+import codex_account_meters
 from account_broker_support import (
     all_product_adapters,
     Account,
@@ -262,7 +263,8 @@ def _attempt_once(context: _RunContext, decision: Decision) -> JobOutcome | None
         _record_spent_attempt(context, account, status, COMMAND_MISSING_EXIT_CODE)
         if isinstance(error, subprocess.TimeoutExpired) or not context.all_readings:
             context.report.final_decision = decision
-            return JobOutcome(COMMAND_MISSING_EXIT_CODE, "", str(error), account.name, tuple(context.all_attempts), "advisor_blocked", None, None)
+            final_status = "advisor_blocked" if context.product is Product.CLAUDE else status
+            return JobOutcome(COMMAND_MISSING_EXIT_CODE, "", str(error), account.name, tuple(context.all_attempts), final_status, None, None)
         return None
     combined = f"{completion.stdout}{completion.stderr}".casefold()
     is_limited = completion.returncode != 0 and any(
@@ -310,11 +312,14 @@ def run_job(
 def _parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description=__doc__)
     commands = parser.add_subparsers(dest="action", required=True)
-    for each_action in ("choose", "check", "accounts", "run"):
+    for each_action in ("choose", "check", "accounts", "limits", "run"):
         command = commands.add_parser(each_action)
         command.add_argument("--product", choices=[each_product.value for each_product in Product], required=True)
         if each_action == "choose":
             command.add_argument("--spent", action="append", default=[])
+        if each_action == "limits":
+            command.add_argument("--home", type=Path, required=True)
+            command.add_argument("--codex", type=Path)
         if each_action == "run":
             command.add_argument("--report", type=Path, required=True)
             command.add_argument("command", nargs=argparse.REMAINDER)
@@ -344,6 +349,19 @@ def _accounts_cli(product: Product) -> int:
     return 0
 
 
+def _limits_cli(product: Product, parsed: argparse.Namespace) -> int:
+    if product is not Product.CODEX:
+        raise BrokerConfigurationError("limits reads Codex accounts only")
+    try:
+        rate_limit_records = codex_account_meters.read_rate_limit_records(
+            codex_account_meters.resolve_codex_path(parsed.codex), parsed.home
+        )
+    except (codex_account_meters.CodexMeterUnreadError, OSError) as error:
+        raise BrokerConfigurationError(str(error)) from error
+    print(json.dumps({"home": str(parsed.home), "rate_limits": rate_limit_records}))
+    return 0
+
+
 def _run_cli(product: Product, parsed: argparse.Namespace, parser: argparse.ArgumentParser) -> int:
     command = list(parsed.command)
     if command and command[0] == "--":
@@ -387,6 +405,8 @@ def main(all_arguments: Sequence[str]) -> int:
     try:
         if parsed.action == "accounts":
             return _accounts_cli(product)
+        if parsed.action == "limits":
+            return _limits_cli(product, parsed)
         if parsed.action == "run":
             return _run_cli(product, parsed, parser)
         return _choose_cli(product, parsed)

package/scripts/codex_account_meters.py

@@ -161,7 +161,7 @@ def _parse_window(raw_window: object) -> UsageWindow | None:
     )
 
 
-def _rate_limits_mapping(reply_text: str) -> Mapping[str, object]:
+def _reply_body(reply_text: str) -> Mapping[str, object]:
     try:
         reply = json.loads(reply_text)
     except json.JSONDecodeError as error:
@@ -171,7 +171,13 @@ def _rate_limits_mapping(reply_text: str) -> Mapping[str, object]:
     if reply.get("error") is not None:
         raise CodexMeterUnreadError(f"rate-limit read failed: {reply['error']}")
     body = reply.get("result")
-    rate_limits = body.get("rateLimits") if isinstance(body, dict) else None
+    if not isinstance(body, dict):
+        raise CodexMeterUnreadError("rate-limit reply has no result")
+    return body
+
+
+def _rate_limits_mapping(reply_text: str) -> Mapping[str, object]:
+    rate_limits = _reply_body(reply_text).get("rateLimits")
     if not isinstance(rate_limits, dict):
         raise CodexMeterUnreadError("rate-limit reply names no rateLimits")
     return rate_limits
@@ -338,13 +344,45 @@ def read_codex_meters(
     Raises:
         CodexMeterUnreadError: The server failed, timed out, or sent no usable reply.
     """
+    return parse_rate_limits_reply(_rate_limits_reply_line(codex_path, codex_home, exchange))
+
+
+def read_rate_limit_records(
+    codex_path: Path,
+    codex_home: Path,
+    exchange: ServerExchange = exchange_with_app_server,
+) -> Mapping[str, object]:
+    """Read one account's whole rate-limit reply through the app server.
+
+    ::
+
+        {"id": 2, "result": {"rateLimits": {...}, "rateLimitsByLimitId": {...}}}
+        -> {"rateLimits": {...}, "rateLimitsByLimitId": {...}}
+
+    Args:
+        codex_path: The Codex executable.
+        codex_home: The account's Codex home.
+        exchange: Sends messages and returns output lines; tests pass a fake.
+
+    Returns:
+        The reply's ``result`` object, with every limit record it carries.
+
+    Raises:
+        CodexMeterUnreadError: The server failed, timed out, or sent no usable reply.
+    """
+    return _reply_body(_rate_limits_reply_line(codex_path, codex_home, exchange))
+
+
+def _rate_limits_reply_line(
+    codex_path: Path, codex_home: Path, exchange: ServerExchange
+) -> str:
     try:
         all_lines = exchange(codex_path, codex_home, request_messages())
     except (OSError, subprocess.SubprocessError, UnicodeDecodeError) as error:
         raise CodexMeterUnreadError(f"codex app-server failed: {error}") from error
     for each_line in all_lines:
         if _is_rate_limits_reply(each_line):
-            return parse_rate_limits_reply(each_line)
+            return each_line
     raise CodexMeterUnreadError("codex app-server sent no rate-limit reply")
 
 

package/scripts/test_account_broker.py

@@ -435,13 +435,44 @@ def test_should_stop_after_timeout_without_running_job_again(
 
     assert invoked_homes == ["first"]
     assert outcome.attempts == (("first", "timeout"),)
-    assert outcome.status == "advisor_blocked"
+    assert outcome.status == "timeout"
     assert outcome.account_name == "first"
     assert report.final_decision.account.name == "first"
     assert account_broker.main(("choose", "--product", "codex")) == 0
     assert json.loads(capsys.readouterr().out)["decision"]["account"] == "first"
 
 
+@pytest.mark.parametrize(
+    ("product", "roster_names", "start_error", "expected_code"),
+    (
+        (Product.CLAUDE, ("first",), subprocess.TimeoutExpired("job", 1), 4),
+        (Product.CODEX, ("first",), subprocess.TimeoutExpired("job", 1), 127),
+        (Product.CODEX, (), OSError("missing command"), 127),
+    ),
+)
+def test_should_exit_four_only_for_a_blocked_claude_job(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    product: Product,
+    roster_names: tuple[str, ...],
+    start_error: Exception,
+    expected_code: int,
+) -> None:
+    accounts = tuple(_account(each_name, product) for each_name in roster_names)
+    monkeypatch.setitem(account_broker.all_product_adapters, product, _adapter(accounts, {
+        each_name: _meters(80, 80) for each_name in roster_names
+    }))
+    monkeypatch.setattr(account_broker.sys, "stdin", io.TextIOWrapper(io.BytesIO(b""), encoding="utf-8"))
+
+    def runner(argv: object, **options: object) -> subprocess.CompletedProcess[str]:
+        raise start_error
+
+    with account_broker.override_subprocess_runner(runner):
+        code = account_broker.main(("run", "--product", product.value, "--report", str(tmp_path / "report.json"), "--", "job"))
+
+    assert code == expected_code
+
+
 def test_should_keep_usage_limited_account_spent_for_later_choices(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:
@@ -663,3 +694,41 @@ def test_should_run_job_through_override(
     assert outcome.status == "served"
     assert outcome.attempts == (("only", "served"),)
     assert calls == [b"input"]
+
+
+
+def test_should_print_the_whole_rate_limit_result_for_one_home(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    rate_limit_records = {"rateLimitsByLimitId": {"codex": {"primary": {"usedPercent": 20}}}}
+    observed: list[tuple[Path, Path]] = []
+
+    def read_result(codex_path: Path, codex_home: Path) -> dict[str, object]:
+        observed.append((codex_path, codex_home))
+        return rate_limit_records
+
+    monkeypatch.setattr(account_broker.codex_account_meters, "read_rate_limit_records", read_result)
+    home = tmp_path / "codex-2"
+
+    assert account_broker.main(("limits", "--product", "codex", "--home", str(home), "--codex", "codex-bin")) == 0
+    assert json.loads(capsys.readouterr().out) == {"home": str(home), "rate_limits": rate_limit_records}
+    assert observed == [(Path("codex-bin"), home)]
+
+
+def test_should_exit_two_when_the_limits_read_fails(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    def read_result(_codex_path: Path, _codex_home: Path) -> dict[str, object]:
+        raise account_broker.codex_account_meters.CodexMeterUnreadError("codex app-server sent no rate-limit reply")
+
+    monkeypatch.setattr(account_broker.codex_account_meters, "read_rate_limit_records", read_result)
+
+    assert account_broker.main(("limits", "--product", "codex", "--home", str(tmp_path), "--codex", "codex-bin")) == 2
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "no rate-limit reply" in captured.err
+
+
+def test_should_refuse_limits_for_claude(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    assert account_broker.main(("limits", "--product", "claude", "--home", str(tmp_path))) == 2
+    assert "Codex accounts only" in capsys.readouterr().err

package/scripts/test_codex_account_meters.py

@@ -15,6 +15,7 @@ from codex_account_meters import (
     exchange_with_app_server,
     parse_rate_limits_reply,
     read_codex_meters,
+    read_rate_limit_records,
     request_messages,
     resolve_codex_path,
 )
@@ -163,6 +164,38 @@ class TestReadCodexMeters:
             read_codex_meters(Path("codex"), Path("/h"), broken_exchange)
 
 
+
+class TestReadRateLimitRecords:
+    def should_return_every_limit_record_the_reply_carries(self) -> None:
+        rate_limit_records = {
+            "rateLimits": {"limitId": "codex", "primary": {"usedPercent": 20}},
+            "rateLimitsByLimitId": {
+                "codex": {"limitId": "codex", "planType": "pro"},
+                "codex_other": {"limitId": "codex_other"},
+            },
+        }
+
+        assert (
+            read_rate_limit_records(
+                Path("codex"),
+                Path("/h"),
+                lambda *_: [json.dumps({"id": 1}), json.dumps({"id": 2, "result": rate_limit_records})],
+            )
+            == rate_limit_records
+        )
+
+    def should_raise_unread_on_an_error_reply(self) -> None:
+        with pytest.raises(CodexMeterUnreadError, match="read failed"):
+            read_rate_limit_records(
+                Path("codex"),
+                Path("/h"),
+                lambda *_: [json.dumps({"id": 2, "error": {"code": 1}})],
+            )
+
+    def should_raise_unread_when_the_server_never_answers(self) -> None:
+        with pytest.raises(CodexMeterUnreadError, match="no rate-limit reply"):
+            read_rate_limit_records(Path("codex"), Path("/h"), lambda *_: [])
+
 FAKE_APP_SERVER = """#!/usr/bin/env python3
 import json, os, sys
 for line in sys.stdin: