tokenmaxxing 1.79.0 → 1.80.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.79.0",
+  "version": "1.80.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/codexsupervisor.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { codexPaths, codexPool } from "../lib/paths.ts";
@@ -10,7 +10,7 @@ import { clearPresence, livingPresences } from "../lib/presence.ts";
 import { isExhausted } from "../lib/picker.ts";
 import { exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough } from "../lib/supervise.ts";
 import { saveTermios } from "../lib/tty.ts";
-import { loadAccounts } from "../lib/state.ts";
+import { loadAccounts, readJsonFile } from "../lib/state.ts";
 import { CodexRespawnMarkerSchema, type Account } from "../lib/types.ts";
 import { errorMessage, log } from "../lib/log.ts";
 
@@ -26,7 +26,7 @@ const PASSTHROUGH_FLAGS = new Set(["--version", "-V", "--help", "-h"]);
 
 function readCodexMarker(marker: string): z.infer<typeof CodexRespawnMarkerSchema> {
   try {
-    return CodexRespawnMarkerSchema.parse(JSON.parse(readFileSync(marker, "utf8")));
+    return readJsonFile(marker, CodexRespawnMarkerSchema);
   } catch (e) {
     log("codexsupervisor.marker_invalid", { err: errorMessage(e) });
     throw new Error(

package/src/entries/supervisor.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, readdirSync, statSync } from "node:fs";
+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";
@@ -16,7 +16,7 @@ import { teeObservation } from "../lib/sample.ts";
 import { exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough } from "../lib/supervise.ts";
 import { saveTermios } from "../lib/tty.ts";
 import { liveSessionId, loadSessionFlags, pruneStaleSessions, saveSessionFlags, writeRespawnMarker } from "../lib/sessions.ts";
-import { loadAccounts, loadConfig, releaseWaitClaim } from "../lib/state.ts";
+import { loadAccounts, loadConfig, readJsonFile, releaseWaitClaim } from "../lib/state.ts";
 import { gatedFamilies, modelFromFlag } from "../lib/usage.ts";
 import { RespawnMarkerSchema, type Account, type Config, type ModelInfo } from "../lib/types.ts";
 import { errorMessage, log } from "../lib/log.ts";
@@ -183,7 +183,7 @@ type MarkerGate = {
 function consumableMarker(marker: string, gate: MarkerGate): z.infer<typeof RespawnMarkerSchema> | null {
   let m: z.infer<typeof RespawnMarkerSchema>;
   try {
-    m = RespawnMarkerSchema.parse(JSON.parse(readFileSync(marker, "utf8")));
+    m = readJsonFile(marker, RespawnMarkerSchema);
   } catch (e) {
     log("supervisor.marker_invalid", { err: errorMessage(e) });
     throw new Error(

package/src/lib/claude.ts

@@ -12,7 +12,7 @@ import { pickBest, pickEarliestReset, thresholdBars, type PickCtx } from "./pick
 import { seatCounts } from "./presence.ts";
 import { StoreUnusableError, type Observation, type Provider, type SampleReport } from "./provider.ts";
 import { foldTee, sampleAccountUsage, teeObservation, usageBlockedUntil } from "./sample.ts";
-import { clearUsageSnapshot, loadAccounts, loadConfig, loadUsageSnapshot, pinBinOverride, saveAccounts, type Harvest } from "./state.ts";
+import { clearUsageSnapshot, 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 { CredentialBlobSchema, JsonTextSchema, OAuthAccountSchema, type Account, type Config, type ModelInfo } from "./types.ts";
@@ -185,7 +185,7 @@ async function login(): Promise<Harvest | null> {
     let blob, oauthAccount;
     try {
       blob = CredentialBlobSchema.parse(JSON.parse(blobRaw));
-      oauthAccount = OAuthAccountSchema.parse(JSON.parse(readFileSync(cjPath, "utf8")).oauthAccount);
+      oauthAccount = readJsonFile(cjPath, z.object({ oauthAccount: OAuthAccountSchema })).oauthAccount;
     } catch {
       console.error(c.red("could not parse the onboarded account's credential/identity."));
       return null;

package/src/lib/codexauth.ts

@@ -1,22 +1,23 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, symlinkSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, rmSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { codexAuthJsonFor, codexPaths, codexStoreDirFor } from "./paths.ts";
+import { readJsonFile } from "./state.ts";
 import { CodexAuthJsonSchema, ErrnoSchema, type CodexAuthJson } from "./types.ts";
 
+const CodexAuthFileSchema = z
+  .looseObject({ tokens: z.unknown().optional() })
+  .transform((auth) => (auth.tokens === undefined || auth.tokens === null ? null : auth))
+  .pipe(CodexAuthJsonSchema.nullable());
+
 export function readCodexAuthAt(input: { path: string }): CodexAuthJson | null {
-  let raw: string;
   try {
-    raw = readFileSync(input.path, "utf8");
+    return readJsonFile(input.path, CodexAuthFileSchema);
   } catch (e) {
     if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return null;
     throw e;
   }
-  const parsed = JSON.parse(raw);
-  const probe = z.looseObject({ tokens: z.unknown().optional() }).parse(parsed);
-  if (probe.tokens === undefined || probe.tokens === null) return null;
-  return CodexAuthJsonSchema.parse(parsed);
 }
 
 export function readCodexStoreAuth(accountId: string): CodexAuthJson | null {

package/src/lib/install.ts

@@ -7,7 +7,7 @@ import { codexPaths, codexStoreDirFor, HOME, optionalEnv, paths } from "./paths.
 import { writeFileAtomic } from "./atomic.ts";
 import { installedBin, installSettings, isOurHookCommand, uninstallSettings } from "./settings.ts";
 import { CLAUDE_BIN, resolveRealBin } from "./claudebin.ts";
-import { loadConfig } from "./state.ts";
+import { loadConfig, readJsonFile } from "./state.ts";
 import { ErrnoSchema } from "./types.ts";
 
 export type InstallOutcome = { claudeWrapper: string; installedBin: string; pathAhead: boolean; timerLoaded: boolean; hubLoaded: boolean; checkIntervalS: number };
@@ -134,7 +134,7 @@ function withoutOurCodexStopHooks(groups: { hooks: { type?: string; command?: st
 
 export function installCodexStopHook(): void {
   const current = existsSync(codexPaths.hooksJson)
-    ? CodexHooksFileSchema.parse(JSON.parse(readFileSync(codexPaths.hooksJson, "utf8")))
+    ? readJsonFile(codexPaths.hooksJson, CodexHooksFileSchema)
     : CodexHooksFileSchema.parse({});
   const next = {
     ...current,
@@ -151,7 +151,7 @@ export function installCodexStopHook(): void {
 
 export function uninstallCodexStopHook(): void {
   if (!existsSync(codexPaths.hooksJson)) return;
-  const current = CodexHooksFileSchema.parse(JSON.parse(readFileSync(codexPaths.hooksJson, "utf8")));
+  const current = readJsonFile(codexPaths.hooksJson, CodexHooksFileSchema);
   const next = {
     ...current,
     hooks: {
@@ -166,7 +166,7 @@ export function codexStopHookGroupIndex(): number | null {
   if (!existsSync(codexPaths.hooksJson)) return null;
   let parsed: z.infer<typeof CodexHooksFileSchema>;
   try {
-    parsed = CodexHooksFileSchema.parse(JSON.parse(readFileSync(codexPaths.hooksJson, "utf8")));
+    parsed = readJsonFile(codexPaths.hooksJson, CodexHooksFileSchema);
   } catch {
     return null;
   }

package/src/lib/presence.ts

@@ -4,7 +4,8 @@ import { countBy } from "es-toolkit";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { pidExists, pidStartTime } from "./proc.ts";
-import { ErrnoSchema } from "./types.ts";
+import { readJsonFile } from "./state.ts";
+import { ErrnoSchema, JsonTextSchema } from "./types.ts";
 
 const PresenceSchema = z.object({
   accountId: z.string(),
@@ -19,14 +20,12 @@ export function writePresence(input: { dir: string; id: string; accountId: strin
 }
 
 export function presencePid(input: { dir: string; id: string }): number | null {
-  let raw: string;
   try {
-    raw = readFileSync(join(input.dir, input.id), "utf8");
+    return readJsonFile(join(input.dir, input.id), PresenceSchema).pid;
   } catch (e) {
     if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return null;
     throw e;
   }
-  return PresenceSchema.parse(JSON.parse(raw)).pid;
 }
 
 export function clearPresence(input: { dir: string; id: string }): void {
@@ -47,13 +46,7 @@ export function livingPresences(dir: string): LivingPresence[] {
       if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") continue;
       throw e;
     }
-    const parsed = PresenceSchema.safeParse((() => {
-      try {
-        return JSON.parse(raw);
-      } catch {
-        return null;
-      }
-    })());
+    const parsed = PresenceSchema.safeParse(JsonTextSchema.safeParse(raw).data);
     if (!parsed.success) {
       throw new Error(`${file} is not a readable presence record - it may belong to a RUNNING session, refusing to treat it as absent; remove the file (or respawn that session) to proceed`);
     }

package/src/lib/sessions.ts

@@ -1,10 +1,11 @@
-import { existsSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, type Dirent } from "node:fs";
+import { existsSync, readdirSync, realpathSync, rmSync, statSync, type Dirent } from "node:fs";
 import { basename, join, sep } from "node:path";
 import { z } from "zod";
 import { errorMessage, log } from "./log.ts";
 import { codexPaths, grokPaths, opencodeGoPaths, paths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import { presencePid } from "./presence.ts";
+import { readJsonFile } from "./state.ts";
 import { spawnedThroughShellsBy } from "./proc.ts";
 import type { RespawnMarkerSchema } from "./types.ts";
 
@@ -25,7 +26,7 @@ export function saveSessionFlags(sid: string, flags: string[], cwd: string): voi
 function loadSession(sid: string): z.infer<typeof SessionSchema> | null {
   const f = sessionFile(sid);
   if (!existsSync(f)) return null;
-  return SessionSchema.parse(JSON.parse(readFileSync(f, "utf8")));
+  return readJsonFile(f, SessionSchema);
 }
 
 export function loadSessionFlags(sid: string): string[] | null {

package/src/lib/settings.ts

@@ -1,8 +1,10 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { paths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
+import { readJsonFile } from "./state.ts";
+import { JsonTextSchema } from "./types.ts";
 
 export function installedBin(): string {
   return join(paths.binDir, "tokenmaxxing");
@@ -31,7 +33,7 @@ const STOP_FAILURE_MATCHER = "rate_limit";
 
 function readSettings(): Settings {
   if (!existsSync(paths.claudeSettings)) return {};
-  return SettingsSchema.parse(JSON.parse(readFileSync(paths.claudeSettings, "utf8")));
+  return readJsonFile(paths.claudeSettings, SettingsSchema);
 }
 
 function writeSettings(s: Settings): void {
@@ -71,13 +73,7 @@ export function isOurHookCommand(cmd: string, sub: string): boolean {
   if (!cmd.endsWith(` ${sub}`)) return false;
   const quotedPath = cmd.slice(0, cmd.length - (sub.length + 1));
   if (!quotedPath.startsWith('"') || !quotedPath.endsWith('"')) return false;
-  let path: unknown;
-  try {
-    path = JSON.parse(quotedPath);
-  } catch {
-    return false;
-  }
-  const parsed = z.string().safeParse(path);
+  const parsed = z.string().safeParse(JsonTextSchema.safeParse(quotedPath).data);
   return parsed.success && parsed.data.endsWith("/tokenmaxxing");
 }
 

package/src/lib/state.ts

@@ -7,6 +7,7 @@ import {
   AccountsIndexSchema,
   ConfigSchema,
   ErrnoSchema,
+  JsonTextSchema,
   UsageStateSchema,
   WaitQueueSchema,
   type Account,
@@ -17,21 +18,19 @@ import {
   type Window,
 } from "./types.ts";
 
-export function loadConfig(): Config {
-  let raw: unknown = {};
-  if (existsSync(paths.configJson)) {
-    try {
-      raw = JSON.parse(readFileSync(paths.configJson, "utf8"));
-    } catch {
-      throw new Error(`${paths.configJson} is corrupt (unparsable JSON) - fix or remove it`);
-    }
-  }
-  const parsed = ConfigSchema.safeParse(raw);
+export function readJsonFile<T extends z.ZodType>(path: string, schema: T): z.output<T> {
+  const json = JsonTextSchema.safeParse(readFileSync(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) {
     const fields = parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
-    throw new Error(`${paths.configJson} is invalid (${fields}) - fix or remove the offending values`);
+    throw new Error(`${path} does not match its schema (${fields}) - repair or remove the file`);
   }
-  const cfg = parsed.data;
+  return parsed.data;
+}
+
+export function loadConfig(): Config {
+  const cfg = existsSync(paths.configJson) ? readJsonFile(paths.configJson, ConfigSchema) : ConfigSchema.parse({});
   cfg.claudeBin = optionalEnv("TOKENMAXXING_CLAUDE_BIN") ?? cfg.claudeBin;
   cfg.codexBin = optionalEnv("TOKENMAXXING_CODEX_BIN") ?? cfg.codexBin;
   cfg.grokBin = optionalEnv("TOKENMAXXING_GROK_BIN") ?? cfg.grokBin;
@@ -42,10 +41,7 @@ export function loadConfig(): Config {
 export type BinKey = "claudeBin" | "codexBin" | "grokBin" | "opencodeBin";
 
 export function pinBinOverride(input: { key: BinKey; bin: string }): void {
-  let raw: Record<string, unknown> = {};
-  if (existsSync(paths.configJson)) {
-    raw = z.record(z.string(), z.unknown()).parse(JSON.parse(readFileSync(paths.configJson, "utf8")));
-  }
+  const raw: Record<string, unknown> = existsSync(paths.configJson) ? readJsonFile(paths.configJson, z.record(z.string(), z.unknown())) : {};
   raw[input.key] = input.bin;
   writeFileAtomic(paths.configJson, JSON.stringify(raw, null, 2) + "\n");
 }
@@ -54,17 +50,7 @@ const emptyIndex = (): AccountsIndex => ({ version: 2, accounts: [] });
 
 export function loadAccounts(pool: PoolPaths): AccountsIndex {
   if (!existsSync(pool.accountsJson)) return emptyIndex();
-  let json: unknown;
-  try {
-    json = JSON.parse(readFileSync(pool.accountsJson, "utf8"));
-  } catch {
-    throw new Error(`${pool.accountsJson} is corrupt (unparsable JSON) - refusing to treat a damaged pool as empty; repair or remove the file`);
-  }
-  const parsed = AccountsIndexSchema.safeParse(json);
-  if (!parsed.success) {
-    throw new Error(`${pool.accountsJson} does not match the accounts schema - refusing to treat a damaged pool as empty; repair or remove the file`);
-  }
-  return parsed.data;
+  return readJsonFile(pool.accountsJson, AccountsIndexSchema);
 }
 
 export function saveAccounts(pool: PoolPaths, idx: AccountsIndex): void {
@@ -73,17 +59,7 @@ export function saveAccounts(pool: PoolPaths, idx: AccountsIndex): void {
 
 function loadWaitQueue(): WaitClaim[] {
   if (!existsSync(claudePool.waitQueueJson)) return [];
-  let json: unknown;
-  try {
-    json = JSON.parse(readFileSync(claudePool.waitQueueJson, "utf8"));
-  } catch {
-    throw new Error(`${claudePool.waitQueueJson} is corrupt (unparsable JSON) - refusing to treat a damaged wait queue as empty; repair or remove the file`);
-  }
-  const parsed = WaitQueueSchema.safeParse(json);
-  if (!parsed.success) {
-    throw new Error(`${claudePool.waitQueueJson} does not match the wait-queue schema - refusing to treat a damaged wait queue as empty; repair or remove the file`);
-  }
-  return parsed.data.claims;
+  return readJsonFile(claudePool.waitQueueJson, WaitQueueSchema).claims;
 }
 
 function saveWaitQueue(claims: WaitClaim[]): void {

package/src/lib/update.ts

@@ -1,4 +1,4 @@
-import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { existsSync, lstatSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
@@ -8,6 +8,7 @@ import { isNixPackaged } from "./install.ts";
 import { withLock } from "./lock.ts";
 import { errorMessage, log } from "./log.ts";
 import { env, HOME, optionalEnv, paths } from "./paths.ts";
+import { readJsonFile } from "./state.ts";
 
 const UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const INSTALL_DEADLINE_MS = 60_000;
@@ -67,18 +68,12 @@ function detectGlobalRoot(): string | null {
 }
 
 function installedVersion(root: string): string {
-  return VersionSchema.parse(JSON.parse(readFileSync(join(packageDir(root), "package.json"), "utf8"))).version;
+  return readJsonFile(join(packageDir(root), "package.json"), VersionSchema).version;
 }
 
 function isDue(now: number): boolean {
   if (!existsSync(updateJson)) return true;
-  let json: unknown;
-  try {
-    json = JSON.parse(readFileSync(updateJson, "utf8"));
-  } catch {
-    throw new Error(`${updateJson} is corrupt (unparsable JSON) - repair or remove the file`);
-  }
-  return now - AttemptSchema.parse(json).attemptedAt >= UPDATE_INTERVAL_MS;
+  return now - readJsonFile(updateJson, AttemptSchema).attemptedAt >= UPDATE_INTERVAL_MS;
 }
 
 async function updateToLatest(root: string): Promise<void> {