tokenmaxxing 1.103.0 → 1.105.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.103.0",
+  "version": "1.105.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/stopfailurehook.ts

@@ -20,10 +20,10 @@ const StopFailureStdin = z.looseObject({
 const ROW_WAIT_MS = 3_000;
 const ROW_POLL_MS = 200;
 
-async function awaitEnforcedRow(input: { transcriptPath: string; error: string; lastAssistantMessage: string | undefined; now: number }): Promise<TranscriptRow | null> {
+async function awaitEnforcedRow(input: { transcriptPath: string; error: string; lastAssistantMessage: string | undefined }): Promise<TranscriptRow | null> {
   const deadline = Date.now() + ROW_WAIT_MS;
   while (true) {
-    const row = findEnforcedRow({ rows: await readTranscriptTail(input.transcriptPath), error: input.error, lastAssistantMessage: input.lastAssistantMessage, now: input.now });
+    const row = findEnforcedRow({ rows: await readTranscriptTail(input.transcriptPath), error: input.error, lastAssistantMessage: input.lastAssistantMessage });
     if (row || Date.now() >= deadline) return row;
     await Bun.sleep(ROW_POLL_MS);
   }
@@ -52,7 +52,7 @@ export async function runStopFailureHook(): Promise<number> {
     const canRespawn = session != null && mainLoop;
     const cfg = loadConfig();
     const row = stdin.transcript_path
-      ? await awaitEnforcedRow({ transcriptPath: stdin.transcript_path, error, lastAssistantMessage: stdin.last_assistant_message, now })
+      ? await awaitEnforcedRow({ transcriptPath: stdin.transcript_path, error, lastAssistantMessage: stdin.last_assistant_message })
       : null;
     const limit = row ? classifyEnforcedLimit(row, cfg.policy.switchModels) : null;
 

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/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

@@ -52,7 +52,6 @@ export function modelFromFlag(value: string | null): ModelInfo | null {
 const TranscriptBlockSchema = z.looseObject({ type: z.string().optional(), text: z.string().optional() });
 export const TranscriptRowSchema = z.looseObject({
   type: z.string().optional(),
-  timestamp: z.string().optional(),
   isApiErrorMessage: z.boolean().optional(),
   apiErrorIsTransient: z.boolean().optional(),
   apiError: z.string().optional(),
@@ -84,21 +83,11 @@ export function transcriptRowText(row: TranscriptRow): string {
   return blocks.data.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n").trim();
 }
 
-const ROW_RECENCY_MS = 60_000;
-
 export const ENFORCED_ERRORS = ["rate_limit", "oauth_org_not_allowed"];
 
-export function findEnforcedRow(input: { rows: TranscriptRow[]; error: string; lastAssistantMessage: string | undefined; now: number }): TranscriptRow | null {
-  const { rows, error, lastAssistantMessage, now } = input;
-  for (let i = rows.length - 1; i >= 0; i--) {
-    const row = rows[i]!;
-    if (row.isApiErrorMessage !== true || row.error !== error) continue;
-    const ts = row.timestamp ? Date.parse(row.timestamp) : Number.NaN;
-    const byContent = lastAssistantMessage != null && lastAssistantMessage !== "" && transcriptRowText(row) === lastAssistantMessage;
-    const byRecency = Number.isFinite(ts) && Math.abs(now - ts) <= ROW_RECENCY_MS;
-    if (byContent || byRecency) return row;
-  }
-  return null;
+export function findEnforcedRow(input: { rows: TranscriptRow[]; error: string; lastAssistantMessage: string | undefined }): TranscriptRow | null {
+  const { rows, error, lastAssistantMessage } = input;
+  return rows.findLast((row) => row.isApiErrorMessage === true && row.error === error && transcriptRowText(row) === lastAssistantMessage) ?? null;
 }
 
 export type EnforcedClass =
@@ -164,12 +153,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;