claude-multiacc 2.0.61 → 2.0.64

package/lib/codex_resume_cwd.py

@@ -0,0 +1,57 @@
+"""Recover Codex's saved working directory from its bound main-thread rollout."""
+
+import os
+
+from session_settings import _record, _reverse_lines
+
+
+def _directory(value):
+    if isinstance(value, str) and os.path.isabs(value) and not any(c in value for c in "\0\n\r"):
+        return value
+    return None
+
+
+def _record_cwd(doc, own):
+    payload = doc.get("payload") if doc else None
+    if not isinstance(payload, dict) or payload.get("thread_id") not in (None, own):
+        return None
+    if doc.get("type") == "turn_context":
+        turn, root = payload.get("turn_id"), payload.get("root_turn_id")
+        if turn and root and turn != root:
+            return None
+        return _directory(payload.get("cwd"))
+    if doc.get("type") == "event_msg" and payload.get("type") == "thread_settings_applied":
+        settings = payload.get("thread_settings")
+        return _directory(settings.get("cwd")) if isinstance(settings, dict) else None
+    return None
+
+
+def codex_resume_cwd(path, sid=None, upto=None):
+    """Latest saved main-thread cwd, then its initial cwd; unknown/unreadable gives None.
+
+    Match the native resume picker: a settings change can update cwd before the next
+    turn_context. Read independently of the watcher's quota cursor so chained restarts
+    still recover settings written before that cursor. Only the first metadata record
+    identifies this thread; a fork can contain its parent's metadata later in the file.
+    ``upto`` bounds history to a validated handoff snapshot's byte boundary.
+    """
+    if not path:
+        return None
+    try:
+        with open(path, "rb") as fh:
+            meta = _record(fh.readline(4 << 20))
+        payload = meta.get("payload") if meta and meta.get("type") == "session_meta" else None
+        if not isinstance(payload, dict) or not isinstance(payload.get("id"), str):
+            return None
+        own = payload["id"]
+        if sid is not None and sid != own:
+            return None
+        for line in _reverse_lines(path, upto):
+            if b'"cwd"' not in line:
+                continue
+            directory = _record_cwd(_record(line), own)
+            if directory is not None:
+                return directory
+        return _directory(payload.get("cwd"))
+    except (OSError, ValueError):
+        return None

package/lib/codex_retry_process.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# Sourced only by the buffered exec retry path. The caller keeps prompt input on fd 3
+# and owns stdout/stderr redirections and its EXIT cleanup; this helper preserves them.
+
+codex_retry_signal() {
+  codex_retry_pending_signal="$1"
+  codex_retry_signal_status="$2"
+  # A signal can arrive between installing the traps and assigning the async PID.
+  # Remember it; codex_retry_run delivers it as soon as the owned PID is known.
+  [ -n "$codex_retry_child_pid" ] || return 0
+  trap '' TERM INT HUP
+  kill -s "$codex_retry_pending_signal" "$codex_retry_child_pid" 2>/dev/null || true
+  wait "$codex_retry_child_pid" 2>/dev/null || true
+  codex_retry_child_pid=""
+  exit "$codex_retry_signal_status"
+}
+
+codex_retry_run() {
+  local codex_retry_child_pid="" codex_retry_pending_signal="" codex_retry_signal_status=0
+  local codex_retry_previous_traps rc
+  codex_retry_previous_traps="$(trap -p TERM INT HUP)"
+  trap 'codex_retry_signal TERM 143' TERM
+  trap 'codex_retry_signal INT 130' INT
+  trap 'codex_retry_signal HUP 129' HUP
+  [ -z "$codex_retry_pending_signal" ] || exit "$codex_retry_signal_status"
+  "$@" <&3 &
+  codex_retry_child_pid=$!
+  if [ -n "$codex_retry_pending_signal" ]; then
+    codex_retry_signal "$codex_retry_pending_signal" "$codex_retry_signal_status"
+  fi
+  if wait "$codex_retry_child_pid"; then rc=0; else rc=$?; fi
+  codex_retry_child_pid=""
+  trap - TERM INT HUP
+  # trap -p emits shell-quoted definitions from this process, never fetched input.
+  eval "$codex_retry_previous_traps"
+  return "$rc"
+}

package/lib/common.sh

@@ -30,6 +30,8 @@ DEFAULT_SERVER="root@138.197.36.107"
 DEFAULT_SERVER_REPO="/root/claude-multiacc"
 
 LIB_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd -P)"
+codex_mcp_oauth_ensure() { :; }
+if [ -f "$LIB_DIR/codex_mcp_oauth.sh" ]; then . "$LIB_DIR/codex_mcp_oauth.sh"; fi
 
 # INSTANCE-SCOPED POOLS: <PROVIDER>_ACCOUNTS_ROOT relocates the whole pool, so
 # several app-robot instances on one machine/user keep completely isolated account
@@ -806,6 +808,7 @@ seed_account_dir() { # $1 = acct dir
     fi
     codex_share_state_index "$d"
     seed_mcp_registry "$d"
+    codex_mcp_oauth_ensure "$ACC_ROOT" "$PYBIN" "$LIB_DIR/codex_mcp_oauth.py" "$d"
     return 0
   fi
   if [ ! -f "$d/.claude.json" ] && [ -f "$HOME/.claude.json" ]; then

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.61",
+  "version": "2.0.64",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {
@@ -56,11 +56,16 @@
   "scripts": {
     "postinstall": "node scripts/postinstall.mjs",
     "test": "npm run test:core && npm run test:seeding && npm run test:commands",
-    "test:core": "bash tests/run-tests.sh && npm run test:selector && python3 tests/test_shim_path.py",
+    "test:core": "bash tests/run-tests.sh && npm run test:selector && npm run test:shim",
+    "test:shim": "python3 tests/test_shim_path.py && npm run test:codex-stdin",
+    "test:codex-stdin": "python3 tests/test_codex_exec_stdin.py && python3 tests/test_codex_retry_process.py",
     "test:selector": "python3 -m unittest discover -s tests -p 'test_selector*.py'",
-    "test:seeding": "python3 tests/test_account_seeding.py && python3 tests/test_claude_pool_prepare.py && python3 -m unittest discover -s tests -p 'test_mcp_*.py' && npm run test:codex-settings",
+    "test:seeding": "npm run test:account-seeding && npm run test:mcp && npm run test:codex-settings",
     "test:codex-settings": "python3 tests/test_codex_config_edit.py && python3 tests/test_codex_settings.py",
-    "test:commands": "python3 tests/test_packaged_commands.py"
+    "test:commands": "python3 tests/test_packaged_commands.py",
+    "test:codex-mcp-auth": "python3 -m unittest discover -s tests -p 'test_codex_mcp_oauth*.py'",
+    "test:account-seeding": "python3 tests/test_account_seeding.py && python3 tests/test_claude_pool_prepare.py",
+    "test:mcp": "python3 -m unittest discover -s tests -p 'test_mcp_*.py' && npm run test:codex-mcp-auth"
   },
   "dependencies": {
     "update-notifier": "^7.3.1"

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/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()