claude-multiacc 2.0.42 → 2.0.43

package/README.md

@@ -274,6 +274,17 @@ account's `.credentials.json` (0600), or its macOS Keychain item.
 > login made over ssh migrates into the Keychain the first time a GUI-session process
 > refreshes its token — the pool reads both places (`lib/keychain.py`), and an account
 > that must work from everywhere should carry a portable token (`claude-accounts mint`).
+> The item's **account name** is the client's `$USER` — and a client started without USER
+> files it under `unknown`, beside the older item, where the next client never looks. So
+> `claude-accounts`/`codex-accounts` and the shim fill `USER`/`LOGNAME` from `id -un` when
+> the caller's env has none, and the pool judges only the item under that canonical name —
+> the one the client reads (one `security` call per lookup). A login found only under
+> another name counts nowhere until the scheduled limits pass moves it under the canonical
+> name. A token refresh writes back under the canonical name and drops the siblings it
+> made stale (the same grant, a dead one) but keeps another live grant; a sign-in whose
+> identity checked out prunes every sibling; `remove` deletes every item.
+> `python3 lib/keychain.py prune <acct dir>` prunes by hand (only when the canonical item
+> is a live login; it never writes).
 > Override: `CLAUDE_MULTIACC_KEYCHAIN=0` disables the lookup. This is what keeps idle accounts' telemetry fresh so they win
 selection over busy accounts; without it, stale telemetry ranks neutral and a truly-idle
 account would lose to a busy-but-fresh one. Refresh failures fail open and back off via

package/bin/claude

@@ -12,6 +12,17 @@
 
 set -u
 
+# Claude Code names its macOS Keychain item after $USER, and under Bun a client with no
+# USER calls the user "unknown" — so a caller whose env lacks it (app-robot's panel
+# ceremony, 2026-09-24) gets a login filed under a name the next client never reads
+# (lib/keychain.py). Every client this shim starts, passthrough included, inherits a
+# real name; lib/common.sh does the same for claude-accounts.
+if [ -z "${USER:-}" ]; then
+  USER="$(id -un 2>/dev/null || true)"
+  if [ -n "$USER" ]; then export USER; else unset USER; fi
+fi
+if [ -z "${LOGNAME:-}" ] && [ -n "${USER:-}" ]; then export LOGNAME="$USER"; fi
+
 # ${HOME:-} guards: with HOME stripped (env -i, some cron/systemd units) the shim
 # must still fail OPEN into plain passthrough, never abort on an unbound variable.
 # CLAUDE_ACCOUNTS_ROOT scopes the pool to one app-robot instance; CLAUDE_ACCOUNTS_DIR
@@ -177,7 +188,8 @@ mcp_nested_mirror() {
 }
 
 # Fast passthrough: caller pinned a config dir or token, addon disabled, recursion
-# guard, or no account data yet. Byte-identical behavior to stock claude.
+# guard, or no account data yet. Byte-identical behavior to stock claude (a USER the
+# caller left out is filled at the top — see there).
 if [ -n "${CLAUDE_CONFIG_DIR:-}" ] || [ -n "${CLAUDE_CODE_OAUTH_TOKEN:-}" ] \
   || [ "${CLAUDE_MULTIACC_DISABLE:-0}" = "1" ] || [ -n "${CLAUDE_SHIM_ACTIVE:-}" ] \
   || [ ! -f "$MANIFEST" ]; then
@@ -216,6 +228,11 @@ case "${CLAUDE_MULTIACC_KEYCHAIN:-}" in
   *) if [ "$(uname -s)" = "Darwin" ]; then KC_ON=1; else KC_ON=0; fi ;;
 esac
 if [ "$KC_ON" = "1" ] && ! command -v security >/dev/null 2>&1; then KC_ON=0; fi
+# The client reads ONLY the item under its own account name — $USER (filled above),
+# anything outside [A-Za-z0-9._-] becoming "claude-code-user" — so that one item is what
+# this shim judges: a sibling under another name is invisible to the client it launches.
+KC_ACCOUNT="${USER:-}"
+case "$KC_ACCOUNT" in ''|*[!A-Za-z0-9._-]*) KC_ACCOUNT=claude-code-user ;; esac
 kc_service() { # $1 = acct dir -> the keychain service name the client uses for it
   local h=""
   if command -v shasum >/dev/null 2>&1; then h="$(printf '%s' "$1" | shasum -a 256 2>/dev/null)"
@@ -230,7 +247,7 @@ kc_lookup() { # $1 = acct dir; sets KC_JSON; rc 0 readable, 1 none, 2 exists but
   [ "$KC_ON" = "1" ] || { KC_JSON=""; return 1; }
   if [ "$KC_MEMO_DIR" = "$1" ]; then return "$KC_MEMO_RC"; fi
   local out rc
-  out="$(security find-generic-password -s "$(kc_service "$1")" -w 2>/dev/null)"; rc=$?
+  out="$(security find-generic-password -a "$KC_ACCOUNT" -s "$(kc_service "$1")" -w 2>/dev/null)"; rc=$?
   KC_MEMO_DIR="$1"; KC_JSON=""; KC_MEMO_RC=1
   case "$rc" in
     0) case "$out" in *claudeAiOauth*) KC_JSON="$out"; KC_MEMO_RC=0 ;; esac ;;
@@ -242,7 +259,7 @@ kc_mtime() { # $1 = acct dir -> epoch of the item's last write (0 when none); at
              # are readable even when the secret is locked, so a marker still self-heals
   [ "$KC_ON" = "1" ] || { echo 0; return 0; }
   local stamp
-  stamp="$(security find-generic-password -s "$(kc_service "$1")" 2>/dev/null \
+  stamp="$(security find-generic-password -a "$KC_ACCOUNT" -s "$(kc_service "$1")" 2>/dev/null \
     | LC_ALL=C sed -n 's/.*"mdat"<timedate>=0x[0-9A-Fa-f]*  *"\([0-9]\{14\}\)Z.*/\1/p' | head -1)"
   case "$stamp" in
     [0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9])

package/bin/claude-accounts

@@ -678,6 +678,8 @@ cmd_add() {
   mutate_unlock
   RESERVED_DIR=""            # committed — the trap must not delete it now
   trap - EXIT INT TERM
+  # Registered under the identity it read back: leave one Keychain item for the dir.
+  [ "$token" = "1" ] || keychain_prune "$d"
   # Only the full-login path actually READ the identity back. Saying "verified" for a
   # setup token would relaunder the very assumption this flow just warned about.
   local verdict="sign-in verified"
@@ -784,9 +786,10 @@ def has_auth(aid):
     if (os.path.isfile(c) and os.path.getsize(c) > 0) or (os.path.isfile(t) and os.path.getsize(t) > 0):
         return True
     # A login the client moved into the macOS Keychain still counts — deduping must
-    # not throw away the one duplicate that actually holds the grant.
+    # not throw away the one duplicate that actually holds the grant, even one filed
+    # under a name its client no longer reads (the limits pass moves those back).
     try:
-        return keychain.probe(d)['state'] in ('present', 'locked', 'corrupt')
+        return keychain.probe(d, legacy=True)['state'] in ('present', 'locked', 'corrupt')
     except Exception:
         return False
 by_email = {}
@@ -1323,6 +1326,9 @@ cmd_login() {
     if [ -z "$got" ] && [ "$force" != "1" ]; then
       die "signed in, but the account identity could not be read back — refusing to call $id fixed (retry, or pass --force)"
     fi
+    # Only now, with the identity confirmed, may the stale Keychain items go: a sign-in
+    # as the wrong account (died above) must leave every item as it was.
+    keychain_prune "$d"
     clear_auth_markers "$d" keep-token-park
     if [ -s "$d/.credentials.json" ]; then
       echo "$id login saved (.credentials.json, this machine, auto-refreshing)."
@@ -1859,36 +1865,49 @@ class FileStore:
 
 class KeychainStore:
     """The same credential, held in the macOS Keychain by the client itself (see
-    lib/keychain.py). Read and written in place — NEVER copied out to a file: a file
-    beside a Keychain item is a second copy of a ROTATING refresh grant, and the
-    client reads the Keychain first, so the two would drift apart and strand one."""
+    lib/keychain.py). Read from the item the client reads (the canonical name; this
+    pass alone also accepts the legacy first match, which oauth_store moves) and written
+    back under the canonical name, which also drops the siblings holding the grant the
+    refresh started from — NEVER copied out to a file: a file beside a Keychain item is
+    a second copy of a ROTATING refresh grant, and the client reads the Keychain first,
+    so the two would drift apart and strand one."""
     kind = 'keychain'
 
     def __init__(self, d, probe):
         self.d = d
-        self.account = probe.get('account')
+        self.grant = None
+        self.moved = False
 
     def read(self):
-        p = keychain.probe(self.d)
+        p = keychain.probe(self.d, legacy=True)
         if p['state'] != 'present':
             raise ValueError(f'keychain credential {p["state"]}')
+        grant = p['doc']['claudeAiOauth'].get('refreshToken')
+        self.grant = grant if isinstance(grant, str) else None
         return p['doc']
 
     def write(self, doc):
-        if not keychain.write(self.d, doc, account=self.account):
+        if not keychain.write(self.d, doc, supersedes=self.grant):
             raise OSError('keychain write refused')
 
 
 def oauth_store(d):
     """Where <d>'s OAuth login lives for THIS process: a FileStore, a KeychainStore,
     the string 'locked' (Keychain item exists but this session cannot open it), or
-    None. The file wins when both exist — same rule as lib/audit.oauth_login."""
+    None. The file wins when both exist — same rule as lib/audit.oauth_login.
+
+    A Keychain login found only under a name its client no longer reads (a USER-less
+    sign-in's "unknown", lib/keychain.py) is moved under the canonical name here, once:
+    until then the client, the shim and the audit all see no login."""
     cpath = os.path.join(d, '.credentials.json')
     if os.path.isfile(cpath):
         return FileStore(cpath)
-    p = keychain.probe(d)
+    p = keychain.probe(d, legacy=True)
     if p['state'] == 'present':
-        return KeychainStore(d, p)
+        store = KeychainStore(d, p)
+        if p['account'] != p['canonical']:
+            store.moved = keychain.write(d, p['doc'])
+        return store
     if p['state'] == 'locked':
         return 'locked'
     return None
@@ -2096,6 +2115,9 @@ for acct in manifest.get('accounts', []):
     except Exception as e:
         say(f'{aid}: could not locate the oauth credential ({str(e)[:120]}); failing open')
         store = None
+    if getattr(store, 'moved', False):
+        say(f'{aid}: Keychain login moved under {keychain.canonical_account()}, '
+            f'the name its client reads')
     locked = store == 'locked'
     if locked:
         store = None
@@ -2784,6 +2806,9 @@ for acct in manifest.get('accounts', []):
         # The login may be in the macOS Keychain (lib/keychain.py). A Keychain this
         # session cannot open is not a failure of the ACCOUNT: the real call below
         # would fail for the session, not the grant, so it is a skip with a reason.
+        # Only the canonical item counts — the one the client below reads; testing an
+        # item under another name would run the client on a login it cannot see and
+        # park an account its token serves.
         kc = keychain.probe(d)
         if kc['state'] == 'present':
             has_creds, cred_doc = True, kc['doc']

package/docs/ACCOUNT_OPERATIONS.md

@@ -73,6 +73,11 @@ auto-refreshing login — `.credentials.json`, or on macOS the login Keychain wh
 the session can open it (Claude Code migrates the file into the Keychain on the first
 refresh from a keychain-capable session; ssh sessions then see the account as
 `KEYCHAIN LOCKED` and cannot run it, while the Mac's own session uses it normally).
+The Keychain item is named after `$USER`; the CLI fills it from `id -un` when the caller's
+env has none (a USER-less client files its login under `unknown`, where the next client
+never reads it). The pool judges only the item under that name, as the client does; a
+login found only under another name is moved there by the next limits pass, and a
+sign-in whose identity matched leaves exactly one item, under that name.
 That credential is **machine-local** (never synced),
 which is what keeps two machines from invalidating each other's refresh token — so an
 account you `add` on the Mac runs on the Mac, and you `add` it on the server (over SSH) if

package/lib/common.sh

@@ -12,6 +12,19 @@
 # shellcheck disable=SC2034
 
 MULTIACC_PROVIDER="${MULTIACC_PROVIDER:-claude}"
+
+# Claude Code names its macOS Keychain item after $USER, and under Bun a client with no
+# USER calls the user "unknown": `claude-accounts login` run from an env without it
+# (app-robot's panel, 2026-09-24) filed the fresh login beside the old item, under a
+# name the next client never reads (lib/keychain.py). So every client these CLIs start
+# inherits a real name, whatever env the caller passed; bin/claude does the same.
+# Harmless for codex and on Linux.
+if [ -z "${USER:-}" ]; then
+  USER="$(id -un 2>/dev/null || true)"
+  if [ -n "$USER" ]; then export USER; else unset USER; fi
+fi
+if [ -z "${LOGNAME:-}" ] && [ -n "${USER:-}" ]; then export LOGNAME="$USER"; fi
+
 PYBIN="${CLAUDE_MULTIACC_PYTHON:-python3}"
 DEFAULT_SERVER="root@138.197.36.107"
 DEFAULT_SERVER_REPO="/root/claude-multiacc"
@@ -469,10 +482,20 @@ keychain_state() { # $1 = acct dir -> prints present|locked|absent|corrupt|unava
 keychain_has_login() { # $1 = acct dir: an item EXISTS here (readable or locked)
   case "$(keychain_state "$1")" in present|locked|corrupt) return 0 ;; *) return 1 ;; esac
 }
-keychain_forget() { # $1 = acct dir: drop the item (a removed account must not leave a grant behind)
+keychain_forget() { # $1 = acct dir: drop every item (a removed account must not leave a grant behind)
   [ "$MULTIACC_PROVIDER" = "codex" ] && return 0
   "$PYBIN" "$LIB_DIR/keychain.py" delete "$1" >/dev/null 2>&1 || true
 }
+keychain_prune() { # $1 = acct dir: drop the non-canonical items once the canonical one is a
+                   # live login (lib/keychain.py prune). Quiet, never fails; logs only a change.
+  [ "$MULTIACC_PROVIDER" = "codex" ] && return 0
+  local line
+  line="$("$PYBIN" "$LIB_DIR/keychain.py" prune "$1" 2>/dev/null)" || true
+  case "$line" in
+    pruned:*|failed:*) log_to ops.log "keychain prune $(basename "$1"): $line" ;;
+  esac
+  return 0
+}
 
 # ---- expired-login bookkeeping -------------------------------------------------
 # `.expired` is the persistent "this account cannot authenticate" marker the shim