tokenmaxxing 1.170.0 → 1.172.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.170.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,10 +41,25 @@ 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 };
+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;
 
-async function freshCodexAuth(account: Account, now: number, refresh: boolean, holder?: string): Promise<{ ok: true; auth: CodexAuthJson } | CodexReadFailure> {
+const REJECTED_REFRESH_BACKOFF_MS = 60 * 60 * 1000;
+
+function afterRejection(rejected: CodexReadFailure, refreshFailure: CodexReadFailure): CodexReadFailure {
+  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> {
   let auth: CodexAuthJson | null;
   try {
     auth = readCodexStoreAuth(account.id);
@@ -52,7 +67,11 @@ async function freshCodexAuth(account: Account, now: number, refresh: boolean, h
     return { ok: false, reason: `store credential unreadable (${errorMessage(e).slice(0, 80)})`, deadGrant: false };
   }
   if (!auth) return { ok: false, reason: "no credential in this account's store - run `tokenmaxxing auth --codex`", deadGrant: false };
-  if (!isCodexAccessExpiring({ auth, now })) return { ok: true, auth };
+  const expiring = isCodexAccessExpiring({ auth, now });
+  if (auth.tokens.access_token !== rejectedToken && !expiring) return { ok: true, auth };
+  if (!expiring && auth.last_refresh != null && now - Date.parse(auth.last_refresh) < REJECTED_REFRESH_BACKOFF_MS) {
+    return { ok: false, reason: "the store was refreshed within the last hour", deadGrant: false };
+  }
   if (!refresh) return { ok: false, reason: "stored access token is expiring and this read never refreshes a store", deadGrant: false, expiring: true };
   if (livingPresences(codexPaths.presenceDir).some((p) => p.accountId === account.id && p.id !== holder)) {
     return { ok: false, reason: "running in a live codex session (store refresh unsafe)", deadGrant: false };
@@ -60,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;
   }
@@ -68,21 +87,32 @@ async function freshCodexAuth(account: Account, now: number, refresh: boolean, h
   return { ok: true, auth };
 }
 
-async function readCodexUsage(account: Account, now: number, refresh: boolean, holder?: string): Promise<CodexReadOutcome> {
-  const fresh = await freshCodexAuth(account, now, refresh, holder);
+async function readCodexUsageOnce(account: Account, now: number, refresh: boolean, holder?: string, rejectedToken?: string): Promise<CodexReadOutcome> {
+  const fresh = await freshCodexAuth(account, now, refresh, holder, rejectedToken);
   if (!fresh.ok) return fresh;
   try {
     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 };
+    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;
   }
 }
 
-export async function observeCodex(account: Account, cfg: Config, now: number, opts: { probe: boolean; refresh: boolean; holder?: string }): Promise<Observation | null> {
+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) return outcome;
+  const { rejectedToken } = outcome;
+  const fresh = await withLock(codexPool.lockFile, () => freshCodexAuth(account, now, true, holder, rejectedToken));
+  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; 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);
@@ -91,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);
@@ -108,21 +138,33 @@ 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[] = [];
+  const expiring: { account: Account; rejected?: CodexReadFailure }[] = [];
   await Promise.all(
     accounts.map(async (account) => {
-      const outcome = await readCodexUsage(account, now, false);
-      if (!outcome.ok && outcome.expiring === true) expiring.push(account);
+      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) => ({ account, fresh: await freshCodexAuth(account, now, true) }))));
-    await Promise.all(rotated.map(async ({ account, fresh }) => record(account, fresh.ok ? await readCodexUsage(account, now, false) : fresh)));
+    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 readCodexUsageOnce(account, now, false) : rejected ? afterRejection(rejected, fresh) : fresh),
+      ),
+    );
   }
   return reports;
 }
@@ -249,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);
@@ -261,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" };
       }
@@ -273,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;

package/src/lib/codexusage.ts

@@ -11,9 +11,11 @@ export const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const USAGE_URL = env("TOKENMAXXING_CODEX_USAGE_URL", CODEX_USAGE_URL);
 
 export class CodexUsageReadError extends Error {
-  constructor(detail: string) {
+  readonly status: number | null;
+  constructor(detail: string, status: number | null = null) {
     super(`codex usage read failed: ${detail}`);
     this.name = "CodexUsageReadError";
+    this.status = status;
   }
 }
 
@@ -73,7 +75,7 @@ export async function fetchCodexUsage(input: { auth: CodexAuthJson; at: number }
   }
   const text = await res.text();
   if (!res.ok) {
-    throw new CodexUsageReadError(`HTTP ${res.status}: ${safeErrorDetail({ text })}`);
+    throw new CodexUsageReadError(`HTTP ${res.status}: ${safeErrorDetail({ text })}`, res.status);
   }
   const parsed = WireUsageSchema.safeParse(JsonTextSchema.safeParse(text).data);
   if (!parsed.success) {