claude-multiacc 2.0.16 → 2.0.18

package/bin/claude-accounts

@@ -943,69 +943,18 @@ commit_ceremony_token() {
 CEREMONY_LAST_WORDS=""
 CEREMONY_TRANSCRIPT=""
 ceremony_debrief() { # $1 = capture file, $2 = redacted transcript to write; prints the last words
-  "$PYBIN" - "$1" "$2" <<'PYEOF'
-import os, re, sys
-raw = open(sys.argv[1], 'rb').read().decode('utf-8', 'ignore')
-txt = re.sub(r'\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)', '', raw)          # OSC (hyperlink payloads)
-txt = re.sub(r'\x1b\[[0-9;?<>=]*[A-Za-z]', '', txt)                   # CSI, private modes too ([>4m, [<u)
-txt = re.sub(r'\x1b[()][A-Z0-9]|\x1b[78=>]|[\x0e\x0f]', '', txt)      # charset, save/restore cursor, SI/SO
-txt = txt.replace('\r', '\n')
-lines = []
-flat = re.sub(r'\s+', '', txt)
-api_key = bool(re.search(r'sk-ant-api\d{2}-', flat)) and not re.search(r'sk-ant-oat\d{2}-', flat)
-txt = re.sub(r'sk-ant-[A-Za-z0-9]+-[A-Za-z0-9_-]+', 'sk-ant-***', txt)
-for ln in txt.splitlines():
-    ln = ln.strip()
-    if not ln or re.fullmatch(r'[\W_]+', ln):          # spinner frames, logo art
-        continue
-    if 'https://' in ln or re.search(r'Paste\s*code\s*here', ln):   # the sign-in link, the paste prompt
-        continue
-    if lines and lines[-1] == ln:
-        continue
-    lines.append(ln)
-if api_key:
-    # Said LAST, so it is what the operator reads: the client minted an API key, not a
-    # subscription token — the browser session was signed into a Console org.
-    lines.append('the client minted an API KEY (sk-ant-api…), not a subscription setup-token: '
-                 'the browser session belongs to a Console / API-billing organization — sign in '
-                 'as the subscription account and try again')
-try:
-    fd = os.open(sys.argv[2], os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
-    with os.fdopen(fd, 'w') as f:
-        f.write('\n'.join(lines) + '\n')
-except OSError:
-    pass
-print(' | '.join(lines[-3:])[:400])
-PYEOF
+  "$PYBIN" "$LIB_DIR/ceremony.py" debrief "$1" "$2" 2>/dev/null
 }
 
-# The token, out of the transcript. The client's renderer places WORDS with cursor
-# moves instead of spaces and can emit a long token as positioned, styled segments;
-# a narrow terminal wraps it. A raw-bytes grep therefore missed a perfectly good token
-# on 2026-08-29 ("no token captured" after "token created successfully"). Every
-# terminal escape is stripped first, and the token block the client prints (between
-# "Your OAuth token …:" and "Store this token securely") is joined across spaces and
-# line breaks before matching, so neither placement nor wrapping can split it. The
-# real inference in commit_ceremony_token then proves whatever came out.
+# The token, out of the transcript. `claude setup-token` is a TUI: its renderer places
+# words with absolute cursor moves, so the bytes are terminal OPERATIONS and the token
+# exists only in the RENDERED result. Stripping escapes reassembles it wrongly — a
+# `sk-ant-\x1b[10Gat01-…` stream loses the `o` and three mints failed as "no token
+# captured" seconds after the client said the token was created (2026-08-29). lib/
+# ceremony.py replays the transcript onto a virtual screen and reads what the operator
+# saw; the real inference in commit_ceremony_token then proves whatever came out.
 ceremony_extract() { # $1 = capture file -> the setup-token, or nothing
-  "$PYBIN" - "$1" <<'PYEOF'
-import re, sys
-raw = open(sys.argv[1], 'rb').read().decode('utf-8', 'ignore')
-txt = re.sub(r'\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)', '', raw)          # OSC (hyperlink payloads)
-txt = re.sub(r'\x1b\[[0-9;?<>=]*[A-Za-z]', '', txt)                   # CSI, private modes too ([>4m, [<u)
-txt = re.sub(r'\x1b[()][A-Z0-9]|\x1b[78=>]|[\x0e\x0f]', '', txt)      # charset, save/restore cursor, SI/SO
-pat = re.compile(r'sk-ant-oat\d{2}-[A-Za-z0-9_-]{40,}')
-cands = []
-for m in re.finditer(r'Your\s*OAuth\s*token[^\n]{0,80}?:', txt):
-    block = txt[m.end(): m.end() + 4000]
-    stop = re.search(r'Store\s*this\s*token', block)
-    if stop:
-        block = block[: stop.start()]
-    cands += pat.findall(re.sub(r'\s+', '', block))
-cands += pat.findall(txt)
-cands += pat.findall(re.sub(r'[ \t]+', '', txt))
-print(max(cands, key=len) if cands else '')
-PYEOF
+  "$PYBIN" "$LIB_DIR/ceremony.py" extract "$1" 2>/dev/null
 }
 
 CEREMONY_TOKEN=""
@@ -2165,6 +2114,10 @@ for acct in manifest.get('accounts', []):
                 'percent': pct,
                 'resets_at': resets,
                 'resets_epoch': int(parse_iso(resets) or now + 3600),
+                # Present only for a bucket that belongs to ONE model: such a
+                # bucket parks that model, never the account (see the marker
+                # choice below and the shim's scoped_blocks_run).
+                'model': model,
             })
         if not buckets:
             # Fallback for a payload with no limits[] array: scan EVERY top-level object
@@ -2226,8 +2179,21 @@ for acct in manifest.get('accounts', []):
     offenders = [b for b in buckets if b['percent'] >= threshold]
     mpath = os.path.join(d, '.limited')
     if offenders:
-        worst = max(offenders, key=lambda b: b['percent'])
-        reset_epoch = max(int(b['resets_epoch']) for b in offenders)
+        # ONE bucket, described consistently: the marker's epoch is the reset of
+        # the bucket its detail line names. It used to pair the highest PERCENT
+        # with the LATEST reset over every offender, and the two came from
+        # different buckets: a 100% session bucket resetting in a minute was
+        # written with a Fable weekly bucket's epoch six days out, and everything
+        # that trusts the marker (this shim, app-robot's fleet verdict on every
+        # Mac) parked the whole account for six days over a five-hour window
+        # (2026-08-29, acct-05). An account-level bucket wins over a model-scoped
+        # one — the latter parks a model, not the account (scoped_blocks_run) —
+        # and among those, the longest-lived exclusion, since any bucket over the
+        # threshold stays there until its own reset.
+        account_level = [b for b in offenders if not b.get('model')]
+        worst = max(account_level or offenders,
+                    key=lambda b: (int(b['resets_epoch']), b['percent']))
+        reset_epoch = int(worst['resets_epoch'])
         # Atomic: a concurrent shim must never read a half-written marker.
         with open(mpath + '.tmp', 'w') as f:
             f.write(f'{reset_epoch}\n')

package/lib/ceremony.py

@@ -0,0 +1,193 @@
+"""Read what the sign-in ceremony actually PUT ON THE SCREEN.
+
+`claude setup-token` is a TUI. Its renderer places words with absolute cursor
+moves rather than spaces, so the bytes it emits are terminal OPERATIONS, not
+text: on 2026-08-29 a perfectly good token arrived as
+
+    sk-ant-\x1b[10Gat01-w_C6…
+
+Stripping the escapes yields `sk-ant-at01-…` — the sequence's own final byte ate
+the token's `o` — and no amount of whitespace-joining puts it back. Three mints
+failed as "no token captured" seconds after the client printed
+"✓ Long-lived authentication token created successfully!".
+
+So the transcript is REPLAYED onto a virtual screen and the result is read, which
+is by definition what the operator saw. Only the handful of sequences this TUI
+uses are honoured; everything else is skipped, and any byte that would move the
+cursor off-screen is clamped rather than trusted.
+
+Run directly:  ceremony.py extract <capture>          -> the setup-token, or nothing
+               ceremony.py debrief <capture> <out>    -> last words; writes a
+                                                         redacted transcript (0600)
+"""
+
+import os
+import re
+import sys
+
+TOKEN = re.compile(r'sk-ant-oat\d{2}-[A-Za-z0-9_-]{40,}')
+ANY_CRED = re.compile(r'sk-ant-[A-Za-z0-9]+-[A-Za-z0-9_-]+')
+API_KEY = re.compile(r'sk-ant-api\d{2}-')
+_CSI = re.compile(r'\x1b\[([0-9;?<>=]*)([@-~])')
+_CHARSET = re.compile(r'\x1b[()][A-Z0-9]|\x1b[78=>]')
+# A screen this TUI could never legitimately need; a corrupt stream must not make
+# the renderer allocate without bound.
+MAX_ROWS = 2000
+MAX_COLS = 4000
+
+
+def render(raw):
+    """The transcript's final screen, as a list of lines."""
+    rows, cur, col = [[]], 0, 0
+
+    def put(ch):
+        nonlocal col
+        if cur >= MAX_ROWS or col >= MAX_COLS:
+            return
+        while len(rows) <= cur:
+            rows.append([])
+        row = rows[cur]
+        while len(row) <= col:
+            row.append(' ')
+        row[col] = ch
+        col += 1
+
+    i, n = 0, len(raw)
+    while i < n:
+        ch = raw[i]
+        if ch == '\x1b':
+            if raw.startswith('\x1b]', i):                 # OSC … BEL | ST
+                bel, st = raw.find('\x07', i), raw.find('\x1b\\', i)
+                ends = [x for x in ((bel, 1), (st, 2)) if x[0] != -1]
+                i = min(ends)[0] + min(ends)[1] if ends else n
+                continue
+            m = _CSI.match(raw, i)
+            if m:
+                params, fin = m.group(1), m.group(2)
+                nums = [int(p) for p in params.split(';') if p.isdigit()]
+                a = nums[0] if nums else 1
+                if fin == 'G':
+                    col = min(max(0, a - 1), MAX_COLS)
+                elif fin == 'C':
+                    col = min(col + a, MAX_COLS)
+                elif fin == 'D':
+                    col = max(0, col - a)
+                elif fin == 'A':
+                    cur = max(0, cur - a)
+                elif fin == 'B':
+                    cur = min(cur + a, MAX_ROWS)
+                elif fin == 'H':
+                    cur = min(max(0, a - 1), MAX_ROWS)
+                    col = min(max(0, (nums[1] if len(nums) > 1 else 1) - 1), MAX_COLS)
+                elif fin == 'K':
+                    while len(rows) <= cur:
+                        rows.append([])
+                    if params.startswith('2'):
+                        rows[cur] = []
+                    elif not params or params == '0':
+                        rows[cur] = rows[cur][:col]
+                elif fin == 'J' and params.startswith('2'):
+                    rows, cur, col = [[]], 0, 0
+                i = m.end()
+                continue
+            m = _CHARSET.match(raw, i)
+            i = m.end() if m else i + 1
+            continue
+        if ch == '\r':
+            col = 0
+        elif ch == '\n':
+            cur = min(cur + 1, MAX_ROWS)
+            col = 0
+        elif ord(ch) >= 32:
+            put(ch)
+        i += 1
+    return [''.join(r).rstrip() for r in rows]
+
+
+# The block the client prints the token inside. Joining WITHIN it is what survives a
+# terminal narrow enough to wrap the token across rows, without gluing the token to
+# whatever the next paragraph happens to say.
+_BLOCK_START = re.compile(r'Your\s*OAuth\s*token[^\n]{0,80}?:')
+_BLOCK_END = re.compile(r'Store\s*this\s*token')
+
+
+def extract_token(raw):
+    """The setup-token the ceremony printed, or ''.
+
+    Every reading is a candidate and the LONGEST wins, because the two shapes fail
+    each other's method: a token painted out of order is whole only on the rendered
+    line, while one the terminal wrapped is whole only across rows. A per-line match
+    on a wrapped token returns its first 79 characters — exactly the truncation this
+    whole path exists to prevent — so the joined reading has to compete with it.
+    """
+    lines = render(raw)
+    text = '\n'.join(lines)
+    cands = [m.group(0) for ln in lines for m in [TOKEN.search(ln)] if m]
+    for m in _BLOCK_START.finditer(text):
+        block = text[m.end(): m.end() + 4000]
+        stop = _BLOCK_END.search(block)
+        if stop:
+            block = block[: stop.start()]
+        cands += TOKEN.findall(re.sub(r'\s+', '', block))
+    if not cands:                                    # a TUI this renderer misreads
+        flat = _CSI.sub('', _CHARSET.sub('', raw))
+        cands = TOKEN.findall(flat) + TOKEN.findall(re.sub(r'\s+', '', flat))
+    return max(cands, key=len) if cands else ''
+
+
+def debrief(raw):
+    """(readable lines, api_key_minted). The screen the operator was left looking
+    at, with every credential-shaped string masked."""
+    api_key = False
+    for ln in render(raw):
+        if API_KEY.search(ln):
+            api_key = True
+    if extract_token(raw):
+        api_key = False
+    lines = []
+    for ln in render(raw):
+        ln = ANY_CRED.sub('sk-ant-***', ln).strip()
+        if not ln or re.fullmatch(r'[\W_]+', ln):        # spinner frames, logo art
+            continue
+        if 'https://' in ln or re.search(r'Paste\s*code\s*here', ln):
+            continue
+        if lines and lines[-1] == ln:
+            continue
+        lines.append(ln)
+    if api_key:
+        # Said LAST, so it is what the operator reads.
+        lines.append('the client minted an API KEY (sk-ant-api…), not a subscription '
+                     'setup-token: the browser session belongs to a Console / '
+                     'API-billing organization — sign in as the subscription account '
+                     'and try again')
+    return lines, api_key
+
+
+def _read(path):
+    with open(path, 'rb') as f:
+        return f.read().decode('utf-8', 'ignore')
+
+
+def main(argv):
+    if len(argv) < 2:
+        return 2
+    verb, path = argv[0], argv[1]
+    if verb == 'extract':
+        sys.stdout.write(extract_token(_read(path)))
+        return 0
+    if verb == 'debrief':
+        lines, _ = debrief(_read(path))
+        if len(argv) > 2:
+            try:
+                fd = os.open(argv[2], os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+                with os.fdopen(fd, 'w') as f:
+                    f.write('\n'.join(lines) + '\n')
+            except OSError:
+                pass
+        print(' | '.join(lines[-3:])[:400])
+        return 0
+    return 2
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.16",
+  "version": "2.0.18",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {

package/tests/run-tests.sh

@@ -94,6 +94,16 @@ if [ "${1:-}" = "setup-token" ]; then
     printf 'Store\033[7Gthis\033[12Gtoken\033[18Gsecurely.\n'
     exit 0
   fi
+  if [ -n "${FAKE_TOKEN_CURSOR:-}" ]; then
+    # The 2026-08-29 shape: the TUI paints the token OUT OF ORDER with absolute cursor
+    # moves, so the byte stream is `sk-ant-<ESC>[10Gat01-…` and escape-stripping loses
+    # the `o`. Only replaying the transcript onto a screen recovers it.
+    tok="sk-ant-oat01-$(printf '%66s' '' | tr ' ' W)$(printf '%23s' '' | tr ' ' T)TAILOK"
+    printf ' Your\033[6GOAuth\033[12Gtoken\033[18G(valid\033[25Gfor\033[29G1\033[31Gyear):\n'
+    printf ' %s\033[10G%s\033[9G%s\n' "${tok:0:7}" "${tok:8}" "${tok:7:1}"
+    printf ' Store\033[7Gthis\033[12Gtoken\033[18Gsecurely.\n'
+    exit 0
+  fi
   if [ -n "${FAKE_TOKEN_APIKEY:-}" ]; then
     # A browser session signed into a Console (API-billing) org: the client mints an
     # API key, which is not a subscription token and must not be saved.
@@ -1475,6 +1485,28 @@ esac
 [ -f "$ACC/acct-04/.server-token-verified" ] && t_ok "the joined token was proven by a real call" \
   || t_fail "split token proof" "marker missing"
 printf '%s' "$orig" > "$ACC/acct-04/server.token"; rm -f "$ACC/acct-04/.server-token-verified"
+# The token painted OUT OF ORDER with absolute cursor moves — the shape that made three
+# real mints fail as "no token captured" right after "token created successfully".
+out="$(FAKE_TOKEN_CURSOR=1 claude-accounts mint acct-04 2>&1 </dev/null)"
+rc=$?
+[ "$rc" = "0" ] && t_ok "a cursor-painted token is read off the rendered screen" \
+  || t_fail "cursor-painted mint rc" "rc=$rc: $(printf '%s' "$out" | tail -c 220)"
+case "$(tr -d '[:space:]' < "$ACC/acct-04/server.token")" in
+  sk-ant-oat01-WWW*TAILOK) [ "$(tr -d '[:space:]' < "$ACC/acct-04/server.token" | wc -c | tr -d ' ')" = "108" ] \
+    && t_ok "the rendered token is complete and in order" || t_fail "rendered token" "wrong length" ;;
+  *) t_fail "rendered token" "wrong content — escape-stripping order bug" ;;
+esac
+printf '%s' "$orig" > "$ACC/acct-04/server.token"; rm -f "$ACC/acct-04/.server-token-verified"
+# The renderer itself, on the exact byte pattern from the field.
+printf ' sk-ant-\033[10Gat01-%s\033[9Go\n' "$(printf '%95s' '' | tr ' ' Z)" > "$WORK/painted.raw"
+n="$(python3 "$REPO_DIR/lib/ceremony.py" extract "$WORK/painted.raw" | wc -c | tr -d ' ')"
+[ "$n" = "108" ] && t_ok "ceremony.py renders a cursor-painted token whole" \
+  || t_fail "ceremony.py extract" "got $n characters, expected 108"
+# ...and the debrief reads as prose, not as words jammed together by the stripping.
+printf ' Store\033[8Gthis\033[13Gtoken\033[19Gsecurely.\n' > "$WORK/prose.raw"
+out="$(python3 "$REPO_DIR/lib/ceremony.py" debrief "$WORK/prose.raw" "$WORK/prose.out")"
+check "the debrief renders readable words" "Store this token securely." "$out"
+
 # A browser session on a Console (API-billing) org: the client mints an API KEY. Not a
 # subscription token — refused, with the cause named and the raw capture kept.
 before_raw="$(ls "$ACC"/tmp/mint-failed.*.raw 2>/dev/null | wc -l | tr -d ' ')"
@@ -1851,6 +1883,70 @@ sc="$(python3 -c "import json;d=json.load(open('$ACC/acct-01/limits.json'));prin
   || t_fail "ranking score" "got $sc"
 rm -f "$ACC/acct-01/limits.json" "$ACC/acct-01/.limited"
 
+# ---- 16-marker. the marker names ONE bucket and carries THAT bucket's reset ----------
+# A 100% session bucket (resets in an hour) beside a 100% Fable-only weekly bucket
+# (resets in five days) used to produce "bucket=session … resets_at=<+1h>" on line 2
+# under a line-1 epoch five days out — the highest percent paired with the latest
+# reset of a DIFFERENT bucket. Every reader of the marker (this shim, app-robot's
+# fleet-wide verdict) then parked the whole account for five days over a five-hour
+# window (2026-08-29, acct-05). The account-level bucket is named with its own reset.
+cat > "$WORK/usage-session-vs-fable.json" <<'EOF2'
+{"limits":[
+  {"kind":"session","percent":100,"resets_at":"2099-01-01T01:00:00+00:00","scope":null},
+  {"kind":"weekly_all","percent":40,"resets_at":"2099-01-05T00:00:00+00:00","scope":null},
+  {"kind":"weekly_scoped","percent":100,"resets_at":"2099-01-06T00:00:00+00:00","scope":{"model":{"display_name":"Fable"}}}
+]}
+EOF2
+out="$(CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-session-vs-fable.json" claude-accounts limits --force 2>&1)"
+check "session over threshold names the session bucket, not the Fable one" "LIMITED session at 100%" "$out"
+python3 - "$ACC/acct-01/.limited" <<'EOF2'
+import sys, time, calendar
+lines = open(sys.argv[1]).read().splitlines()
+epoch, detail = int(lines[0]), lines[1]
+want = calendar.timegm(time.strptime("2099-01-01T01:00:00", "%Y-%m-%dT%H:%M:%S"))
+assert epoch == want, (epoch, want, detail)                       # the SESSION reset
+assert "bucket=session percent=100" in detail, detail
+assert "resets_at=2099-01-01T01:00:00+00:00" in detail, detail
+EOF2
+[ $? -eq 0 ] && t_ok "marker epoch is the named bucket's own reset (session +1h, not Fable +5d)" \
+  || t_fail "marker epoch/bucket consistency" "$(cat "$ACC/acct-01/.limited" 2>&1 | tr '\n' ' ')"
+# Two ACCOUNT-level offenders: the longest-lived exclusion is the one named, with its
+# own reset — a session bucket that resets in an hour must not shorten a weekly park.
+cat > "$WORK/usage-session-vs-weekly.json" <<'EOF2'
+{"limits":[
+  {"kind":"session","percent":100,"resets_at":"2099-01-01T01:00:00+00:00","scope":null},
+  {"kind":"weekly_all","percent":95,"resets_at":"2099-01-05T00:00:00+00:00","scope":null}
+]}
+EOF2
+out="$(CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-session-vs-weekly.json" claude-accounts limits --force 2>&1)"
+check "two account-level offenders: the longest-lived one is named" "LIMITED weekly_all at 95%" "$out"
+python3 - "$ACC/acct-01/.limited" <<'EOF2'
+import sys, time, calendar
+lines = open(sys.argv[1]).read().splitlines()
+want = calendar.timegm(time.strptime("2099-01-05T00:00:00", "%Y-%m-%dT%H:%M:%S"))
+assert int(lines[0]) == want, lines
+assert "bucket=weekly_all percent=95" in lines[1] and "resets_at=2099-01-05T00:00:00+00:00" in lines[1], lines
+EOF2
+[ $? -eq 0 ] && t_ok "weekly_all marker carries the weekly reset" \
+  || t_fail "weekly_all marker" "$(cat "$ACC/acct-01/.limited" 2>&1 | tr '\n' ' ')"
+# Only a model-scoped offender left: the scoped bucket is named (the shim treats it
+# as "switch model", never as an account park) with ITS reset.
+cat > "$WORK/usage-fable-only.json" <<'EOF2'
+{"limits":[
+  {"kind":"session","percent":10,"resets_at":"2099-01-01T01:00:00+00:00","scope":null},
+  {"kind":"weekly_scoped","percent":100,"resets_at":"2099-01-06T00:00:00+00:00","scope":{"model":{"display_name":"Fable"}}}
+]}
+EOF2
+out="$(CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-fable-only.json" claude-accounts limits --force 2>&1)"
+check "a scoped-only offender still marks, scoped" "LIMITED weekly_scoped:Fable at 100%" "$out"
+grep -q "^bucket=weekly_scoped:Fable percent=100 " "$ACC/acct-01/.limited" 2>/dev/null \
+  && [ "$(head -1 "$ACC/acct-01/.limited")" = "$(python3 -c 'import time,calendar;print(calendar.timegm(time.strptime("2099-01-06T00:00:00","%Y-%m-%dT%H:%M:%S")))')" ] \
+  && t_ok "scoped marker carries the scoped bucket's reset" \
+  || t_fail "scoped marker" "$(cat "$ACC/acct-01/.limited" 2>&1 | tr '\n' ' ')"
+grep -q '"model": "Fable"' "$ACC/acct-01/limits.json" && t_ok "limits.json buckets record the model scope" \
+  || t_fail "bucket model field" "missing from limits.json"
+rm -f "$ACC/acct-01/limits.json" "$ACC/acct-01/.limited"
+
 # ---- 16a. future-proofing: works if the Fable bucket separation disappears ---------
 cat > "$WORK/usage-no-fable.json" <<'EOF'
 {"limits":[