claude-dev-env 8.12.0 → 8.13.0

package/scripts/test_codex_account_choice.py

@@ -0,0 +1,276 @@
+"""Tests for the picker that names which Codex account a runner job uses."""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import pytest
+
+import codex_account_choice as choice
+from codex_account_meters import CodexAccountMeters, CodexMeterUnreadError, UsageWindow
+
+NOW = datetime(2026, 9, 23, 17, 0, tzinfo=timezone.utc)
+
+
+def reading(
+    name: str,
+    *,
+    weekly_used: float,
+    short_used: float = 0.0,
+    weekly_resets_in: timedelta = timedelta(days=3),
+) -> choice.AccountReading:
+    return choice.AccountReading(
+        name=name,
+        codex_home=Path("/profiles") / name,
+        meters=CodexAccountMeters(
+            all_windows=(
+                UsageWindow(300, short_used, NOW + timedelta(hours=2)),
+                UsageWindow(10080, weekly_used, NOW + weekly_resets_in),
+            )
+        ),
+    )
+
+
+def unread(name: str) -> choice.AccountReading:
+    return choice.AccountReading(name, Path("/profiles") / name, None, "not signed in")
+
+
+class TestChooseCodexAccount:
+    def should_take_the_first_account_in_order_with_room(self) -> None:
+        decision = choice.choose_codex_account(
+            [reading("codex-1", weekly_used=50.0), reading("codex-2", weekly_used=0.0)]
+        )
+        assert (decision.tier, decision.reading.name) == ("normal", "codex-1")
+        assert decision.stop_below_percent is None
+
+    def should_pass_over_an_account_at_the_ten_percent_bar(self) -> None:
+        decision = choice.choose_codex_account(
+            [reading("codex-1", weekly_used=90.0), reading("codex-2", weekly_used=60.0)]
+        )
+        assert (decision.tier, decision.reading.name) == ("normal", "codex-2")
+
+    def should_measure_room_by_the_tightest_window(self) -> None:
+        decision = choice.choose_codex_account(
+            [
+                reading("codex-1", weekly_used=10.0, short_used=95.0),
+                reading("codex-2", weekly_used=70.0),
+            ]
+        )
+        assert decision.reading.name == "codex-2"
+
+    def should_skip_an_unread_account(self) -> None:
+        decision = choice.choose_codex_account(
+            [unread("codex-1"), reading("codex-2", weekly_used=20.0)]
+        )
+        assert (decision.tier, decision.reading.name) == ("normal", "codex-2")
+
+    def should_fall_back_to_luna_on_the_roomiest_account_under_the_bar(self) -> None:
+        decision = choice.choose_codex_account(
+            [
+                reading("codex-1", weekly_used=97.0),
+                reading("codex-2", weekly_used=92.0),
+                reading("codex-3", weekly_used=100.0),
+            ]
+        )
+        assert (decision.tier, decision.reading.name) == ("luna", "codex-2")
+        assert decision.stop_below_percent == 1.0
+
+    def should_keep_luna_off_an_account_under_twenty_percent_of_its_five_hour_window(
+        self,
+    ) -> None:
+        decision = choice.choose_codex_account(
+            [
+                reading("codex-1", weekly_used=92.0, short_used=85.0),
+                reading("codex-2", weekly_used=97.0, short_used=80.0),
+            ]
+        )
+        assert (decision.tier, decision.reading.name) == ("luna", "codex-2")
+
+    def should_run_luna_on_an_account_with_no_five_hour_window(self) -> None:
+        weekly_only = choice.AccountReading(
+            "codex-3",
+            Path("/profiles/codex-3"),
+            CodexAccountMeters((UsageWindow(10080, 95.0, NOW + timedelta(days=1)),)),
+        )
+        decision = choice.choose_codex_account(
+            [reading("codex-1", weekly_used=92.0, short_used=90.0), weekly_only]
+        )
+        assert (decision.tier, decision.reading.name) == ("luna", "codex-3")
+
+    def should_wait_on_the_account_that_resets_first_when_none_passes_one_percent(
+        self,
+    ) -> None:
+        decision = choice.choose_codex_account(
+            [
+                reading(
+                    "codex-1", weekly_used=99.5, weekly_resets_in=timedelta(days=2)
+                ),
+                reading(
+                    "codex-2", weekly_used=100.0, weekly_resets_in=timedelta(hours=6)
+                ),
+            ]
+        )
+        assert decision.tier == "wait"
+        assert decision.reading.name == "codex-2"
+        assert (NOW + timedelta(hours=6)).isoformat() in decision.reason
+
+    def should_wait_when_no_meter_reads(self) -> None:
+        decision = choice.choose_codex_account([unread("codex-1"), unread("codex-2")])
+        assert (decision.tier, decision.reading) == ("wait", None)
+
+
+class TestDecisionPayload:
+    def should_name_no_account_or_home_on_wait(self) -> None:
+        all_readings = [reading("codex-1", weekly_used=100.0)]
+        payload = choice.decision_payload(
+            choice.choose_codex_account(all_readings), all_readings
+        )
+        assert (payload["tier"], payload["account"], payload["codex_home"]) == (
+            "wait",
+            None,
+            None,
+        )
+
+    def should_report_every_account_and_the_chosen_home(self) -> None:
+        all_readings = [unread("codex-1"), reading("codex-2", weekly_used=25.0)]
+        payload = choice.decision_payload(
+            choice.choose_codex_account(all_readings), all_readings
+        )
+        assert payload["codex_home"] == str(Path("/profiles") / "codex-2")
+        assert payload["percent_left"] == 75.0
+        assert [each["name"] for each in payload["accounts"]] == ["codex-1", "codex-2"]
+        assert payload["accounts"][0]["unread"] == "not signed in"
+        json.dumps(payload)
+
+
+class TestReadAccount:
+    def should_call_an_account_without_a_sign_in_unread(self, tmp_path: Path) -> None:
+        def never_called(codex_home: Path) -> CodexAccountMeters:
+            raise AssertionError("no sign-in, no read")
+
+        account_reading = choice.read_account("codex-1", tmp_path, never_called)
+        assert (account_reading.meters, account_reading.unread_reason) == (None, "not signed in")
+
+    def should_read_under_the_accounts_own_home(self, tmp_path: Path) -> None:
+        (tmp_path / "codex-2").mkdir()
+        (tmp_path / "codex-2" / "auth.json").write_text("{}")
+        all_homes: list[Path] = []
+
+        def fake_reader(codex_home: Path) -> CodexAccountMeters:
+            all_homes.append(codex_home)
+            return CodexAccountMeters((UsageWindow(10080, 40.0, None),))
+
+        account_reading = choice.read_account("codex-2", tmp_path, fake_reader)
+        assert all_homes == [tmp_path / "codex-2"]
+        assert account_reading.meters.percent_left == 60.0
+
+    def should_keep_the_unread_reason(self, tmp_path: Path) -> None:
+        (tmp_path / "codex-1").mkdir()
+        (tmp_path / "codex-1" / "auth.json").write_text("{}")
+
+        def failing_reader(codex_home: Path) -> CodexAccountMeters:
+            raise CodexMeterUnreadError("codex app-server sent no rate-limit reply")
+
+        account_reading = choice.read_account("codex-1", tmp_path, failing_reader)
+        assert account_reading.unread_reason == "codex app-server sent no rate-limit reply"
+
+
+class TestCheck:
+    @pytest.mark.parametrize(
+        ("weekly_used", "exit_code"), [(98.0, 0), (99.0, 3), (100.0, 3)]
+    )
+    def should_answer_room_only_above_the_floor(
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        weekly_used: float,
+        exit_code: int,
+    ) -> None:
+        (tmp_path / "codex-3").mkdir()
+        (tmp_path / "codex-3" / "auth.json").write_text("{}")
+        monkeypatch.setattr(
+            choice,
+            "_meter_reader",
+            lambda codex_path: (
+                lambda codex_home: CodexAccountMeters(
+                    (UsageWindow(10080, weekly_used, None),)
+                )
+            ),
+        )
+        assert (
+            choice.main(["--profiles-root", str(tmp_path), "check", "codex-3"])
+            == exit_code
+        )
+
+    def should_answer_no_room_for_an_unread_account(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setattr(choice, "_meter_reader", lambda codex_path: None)
+        assert choice.main(["--profiles-root", str(tmp_path), "check", "codex-4"]) == 3
+
+
+class TestSync:
+    @pytest.mark.skipif(
+        os.name == "nt", reason="junction creation needs a Windows shell"
+    )
+    def should_link_the_shared_setup_and_keep_each_sign_in(
+        self, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        main_home = tmp_path / "main"
+        (main_home / "rules").mkdir(parents=True)
+        (main_home / "config.toml").write_text("model = 'x'")
+        (main_home / "auth.json").write_text("{}")
+        (main_home / "sessions").mkdir()
+        profiles_root = tmp_path / "profiles"
+
+        assert (
+            choice.main(
+                [
+                    "--profiles-root",
+                    str(profiles_root),
+                    "sync",
+                    "--main-home",
+                    str(main_home),
+                ]
+            )
+            == 0
+        )
+
+        report = json.loads(capsys.readouterr().out)
+        assert list(report) == ["codex-1", "codex-2", "codex-3", "codex-4"]
+        each_home = profiles_root / "codex-3"
+        assert os.readlink(each_home / "rules") == str(main_home / "rules")
+        assert os.readlink(each_home / "config.toml") == str(main_home / "config.toml")
+        assert not (each_home / "auth.json").exists()
+        assert not (each_home / "sessions").exists()
+
+
+class TestSmallHelpers:
+    @pytest.mark.parametrize(
+        ("entry_name", "is_local"),
+        [("auth.json", True), ("sessions", True), ("state_5.sqlite", True), ("config.toml", False), ("plugins", False)],
+    )
+    def should_keep_every_entry_outside_the_shared_set_per_account(
+        self, entry_name: str, is_local: bool
+    ) -> None:
+        assert choice.is_account_local_codex_entry(entry_name) is is_local
+
+    def should_take_the_profiles_root_from_the_environment(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("CODEX_PROFILES_ROOT", str(tmp_path))
+        assert choice.default_profiles_root() == tmp_path
+
+    def should_default_the_profiles_root_under_the_user_home(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.delenv("CODEX_PROFILES_ROOT", raising=False)
+        assert choice.default_profiles_root() == Path.home() / ".codex-profiles"
+
+    def should_list_each_window_in_a_read_accounts_payload(self) -> None:
+        payload = choice.reading_payload(reading("codex-1", weekly_used=40.0, short_used=5.0))
+        assert payload["percent_left"] == 60.0
+        assert [each["minutes"] for each in payload["windows"]] == [300, 10080]

package/scripts/test_codex_account_meters.py

@@ -0,0 +1,205 @@
+"""Tests for the reader of one Codex account's rate-limit windows."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Mapping, Sequence
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+from codex_account_meters import (
+    CodexMeterUnreadError,
+    exchange_with_app_server,
+    parse_rate_limits_reply,
+    read_codex_meters,
+    request_messages,
+    resolve_codex_path,
+)
+
+RESET_SECONDS = 1790000000
+
+
+def reply_line(rate_limits: object) -> str:
+    return json.dumps(
+        {"jsonrpc": "2.0", "id": 2, "result": {"rateLimits": rate_limits}}
+    )
+
+
+class TestParseRateLimitsReply:
+    def should_measure_room_by_the_tightest_window(self) -> None:
+        meters = parse_rate_limits_reply(
+            reply_line(
+                {
+                    "primary": {
+                        "usedPercent": 30,
+                        "windowDurationMins": 300,
+                        "resetsAt": RESET_SECONDS,
+                    },
+                    "secondary": {
+                        "usedPercent": 85,
+                        "windowDurationMins": 10080,
+                        "resetsAt": RESET_SECONDS,
+                    },
+                }
+            )
+        )
+        assert meters.percent_left == 15.0
+        assert [each.duration_minutes for each in meters.all_windows] == [300, 10080]
+        assert meters.all_windows[0].resets_at == datetime.fromtimestamp(
+            RESET_SECONDS, tz=timezone.utc
+        )
+
+    def should_read_a_reply_with_one_window(self) -> None:
+        meters = parse_rate_limits_reply(
+            reply_line(
+                {
+                    "primary": None,
+                    "secondary": {"usedPercent": 40, "windowDurationMins": 10080},
+                }
+            )
+        )
+        assert meters.percent_left == 60.0
+
+    def should_clamp_used_percent_past_full(self) -> None:
+        meters = parse_rate_limits_reply(reply_line({"primary": {"usedPercent": 130}}))
+        assert meters.percent_left == 0.0
+
+    @pytest.mark.parametrize(
+        "line",
+        [
+            "not json",
+            json.dumps({"id": 2, "error": {"message": "not signed in"}}),
+            reply_line({"primary": None, "secondary": None}),
+            reply_line({"primary": {"usedPercent": "high"}}),
+            json.dumps({"id": 2, "result": {}}),
+        ],
+    )
+    def should_raise_unread_for_a_reply_without_a_usable_window(
+        self, line: str
+    ) -> None:
+        with pytest.raises(CodexMeterUnreadError):
+            parse_rate_limits_reply(line)
+
+
+class TestShortWindowPercentLeft:
+    def should_read_the_room_left_in_the_five_hour_window(self) -> None:
+        meters = parse_rate_limits_reply(
+            reply_line(
+                {
+                    "primary": {"usedPercent": 70, "windowDurationMins": 300},
+                    "secondary": {"usedPercent": 20, "windowDurationMins": 10080},
+                }
+            )
+        )
+        assert meters.short_window_percent_left == 30.0
+
+    def should_name_no_short_window_for_a_weekly_only_account(self) -> None:
+        meters = parse_rate_limits_reply(
+            reply_line({"secondary": {"usedPercent": 20, "windowDurationMins": 10080}})
+        )
+        assert meters.short_window_percent_left is None
+
+
+class TestBlockingReset:
+    def should_name_when_the_last_blocking_window_resets(self) -> None:
+        meters = parse_rate_limits_reply(
+            reply_line(
+                {
+                    "primary": {"usedPercent": 95, "resetsAt": RESET_SECONDS},
+                    "secondary": {"usedPercent": 99, "resetsAt": RESET_SECONDS + 3600},
+                }
+            )
+        )
+        assert meters.resets_before_room(10.0) == datetime.fromtimestamp(
+            RESET_SECONDS + 3600, tz=timezone.utc
+        )
+
+
+class TestReadCodexMeters:
+    def should_send_the_handshake_then_the_read_under_the_home(self) -> None:
+        all_calls: list[tuple[Path, Path, list[str]]] = []
+
+        def fake_exchange(
+            codex_path: Path,
+            codex_home: Path,
+            all_messages: Sequence[Mapping[str, object]],
+        ) -> list[str]:
+            all_calls.append(
+                (
+                    codex_path,
+                    codex_home,
+                    [str(each.get("method")) for each in all_messages],
+                )
+            )
+            return [
+                json.dumps({"id": 1, "result": {}}),
+                reply_line({"primary": {"usedPercent": 20}}),
+            ]
+
+        meters = read_codex_meters(Path("codex"), Path("profiles") / "codex-1", fake_exchange)
+        assert meters.percent_left == 80.0
+        assert all_calls == [
+            (
+                Path("codex"),
+                Path("profiles") / "codex-1",
+                ["initialize", "initialized", "account/rateLimits/read"],
+            )
+        ]
+
+    def should_raise_unread_when_the_server_never_answers(self) -> None:
+        with pytest.raises(CodexMeterUnreadError):
+            read_codex_meters(
+                Path("codex"), Path("/h"), lambda *_: [json.dumps({"id": 1})]
+            )
+
+    def should_raise_unread_when_the_server_cannot_start(self) -> None:
+        def broken_exchange(*_: object) -> list[str]:
+            raise FileNotFoundError("codex")
+
+        with pytest.raises(CodexMeterUnreadError):
+            read_codex_meters(Path("codex"), Path("/h"), broken_exchange)
+
+
+FAKE_APP_SERVER = """#!/usr/bin/env python3
+import json, os, sys
+for line in sys.stdin:
+    message = json.loads(line)
+    if message.get("id") == 2:
+        used = 12 if os.environ.get("CODEX_HOME", "").endswith("codex-2") else 99
+        print(json.dumps({"id": 2, "result": {"rateLimits": {"primary": {"usedPercent": used}}}}), flush=True)
+"""
+
+
+class TestExchangeWithAppServer:
+    @pytest.mark.skipif(os.name == "nt", reason="the fake server runs through a shebang")
+    def should_read_the_reply_while_input_stays_open(self, tmp_path: Path) -> None:
+        fake_codex = tmp_path / "codex"
+        fake_codex.write_text(FAKE_APP_SERVER)
+        fake_codex.chmod(0o755)
+
+        meters = read_codex_meters(fake_codex, tmp_path / "codex-2", exchange_with_app_server)
+
+        assert meters.percent_left == 88.0
+
+
+class TestRequestMessages:
+    def should_ask_for_rate_limits_after_the_handshake(self) -> None:
+        all_messages = request_messages()
+        assert [each.get("id") for each in all_messages] == [1, None, 2]
+        assert all_messages[2]["method"] == "account/rateLimits/read"
+
+
+class TestResolveCodexPath:
+    def should_use_the_named_path(self, tmp_path: Path) -> None:
+        assert resolve_codex_path(tmp_path / "codex.exe") == tmp_path / "codex.exe"
+
+    def should_raise_when_no_codex_is_found(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("PATH", "")
+        monkeypatch.setattr(Path, "home", lambda: tmp_path)
+        with pytest.raises(FileNotFoundError):
+            resolve_codex_path(None)

package/scripts/tests/test_automatic_advisory.py

@@ -172,7 +172,7 @@ def _build_registration(tmp_path: Path, checkout_path: Path) -> AdvisoryRegistra
         encoding="utf-8",
     )
     return AdvisoryRegistration(
-        RepositorySettings("JonEcho/python-automation", "unused"),
+        RepositorySettings("example-owner/example-repo", "unused"),
         2985,
         checkout_path,
         PurePosixPath("manifest.json"),
@@ -185,7 +185,7 @@ def _build_registration(tmp_path: Path, checkout_path: Path) -> AdvisoryRegistra
 
 def _build_candidate(head_sha: str, merge_sha: str = "unused") -> PullRequestCandidate:
     return PullRequestCandidate(
-        "JonEcho/python-automation",
+        "example-owner/example-repo",
         2985,
         "main",
         head_sha,
@@ -291,7 +291,7 @@ def _publish_recorded(
 ) -> FakePublication:
     all_events.append("publish")
     assert github_client is github
-    assert repository.slug == "JonEcho/python-automation"
+    assert repository.slug == "example-owner/example-repo"
     assert pull_request_number == 2985
     assert checkout.is_dir()
     assert manifest.is_file()

package/scripts/tests/test_automatic_advisory_polling.py

@@ -28,7 +28,7 @@ class _CycleFailsOnceRunner:
             raise self.cycle_error
         return (
             AdvisoryState(
-                "JonEcho/python-automation",
+                "example-owner/example-repo",
                 3087,
                 "passed",
                 "unchanged remote head and base",

package/scripts/tests/test_automatic_advisory_recovery.py

@@ -271,7 +271,7 @@ def test_start_polling_returns_without_waiting_for_detached_process(
 def test_configuration_rejects_two_pairs_for_one_repository(tmp_path: Path) -> None:
     settings_path = tmp_path / "settings.json"
     registration = {
-        "repository": "JonEcho/python-automation",
+        "repository": "example-owner/example-repo",
         "pull_request": 2985,
         "app_id": 4841271,
         "installation_id": 159293880,

package/scripts/tests/test_closed_pr_label.py

@@ -47,7 +47,7 @@ class ClosedPullRequestGitHub(AdvisoryGitHub):
 
 def _build_registration(tmp_path: Path) -> AdvisoryRegistration:
     return AdvisoryRegistration(
-        RepositorySettings("JonEcho/python-automation", "unused"),
+        RepositorySettings("example-owner/example-repo", "unused"),
         3082,
         tmp_path / "checkout",
         PurePosixPath("manifest.json"),

package/scripts/tests/test_private_term_scan.py

@@ -162,6 +162,34 @@ def test_should_flag_a_commit_message_and_a_commit_identity(tmp_path: Path) -> N
     assert all("acme" not in each_finding.lower() for each_finding in all_findings)
 
 
+def test_should_skip_a_github_noreply_address_in_a_commit_identity(
+    tmp_path: Path,
+) -> None:
+    repository_root, base, head = _repository_with_commits(
+        tmp_path,
+        [
+            ("fix: clean change", "Pat", "81234567+acmewidget@users.noreply.github.com"),
+            ("chore: clean", *_CLEAN_IDENTITY),
+        ],
+    )
+    assert private_term_scan.scan_commits(repository_root, f"{base}..{head}") == []
+
+
+def test_should_flag_a_private_name_beside_a_github_noreply_address(
+    tmp_path: Path,
+) -> None:
+    repository_root, base, head = _repository_with_commits(
+        tmp_path,
+        [
+            ("fix: clean change", "Acme Widget", "81234567+pat@users.noreply.github.com"),
+            ("chore: clean", *_CLEAN_IDENTITY),
+        ],
+    )
+    all_findings = private_term_scan.scan_commits(repository_root, f"{base}..{head}")
+    assert len(all_findings) == 1
+    assert " identity:" in all_findings[0]
+
+
 def test_should_print_findings_and_fail_from_the_command_line(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:

package/scripts/tests/test_review_closure.py

@@ -60,12 +60,12 @@ def stub_reads(
 
 def should_build_a_parser_that_collects_extra_driver_logins() -> None:
     parsed = command.build_parser().parse_args(
-        [SLUG, "7", "--driver-login", "JonEcho", "--driver-login", "claude[bot]"]
+        [SLUG, "7", "--driver-login", "octocat", "--driver-login", "claude[bot]"]
     )
 
     assert parsed.slug == SLUG
     assert parsed.number == 7
-    assert parsed.driver_login == ["JonEcho", "claude[bot]"]
+    assert parsed.driver_login == ["octocat", "claude[bot]"]
 
 
 def should_report_an_unanswered_finding(monkeypatch: pytest.MonkeyPatch) -> None:

package/scripts/tests/test_review_closure_model.py

@@ -236,9 +236,9 @@ def should_count_the_pull_request_author_as_the_driving_agent() -> None:
 
 
 def should_add_each_login_named_on_the_command_line() -> None:
-    all_logins = model.driver_logins({"user": {"login": "claude[bot]"}}, ["JonEcho"])
+    all_logins = model.driver_logins({"user": {"login": "claude[bot]"}}, ["octocat"])
 
-    assert all_logins == frozenset({"claude[bot]", "JonEcho"})
+    assert all_logins == frozenset({"claude[bot]", "octocat"})
 
 
 def should_read_the_head_commit_from_the_pull_request() -> None: