tokenmaxxing 1.171.0 → 1.172.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.171.0",
+  "version": "1.172.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts, start each session on its own account, and resume a session on a fresher account when quota fills.",
   "type": "module",
   "license": "MIT",

package/src/lib/codex.ts

@@ -41,13 +41,22 @@ function applyUsage(account: Account, usage: CodexUsage, at: number): void {
   if (usage.planType != null) account.tier = usage.planType;
 }
 
-type CodexReadFailure = { ok: false; reason: string; deadGrant: boolean; expiring?: boolean; rejectedToken?: string };
+type CodexReadFailure = { ok: false; reason: string; deadGrant: boolean; deadAccessToken?: string; expiring?: boolean; rejected?: boolean; rejectedToken?: string };
 type CodexReadOutcome = { ok: true; usage: CodexUsage; at: number } | CodexReadFailure;
 
 const REJECTED_REFRESH_BACKOFF_MS = 60 * 60 * 1000;
 
 function afterRejection(rejected: CodexReadFailure, refreshFailure: CodexReadFailure): CodexReadFailure {
-  return { ...refreshFailure, reason: `${rejected.reason}; refresh skipped: ${refreshFailure.reason}` };
+  return { ...refreshFailure, rejected: true, reason: `${rejected.reason}; refresh skipped: ${refreshFailure.reason}` };
+}
+
+function storeHolds(accountId: string, accessToken: string | undefined): boolean {
+  if (accessToken === undefined) return true;
+  try {
+    return readCodexStoreAuth(accountId)?.tokens.access_token === accessToken;
+  } catch {
+    return false;
+  }
 }
 
 async function freshCodexAuth(account: Account, now: number, refresh: boolean, holder?: string, rejectedToken?: string): Promise<{ ok: true; auth: CodexAuthJson } | CodexReadFailure> {
@@ -70,7 +79,7 @@ async function freshCodexAuth(account: Account, now: number, refresh: boolean, h
   try {
     auth = await refreshCodexAuth({ auth, now });
   } catch (e) {
-    if (e instanceof CodexInvalidGrantError) return { ok: false, reason: e.message, deadGrant: true };
+    if (e instanceof CodexInvalidGrantError) return { ok: false, reason: e.message, deadGrant: true, deadAccessToken: auth.tokens.access_token };
     if (e instanceof CodexRefreshFailedError) return { ok: false, reason: e.message, deadGrant: false };
     throw e;
   }
@@ -85,22 +94,25 @@ async function readCodexUsageOnce(account: Account, now: number, refresh: boolea
     const at = Date.now();
     return { ok: true, usage: await fetchCodexUsage({ auth: fresh.auth, at }), at };
   } catch (e) {
-    if (e instanceof CodexUsageReadError) return { ok: false, reason: e.message, deadGrant: false, rejectedToken: e.status === 401 ? fresh.auth.tokens.access_token : undefined };
+    if (e instanceof CodexUsageReadError) return { ok: false, reason: e.message, deadGrant: false, rejected: e.status === 401, rejectedToken: e.status === 401 ? fresh.auth.tokens.access_token : undefined };
     throw e;
   }
 }
 
 async function readCodexUsage(account: Account, now: number, refresh: boolean, holder?: string): Promise<CodexReadOutcome> {
   const outcome = await readCodexUsageOnce(account, now, refresh, holder);
-  if (outcome.ok || outcome.rejectedToken === undefined || !refresh) return outcome;
+  if (outcome.ok || outcome.rejectedToken === undefined) return outcome;
   const { rejectedToken } = outcome;
   const fresh = await withLock(codexPool.lockFile, () => freshCodexAuth(account, now, true, holder, rejectedToken));
-  return fresh.ok ? readCodexUsageOnce(account, now, false) : afterRejection(outcome, fresh);
+  if (!fresh.ok) return afterRejection(outcome, fresh);
+  const retried = await readCodexUsageOnce(account, now, false);
+  return retried.ok ? retried : { ...retried, rejectedToken: undefined };
 }
 
-export async function observeCodex(account: Account, cfg: Config, now: number, opts: { probe: boolean; refresh: boolean; holder?: string }): Promise<Observation | null> {
+export async function observeCodex(account: Account, cfg: Config, now: number, opts: { probe: boolean; refresh: boolean; holder?: string; rejected?: Set<string> }): Promise<Observation | null> {
   if (opts.probe && (account.lastUsageAt == null || now - account.lastUsageAt > cfg.policy.usagePollTtlMs)) {
     const outcome = await readCodexUsage(account, now, opts.refresh, opts.holder);
+    if (!outcome.ok && outcome.rejected === true) opts.rejected?.add(account.id);
     await withLock(codexPool.lockFile, () => {
       const idx = loadAccounts(codexPool);
       const a = idx.accounts.find((x) => x.id === account.id);
@@ -109,7 +121,7 @@ export async function observeCodex(account: Account, cfg: Config, now: number, o
         if (a.lastUsageAt == null || outcome.at > a.lastUsageAt) {
           applyUsage(a, outcome.usage, outcome.at);
         }
-      } else if (outcome.deadGrant) {
+      } else if (outcome.deadGrant && storeHolds(a.id, outcome.deadAccessToken)) {
         a.needsReauth = true;
       }
       saveAccounts(codexPool, idx);
@@ -126,23 +138,31 @@ async function samplePool(accounts: Account[], now: number): Promise<Map<string,
       applyUsage(account, outcome.usage, outcome.at);
       reports.set(account.id, { ok: true, source: "probe" });
     } else {
-      if (outcome.deadGrant) account.needsReauth = true;
       reports.set(account.id, { ok: false, reason: outcome.reason });
     }
   };
   const expiring: { account: Account; rejected?: CodexReadFailure }[] = [];
   await Promise.all(
     accounts.map(async (account) => {
-      const outcome = await readCodexUsage(account, now, false);
+      const outcome = await readCodexUsageOnce(account, now, false);
       if (!outcome.ok && (outcome.expiring === true || outcome.rejectedToken !== undefined)) expiring.push({ account, rejected: outcome.rejectedToken === undefined ? undefined : outcome });
       else record(account, outcome);
     }),
   );
   if (expiring.length > 0) {
-    const rotated = await withLock(codexPool.lockFile, () => Promise.all(expiring.map(async ({ account, rejected }) => ({ account, rejected, fresh: await freshCodexAuth(account, now, true, undefined, rejected?.rejectedToken) }))));
+    const rotated = await withLock(codexPool.lockFile, async () => {
+      const results = await Promise.all(expiring.map(async ({ account, rejected }) => ({ account, rejected, fresh: await freshCodexAuth(account, now, true, undefined, rejected?.rejectedToken) })));
+      const dead = new Set(results.filter(({ fresh }) => !fresh.ok && fresh.deadGrant).map(({ account }) => account.id));
+      if (dead.size > 0) {
+        const idx = loadAccounts(codexPool);
+        for (const a of idx.accounts) if (dead.has(a.id)) a.needsReauth = true;
+        saveAccounts(codexPool, idx);
+      }
+      return results;
+    });
     await Promise.all(
       rotated.map(async ({ account, rejected, fresh }) =>
-        record(account, fresh.ok ? await readCodexUsage(account, now, false) : rejected ? afterRejection(rejected, fresh) : fresh),
+        record(account, fresh.ok ? await readCodexUsageOnce(account, now, false) : rejected ? afterRejection(rejected, fresh) : fresh),
       ),
     );
   }
@@ -271,10 +291,11 @@ export async function borrowCodexSeat(pid: number): Promise<SeatBorrow> {
   const now = Date.now();
   const seatId = `seat-${pid}`;
   const cfg = loadConfig();
+  const rejected = new Set<string>();
   await Promise.all(
     loadAccounts(codexPool)
       .accounts.filter((a) => a.needsReauth !== true && codexStoreUsable(a.id))
-      .map((a) => observeCodex(a, cfg, now, { probe: true, refresh: false })),
+      .map((a) => observeCodex(a, cfg, now, { probe: true, refresh: false, rejected })),
   );
   const granted = await withLock(codexPool.lockFile, (): SeatBorrow => {
     const ctx = codexPickCtx(now, null);
@@ -283,6 +304,9 @@ export async function borrowCodexSeat(pid: number): Promise<SeatBorrow> {
     const held = living.find((p) => p.id === seatId);
     const heldAccount = held ? (idx.accounts.find((x) => x.id === held.accountId) ?? null) : null;
     if (heldAccount) {
+      if (rejected.has(heldAccount.id)) {
+        return { denied: "the usage endpoint rejects the account this pid holds and its store could not be refreshed now - borrow again later" };
+      }
       if (heldAccount.needsReauth === true) {
         return { denied: "the account this pid holds needs reauthentication - run `tokenmaxxing auth --codex` and borrow again" };
       }
@@ -295,7 +319,7 @@ export async function borrowCodexSeat(pid: number): Promise<SeatBorrow> {
     const closed = new Set(living.filter((p) => p.id === parent || p.id.startsWith(PI_PRESENCE_PREFIX)).map((p) => p.accountId));
     const lent = countBy(living, (p) => p.accountId);
     const usable = idx.accounts.filter(
-      (a) => !closed.has(a.id) && a.needsReauth !== true && !isExhausted(a, ctx) && codexStoreUsable(a.id)
+      (a) => !closed.has(a.id) && !rejected.has(a.id) && a.needsReauth !== true && !isExhausted(a, ctx) && codexStoreUsable(a.id)
     );
     const plan = usable.filter((a) => !onCredits(a, ctx));
     const open = plan.length > 0 ? plan : usable;