tokenmaxxing 1.40.0 → 1.42.0

package/README.md

@@ -66,7 +66,7 @@ claude                  # use claude as always; each session gets its own accoun
 | `tokenmaxxing init --codex` | same for codex: import login, install codex supervisor + Stop hook |
 | `tokenmaxxing add` | register an additional account (isolated login, harvested once into its own store) |
 | `tokenmaxxing add --codex` | register an additional codex account (isolated login) |
-| `tokenmaxxing auth [--codex] [sel \| --all]` | reauthenticate a pooled account in place: bare lists the pool (emails shown) and asks which; a selector targets one account and tells you the email to sign in with; `--all` walks every needs-reauth account one by one; `--codex` does the same for the codex pool |
+| `tokenmaxxing auth [--codex] [sel \| --all]` | reauthenticate a pooled account in place: bare lists the pool (emails shown) and asks which; a selector targets one account and tells you the email to sign in with; `--all` walks every account that is flagged or has no usable credential in its store, one by one; `--codex` does the same for the codex pool |
 | `tokenmaxxing switch --codex [sel]` | switch the codex pool (takes effect on the next codex start); the claude pool has no manual switch, each session is placed at launch |
 | `tokenmaxxing status [--cached]` | accounts with 5h / weekly usage bars, live session counts, exhausted-until-reset; `--cached` renders the stored figures without sampling |
 | `tokenmaxxing config` | the config path and the effective values; edit the file in an editor, a bad value fails the next load with the field name |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.40.0",
+  "version": "1.42.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/cli/auth.ts

@@ -18,14 +18,13 @@ const AuthPlanSchema = z.discriminatedUnion("kind", [
 ]);
 export type AuthPlan = z.infer<typeof AuthPlanSchema>;
 
-export function planAuth(input: { p: Provider; accounts: Account[]; argv: string[] }): AuthPlan {
+export function planAuth(input: { p: Provider; accounts: Account[]; argv: string[]; needsAuth: Set<string> }): AuthPlan {
   const all = input.argv.includes("--all");
   const rest = input.argv.filter((a) => a !== "--all");
   if ((all && rest.length > 0) || rest.length > 1) return { kind: "usage" };
   if (input.accounts.length === 0) return { kind: "error", message: `no accounts in the pool - run \`tokenmaxxing init${input.p.flag}\` first` };
   if (all) {
-    const flagged = input.accounts.filter((a) => a.needsReauth === true);
-    return { kind: "targets", ids: flagged.map((a) => a.id) };
+    return { kind: "targets", ids: input.accounts.filter((a) => input.needsAuth.has(a.id)).map((a) => a.id) };
   }
   const selector = rest[0];
   if (selector !== undefined) {
@@ -36,18 +35,19 @@ export function planAuth(input: { p: Provider; accounts: Account[]; argv: string
   return { kind: "pick" };
 }
 
-export function pickerOrder(accounts: Account[]): Account[] {
-  const [flagged, healthy] = partition(accounts, (a) => a.needsReauth === true);
+export function pickerOrder(accounts: Account[], needsAuth: Set<string>): Account[] {
+  const [flagged, healthy] = partition(accounts, (a) => needsAuth.has(a.id));
   return [...flagged, ...healthy];
 }
 
-function askWhichAccount(idx: AccountsIndex): Account | null {
-  const ordered = pickerOrder(idx.accounts);
+function askWhichAccount(idx: AccountsIndex, needsAuth: Set<string>): Account | null {
+  const ordered = pickerOrder(idx.accounts, needsAuth);
   console.log("which account do you want to reauthenticate?");
   for (const [i, a] of ordered.entries()) {
     const flags: string[] = [];
     if (a.id === idx.activeId) flags.push(c.green("active"));
     if (a.needsReauth) flags.push(c.red("needs-reauth"));
+    else if (needsAuth.has(a.id)) flags.push(c.red("no-credential"));
     const labelNote = a.email != null && a.label !== a.email ? ` (${a.label})` : "";
     const tag = flags.length ? ` ${flags.join(" ")}` : "";
     console.log(`  ${i + 1}. ${c.bold(a.email ?? a.label)}${labelNote}${tag}`);
@@ -107,7 +107,11 @@ async function reauthOne(p: Provider, target: Account): Promise<boolean> {
 
 export async function cmdAuth(p: Provider, argv: string[]): Promise<number> {
   const idx = loadAccounts(p.pool);
-  const plan = planAuth({ p, accounts: idx.accounts, argv });
+  const needsAuth = new Set<string>();
+  for (const a of idx.accounts) {
+    if (a.needsReauth === true || !(await p.storeUsable(a))) needsAuth.add(a.id);
+  }
+  const plan = planAuth({ p, accounts: idx.accounts, argv, needsAuth });
   if (plan.kind === "usage") {
     console.error(AUTH_USAGE);
     return 2;
@@ -119,7 +123,7 @@ export async function cmdAuth(p: Provider, argv: string[]): Promise<number> {
 
   const targets: Account[] = [];
   if (plan.kind === "pick") {
-    const picked = askWhichAccount(idx);
+    const picked = askWhichAccount(idx, needsAuth);
     if (!picked) return 1;
     targets.push(picked);
   } else {
@@ -128,7 +132,7 @@ export async function cmdAuth(p: Provider, argv: string[]): Promise<number> {
       if (account) targets.push(account);
     }
     if (targets.length === 0) {
-      console.log(`${c.green("✓")} no account needs reauth`);
+      console.log(`${c.green("✓")} every account has a usable credential`);
       return 0;
     }
   }

package/src/lib/claude.ts

@@ -108,6 +108,15 @@ async function prepareMove(target: Account): Promise<void> {
   log("move.prepared", { account: target.id.slice(0, 8), label: target.label });
 }
 
+async function storeUsable(a: Account): Promise<boolean> {
+  try {
+    const creds = await readStore(a.id);
+    return creds != null && !isDeadCredential(creds);
+  } catch {
+    return false;
+  }
+}
+
 export function pickSeat(now: number): Account | null {
   const cfg = loadConfig();
   const idx = loadAccounts(claudePool);
@@ -277,6 +286,7 @@ export const claude: Provider = {
   swap: prepareMove,
   classifySwapError: (e) => (e instanceof InvalidGrantError ? "dead-grant" : e instanceof StoreUnusableError ? "skip" : "fatal"),
   removeCredentials,
+  storeUsable,
   login,
   importLive,
   preflight: () => pinBinOverride({ key: "claudeBin", bin: resolveVerifiedClaude() }),

package/src/lib/codex.ts

@@ -334,6 +334,13 @@ export const codex: Provider = {
   swap,
   classifySwapError: (e) => (e instanceof CodexInvalidGrantError ? "dead-grant" : "fatal"),
   removeCredentials: async (a) => deleteParkedCodexAuth({ credFile: codexCredItemFor(a.id) }),
+  storeUsable: async (a) => {
+    try {
+      return readParkedCodexAuth({ credFile: codexCredItemFor(a.id) }) != null;
+    } catch {
+      return false;
+    }
+  },
   login,
   importLive,
   preflight,

package/src/lib/provider.ts

@@ -23,6 +23,7 @@ export type Provider = {
   swap(target: Account): Promise<void>;
   classifySwapError(e: unknown): SwapFailure;
   removeCredentials(account: Account): Promise<void>;
+  storeUsable(account: Account): Promise<boolean>;
   login(): Promise<Harvest | null>;
   importLive(): Promise<Harvest | null>;
   preflight(): void;

package/src/lib/sample.ts

@@ -6,11 +6,12 @@ import { writeFileAtomic } from "./atomic.ts";
 import { readStore } from "./credstore.ts";
 import { withLock } from "./lock.ts";
 import { log } from "./log.ts";
-import { claudeTierLabel, isDeadCredential } from "./oauth.ts";
-import { claudePool, sampleDirFor, storeDirFor } from "./paths.ts";
+import { claudeTierLabel, isAccessTokenExpiring, isDeadCredential } from "./oauth.ts";
+import { claudePool, paths, sampleDirFor, storeDirFor } from "./paths.ts";
+import { seatCounts } from "./presence.ts";
 import type { Observation } from "./provider.ts";
 import { loadAccounts, loadUsageSnapshot, saveAccounts } from "./state.ts";
-import { mergeWindows, probeUsage, windowsOf } from "./usage.ts";
+import { fetchUsageDirect, mergeWindows, probeUsage, windowsOf } from "./usage.ts";
 import { UsageWindowsSchema, type Account, type Config } from "./types.ts";
 
 const SampleOutcomeSchema = z.discriminatedUnion("ok", [
@@ -93,11 +94,28 @@ export async function sampleOldest(cfg: Config): Promise<void> {
       log("sample.failed", { account: target.id.slice(0, 8), reason: prepared.reason.slice(0, 200) });
       return null;
     }
-    return { account: target, dir: prepared.dir };
+    let token: string | null = null;
+    if (!seatCounts(paths.presenceDir).has(target.id)) {
+      const creds = await readStore(target.id).catch(() => null);
+      if (creds && !isDeadCredential(creds) && !isAccessTokenExpiring(creds)) token = creds.accessToken;
+    }
+    return { account: target, dir: prepared.dir, token };
   });
   if (!reserved) return;
   const startedAt = Date.now();
-  const outcome = await runProbe(reserved.account, reserved.dir, { retries: 0 });
+  let via = "probe";
+  let outcome: SampleOutcome;
+  if (reserved.token) {
+    const usage = await fetchUsageDirect(reserved.token);
+    if (usage) {
+      via = "get";
+      outcome = { ok: true, usage };
+    } else {
+      outcome = await runProbe(reserved.account, reserved.dir, { retries: 0 });
+    }
+  } else {
+    outcome = await runProbe(reserved.account, reserved.dir, { retries: 0 });
+  }
   await withLock(claudePool.lockFile, () => {
     const idx = loadAccounts(claudePool);
     const stored = idx.accounts.find((a) => a.id === reserved.account.id);
@@ -108,7 +126,7 @@ export async function sampleOldest(cfg: Config): Promise<void> {
     }
     log(outcome.ok ? "sample.ok" : "sample.failed", {
       account: reserved.account.id.slice(0, 8),
-      ...(outcome.ok ? {} : { reason: outcome.reason.slice(0, 200) }),
+      ...(outcome.ok ? { via } : { reason: outcome.reason.slice(0, 200) }),
     });
   });
 }

package/src/lib/usage.ts

@@ -2,7 +2,9 @@ import { closeSync, fstatSync, openSync, readSync } from "node:fs";
 import { delay } from "es-toolkit";
 import { z } from "zod";
 import { MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealClaude } from "./claudebin.ts";
+import { http } from "./http.ts";
 import { log } from "./log.ts";
+import { env } from "./paths.ts";
 import { JsonTextSchema, RateLimitsStdinSchema, type ModelInfo, type UsageWindow, type UsageWindows, type Window } from "./types.ts";
 
 export function normalizeResetsAt(v: unknown): number | null {
@@ -341,10 +343,10 @@ function probeEnv(target: ProbeTarget): Record<string, string> {
 }
 
 export async function probeUsage(target: ProbeTarget, now = Date.now(), opts: { retries?: number } = {}): Promise<UsageWindows | null> {
-  const env = probeEnv(target);
+  const probe = probeEnv(target);
 
   for (let attempt = 0; ; attempt++) {
-    const full = await probeUsageOnce(env, now);
+    const full = await probeUsageOnce(probe, now);
     if (full) return full;
     if (attempt >= (opts.retries ?? PROBE_RETRY_DELAYS_MS.length)) {
       log("usage.probe_gave_up", { attempts: attempt + 1 });
@@ -353,3 +355,42 @@ export async function probeUsage(target: ProbeTarget, now = Date.now(), opts: {
     await delay(PROBE_RETRY_DELAYS_MS[Math.min(attempt, PROBE_RETRY_DELAYS_MS.length - 1)]!);
   }
 }
+
+const USAGE_URL = env("TOKENMAXXING_OAUTH_USAGE_URL", "https://api.anthropic.com/api/oauth/usage");
+const USAGE_DEADLINE_MS = 10_000;
+
+const UsageWindowResponseSchema = z.object({ utilization: z.number(), resets_at: z.number().nullable().optional() });
+const UsageResponseSchema = z.object({
+  rate_limits: z
+    .object({ five_hour: UsageWindowResponseSchema.nullish(), seven_day: UsageWindowResponseSchema.nullish() })
+    .nullish(),
+});
+
+export async function fetchUsageDirect(accessToken: string): Promise<UsageWindows | null> {
+  let res: Response;
+  try {
+    res = await http.get(`${USAGE_URL}?at_wall=1&skip_spend=1`, {
+      headers: { Authorization: `Bearer ${accessToken}`, "Content-Type": "application/json" },
+      signal: AbortSignal.timeout(USAGE_DEADLINE_MS),
+    });
+  } catch (e) {
+    log("usage.get_failed", { err: e instanceof Error ? e.message : String(e) });
+    return null;
+  }
+  if (!res.ok) {
+    log("usage.get_failed", { status: res.status });
+    return null;
+  }
+  const parsed = UsageResponseSchema.safeParse(JsonTextSchema.safeParse(await res.text()).data);
+  const five = parsed.success ? parsed.data.rate_limits?.five_hour : null;
+  const seven = parsed.success ? parsed.data.rate_limits?.seven_day : null;
+  if (!five || !seven) {
+    log("usage.get_incomplete", { ok: parsed.success });
+    return null;
+  }
+  const win = (w: z.infer<typeof UsageWindowResponseSchema>): UsageWindow => ({
+    usedPercentage: w.utilization * 100,
+    resetsAt: w.resets_at != null ? w.resets_at * 1000 : null,
+  });
+  return { fiveHour: win(five), sevenDay: win(seven), perModel: {} };
+}

package/src/main.ts

@@ -42,7 +42,7 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing init --codex")}  same for codex: import login, install codex supervisor + Stop hook (trust it via /hooks)
   ${c.cyan("tokenmaxxing add")}        register an additional account (isolated login)
   ${c.cyan("tokenmaxxing add --codex")}   register an additional codex account (isolated login)
-  ${c.cyan("tokenmaxxing auth")} [--codex] [sel | --all]  reauthenticate a pooled account in place (bare = pick from a list; --all = every needs-reauth account, one by one)
+  ${c.cyan("tokenmaxxing auth")} [--codex] [sel | --all]  reauthenticate a pooled account in place (bare = pick from a list; --all = every account that is flagged or has no usable credential in its store, one by one)
   ${c.cyan("tokenmaxxing switch --codex")} [sel]  switch the codex pool (takes effect on next codex start)
   ${c.cyan("tokenmaxxing status")} [--cached]  accounts with 5h / weekly / per-model usage bars (--cached: the stored figures, no sampling)
   ${c.cyan("tokenmaxxing config")}     print the config path and the effective values (edit the file in an editor)