claude-dev-env 8.45.1 → 8.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.45.1",
+    "version": "8.46.0",
     "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,
@@ -310,11 +311,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 +348,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 +404,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

@@ -663,3 +663,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: