tokenmaxxing 1.57.0 → 1.58.0

package/src/lib/sample.ts

@@ -1,29 +1,20 @@
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { readStore } from "./credstore.ts";
 import { withLock } from "./lock.ts";
-import { log } from "./log.ts";
+import { errorMessage, log } from "./log.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 { fetchUsageDirect, mergeWindows, probeUsage, windowsOf } from "./usage.ts";
-import { UsageWindowsSchema, type Account, type Config } from "./types.ts";
+import { fetchUsageDirect, mergeWindows, refreshViaProbe, windowsOf } from "./usage.ts";
+import type { Account, Config, UsageWindows } from "./types.ts";
 
-const SampleOutcomeSchema = z.discriminatedUnion("ok", [
-  z.object({ ok: z.literal(true), usage: UsageWindowsSchema, via: z.enum(["get", "probe"]) }),
-  z.object({ ok: z.literal(false), reason: z.string() }),
-]);
-export type SampleOutcome = z.infer<typeof SampleOutcomeSchema>;
+export type SampleOutcome = { ok: true; usage: UsageWindows; via: "get" | "probe" } | { ok: false; reason: string };
 
-const PreparedSampleSchema = z.discriminatedUnion("ok", [
-  z.object({ ok: z.literal(true), token: z.string().nullable() }),
-  z.object({ ok: z.literal(false), reason: z.string() }),
-]);
-type PreparedSample = z.infer<typeof PreparedSampleSchema>;
+type PreparedSample = { ok: true; token: string | null } | { ok: false; reason: string };
 
 export function teeObservation(account: Account): Observation | null {
   const stored = account.lastUsageAt != null ? { windows: account.windows, at: account.lastUsageAt } : null;
@@ -48,7 +39,7 @@ export async function prepareSample(account: Account): Promise<PreparedSample> {
   try {
     creds = await readStore(account.id);
   } catch (e) {
-    return { ok: false, reason: `store credential unreadable (${(e instanceof Error ? e.message : String(e)).slice(0, 80)}) - run \`tokenmaxxing auth\`` };
+    return { ok: false, reason: `store credential unreadable (${errorMessage(e).slice(0, 80)}) - run \`tokenmaxxing auth\`` };
   }
   if (!creds) return { ok: false, reason: "no credential in this account's store - run `tokenmaxxing auth`" };
   if (isDeadCredential(creds)) {
@@ -60,25 +51,29 @@ export async function prepareSample(account: Account): Promise<PreparedSample> {
   return { ok: true, token: isAccessTokenExpiring(creds) ? null : creds.accessToken };
 }
 
-async function runProbe(account: Account, suffix: string, retries: number | undefined): Promise<SampleOutcome> {
+async function refreshedToken(account: Account, suffix: string): Promise<string | null> {
   const dir = sampleDirFor(account.id, suffix);
   mkdirSync(dir, { recursive: true });
   writeFileAtomic(join(dir, ".claude.json"), JSON.stringify({ oauthAccount: account.oauthAccount, hasCompletedOnboarding: true }));
-  const usage = await probeUsage({ configDir: dir, store: storeDirFor(account.id) }, Date.now(), { retries });
-  return usage ? { ok: true, usage, via: "probe" } : { ok: false, reason: "`/usage` returned no limit data (see log)" };
+  if (!(await refreshViaProbe({ configDir: dir, store: storeDirFor(account.id) }))) return null;
+  const prepared = await prepareSample(account);
+  return prepared.ok ? prepared.token : null;
 }
 
-export async function runSample(account: Account, token: string | null, opts: { retries?: number; suffix?: string }): Promise<SampleOutcome> {
+export async function runSample(account: Account, token: string | null, suffix = ""): Promise<SampleOutcome> {
   if (token) {
     const usage = await fetchUsageDirect(token);
     if (usage) return { ok: true, usage, via: "get" };
   }
-  return runProbe(account, opts.suffix ?? "", opts.retries);
+  const fresh = await refreshedToken(account, suffix);
+  if (!fresh) return { ok: false, reason: "the `/usage` probe left no usable access token in the store (see log)" };
+  const usage = await fetchUsageDirect(fresh);
+  return usage ? { ok: true, usage, via: "probe" } : { ok: false, reason: "usage read failed after the `/usage` probe (see log)" };
 }
 
-export async function sampleAccountUsage(account: Account, opts: { retries?: number } = {}): Promise<SampleOutcome> {
+export async function sampleAccountUsage(account: Account): Promise<SampleOutcome> {
   const prepared = await prepareSample(account);
-  return prepared.ok ? runSample(account, prepared.token, opts) : prepared;
+  return prepared.ok ? runSample(account, prepared.token) : prepared;
 }
 
 const SAMPLE_BATCH = 3;
@@ -119,15 +114,21 @@ export async function sampleOldest(cfg: Config): Promise<void> {
   await Promise.all(
     reserved.map(async ({ account, token }) => {
       const startedAt = Date.now();
-      const outcome = await runSample(account, token, { retries: 0, suffix: "-tick" });
+      const outcome = await runSample(account, token, "-tick");
       await withLock(claudePool.lockFile, () => {
         const idx = loadAccounts(claudePool);
         const stored = idx.accounts.find((a) => a.id === account.id);
+        let dirty = false;
+        if (stored && account.needsReauth === true && stored.needsReauth !== true) {
+          stored.needsReauth = true;
+          dirty = true;
+        }
         if (stored && outcome.ok && (stored.lastUsageAt == null || startedAt > stored.lastUsageAt)) {
           stored.windows = mergeWindows(windowsOf(outcome.usage, startedAt), stored.windows);
           stored.lastUsageAt = startedAt;
-          saveAccounts(claudePool, idx);
+          dirty = true;
         }
+        if (dirty) saveAccounts(claudePool, idx);
         log(outcome.ok ? "sample.ok" : "sample.failed", {
           account: account.id.slice(0, 8),
           ...(outcome.ok ? { via: outcome.via } : { reason: outcome.reason.slice(0, 200) }),

package/src/lib/sessions.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { paths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
-import { RespawnMarkerSchema } from "./types.ts";
+import type { RespawnMarkerSchema } from "./types.ts";
 
 const SessionSchema = z.object({ flags: z.array(z.string()), cwd: z.string() });
 
@@ -36,8 +36,7 @@ export function pruneStaleSessions(now: number): void {
   }
 }
 
-const SupervisedSessionSchema = z.object({ sid: z.string().min(1), launchedAt: z.number().finite().nullable() });
-export type SupervisedSession = z.infer<typeof SupervisedSessionSchema>;
+export type SupervisedSession = { sid: string; launchedAt: number | null };
 
 const LaunchedAtSchema = z.coerce.number().finite().optional().catch(undefined);
 
@@ -45,18 +44,18 @@ export function supervisedSession(env: Record<string, string | undefined> = proc
   if (env.TOKENMAXXING_SUPERVISED !== "1") return null;
   const sid = env.TOKENMAXXING_SESSION_ID;
   if (sid == null || sid === "") return null;
-  return SupervisedSessionSchema.parse({ sid, launchedAt: LaunchedAtSchema.parse(env.TOKENMAXXING_LAUNCHED_AT) ?? null });
+  return { sid, launchedAt: LaunchedAtSchema.parse(env.TOKENMAXXING_LAUNCHED_AT) ?? null };
 }
 
 export function writeRespawnMarker(input: { session: SupervisedSession; sessionId: string; accountId: string; waitUntil: number; compact: boolean }): void {
   mkdirSync(paths.respawnDir, { recursive: true });
-  const payload = RespawnMarkerSchema.parse({
+  const payload: z.infer<typeof RespawnMarkerSchema> = {
     accountId: input.accountId,
     ts: Date.now(),
     waitUntil: input.waitUntil,
     sessionId: input.sessionId,
     compact: input.compact,
     ...(input.session.launchedAt != null ? { launchedAt: input.session.launchedAt } : {}),
-  });
+  };
   writeFileAtomic(join(paths.respawnDir, input.session.sid), JSON.stringify(payload));
 }

package/src/lib/settings.ts

@@ -112,14 +112,7 @@ export function uninstallSettings(): void {
   writeSettings(s);
 }
 
-const SettingsCheckSchema = z.object({
-  statusLineOk: z.boolean(),
-  subagentStatusLineOk: z.boolean(),
-  stopOk: z.boolean(),
-  stopFailureOk: z.boolean(),
-  sessionStartOk: z.boolean(),
-});
-export type SettingsCheck = z.infer<typeof SettingsCheckSchema>;
+export type SettingsCheck = Record<"statusLineOk" | "subagentStatusLineOk" | "stopOk" | "stopFailureOk" | "sessionStartOk", boolean>;
 
 export function checkSettings(): SettingsCheck {
   const s = readSettings();

package/src/lib/state.ts

@@ -1,13 +1,12 @@
 import { closeSync, existsSync, fstatSync, openSync, readFileSync, rmSync, utimesSync } from "node:fs";
 import { isEqual } from "es-toolkit";
 import { z } from "zod";
-import { paths, realClaudeBinFromEnv, realCodexBinFromEnv, realGrokBinFromEnv, realOpencodeBinFromEnv, usageJsonFor, type PoolPaths } from "./paths.ts";
+import { optionalEnv, paths, usageJsonFor, type PoolPaths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import {
   AccountsIndexSchema,
   ConfigSchema,
   ErrnoSchema,
-  LastSwapSchema,
   UsageStateSchema,
   type Account,
   type AccountsIndex,
@@ -31,14 +30,10 @@ export function loadConfig(): Config {
     throw new Error(`${paths.configJson} is invalid (${fields}) - fix or remove the offending values`);
   }
   const cfg = parsed.data;
-  const envBin = realClaudeBinFromEnv();
-  if (envBin) cfg.claudeBin = envBin;
-  const envCodexBin = realCodexBinFromEnv();
-  if (envCodexBin) cfg.codexBin = envCodexBin;
-  const envGrokBin = realGrokBinFromEnv();
-  if (envGrokBin) cfg.grokBin = envGrokBin;
-  const envOpencodeBin = realOpencodeBinFromEnv();
-  if (envOpencodeBin) cfg.opencodeBin = envOpencodeBin;
+  cfg.claudeBin = optionalEnv("TOKENMAXXING_CLAUDE_BIN") ?? cfg.claudeBin;
+  cfg.codexBin = optionalEnv("TOKENMAXXING_CODEX_BIN") ?? cfg.codexBin;
+  cfg.grokBin = optionalEnv("TOKENMAXXING_GROK_BIN") ?? cfg.grokBin;
+  cfg.opencodeBin = optionalEnv("TOKENMAXXING_OPENCODE_BIN") ?? cfg.opencodeBin;
   return cfg;
 }
 
@@ -51,7 +46,7 @@ export function pinBinOverride(input: { key: "claudeBin" | "codexBin" | "grokBin
   writeFileAtomic(paths.configJson, JSON.stringify(raw, null, 2) + "\n");
 }
 
-const emptyIndex = (): AccountsIndex => ({ version: 2, activeId: null, accounts: [] });
+const emptyIndex = (): AccountsIndex => ({ version: 2, accounts: [] });
 
 export function loadAccounts(pool: PoolPaths): AccountsIndex {
   if (!existsSync(pool.accountsJson)) return emptyIndex();
@@ -127,24 +122,6 @@ export function clearUsageSnapshot(accountId: string): void {
   rmSync(usageJsonFor(accountId), { force: true });
 }
 
-export function loadLastSwapAt(pool: PoolPaths): number | null {
-  if (pool.lastSwapJson == null || !existsSync(pool.lastSwapJson)) return null;
-  let json: unknown;
-  try {
-    json = JSON.parse(readFileSync(pool.lastSwapJson, "utf8"));
-  } catch {
-    throw new Error(`${pool.lastSwapJson} is corrupt (unparsable JSON) - refusing to treat a damaged swap clock as never-swapped; repair or remove the file`);
-  }
-  return LastSwapSchema.parse(json).ts;
-}
-
-export function saveLastSwapAt(pool: PoolPaths, ts: number): void {
-  if (pool.lastSwapJson == null) throw new Error("this pool keeps no swap clock");
-  writeFileAtomic(pool.lastSwapJson, JSON.stringify(LastSwapSchema.parse({ ts })));
-}
-
-export const POST_SWAP_COOLDOWN_MS = 45_000;
-
 const USAGE_TS_REFRESH_MS = 10 * 60_000;
 const SAMPLED_AT_REFRESH_MS = 30_000;
 

package/src/lib/statusonly.ts

@@ -0,0 +1,143 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import type { PoolPaths } from "./paths.ts";
+import type { Provider, SampleReport } from "./provider.ts";
+import { loadConfig, pinBinOverride, type Harvest } from "./state.ts";
+import type { Account } from "./types.ts";
+import { c } from "../cli/render.ts";
+
+export type AuthEntry = { id: string; usable: boolean; harvest: Harvest | null };
+
+export type StatusOnlySpec = {
+  name: Provider["name"];
+  flag: string;
+  pool: PoolPaths;
+  binName: string;
+  binKey: "grokBin" | "opencodeBin";
+  storeDirFor: (accountId: string) => string;
+  authJsonFor: (accountId: string) => string;
+  onboardDir: string;
+  homeEnv: string;
+  loginArgs: string[];
+  onboardAuthRel: string;
+  liveAuthPath: () => string;
+  readAuth: (path: string) => AuthEntry[];
+  liveId: () => string | null;
+  versionOk: (versionOutput: string) => boolean;
+  importIntro: string;
+  foundLive: (count: number) => string;
+  installNotice: string;
+  loginStep: () => string;
+};
+
+export function statusOnlyProvider(spec: StatusOnlySpec): Provider {
+  function resolveBin(): string {
+    const configured = loadConfig()[spec.binKey];
+    if (configured) {
+      if (!existsSync(configured)) throw new Error(`configured ${spec.binKey} does not exist: ${configured} - fix config.json`);
+      return configured;
+    }
+    for (const d of (process.env.PATH ?? "").split(":")) {
+      if (!d) continue;
+      const cand = join(d, spec.binName);
+      try {
+        if (existsSync(cand)) return cand;
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(`could not locate the real \`${spec.binName}\` binary (set ${spec.binKey} in config.json)`);
+  }
+
+  async function storeUsable(a: Account): Promise<boolean> {
+    try {
+      return spec.readAuth(spec.authJsonFor(a.id)).some((e) => e.id === a.id && e.usable);
+    } catch {
+      return false;
+    }
+  }
+
+  async function samplePool(accounts: Account[]): Promise<Map<string, SampleReport>> {
+    const reports = new Map<string, SampleReport>();
+    for (const a of accounts) {
+      reports.set(a.id, (await storeUsable(a)) ? { ok: true, source: "probe" } : { ok: false, reason: `no usable credential in this account's store - run \`tokenmaxxing auth${spec.flag}\`` });
+    }
+    return reports;
+  }
+
+  async function login(): Promise<Harvest | null> {
+    const real = resolveBin();
+    const onboardDir = spec.onboardDir;
+    rmSync(onboardDir, { recursive: true, force: true });
+    mkdirSync(onboardDir, { recursive: true });
+    const p = Bun.spawn([real, ...spec.loginArgs], {
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+      env: { ...process.env, [spec.homeEnv]: onboardDir, TOKENMAXXING_PROBE: "1" },
+    });
+    await p.exited;
+    try {
+      const first = p.exitCode === 0 ? spec.readAuth(join(onboardDir, spec.onboardAuthRel))[0] : undefined;
+      if (!first) {
+        console.error(c.red(`no ${spec.name} login landed in the isolated home - nothing added.`));
+        return null;
+      }
+      return first.harvest;
+    } finally {
+      rmSync(onboardDir, { recursive: true, force: true });
+    }
+  }
+
+  async function importLive(): Promise<Harvest | null> {
+    console.log(c.cyan(spec.importIntro));
+    console.log();
+    const live = spec.readAuth(spec.liveAuthPath());
+    const first = live[0];
+    if (first) {
+      console.log(c.dim(spec.foundLive(live.length)));
+      if (first.harvest) return first.harvest;
+    }
+    return login();
+  }
+
+  function preflight(): void {
+    const real = resolveBin();
+    const p = Bun.spawnSync([real, "--version"], { stdout: "pipe", stderr: "pipe", timeout: 15_000 });
+    if (p.exitCode !== 0 || !spec.versionOk(p.stdout?.toString() ?? "")) {
+      throw new Error(`${spec.binName} binary failed verification: ${real}`);
+    }
+    pinBinOverride({ key: spec.binKey, bin: real });
+  }
+
+  return {
+    name: spec.name,
+    flag: spec.flag,
+    pool: spec.pool,
+    seats: "live",
+    waitsWhenDepleted: false,
+    statusOnly: true,
+    liveId: spec.liveId,
+    presence: () => new Map(),
+    gatedFamilies: () => null,
+    observeLive: async (account) => (account.lastUsageAt != null ? { windows: account.windows, at: account.lastUsageAt } : null),
+    samplePool,
+    mergeWindows: (next) => next,
+    swap: async () => {
+      throw new Error(`${spec.name} moves are not supported yet (status-only pool)`);
+    },
+    classifySwapError: () => "fatal",
+    removeCredentials: async (a) => {
+      rmSync(spec.storeDirFor(a.id), { recursive: true, force: true });
+    },
+    storeUsable,
+    login,
+    importLive,
+    preflight,
+    install: () => {
+      console.log(c.dim(spec.installNotice));
+    },
+    loginStep: spec.loginStep,
+    windowLabel: (name) => name.toLowerCase(),
+  };
+}

package/src/lib/supervise.ts

@@ -0,0 +1,111 @@
+import type { Subprocess } from "bun";
+import { LOOP_DIAGNOSIS, MAX_WRAP_DEPTH, WRAP_RATE_MAX, WRAP_RATE_WINDOW_MS, wrapDepth, wrapperEntryRateTripped } from "./claudebin.ts";
+import { errorMessage, log } from "./log.ts";
+import { paths } from "./paths.ts";
+import { writePresence } from "./presence.ts";
+import { restoreTermios } from "./tty.ts";
+
+export type WrappedProduct = "claude" | "codex";
+
+type ChildHandle = {
+  pid: number;
+  exitCode: number | null;
+  signalCode: string | null;
+  kill: () => void;
+  exited: Promise<unknown>;
+};
+
+const WRAPPED: Record<WrappedProduct, { setting: string; binary: string; events: string }> = {
+  claude: { setting: "claudeBin", binary: "Claude", events: "supervisor" },
+  codex: { setting: "codexBin", binary: "codex", events: "codexsupervisor" },
+};
+
+export function exitStatus(child: { exitCode: number | null; signalCode: string | null }): number {
+  return child.exitCode ?? (child.signalCode ? 1 : 0);
+}
+
+export function loopGuardTripped(product: WrappedProduct): boolean {
+  const { setting, binary, events } = WRAPPED[product];
+  const depth = wrapDepth();
+  if (depth >= MAX_WRAP_DEPTH) {
+    console.error(
+      `tokenmaxxing: ${LOOP_DIAGNOSIS} ${binary} (depth ${depth}) - ${setting} in ${paths.configJson} does not launch the real ${binary} binary. Fix ${setting}, then run \`tokenmaxxing doctor\`.`,
+    );
+    log(`${events}.loop_abort`, { depth });
+    return true;
+  }
+  if (wrapperEntryRateTripped(Date.now())) {
+    console.error(
+      `tokenmaxxing: ${LOOP_DIAGNOSIS} ${binary} (over ${WRAP_RATE_MAX} wrapper entries in ${WRAP_RATE_WINDOW_MS / 1000}s) - ${setting} in ${paths.configJson} does not launch the real ${binary} binary. Fix ${setting}, then run \`tokenmaxxing doctor\`.`,
+    );
+    log(`${events}.rate_abort`, { max: WRAP_RATE_MAX });
+    return true;
+  }
+  return false;
+}
+
+export async function runPassthrough(input: { real: string; argv: string[]; env: Record<string, string | undefined>; onSpawn?: (child: Subprocess) => void }): Promise<number> {
+  const p = Bun.spawn([input.real, ...input.argv], { stdin: "inherit", stdout: "inherit", stderr: "inherit", env: input.env });
+  input.onSpawn?.(p);
+  await p.exited;
+  return exitStatus(p);
+}
+
+export async function recordPresenceOrStop(input: { child: ChildHandle; dir: string; id: string; accountId: string; event: string; message: string; savedTermios: string | null }): Promise<void> {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      writePresence({ dir: input.dir, id: input.id, accountId: input.accountId, pid: input.child.pid });
+      return;
+    } catch (e) {
+      if (input.child.exitCode !== null || input.child.signalCode !== null) return;
+      if (attempt >= 9) {
+        log(input.event, { err: errorMessage(e) });
+        input.child.kill();
+        await input.child.exited;
+        restoreTermios(input.savedTermios);
+        throw new Error(input.message);
+      }
+      await Bun.sleep(100);
+    }
+  }
+}
+
+export async function raceMarkerOrExit(input: {
+  child: { exited: Promise<unknown>; kill: () => void };
+  tick: () => boolean | Promise<boolean>;
+  savedTermios: string | null;
+  onKill?: () => void;
+  onError?: () => void;
+  onExited?: () => void;
+}): Promise<void> {
+  let done = false;
+  const markerWatch = (async () => {
+    while (!done) {
+      if (await input.tick()) return true;
+      await Bun.sleep(150);
+    }
+    return false;
+  })();
+  const exited = input.child.exited.then(() => {
+    done = true;
+    return "exit" as const;
+  });
+  try {
+    const winner = await Promise.race([exited, markerWatch.then((found) => (found ? "marker" : "exit"))]);
+    if (winner === "marker") {
+      input.onKill?.();
+      input.child.kill();
+    }
+  } catch (e) {
+    input.onKill?.();
+    input.child.kill();
+    input.onError?.();
+    throw e;
+  } finally {
+    await input.child.exited;
+    input.onExited?.();
+    done = true;
+    await markerWatch.catch(() => false);
+    restoreTermios(input.savedTermios);
+  }
+}

package/src/lib/types.ts

@@ -36,10 +36,7 @@ const AggregateWindowsSchema = z.object({
   sevenDay: UsageWindowSchema,
 });
 
-export const UsageWindowsSchema = AggregateWindowsSchema.extend({
-  perModel: z.record(z.string(), UsageWindowSchema).default({}),
-});
-export type UsageWindows = z.infer<typeof UsageWindowsSchema>;
+export type UsageWindows = z.infer<typeof AggregateWindowsSchema> & { perModel: Record<string, UsageWindow> };
 
 export const WindowSchema = z.object({
   name: z.string().nullable(),
@@ -80,27 +77,19 @@ export type Account = z.infer<typeof AccountSchema>;
 
 export const AccountsIndexSchema = z.object({
   version: z.literal(2),
-  activeId: z.string().nullable(),
   accounts: z.array(AccountSchema).default([]),
 });
-
-export const LastSwapSchema = z.object({ ts: z.number() });
 export type AccountsIndex = z.infer<typeof AccountsIndexSchema>;
 
-export const EnforcedLimitSchema = z.object({
-  account: z.string(),
-  kind: z.enum(["session", "weekly", "model"]),
-  family: z.string().nullable(),
-  resetsAt: z.number().nullable(),
-  blind: z.boolean(),
-});
-export type EnforcedLimit = z.infer<typeof EnforcedLimitSchema>;
+export type EnforcedLimit = {
+  account: string;
+  kind: "session" | "weekly" | "model";
+  family: string | null;
+  resetsAt: number | null;
+  blind: boolean;
+};
 
-export const ThresholdsSchema = z.object({
-  session: z.number().min(0).max(100),
-  weekly: z.number().min(0).max(100),
-});
-export type Thresholds = z.infer<typeof ThresholdsSchema>;
+export type Thresholds = { session: number; weekly: number };
 
 export const ConfigSchema = z
   .object({
@@ -142,11 +131,15 @@ export const RespawnMarkerSchema = z.object({
   launchedAt: z.number().optional(),
 });
 
+export const EpochSecondsSchema = z.number().transform((seconds) => seconds * 1000);
+
+const StdinWindowSchema = z.looseObject({ used_percentage: z.number(), resets_at: EpochSecondsSchema.nullable().optional() });
+
 export const RateLimitsStdinSchema = z.looseObject({
   rate_limits: z
     .looseObject({
-      five_hour: z.looseObject({ used_percentage: z.number(), resets_at: z.number().nullable().optional() }).optional(),
-      seven_day: z.looseObject({ used_percentage: z.number(), resets_at: z.number().nullable().optional() }).optional(),
+      five_hour: StdinWindowSchema.optional(),
+      seven_day: StdinWindowSchema.optional(),
     })
     .optional(),
   model: z.looseObject({ id: z.string().optional(), display_name: z.string().optional() }).optional(),
@@ -196,13 +189,12 @@ export const ProfileResponseSchema = z.looseObject({
   organization: z.looseObject({ uuid: z.string(), name: z.string().nullish() }),
 });
 
-export const TokenIdentitySchema = z.object({
-  accountUuid: z.string(),
-  email: z.string().nullable(),
-  organizationUuid: z.string(),
-  organizationName: z.string().nullable(),
-});
-export type TokenIdentity = z.infer<typeof TokenIdentitySchema>;
+export type TokenIdentity = {
+  accountUuid: string;
+  email: string | null;
+  organizationUuid: string;
+  organizationName: string | null;
+};
 
 const CodexTokensSchema = z.looseObject({
   id_token: z.string(),
@@ -217,13 +209,12 @@ export const CodexAuthJsonSchema = z.looseObject({
 });
 export type CodexAuthJson = z.infer<typeof CodexAuthJsonSchema>;
 
-export const CodexUsageSchema = z.object({
-  accountId: z.string(),
-  email: z.string().nullable(),
-  planType: z.string().nullable(),
-  windows: z.array(WindowSchema),
-});
-export type CodexUsage = z.infer<typeof CodexUsageSchema>;
+export type CodexUsage = {
+  accountId: string;
+  email: string | null;
+  planType: string | null;
+  windows: Window[];
+};
 
 export const CodexStopStdinSchema = z.looseObject({
   session_id: z.string().optional(),

package/src/lib/update.ts

@@ -5,14 +5,13 @@ import { writeFileAtomic } from "./atomic.ts";
 import { http } from "./http.ts";
 import { isNixPackaged } from "./install.ts";
 import { withLock } from "./lock.ts";
-import { log } from "./log.ts";
-import { HOME, paths } from "./paths.ts";
+import { errorMessage, log } from "./log.ts";
+import { env, HOME, optionalEnv, paths } from "./paths.ts";
 
 const UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const INSTALL_DEADLINE_MS = 60_000;
 const REGISTRY_DEADLINE_MS = 15_000;
 
-const OverrideSchema = z.string().min(1).optional().catch(undefined);
 const AttemptSchema = z.object({ attemptedAt: z.number() });
 const VersionSchema = z.object({ version: z.string().min(1) });
 const LatestSchema = z.object({ version: z.string().min(1), engines: z.looseObject({ bun: z.string().min(1).optional() }).optional() });
@@ -21,7 +20,7 @@ const updateJson = join(paths.home, "update.json");
 const updateLock = join(paths.home, "update.lock");
 
 function registry(): { base: URL; authorization: string | null } {
-  const raw = OverrideSchema.parse(process.env.TOKENMAXXING_NPM_REGISTRY) ?? "https://registry.npmjs.org";
+  const raw = env("TOKENMAXXING_NPM_REGISTRY", "https://registry.npmjs.org");
   const base = new URL(raw.endsWith("/") ? raw : `${raw}/`);
   const authorization =
     base.username !== "" || base.password !== "" ? `Basic ${btoa(`${decodeURIComponent(base.username)}:${decodeURIComponent(base.password)}`)}` : null;
@@ -39,8 +38,8 @@ function realOrNull(path: string): string | null {
 }
 
 function globalRootCandidates(): string[] {
-  const globalDir = OverrideSchema.parse(process.env.BUN_INSTALL_GLOBAL_DIR);
-  const bunInstall = OverrideSchema.parse(process.env.BUN_INSTALL);
+  const globalDir = optionalEnv("BUN_INSTALL_GLOBAL_DIR");
+  const bunInstall = optionalEnv("BUN_INSTALL");
   return [
     ...(globalDir != null ? [globalDir] : []),
     ...(bunInstall != null ? [join(bunInstall, "install", "global")] : []),
@@ -127,7 +126,7 @@ export async function maybeAutoUpdate(): Promise<void> {
     try {
       await updateToLatest(root);
     } catch (e) {
-      throw new Error(`self-update from npm failed: ${e instanceof Error ? e.message : String(e)}`);
+      throw new Error(`self-update from npm failed: ${errorMessage(e)}`);
     }
   });
 }