tokenmaxxing 1.76.0 → 1.77.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.76.0",
+  "version": "1.77.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/grok.ts

@@ -2,13 +2,13 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
-import { fetchGrokUsage, GrokUsageReadError } from "./grokusage.ts";
+import { fetchGrokUsage, GrokUsageReadError, type GrokUsage } from "./grokusage.ts";
 import { errorMessage } from "./log.ts";
 import { grokAuthJsonFor, grokPaths, grokPool, grokSeatFromEnv, grokStoreDirFor } from "./paths.ts";
 import type { Provider, SampleReport } from "./provider.ts";
 import { loadAccounts, type Harvest } from "./state.ts";
 import { statusOnlyProvider, type AuthEntry } from "./statusonly.ts";
-import type { Account } from "./types.ts";
+import { InstantSchema, type Account } from "./types.ts";
 import { c } from "../cli/render.ts";
 
 const GrokAuthEntrySchema = z.looseObject({
@@ -69,8 +69,7 @@ function credsIn(path: string): GrokCred[] {
     const id = entry.user_id ?? entry.principal_id ?? key;
     const token = entry.key ?? "";
     if (id === "" || token === "") continue;
-    const expiresAt = entry.expires_at != null ? Date.parse(entry.expires_at) : null;
-    out.push({ id, token, expiresAt: expiresAt != null && Number.isFinite(expiresAt) ? expiresAt : null });
+    out.push({ id, token, expiresAt: InstantSchema.safeParse(entry.expires_at).data ?? null });
   }
   return out;
 }
@@ -91,27 +90,21 @@ function bearerFor(accountId: string, now: number): { token: string; from: "stor
 async function readGrokUsage(account: Account, now: number): Promise<{ ok: true; at: number } | { ok: false; reason: string }> {
   const first = bearerFor(account.id, now);
   if (first == null) return { ok: false, reason: "no usable credential in this account's store - run `tokenmaxxing auth --grok`" };
+  let usage: GrokUsage;
   try {
-    const usage = await fetchGrokUsage({ token: first.token, at: now });
-    account.windows = usage.windows;
-    account.lastUsageAt = usage.at;
-    return { ok: true, at: usage.at };
+    usage = await fetchGrokUsage({ token: first.token, at: now });
   } catch (e) {
-    if (e instanceof GrokUsageReadError && e.status === 401 && first.from === "store") {
-      const live = liveCred(account.id);
-      if (live != null && live.token !== first.token) {
-        try {
-          const usage = await fetchGrokUsage({ token: live.token, at: now });
-          account.windows = usage.windows;
-          account.lastUsageAt = usage.at;
-          return { ok: true, at: usage.at };
-        } catch (retry) {
-          return { ok: false, reason: retry instanceof GrokUsageReadError ? retry.message : errorMessage(retry) };
-        }
-      }
+    const live = e instanceof GrokUsageReadError && e.status === 401 && first.from === "store" ? liveCred(account.id) : null;
+    if (live == null || live.token === first.token) return { ok: false, reason: errorMessage(e) };
+    try {
+      usage = await fetchGrokUsage({ token: live.token, at: now });
+    } catch (retry) {
+      return { ok: false, reason: errorMessage(retry) };
     }
-    return { ok: false, reason: e instanceof GrokUsageReadError ? e.message : errorMessage(e) };
   }
+  account.windows = usage.windows;
+  account.lastUsageAt = usage.at;
+  return { ok: true, at: usage.at };
 }
 
 async function samplePool(accounts: Account[], _liveId: string | null, now: number): Promise<Map<string, SampleReport>> {

package/src/lib/grokusage.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { http, safeErrorDetail } from "./http.ts";
 import { errorMessage } from "./log.ts";
 import { env } from "./paths.ts";
-import { JsonTextSchema, type Window } from "./types.ts";
+import { InstantSchema, JsonTextSchema, type Window } from "./types.ts";
 
 export class GrokUsageReadError extends Error {
   status: number | null;
@@ -13,8 +13,6 @@ export class GrokUsageReadError extends Error {
   }
 }
 
-const InstantSchema = z.iso.datetime({ offset: true });
-
 const CreditsPeriodSchema = z.looseObject({
   start: InstantSchema,
   end: InstantSchema,
@@ -57,17 +55,15 @@ export async function fetchGrokUsage(input: { token: string; at: number }): Prom
   if (!parsed.success) {
     throw new GrokUsageReadError("endpoint returned an unexpected body shape (withheld)");
   }
-  const period = parsed.data.config.currentPeriod;
-  const start = Date.parse(period.start);
-  const end = Date.parse(period.end);
+  const { start, end } = parsed.data.config.currentPeriod;
   return {
     at,
     windows: [
       {
         name: null,
         usedPercentage: parsed.data.config.creditUsagePercent,
-        resetsAt: Number.isFinite(end) ? end : null,
-        windowSeconds: Number.isFinite(start) && Number.isFinite(end) && end > start ? Math.round((end - start) / 1000) : null,
+        resetsAt: end,
+        windowSeconds: end > start ? Math.round((end - start) / 1000) : null,
         sampledAt: at,
       },
     ],

package/src/lib/types.ts

@@ -152,6 +152,8 @@ export const RespawnMarkerSchema = z.object({
 
 export const EpochSecondsSchema = z.number().transform((seconds) => seconds * 1000);
 
+export const InstantSchema = z.iso.datetime({ offset: true }).transform((iso) => Date.parse(iso));
+
 const StdinWindowSchema = z.looseObject({ used_percentage: z.number(), resets_at: EpochSecondsSchema.nullable().optional() });
 
 export const RateLimitsStdinSchema = z.looseObject({

package/src/lib/usage.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { http } from "./http.ts";
 import { errorMessage, log } from "./log.ts";
 import { env } from "./paths.ts";
-import { EpochSecondsSchema, JsonTextSchema, RateLimitsStdinSchema, type ModelInfo, type UsageWindow, type UsageWindows, type Window } from "./types.ts";
+import { EpochSecondsSchema, InstantSchema, JsonTextSchema, RateLimitsStdinSchema, type ModelInfo, type UsageWindow, type UsageWindows, type Window } from "./types.ts";
 
 const win = (w: { used_percentage: number; resets_at?: number | null }): UsageWindow => ({
   usedPercentage: w.used_percentage,
@@ -185,7 +185,7 @@ export const OAUTH_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 const USAGE_URL = env("TOKENMAXXING_OAUTH_USAGE_URL", OAUTH_USAGE_URL);
 const USAGE_DEADLINE_MS = 10_000;
 
-const ResetsAtSchema = z.iso.datetime({ offset: true }).transform((iso) => Date.parse(iso)).nullish();
+const ResetsAtSchema = InstantSchema.nullish();
 const UsageLimitSchema = z.looseObject({ utilization: z.number(), resets_at: ResetsAtSchema });
 const UsageScopedLimitSchema = z.looseObject({
   kind: z.string(),