claude-multiacc 2.0.58 → 2.0.59

package/lib/report.py

@@ -32,8 +32,9 @@ Account status vocabulary (the panel's contract):
 Credential classes (what may be COPIED between machines):
   portable      claude setup-token (server.token) — safe to export/import anywhere
   machine-local claude .credentials.json OR a macOS Keychain item (credentials.oauth_store
-                says which) / codex auth.json — rotating refresh grant; copying it makes
-                two machines fight over one grant and breaks both
+                says which) carrying a claudeAiOauth login — one holding only MCP OAuth
+                state is no login — / codex auth.json — rotating refresh grant; copying it
+                makes two machines fight over one grant and breaks both
   none          nothing on disk (or in the Keychain) here
 """
 
@@ -46,7 +47,7 @@ import time
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import keychain  # noqa: E402
-from audit import creds_doc_state, token_verified  # noqa: E402
+from audit import creds_doc_state, file_has_login, token_verified  # noqa: E402
 from claude_client_error import org_access_verified_at  # noqa: E402
 from claude_reset import marker_superseded, record_from  # noqa: E402
 from codex_credits import credit_view  # noqa: E402
@@ -170,10 +171,12 @@ def _claude_credentials(d):
     macOS Keychain (`oauth_store` says which; `keychain` says whether THIS process could
     open it). A Keychain login this session cannot open is still a login on this Mac —
     reporting it as `none` is what made a whole pool of working accounts read as
-    missing — so the class stays machine-local and the row's status says `locked`."""
+    missing — so the class stays machine-local and the row's status says `locked`.
+    A file or item holding only the client's MCP OAuth state is no login at all
+    (audit.file_has_login, keychain 'nologin'): `oauth` stays false for it."""
     cpath = os.path.join(d, '.credentials.json')
     tpath = os.path.join(d, 'server.token')
-    has_oauth = _size(cpath) > 0
+    has_oauth = file_has_login(cpath)
     has_token = _size(tpath) > 0
     detail = {'oauth': has_oauth, 'token': has_token, 'oauth_store': None, 'keychain': None,
               'oauth_expires_at': None, 'oauth_refresh_expires_at': None,

package/lib/session_settings.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""The model and effort a session is running with, read from its own history (Python 3.8+).
+
+claude: the last main-thread assistant record (not a sidechain, not meta, a real model): its
+``requestedModel``, else ``message.model``; and ``effort``, else ``perTurnEffort``. A natively
+1M model is recorded without ``[1m]``, which it does not need. A ``/model`` switch with no reply
+after it is not visible: only assistant records carry the model.
+codex: whichever comes last of a ``turn_context`` (``model``/``effort``) and a
+``thread_settings_applied`` event for the file's own thread (``thread_settings.model``/
+``reasoning_effort``) -- the rule Codex's own state db follows, so a mid-session ``/model`` or
+effort change is honoured. An absent effort means the model's default.
+
+Bounded: the file is read backwards in chunks (a transcript can be 100 MB) and the scan stops
+at SCAN_LIMIT bytes; ``upto`` caps it at a byte boundary (a handoff's snapshot). The result is
+``{"model": str|None, "effort": str|None}``; a file that cannot be read gives both None.
+"""
+
+import json
+import os
+import sys
+
+CHUNK = 1 << 20
+SCAN_LIMIT = 64 << 20
+SYNTHETIC = "<synthetic>"
+
+
+def _reverse_lines(path, upto=None):
+    """Complete lines of ``path`` from the last one backwards, at most SCAN_LIMIT bytes in."""
+    with open(path, "rb") as fh:
+        end = os.fstat(fh.fileno()).st_size if upto is None else min(upto, os.fstat(fh.fileno()).st_size)
+        rest, pos, scanned = b"", end, 0
+        while pos > 0 and scanned < SCAN_LIMIT:
+            step = min(CHUNK, pos)
+            pos -= step
+            fh.seek(pos)
+            block = fh.read(step) + rest
+            scanned += step
+            lines = block.split(b"\n")
+            rest = lines[0]
+            for line in reversed(lines[1:]):
+                if line.strip():
+                    yield line
+        if pos == 0 and rest.strip():
+            yield rest
+
+
+def _record(line):
+    try:
+        doc = json.loads(line.decode("utf-8", "replace"))
+    except ValueError:
+        return None
+    return doc if isinstance(doc, dict) else None
+
+
+def _text(value):
+    return value if isinstance(value, str) and value.strip() else None
+
+
+def _own_thread_id(path):
+    """The id in the file's first line (its own session_meta; a fork copies its parent's at
+    line two), so another thread's settings snapshots are not mistaken for this one's."""
+    try:
+        with open(path, "rb") as fh:
+            doc = _record(fh.readline(1 << 20))
+    except OSError:
+        return None
+    payload = doc.get("payload") if doc else None
+    return _text(payload.get("id")) if isinstance(payload, dict) else None
+
+
+def codex_settings(path, upto=None):
+    own = _own_thread_id(path)
+    for line in _reverse_lines(path, upto):
+        doc = _record(line)
+        payload = doc.get("payload") if doc else None
+        if not isinstance(payload, dict):
+            continue
+        if doc.get("type") == "turn_context" and _text(payload.get("model")):
+            return {"model": _text(payload.get("model")), "effort": _text(payload.get("effort"))}
+        if doc.get("type") == "event_msg" and payload.get("type") == "thread_settings_applied":
+            settings = payload.get("thread_settings")
+            thread = _text(payload.get("thread_id"))
+            if isinstance(settings, dict) and _text(settings.get("model")) and (own is None or thread in (None, own)):
+                return {"model": _text(settings.get("model")), "effort": _text(settings.get("reasoning_effort"))}
+    return {"model": None, "effort": None}
+
+
+def claude_settings(path, upto=None):
+    for line in _reverse_lines(path, upto):
+        doc = _record(line)
+        if not doc or doc.get("type") != "assistant" or doc.get("isSidechain") or doc.get("isMeta"):
+            continue
+        message = doc.get("message")
+        model = _text(message.get("model")) if isinstance(message, dict) else None
+        if model is None or model == SYNTHETIC:
+            continue
+        return {"model": _text(doc.get("requestedModel")) or model,
+                "effort": _text(doc.get("effort")) or _text(doc.get("perTurnEffort"))}
+    return {"model": None, "effort": None}
+
+
+def session_settings(provider, path, upto=None):
+    """Fail-open: anything unreadable or unknown is ``{"model": None, "effort": None}``."""
+    reader = {"claude": claude_settings, "codex": codex_settings}.get(provider)
+    if reader is None or not path:
+        return {"model": None, "effort": None}
+    try:
+        return reader(path, upto)
+    except (OSError, ValueError):
+        return {"model": None, "effort": None}
+
+
+def main(argv):
+    if len(argv) not in (2, 4) or argv[0] not in ("claude", "codex") or (len(argv) == 4 and argv[2] != "--upto"):
+        sys.stderr.write("usage: session_settings.py <claude|codex> <history.jsonl> [--upto <bytes>]\n")
+        return 2
+    upto = int(argv[3]) if len(argv) == 4 else None
+    print(json.dumps(session_settings(argv[0], argv[1], upto)))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.58",
+  "version": "2.0.59",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {
@@ -58,7 +58,7 @@
     "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: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 tests/test_mcp_registry.py && npm run test:codex-settings",
+    "test:seeding": "python3 tests/test_account_seeding.py && python3 tests/test_claude_pool_prepare.py && python3 tests/test_mcp_registry.py && python3 tests/test_mcp_oauth.py && 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"
   },

package/tests/fake_codex_tui.py

@@ -2,6 +2,7 @@
 
 import json
 import os
+import re
 from pathlib import Path
 import select
 import signal
@@ -50,6 +51,29 @@ def initialize_rollout():
     return rollout
 
 
+def require_resume_trust():
+    if os.environ.get("FAKE_REQUIRE_TRUST") != "1" or "resume" not in sys.argv:
+        return
+    try:
+        import tomllib
+    except ImportError:  # stock python: the same answer from the written line itself
+        tomllib = None
+
+    path = Path(os.environ["CODEX_HOME"]) / "config.toml"
+    text = path.read_text() if path.exists() else ""
+    if tomllib:
+        trusted = tomllib.loads(text).get("projects", {}).get(os.getcwd(), {}).get("trust_level") == "trusted"
+    else:
+        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)
+    if not trusted:
+        print("Folder access\nTrust this folder?\n› 1. Trust and continue\n  2. Quit", flush=True)
+        while True:
+            time.sleep(0.1)
+
+
 def main():
     if sys.argv[1:] == ["--help"]:
         print("Usage: codex [OPTIONS]\n" + ("  --no-daemon  Run locally" if "FAKE_LEGACY" not in os.environ else ""))
@@ -61,6 +85,7 @@ def main():
     settings = termios.tcgetattr(0)
     signal.signal(signal.SIGTERM, stop)
     signal.signal(signal.SIGHUP, stop)
+    require_resume_trust()
     rollout = initialize_rollout()
     try:
         tty.setraw(0)

package/tests/fake_security.sh

@@ -19,7 +19,28 @@
 # cannot open the keychain (ssh/tmux/background). FAKE_SECURITY_LOG=<file> appends one
 # line per call — verb, -a name ("-" without -a), whether the secret was asked for —
 # so a test can count calls; the secret and the -X payload are never logged.
+#
+# `security -i` (how Claude Code writes its item, so the secret stays off argv) runs one
+# command per stdin line, its words split the way the tool's own reader splits them
+# (blanks, "double quotes", backslash escapes), and exits with the LAST command's status,
+# as the real tool does. Its reader takes a line into a 4096-byte buffer, so a longer
+# line is refused here (the real tool would cut it into garbage commands) — which is why
+# the client, and lib/keychain.py write_doc, switch to argv above 4032 bytes. Each such
+# command is logged like an argv call, plus ` via=stdin`.
 KC="${FAKE_KEYCHAIN_DIR:-/nonexistent-keychain}"
+if [ "${1:-}" = "-i" ]; then
+  rc=0
+  while IFS= read -r line || [ -n "$line" ]; do
+    [ -n "$line" ] || continue
+    if [ "${#line}" -ge 4096 ]; then rc=1; line=""; continue; fi
+    words=()
+    while IFS= read -r -d '' w; do words+=("$w"); done < <(printf '%s' "$line" \
+      | python3 -c 'import shlex, sys; sys.stdout.write("".join(w + "\0" for w in shlex.split(sys.stdin.read())))')
+    FAKE_SECURITY_VIA=stdin "$0" ${words[@]+"${words[@]}"} </dev/null; rc=$?
+    line=""
+  done
+  exit "$rc"
+fi
 cmd="${1:-}"; shift || true
 svc=""; acct=""; have_acct=0; want_pw=0; update=0; hexdata=""
 while [ $# -gt 0 ]; do
@@ -32,8 +53,9 @@ while [ $# -gt 0 ]; do
     *) shift ;;
   esac
 done
-[ -n "${FAKE_SECURITY_LOG:-}" ] && printf '%s a=%s w=%s\n' "$cmd" \
-  "$([ "$have_acct" = "1" ] && printf '%s' "$acct" || printf -- '-')" "$want_pw" >> "$FAKE_SECURITY_LOG"
+[ -n "${FAKE_SECURITY_LOG:-}" ] && printf '%s a=%s w=%s%s\n' "$cmd" \
+  "$([ "$have_acct" = "1" ] && printf '%s' "$acct" || printf -- '-')" "$want_pw" \
+  "${FAKE_SECURITY_VIA:+ via=$FAKE_SECURITY_VIA}" >> "$FAKE_SECURITY_LOG"
 locked() { [ -n "${FAKE_KEYCHAIN_LOCKED:-}" ]; }
 item_dir() { # the item a lookup names: -a picks its own, no -a picks the oldest
   local d best="" bestseq="" s

package/tests/fixtures/cross_provider_cli.py

@@ -2,6 +2,7 @@
 
 import json
 import os
+import re
 from pathlib import Path
 import select
 import signal
@@ -14,6 +15,10 @@ import uuid
 PROVIDER = Path(sys.argv[0]).name
 HOME = Path(os.environ["FAKE_HOME"])
 SIDS = {"codex": "01a0cb0f-a719-7461-bba6-a59bdf2412cc", "claude": "f8470bf4-f810-4492-b564-1712a7c4930e"}
+# This launch's transcript (claude) or rollout (codex), once it is open.
+HISTORY = None
+# The model/effort a launch without pins runs with; a pinned launch records its own pins.
+DEFAULT_SETTINGS = {"codex": ("gpt-6-astra", "ultra"), "claude": ("claude-fable-5-1", "max")}
 
 
 def record(kind, **fields):
@@ -23,14 +28,60 @@ def record(kind, **fields):
 
 def stop(signum, _frame):
     record("signal", signal=signum)
+    if signum == signal.SIGTERM and os.environ.get("FAKE_IGNORE_TERM") == PROVIDER:
+        return  # a client SIGTERM does not stop (the 8.3GB claude of 2026-10-20): only KILL
     target = os.environ.get("FAKE_PARK_TARGET_ON_TERM")
     if signum == signal.SIGTERM and target in SIDS and target != PROVIDER:
         for account in (HOME / (target + "-pool")).glob("acct-*"):
             (account / ".limited").write_text(
                 f"{int(time.time()) + 3600}\nbucket=error-cooldown reason=error-cooldown\n")
+    agent = os.environ.get("FAKE_AGENT_LIMIT_ON_TERM")
+    if signum == signal.SIGTERM and agent and PROVIDER == "claude" and HISTORY:
+        agent_limit(agent)
     raise SystemExit(0)
 
 
+def agent_limit(agent):
+    """FAKE_AGENT_LIMIT_ON_TERM=<agent id>: one more of this session's workflow agents meets
+    the five-hour limit while the client is being stopped, recorded to the millisecond in that
+    agent's own transcript, as claude 2.1.303 records it."""
+    now = time.time()
+    path = (Path(HISTORY).with_suffix("") / "subagents" / "workflows" / "wf_term"
+            / ("agent-" + agent + ".jsonl"))
+    path.parent.mkdir(parents=True, exist_ok=True)
+    stamp = time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime(now)) + ".%03dZ" % int(now % 1 * 1000)
+    rejection = {"type": "assistant", "isSidechain": True, "agentId": agent, "timestamp": stamp,
+                 "isApiErrorMessage": True, "error": "rate_limit",
+                 "apiError": "usage_limit_reached", "apiErrorStatus": 429,
+                 "quotaLimits": {"status": "rejected", "resetsAt": int(now) + 3600,
+                                 "rateLimitType": "five_hour"},
+                 "message": {"model": "<synthetic>", "role": "assistant", "content": [
+                     {"type": "text", "text": "You've hit your session limit"}]}}
+    with path.open("a") as target:
+        target.write(json.dumps(rejection, separators=(",", ":")) + "\n")
+    record("agent-limit", agent=agent, timestamp=stamp)
+
+
+def draw_prompt():
+    """FAKE_MEMORY_BANNER=<provider>: draw the prompt the way claude 2.1.304 does -- its box
+    between two rules, its row the mode indicator and a no-break space, the footer below -- a
+    first launch with the client's critical-memory banner at the footer's right, a resumed one
+    without it. Drawn before the session registry exists, so no watcher can read the screen
+    before it is there."""
+    if os.environ.get("FAKE_MEMORY_BANNER") != PROVIDER:
+        return
+    banner = not any(flag in sys.argv[1:] for flag in ("--resume", "-r"))
+    rule = "─" * 60
+    footer = "  ⏵⏵ bypass permissions on"
+    if banner:
+        footer += ("      Critical memory usage (8.3GB) — restart and resume with claude "
+                   "--continue, or run /compact")
+    text = "\n".join(["⏺ Started the release workflows.", "", rule, "❯\xa0", rule, footer])
+    sys.stdout.buffer.write((text + "\n").encode("utf-8"))
+    sys.stdout.flush()
+    record("screen", banner=banner)
+
+
 def timestamp():
     return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
 
@@ -58,6 +109,36 @@ def user_record(sid, prompt):
             "message": {"role": "user", "content": prompt}}
 
 
+def session_settings():
+    """The model and effort this launch asked for (``--model``/``-m``, ``--effort`` or
+    ``-c model_reasoning_effort=``), else the fixture defaults; never a prompt or a session id."""
+    model, effort = DEFAULT_SETTINGS[PROVIDER]
+    arguments = sys.argv[1:-1] if len(sys.argv) > 1 and " " in sys.argv[-1] else sys.argv[1:]
+    for index, flag in enumerate(arguments):
+        value = arguments[index + 1] if index + 1 < len(arguments) else ""
+        if flag in ("--model", "-m"):
+            model = value
+        elif flag.startswith("--model="):
+            model = flag.split("=", 1)[1]
+        elif flag == "--effort" and PROVIDER == "claude":
+            effort = value
+        elif flag == "-c" and value.startswith("model_reasoning_effort=") and PROVIDER == "codex":
+            effort = value.split("=", 1)[1]
+    return model, effort
+
+
+def settings_record(sid):
+    """What the native CLI persists about its model: a Codex turn context, a Claude reply."""
+    model, effort = session_settings()
+    if PROVIDER == "codex":
+        return {"timestamp": timestamp(), "type": "turn_context", "payload": {
+            "cwd": os.getcwd(), "approval_policy": "on-request", "model": model, "effort": effort}}
+    return {"timestamp": timestamp(), "type": "assistant", "sessionId": sid, "cwd": os.getcwd(),
+            "isSidechain": False, "uuid": "7c2b5a51-4f0e-4f43-9d1f-5f3f7d0c2a11", "effort": effort,
+            "message": {"role": "assistant", "model": model, "type": "message",
+                        "content": [{"type": "text", "text": "Working on the synthetic task."}]}}
+
+
 def initialize_history(account, sid):
     if PROVIDER == "codex":
         directory = account / "sessions/2026/10/11"
@@ -78,6 +159,7 @@ def initialize_history(account, sid):
                 "cwd": os.getcwd(), "source": os.environ.get("FAKE_CODEX_SOURCE", "cli"),
                 "thread_source": "user", "originator": "codex-tui"}}) + "\n")
         history.write(json.dumps(user_record(sid, "Complete the synthetic acceptance task.")) + "\n")
+        history.write(json.dumps(settings_record(sid)) + "\n")
     prompt = sys.argv[-1] if len(sys.argv) > 1 and " " in sys.argv[-1] else ""
     if prompt and os.environ.get("FAKE_DROP_PROMPT") != PROVIDER:
         user = user_record(sid, prompt)
@@ -89,6 +171,29 @@ def initialize_history(account, sid):
     return history
 
 
+def require_codex_trust(account):
+    if PROVIDER != "codex" or os.environ.get("FAKE_REQUIRE_TRUST") != "1":
+        return
+    try:
+        import tomllib
+    except ImportError:  # stock python: the same answer from the written line itself
+        tomllib = None
+
+    path = account / "config.toml"
+    text = path.read_text() if path.exists() else ""
+    if tomllib:
+        trusted = tomllib.loads(text).get("projects", {}).get(os.getcwd(), {}).get("trust_level") == "trusted"
+    else:
+        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)
+    if not trusted:
+        print("Folder access\nTrust this folder?\n› 1. Trust and continue\n  2. Quit", flush=True)
+        while True:
+            time.sleep(0.1)
+
+
 def main():
     if sys.argv[1:] == ["--help"]:
         print("Usage: " + PROVIDER + " [OPTIONS]\n  --no-daemon  Run locally\n  --session-id UUID")
@@ -102,7 +207,11 @@ def main():
     settings = termios.tcgetattr(0)
     signal.signal(signal.SIGTERM, stop)
     signal.signal(signal.SIGHUP, stop)
+    require_codex_trust(account)
+    draw_prompt()
     history = initialize_history(account, sid)
+    global HISTORY
+    HISTORY = history.name
     try:
         tty.setraw(0)
         record("ready", sid=sid, path=str(Path(history.name).resolve()))