tokenmaxxing 1.41.0 → 1.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.41.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/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: {} };
+}