tokenmaxxing 1.102.0 → 1.104.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.102.0",
+  "version": "1.104.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/entries/codexstophook.ts

@@ -1,4 +1,5 @@
 import { join } from "node:path";
+import { omit } from "es-toolkit";
 import type { z } from "zod";
 import { codexPaths, optionalEnv } from "../lib/paths.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
@@ -22,8 +23,7 @@ async function compactBeforeMove(input: { sessionId: string | null; now: number
   if (!live || live.needsReauth === true || (live.enforcedUntil != null && live.enforcedUntil > now)) return;
   const observed = await codex.observeLive(live, loadConfig(), now, { probe: true, perModel: false });
   if (!observed || !isExhausted({ ...live, windows: observed.windows }, codexPickCtx(now, live.id))) return;
-  const env: Record<string, string | undefined> = { ...process.env, TOKENMAXXING_PROBE: "1", [WRAP_DEPTH_ENV]: String(MAX_WRAP_DEPTH) };
-  delete env[CODEX_SUPERVISOR_ID_ENV];
+  const env = { ...omit(process.env, [CODEX_SUPERVISOR_ID_ENV]), TOKENMAXXING_PROBE: "1", [WRAP_DEPTH_ENV]: String(MAX_WRAP_DEPTH) };
   log("codexstop.compact_start", { thread: sessionId.slice(0, 8), account: live.id.slice(0, 8) });
   await compactCodexThread({ real: resolveRealBin(CODEX_BIN), threadId: sessionId, env });
 }

package/src/entries/codexsupervisor.ts

@@ -1,6 +1,7 @@
 import type { Subprocess } from "bun";
 import { existsSync, mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { omit } from "es-toolkit";
 import { z } from "zod";
 import { codexPaths, codexPool } from "../lib/paths.ts";
 import { withLock } from "../lib/lock.ts";
@@ -90,11 +91,10 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
   if (loopGuardTripped("codex")) return 1;
 
   const real = resolveRealBin(CODEX_BIN);
-  const childEnv = { ...process.env, [WRAP_DEPTH_ENV]: String(wrapDepth() + 1) };
+  const childEnv: Record<string, string | undefined> = { ...process.env, [WRAP_DEPTH_ENV]: String(wrapDepth() + 1) };
 
   if (!shouldManageCodex({ argv }) || process.env[UNMANAGED_ENV]) {
-    const passthroughEnv: Record<string, string | undefined> = { ...childEnv };
-    delete passthroughEnv[CODEX_SUPERVISOR_ID_ENV];
+    const passthroughEnv = omit(childEnv, [CODEX_SUPERVISOR_ID_ENV]);
     let child: Subprocess | null = null;
     process.on("SIGTERM", () => {
       if (child) child.kill("SIGTERM");

package/src/entries/supervisor.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, rmSync, readdirSync, statSync } from "node:fs";
 import { basename, join } from "node:path";
 import type { FileSink, Subprocess } from "bun";
-import { maxBy } from "es-toolkit";
+import { maxBy, omit } from "es-toolkit";
 import { z } from "zod";
 import { claudePool, paths, storeDirFor } from "../lib/paths.ts";
 import { CLAUDE_BIN, UNMANAGED_ENV, WRAP_DEPTH_ENV, resolveRealBin, wrapDepth } from "../lib/claudebin.ts";
@@ -346,7 +346,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
     log("supervisor.resolve_failed", { err: errorMessage(e) });
     return 1;
   }
-  const childEnv = { ...process.env, [WRAP_DEPTH_ENV]: String(wrapDepth() + 1) };
+  const childEnv: Record<string, string | undefined> = { ...process.env, [WRAP_DEPTH_ENV]: String(wrapDepth() + 1) };
 
   let child: Subprocess | null = null;
   let terminating = false;
@@ -374,11 +374,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
   });
 
   if (!info.manage || process.env[UNMANAGED_ENV]) {
-    const passthroughEnv: Record<string, string | undefined> = { ...childEnv };
-    delete passthroughEnv.TOKENMAXXING_SUPERVISED;
-    delete passthroughEnv.TOKENMAXXING_SESSION_ID;
-    delete passthroughEnv.TOKENMAXXING_MODEL;
-    delete passthroughEnv.TOKENMAXXING_REFUSED;
+    const passthroughEnv = omit(childEnv, ["TOKENMAXXING_SUPERVISED", "TOKENMAXXING_SESSION_ID", "TOKENMAXXING_MODEL", "TOKENMAXXING_REFUSED"]);
     return runPassthrough({ real, argv, env: passthroughEnv, onSpawn: (p) => { child = p; } });
   }
 
@@ -510,12 +506,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
         log("supervisor.compact_skipped", { sid: m.sessionId.slice(0, 8), seat: seat.id.slice(0, 8), until: walledUntil });
       } else if (m.compact && seat && resumable) {
         say(`\n\x1b[36m↻ tokenmaxxing: compacting the conversation on ${seat.label} before the move...\x1b[0m\n`, `tokenmaxxing: compacting the conversation on ${seat.label} before the move.`);
-        const compactEnv: Record<string, string | undefined> = { ...childEnv, TOKENMAXXING_PROBE: "1", CLAUDE_SECURESTORAGE_CONFIG_DIR: storeDirFor(seat.id) };
-        delete compactEnv.TOKENMAXXING_SUPERVISED;
-        delete compactEnv.TOKENMAXXING_SESSION_ID;
-        delete compactEnv.TOKENMAXXING_LAUNCHED_AT;
-        delete compactEnv.TOKENMAXXING_MODEL;
-        delete compactEnv.TOKENMAXXING_REFUSED;
+        const compactEnv = { ...omit(childEnv, ["TOKENMAXXING_SUPERVISED", "TOKENMAXXING_SESSION_ID", "TOKENMAXXING_LAUNCHED_AT", "TOKENMAXXING_MODEL", "TOKENMAXXING_REFUSED"]), TOKENMAXXING_PROBE: "1", CLAUDE_SECURESTORAGE_CONFIG_DIR: storeDirFor(seat.id) };
         const outcome = await compactClaudeSession({ real, sid: m.sessionId, transcript, env: compactEnv, onSpawn: (p) => { child = p; } });
         child = null;
         if (terminating) {

package/src/lib/claude.ts

@@ -1,6 +1,6 @@
 import { mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { countBy } from "es-toolkit";
+import { countBy, omit } from "es-toolkit";
 import { z } from "zod";
 import { readItem, writeItem, deleteItem, isolatedTarget, readStore, storeTarget, claudeAiOauthOnly } from "./credstore.ts";
 import { CLAUDE_BIN, resolveRealBin, resolveVerifiedClaude } from "./claudebin.ts";
@@ -16,7 +16,7 @@ import { StoreUnusableError, type Observation, type Provider, type SampleReport
 import { foldTee, readyToSample, runSample, sampleAccountUsage, sampleDue, sampleIntervalMs, teeObservation, usageBlockedUntil } from "./sample.ts";
 import { clearUsageSnapshot, liveWaitClaims, loadAccounts, loadConfig, loadUsageSnapshot, pinBinOverride, readJsonFile, saveAccounts, type Harvest } from "./state.ts";
 import { saveTermios, restoreTermios } from "./tty.ts";
-import { fetchUsageDirect, gatedFamilies, mergeWindows, modelFromFlag, scrubCredentialEnv, windowsOf } from "./usage.ts";
+import { CRED_ENV_OVERRIDES, fetchUsageDirect, gatedFamilies, mergeWindows, modelFromFlag, windowsOf } from "./usage.ts";
 import { CredentialBlobSchema, JsonTextSchema, OAuthAccountSchema, type Account, type Config, type ModelInfo } from "./types.ts";
 import { c } from "../cli/render.ts";
 
@@ -170,7 +170,7 @@ async function login(): Promise<Harvest | null> {
   const real = resolveRealBin(CLAUDE_BIN);
 
   const savedTermios = saveTermios();
-  const env = scrubCredentialEnv({ ...process.env, CLAUDE_CONFIG_DIR: onboardDir, TOKENMAXXING_PROBE: "1", TOKENMAXXING_SUPERVISED: "" });
+  const env = { ...omit(process.env, CRED_ENV_OVERRIDES), CLAUDE_CONFIG_DIR: onboardDir, TOKENMAXXING_PROBE: "1", TOKENMAXXING_SUPERVISED: "" };
   const p = Bun.spawn([real], {
     stdin: "inherit",
     stdout: "inherit",

package/src/lib/grok.ts

@@ -1,4 +1,3 @@
-import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
@@ -6,9 +5,9 @@ import { fetchGrokUsage, GrokUsageReadError, type GrokUsage } from "./grokusage.
 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 { loadAccounts, readJsonFile, type Harvest } from "./state.ts";
 import { statusOnlyProvider, type AuthEntry } from "./statusonly.ts";
-import { InstantSchema, type Account } from "./types.ts";
+import { ErrnoSchema, InstantSchema, type Account } from "./types.ts";
 import { c } from "../cli/render.ts";
 
 const GrokAuthEntrySchema = z.looseObject({
@@ -37,16 +36,15 @@ function harvestOf(id: string, key: string, entry: GrokAuthEntry): Harvest {
 }
 
 function readMap(path: string): [string, GrokAuthEntry][] {
-  let raw: unknown;
+  let map: Record<string, unknown>;
   try {
-    raw = JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return [];
+    map = readJsonFile(path, z.record(z.string(), z.unknown()));
+  } catch (e) {
+    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return [];
+    throw e;
   }
-  const map = z.record(z.string(), z.unknown()).safeParse(raw);
-  if (!map.success) return [];
   const out: [string, GrokAuthEntry][] = [];
-  for (const [key, value] of Object.entries(map.data)) {
+  for (const [key, value] of Object.entries(map)) {
     const parsed = GrokAuthEntrySchema.safeParse(value);
     if (!parsed.success) continue;
     out.push([key, parsed.data]);

package/src/lib/opencodego.ts

@@ -1,11 +1,11 @@
-import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { env, HOME, opencodeGoAuthJsonFor, opencodeGoPaths, opencodeGoPool, opencodeGoStoreDirFor } from "./paths.ts";
 import type { Provider } from "./provider.ts";
-import { type Harvest } from "./state.ts";
+import { readJsonFile, type Harvest } from "./state.ts";
 import { statusOnlyProvider, type AuthEntry } from "./statusonly.ts";
+import { ErrnoSchema } from "./types.ts";
 import { c } from "../cli/render.ts";
 
 const OpencodeAuthEntrySchema = z.looseObject({ type: z.string(), key: z.string().optional() });
@@ -35,15 +35,14 @@ function harvestOf(key: string): Harvest {
 }
 
 function readAuth(path: string): AuthEntry[] {
-  let raw: unknown;
+  let map: z.infer<typeof OpencodeAuthFileSchema>;
   try {
-    raw = JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return [];
+    map = readJsonFile(path, OpencodeAuthFileSchema);
+  } catch (e) {
+    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return [];
+    throw e;
   }
-  const map = OpencodeAuthFileSchema.safeParse(raw);
-  if (!map.success) return [];
-  const entry = OpencodeAuthEntrySchema.safeParse(map.data["opencode-go"]);
+  const entry = OpencodeAuthEntrySchema.safeParse(map["opencode-go"]);
   if (!entry.success || entry.data.type !== "api" || !entry.data.key) return [];
   return [{ id: idOfKey(entry.data.key), usable: true, harvest: harvestOf(entry.data.key) }];
 }

package/src/lib/sample.ts

@@ -1,6 +1,7 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { omit } from "es-toolkit";
 import { CLAUDE_BIN, MAX_WRAP_DEPTH, resolveRealBin, WRAP_DEPTH_ENV } from "./claudebin.ts";
 import { deleteItem, readStore, storeTarget } from "./credstore.ts";
 import { withLock } from "./lock.ts";
@@ -11,7 +12,7 @@ import { barFor, gatedWindows, landWindows, liveUsed, thresholdBars } from "./pi
 import { seatCounts } from "./presence.ts";
 import type { Observation } from "./provider.ts";
 import { loadAccounts, loadUsageSnapshot, saveAccounts } from "./state.ts";
-import { fetchUsageDirect, mergeWindows, scrubCredentialEnv, windowsOf } from "./usage.ts";
+import { CRED_ENV_OVERRIDES, fetchUsageDirect, mergeWindows, windowsOf } from "./usage.ts";
 import type { Account, Config, Thresholds, UsageWindows, Window } from "./types.ts";
 
 export type SampleOutcome = { ok: true; usage: UsageWindows; via: "get" } | { ok: false; reason: string; retryAt?: number };
@@ -84,9 +85,7 @@ const REFRESH_KILL_MS = 60_000;
 
 async function refreshStore(account: Account): Promise<number | null> {
   const home = mkdtempSync(join(tmpdir(), "tokenmaxxing-refresh-"));
-  const env = scrubCredentialEnv({ ...process.env, TOKENMAXXING_PROBE: "1", [WRAP_DEPTH_ENV]: String(MAX_WRAP_DEPTH) });
-  env.CLAUDE_CONFIG_DIR = home;
-  env.CLAUDE_SECURESTORAGE_CONFIG_DIR = storeDirFor(account.id);
+  const env = { ...omit(process.env, CRED_ENV_OVERRIDES), TOKENMAXXING_PROBE: "1", [WRAP_DEPTH_ENV]: String(MAX_WRAP_DEPTH), CLAUDE_CONFIG_DIR: home, CLAUDE_SECURESTORAGE_CONFIG_DIR: storeDirFor(account.id) };
   try {
     const p = Bun.spawn([resolveRealBin(CLAUDE_BIN), "-p", "/usage", "--no-session-persistence", "--safe-mode"], {
       env,

package/src/lib/state.ts

@@ -18,8 +18,8 @@ import {
   type Window,
 } from "./types.ts";
 
-export function readJsonFile<T extends z.ZodType>(path: string, schema: T): z.output<T> {
-  const json = JsonTextSchema.safeParse(readFileSync(path, "utf8"));
+export function readJsonFile<T extends z.ZodType>(path: string, schema: T, fd?: number): z.output<T> {
+  const json = JsonTextSchema.safeParse(readFileSync(fd ?? path, "utf8"));
   if (!json.success) throw new Error(`${path} is corrupt (unparsable JSON) - repair or remove the file`);
   const parsed = schema.safeParse(json.data);
   if (!parsed.success) {
@@ -119,18 +119,18 @@ export function upsertAccount(
 export type UsageSnapshot = { state: UsageState; at: number };
 
 export function loadUsageSnapshot(accountId: string): UsageSnapshot | null {
+  const path = usageJsonFor(accountId);
   let fd: number;
   try {
-    fd = openSync(usageJsonFor(accountId), "r");
-  } catch {
-    return null;
+    fd = openSync(path, "r");
+  } catch (e) {
+    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return null;
+    throw e;
   }
   try {
     const at = fstatSync(fd).mtimeMs;
-    const parsed = UsageStateSchema.safeParse(JSON.parse(readFileSync(fd, "utf8")));
-    return parsed.success && parsed.data.account === accountId ? { state: parsed.data, at } : null;
-  } catch {
-    return null;
+    const state = readJsonFile(path, UsageStateSchema, fd);
+    return state.account === accountId ? { state, at } : null;
   } finally {
     closeSync(fd);
   }
@@ -145,7 +145,11 @@ const SAMPLED_AT_REFRESH_MS = 30_000;
 
 export function writeUsage(input: UsageState): boolean {
   const file = usageJsonFor(input.account);
-  const prev = loadUsageSnapshot(input.account)?.state ?? null;
+  let prev: UsageState | null = null;
+  try {
+    prev = loadUsageSnapshot(input.account)?.state ?? null;
+  } catch {
+  }
   const next: UsageState = { ...input, sampledAt: input.ts };
   if (
     prev &&

package/src/lib/usage.ts

@@ -164,12 +164,6 @@ export const CRED_ENV_OVERRIDES = [
   "CLAUDE_CODE_USE_VERTEX",
 ] as const;
 
-export function scrubCredentialEnv(env: Record<string, string>): Record<string, string> {
-  const scrubbed = { ...env };
-  for (const k of CRED_ENV_OVERRIDES) delete scrubbed[k];
-  return scrubbed;
-}
-
 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;