claude-multiacc 2.0.61 → 2.0.65

package/tests/fake_codex_tui.py

@@ -51,6 +51,27 @@ def initialize_rollout():
     return rollout
 
 
+def require_resume_cwd():
+    if os.environ.get("FAKE_REQUIRE_RESUME_CWD") != "1" or "resume" not in sys.argv:
+        return
+    path = Path(os.environ["CODEX_HOME"]) / "sessions/2026/10/10"
+    path /= "rollout-test-" + os.environ["FAKE_SID"] + ".jsonl"
+    saved = None
+    for line in path.read_text().splitlines():
+        row = json.loads(line)
+        payload = row.get("payload", {})
+        if row.get("type") in ("session_meta", "turn_context"):
+            saved = payload.get("cwd", saved)
+        elif row.get("type") == "event_msg" and payload.get("type") == "thread_settings_applied":
+            saved = payload.get("thread_settings", {}).get("cwd", saved)
+    matches = saved is None or os.path.realpath(saved) == os.getcwd()
+    record("resume-cwd", saved=saved, matches=matches)
+    if not matches:
+        print("Working directory · resume\n› 1. Use session directory\n  2. Use current directory", flush=True)
+        while True:
+            time.sleep(0.1)
+
+
 def require_resume_trust():
     if os.environ.get("FAKE_REQUIRE_TRUST") != "1" or "resume" not in sys.argv:
         return
@@ -67,7 +88,7 @@ def require_resume_trust():
         table = re.escape(json.dumps(os.getcwd()))
         trusted = re.search(r'^\s*\[projects\.' + table + r'\]\s*\n(?:(?!\s*\[).*\n)*?\s*trust_level\s*=\s*"trusted"',
                             text, re.M) is not None
-    record("trust", trusted=trusted)
+    record("trust", trusted=trusted, cwd=os.getcwd())
     if not trusted:
         print("Folder access\nTrust this folder?\n› 1. Trust and continue\n  2. Quit", flush=True)
         while True:
@@ -85,6 +106,7 @@ def main():
     settings = termios.tcgetattr(0)
     signal.signal(signal.SIGTERM, stop)
     signal.signal(signal.SIGHUP, stop)
+    require_resume_cwd()
     require_resume_trust()
     rollout = initialize_rollout()
     try:

package/tests/run-tests.sh

@@ -2632,16 +2632,27 @@ regB="$(claude-accounts list 2>&1 | grep par2@test | awk '{print $1}')"
 [ -n "$regB" ] && claude-accounts remove "$regB" --yes >/dev/null 2>&1
 
 # ---- 15h. two parallel adds signing into the SAME email: exactly one wins ------------
+if python3 "$REPO_DIR/tests/test_mutate_lock.py"; then
+  t_ok "mutation lock: missing-stat race preserves the replacement owner"
+else
+  t_fail "mutation lock ownership suite" "see unittest output above"
+fi
 ( CLAUDE_MULTIACC_FORCE_TTY=1 FAKE_EMAIL=same@test claude-accounts add >"$WORK/s1.out" 2>&1 ) &
 sA=$!
 ( CLAUDE_MULTIACC_FORCE_TTY=1 FAKE_EMAIL=same@test claude-accounts add >"$WORK/s2.out" 2>&1 ) &
 sB=$!
-wait "$sA"; wait "$sB"
+sArc=0; sBrc=0
+wait "$sA" || sArc=$?
+wait "$sB" || sBrc=$?
+both="$(cat "$WORK/s1.out" "$WORK/s2.out" 2>/dev/null)"
+[ "$sArc:$sBrc" = "0:0" ] && t_ok "same-email parallel add: both callers succeed" \
+  || t_fail "same-email parallel add exit status" "first=$sArc second=$sBrc; $both"
 n="$(claude-accounts list 2>&1 | grep -c same@test)"
 [ "$n" = "1" ] && t_ok "same-email parallel add: exactly one registered (other skipped)" \
   || t_fail "same-email parallel add" "count=$n (expected 1)"
-cat "$WORK/s1.out" "$WORK/s2.out" 2>/dev/null | grep -q "already added as\|skipping" \
-  && t_ok "same-email parallel add: loser skipped gracefully" || t_fail "same-email skip msg" "no skip message"
+grep -qE "already added as|skipping" "$WORK/s1.out" "$WORK/s2.out" \
+  && t_ok "same-email parallel add: loser skipped gracefully" \
+  || t_fail "same-email skip msg" "first=$sArc second=$sBrc; no skip message in: $both"
 regS="$(claude-accounts list 2>&1 | grep same@test | awk '{print $1}')"
 [ -n "$regS" ] && claude-accounts remove "$regS" --yes >/dev/null 2>&1
 
@@ -7797,18 +7808,23 @@ fi
 
 # two parallel imports get distinct ids and both land in the manifest (lock coverage;
 # codex-review finding)
-codex-accounts import p1@cx --no-sync >/dev/null 2>&1 &
+codex-accounts import p1@cx --no-sync >"$WORK/cx-import1.out" 2>&1 &
 imp1=$!
-codex-accounts import p2@cx --no-sync >/dev/null 2>&1 &
+codex-accounts import p2@cx --no-sync >"$WORK/cx-import2.out" 2>&1 &
 imp2=$!
-wait "$imp1"; wait "$imp2"
+imp1rc=0; imp2rc=0
+wait "$imp1" || imp1rc=$?
+wait "$imp2" || imp2rc=$?
+both="$(cat "$WORK/cx-import1.out" "$WORK/cx-import2.out" 2>/dev/null)"
+[ "$imp1rc:$imp2rc" = "0:0" ] && t_ok "codex: both parallel import callers succeed" \
+  || t_fail "codex parallel import exit status" "first=$imp1rc second=$imp2rc; $both"
 n1="$(grep -c '"email": "p1@cx"' "$CX/accounts.json")"
 n2="$(grep -c '"email": "p2@cx"' "$CX/accounts.json")"
 id1="$(python3 -c "import json,sys; print(next((a['id'] for a in json.load(open('$CX/accounts.json'))['accounts'] if a['email']=='p1@cx'), ''))")"
 id2="$(python3 -c "import json,sys; print(next((a['id'] for a in json.load(open('$CX/accounts.json'))['accounts'] if a['email']=='p2@cx'), ''))")"
 { [ "$n1" = "1" ] && [ "$n2" = "1" ] && [ -n "$id1" ] && [ -n "$id2" ] && [ "$id1" != "$id2" ]; } \
   && t_ok "codex: parallel imports get distinct ids ($id1, $id2)" \
-  || t_fail "codex parallel import" "p1=$n1($id1) p2=$n2($id2)"
+  || t_fail "codex parallel import" "p1=$n1($id1) p2=$n2($id2); first=$imp1rc second=$imp2rc; $both"
 codex-accounts remove "$id1" --yes >/dev/null 2>&1
 codex-accounts remove "$id2" --yes >/dev/null 2>&1
 

package/tests/test_autoresume_cwd.py

@@ -0,0 +1,71 @@
+"""Account rotation restores the bound Codex session's last working directory."""
+
+import unittest
+
+import test_autoresume as fixtures
+
+
+class CodexResumeDirectoryTests(unittest.TestCase):
+    def setUp(self):
+        self.pool = fixtures.CodexWatcherTests(methodName="runTest")
+        self.pool.setUp()
+        self.addCleanup(self.pool.tearDown)
+        self.saved = self.pool.tmp / "saved project ü"
+        self.saved.mkdir()
+
+    def restart(self, records, expected, setup=None):
+        pool = self.pool
+        records.append(fixtures.cx_error(pool.t0, "usage_limit_exceeded"))
+        result, _, runner, _ = pool.run_codex(["resume", fixtures.CX_SID], records, setup=setup)
+        self.assertEqual(result, 0)
+        fields, argv = pool.relaunch_of(runner)
+        self.assertEqual(fields["cwd"], str(expected))
+        self.assertEqual(runner.probes[0]["cwd"], str(expected))
+        self.assertEqual(argv[-2], fixtures.CX_SID)
+        self.assertEqual(pool.events(), ["watch", "detect", "switch"])
+
+    def test_recorded_session_directory_wins_over_launch_directory(self):
+        self.restart([fixtures.cx_meta(self.pool.launched - 100, cwd=str(self.saved))], self.saved)
+
+    def test_latest_turn_directory_wins_over_initial_session_directory(self):
+        self.restart([fixtures.cx_meta(self.pool.launched - 100, cwd=str(self.pool.work)),
+                      {"type": "turn_context", "payload": {"cwd": str(self.saved)}}], self.saved)
+
+    def test_latest_own_thread_settings_win_without_a_new_turn(self):
+        settings = {"type": "thread_settings_applied", "thread_id": fixtures.CX_SID,
+                    "thread_settings": {"cwd": str(self.saved)}}
+        self.restart([fixtures.cx_meta(self.pool.launched - 100, cwd=str(self.pool.work)),
+                      {"type": "turn_context", "payload": {"cwd": str(self.pool.work)}},
+                      fixtures.cx_event(self.pool.t0 - 1, settings)], self.saved)
+
+    def test_foreign_thread_settings_and_tool_workdirs_do_not_change_directory(self):
+        foreign = {"type": "thread_settings_applied", "thread_id": fixtures.CX_SID2,
+                   "thread_settings": {"cwd": str(self.pool.work)}}
+        tool = {"type": "response_item", "payload": {"type": "function_call", "name": "exec_command",
+                "arguments": '{"workdir":"/tmp","cmd":"pwd"}'}}
+        self.restart([fixtures.cx_meta(self.pool.launched - 100, cwd=str(self.saved)),
+                      fixtures.cx_event(self.pool.t0 - 1, foreign), tool], self.saved)
+
+    def test_invalid_saved_values_keep_last_valid_directory(self):
+        invalid = [None, 7, {}, "relative/project", "/tmp\nnot-a-directory", "/tmp\0bad"]
+        records = [fixtures.cx_meta(self.pool.launched - 100, cwd=str(self.saved))]
+        records.extend({"type": "turn_context", "payload": {"cwd": value}} for value in invalid)
+        self.restart(records, self.saved)
+
+    def test_deleted_saved_directory_falls_back_to_existing_launch_directory(self):
+        self.restart([fixtures.cx_meta(self.pool.launched - 100, cwd=str(self.saved / "deleted"))],
+                     self.pool.work)
+
+    def test_relaunch_cursor_does_not_hide_the_saved_directory(self):
+        def setup(watcher, runner, path):
+            info = path.stat()
+            watcher.st["rollout_cursor"] = "%d:%d" % (info.st_ino, info.st_size)
+            runner.at(self.pool.t0 + 1, lambda: fixtures.append(path, [
+                fixtures.cx_error(self.pool.t0 + 1, "usage_limit_exceeded")]))
+
+        self.restart([fixtures.cx_meta(self.pool.launched - 100, cwd=str(self.pool.work)),
+                      {"type": "turn_context", "payload": {"cwd": str(self.saved)}}], self.saved, setup=setup)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_cwd_handoff.py

@@ -0,0 +1,92 @@
+"""A Codex handoff binds the saved directory and history to one validated snapshot."""
+
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest import mock
+
+import test_autoresume as fixtures
+from autoresume_cross_unit_support import scenario
+import autoresume_cross as cross
+import autoresume_handoff as handoff
+
+
+class CodexDirectoryHandoffTests(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory(prefix="ar-cwd-handoff-")
+        self.addCleanup(temporary.cleanup)
+        self.home = Path(temporary.name).resolve()
+        self.initial = self.home / "initial"
+        self.saved = self.home / "saved project"
+        self.initial.mkdir()
+        self.saved.mkdir()
+        self.path = self.home / ("rollout-test-" + fixtures.CX_SID + ".jsonl")
+        self.meta = fixtures.cx_meta(1000, cwd=str(self.initial))
+
+    def write(self, records):
+        self.path.write_text("".join(json.dumps(row) + "\n" for row in [self.meta] + records))
+
+    def validate(self, cwd=None):
+        return handoff.validate_source("codex", fixtures.CX_SID, str(self.path), str(cwd or self.saved))
+
+    def test_changed_directory_from_turn_or_settings_replaces_initial_directory(self):
+        turn = {"type": "turn_context", "payload": {"cwd": str(self.saved)}}
+        settings = fixtures.cx_event(1001, {"type": "thread_settings_applied", "thread_id": fixtures.CX_SID,
+                                            "thread_settings": {"cwd": str(self.saved)}})
+        for record in (turn, settings):
+            with self.subTest(kind=record["type"]):
+                self.write([record])
+                history = self.validate()
+                self.assertEqual(history["cwd"], str(self.saved))
+                self.assertEqual(history["offset"], self.path.stat().st_size)
+                self.assertIsNone(self.validate(self.initial))
+
+    def test_foreign_settings_cannot_authorize_unrelated_directory(self):
+        settings = fixtures.cx_event(1001, {"type": "thread_settings_applied", "thread_id": fixtures.CX_SID2,
+                                            "thread_settings": {"cwd": str(self.saved)}})
+        self.write([settings])
+        self.assertIsNone(self.validate())
+        self.assertIsNotNone(self.validate(self.initial))
+
+    def test_saved_directory_after_large_history_is_read_beyond_initial_prefix(self):
+        self.write([{"type": "response_item", "payload": {"text": "x" * handoff.MAX_SOURCE_BYTES}},
+                    {"type": "turn_context", "payload": {"cwd": str(self.saved)}}])
+        self.assertEqual(self.validate()["cwd"], str(self.saved))
+
+    def test_appended_settings_after_snapshot_do_not_change_snapshot_directory(self):
+        self.write([{ "type": "turn_context", "payload": {"cwd": str(self.saved)}}])
+        offset = self.path.stat().st_size
+        original = handoff.codex_resume_cwd
+        later = {"type": "turn_context", "payload": {"cwd": str(self.initial)}}
+        with mock.patch.object(handoff, "codex_resume_cwd", side_effect=lambda *args, **kwargs: (
+                fixtures.append(self.path, [later]), original(*args, **kwargs))[1]):
+            history = self.validate()
+        self.assertEqual((history["cwd"], history["offset"]), (str(self.saved), offset))
+        self.assertIsNone(self.validate())
+
+    def test_replacement_during_directory_read_is_rejected(self):
+        self.write([{"type": "turn_context", "payload": {"cwd": str(self.saved)}}])
+        replacement = self.path.with_suffix(".replacement")
+        replacement.write_bytes(self.path.read_bytes())
+        original = handoff.codex_resume_cwd
+        with mock.patch.object(handoff, "codex_resume_cwd", side_effect=lambda *args, **kwargs: (
+                replacement.replace(self.path), original(*args, **kwargs))[1]):
+            self.assertIsNone(self.validate())
+
+    def test_cross_provider_plan_probes_in_latest_saved_directory(self):
+        case, watcher, runner, history, _ = scenario(self, "codex")
+        saved = case.tmp / "saved project"
+        saved.mkdir()
+        fixtures.append(history, [{"type": "turn_context", "payload": {"cwd": str(saved)}}])
+        plan = cross.plan_fallback(watcher, watcher.tracker.pending, "")
+        self.assertIsNotNone(plan)
+        self.assertEqual(plan["history"]["cwd"], str(saved))
+        self.assertEqual(runner.target_probes[-1]["cwd"], str(saved))
+        self.assertTrue(cross.revalidate(watcher, plan))
+        fixtures.append(history, [{"type": "turn_context", "payload": {"cwd": str(case.work)}}])
+        self.assertFalse(cross.revalidate(watcher, plan))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_cwd_reader.py

@@ -0,0 +1,105 @@
+"""Read only a bound Codex thread's saved cwd, even across chunk and restart boundaries."""
+
+import json
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "lib"))
+from codex_resume_cwd import codex_resume_cwd  # noqa: E402
+import session_settings  # noqa: E402
+
+SID = "01a13956-95c9-7d41-9a8b-b3e5ff79d3b2"
+OTHER = "0aaaaaaa-0000-7000-8000-000000000000"
+
+
+def line(kind, **payload):
+    return json.dumps({"type": kind, "payload": payload}, ensure_ascii=False)
+
+
+class CodexCwdReaderTests(unittest.TestCase):
+    def setUp(self):
+        directory = tempfile.TemporaryDirectory(prefix="codex-cwd-reader-")
+        self.addCleanup(directory.cleanup)
+        self.path = Path(directory.name) / "rollout.jsonl"
+        self.meta = line("session_meta", id=SID, cwd="/initial project")
+
+    def write(self, records):
+        self.path.write_text("\n".join(records) + "\n", encoding="utf-8")
+        return self.path
+
+    def test_bound_id_is_checked_before_any_saved_context(self):
+        path = self.write([self.meta, line("turn_context", cwd="/latest")])
+        self.assertEqual(codex_resume_cwd(path, SID), "/latest")
+        self.assertEqual(codex_resume_cwd(path), "/latest")
+        self.assertIsNone(codex_resume_cwd(path, OTHER))
+        boundary = path.stat().st_size
+        with path.open("a", encoding="utf-8") as output:
+            output.write(line("turn_context", cwd="/after-snapshot") + "\n")
+        self.assertEqual(codex_resume_cwd(path, SID), "/after-snapshot")
+        self.assertEqual(codex_resume_cwd(path, SID, upto=boundary), "/latest")
+
+    def test_missing_or_unreadable_history_has_no_directory(self):
+        for path in (None, self.path, self.path.parent):
+            with self.subTest(path=path):
+                self.assertIsNone(codex_resume_cwd(path, SID))
+        self.write([self.meta])
+        with mock.patch("builtins.open", side_effect=PermissionError("denied")):
+            self.assertIsNone(codex_resume_cwd(self.path, SID))
+
+    def test_invalid_metadata_cannot_bind_a_later_context(self):
+        bad = ["{", "[]", "null", json.dumps({"type": "session_meta", "payload": []}),
+               line("session_meta", id=None, cwd="/initial"),
+               line("turn_context", id=SID, cwd="/initial")]
+        for first in bad:
+            with self.subTest(first=first):
+                path = self.write([first, line("turn_context", cwd="/latest")])
+                self.assertIsNone(codex_resume_cwd(path, SID))
+
+    def test_malformed_and_invalid_later_records_preserve_last_valid_cwd(self):
+        bad = ["{", '[]', '{"payload":{"cwd":',
+               json.dumps({"type": "turn_context", "payload": None}),
+               line("event_msg", type="thread_settings_applied", thread_settings=[])]
+        bad.extend(line("turn_context", cwd=value)
+                   for value in (None, 7, {}, "relative", "/bad\npath", "/bad\rpath", "/bad\0path"))
+        path = self.write([self.meta, line("turn_context", cwd="/saved ü")] + bad)
+        self.assertEqual(codex_resume_cwd(path, SID), "/saved ü")
+
+    def test_foreign_settings_and_subagent_context_do_not_change_main_cwd(self):
+        path = self.write([
+            self.meta,
+            line("event_msg", type="thread_settings_applied", thread_id=OTHER,
+                 thread_settings={"cwd": "/foreign"}),
+            line("turn_context", thread_id=OTHER, cwd="/foreign-context"),
+            line("turn_context", turn_id="child", root_turn_id="parent", cwd="/subagent"),
+            line("response_item", type="function_call", cwd="/tool", arguments='{"cwd":"/quoted"}'),
+            line("session_meta", id=OTHER, cwd="/copied-parent"),
+        ])
+        self.assertEqual(codex_resume_cwd(path, SID), "/initial project")
+
+    def test_reverse_chunks_reassemble_long_records_and_keep_latest_settings(self):
+        saved = "/saved " + "é" * 200
+        path = self.write([
+            self.meta, line("turn_context", cwd="/older"),
+            line("event_msg", type="thread_settings_applied", thread_id=SID,
+                 thread_settings={"cwd": saved}),
+            line("response_item", type="message", text="padding" * 100),
+        ])
+        with mock.patch.object(session_settings, "CHUNK", 127):
+            self.assertEqual(codex_resume_cwd(path, SID), saved)
+
+    def test_initial_metadata_remains_fallback_beyond_reverse_scan_limit(self):
+        large_meta = line("session_meta", id=SID, cwd="/initial project", base_instructions="x" * (1 << 20))
+        path = self.write([large_meta, line("session_meta", id=OTHER, cwd="/copied-parent"),
+                           line("response_item", type="message", text="padding" * 100)])
+        self.assertEqual(codex_resume_cwd(path, SID), "/initial project")
+        with mock.patch.object(session_settings, "CHUNK", 128), \
+                mock.patch.object(session_settings, "SCAN_LIMIT", 128):
+            self.assertEqual(codex_resume_cwd(path, SID), "/initial project")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_cwd_tmux.py

@@ -0,0 +1,54 @@
+"""A quota restart restores the saved directory before Codex checks directory and trust."""
+
+import json
+import time
+import unittest
+
+from autoresume_tmux_support import SID, TMUX, TmuxScenario
+
+QUOTA = {"type": "task_complete", "error": {"message": "You've hit your usage limit.",
+                                           "codex_error_info": "usage_limit_exceeded"}}
+
+
+@unittest.skipUnless(TMUX, "real tmux is unavailable")
+class CodexCwdTmuxTests(unittest.TestCase):
+    def test_quota_restart_restores_latest_directory_before_trust_and_prompt(self):
+        self.check_restart("turn_context")
+
+    def test_settings_change_restores_directory_before_the_next_turn(self):
+        self.check_restart("thread_settings_applied")
+
+    def check_restart(self, record_type):
+        case = TmuxScenario(FAKE_REQUIRE_RESUME_CWD="1", FAKE_REQUIRE_TRUST="1")
+        self.addCleanup(case.close)
+        saved = case.home / "saved project Ω"
+        saved.mkdir()
+        source = case.pool / "acct-01/config.toml"
+        target = case.pool / "acct-02/config.toml"
+        source.write_text("# The original account stays unchanged.\n")
+        case.start()
+        context = {"timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                   "type": "turn_context", "payload": {"cwd": str(saved)}}
+        if record_type == "thread_settings_applied":
+            context.update(type="event_msg", payload={"type": record_type, "thread_id": SID,
+                                                     "thread_settings": {"cwd": str(saved)}})
+        with case.rollout.open("a") as stream:
+            stream.write(json.dumps(context) + "\n")
+        case.append(QUOTA)
+        case.wait(lambda: "autoresume switch" in case.log.read_text(), "restart in saved directory confirmed")
+        first, second = case.records("launch")
+        self.assertEqual([first["cwd"], second["cwd"]], [str(case.work), str(saved)])
+        self.assertEqual([first["account"], second["account"]], ["acct-01", "acct-02"])
+        self.assertIn(SID, second["argv"])
+        self.assertEqual([row["matches"] for row in case.records("resume-cwd")], [True])
+        self.assertEqual([(row["trusted"], row["cwd"]) for row in case.records("trust")], [(True, str(saved))])
+        self.assertIn('[projects.' + json.dumps(str(saved), ensure_ascii=False) + ']', target.read_text())
+        self.assertNotIn(str(case.work), target.read_text())
+        self.assertEqual(source.read_text(), "# The original account stays unchanged.\n")
+        self.assertEqual(len(case.records("prompt")), 1)
+        self.assertEqual(case.log.read_text().count("autoresume switch"), 1)
+        self.assertEqual(case.records("keys"), [], "neither TUI receives a keystroke")
+
+
+if __name__ == "__main__":
+    unittest.main()