tokenmaxxing 1.35.0 → 1.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.35.0",
+  "version": "1.39.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts and hot-swap when quota fills, resuming your session on the fresh account.",
   "type": "module",
   "license": "MIT",

package/src/cli/check.ts

@@ -2,6 +2,7 @@ import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
 import { sampleOldestParked } from "../lib/sample.ts";
 import { loadConfig } from "../lib/state.ts";
+import { maybeAutoUpdate } from "../lib/update.ts";
 import { log } from "../lib/log.ts";
 import { c, emitError, emitJson, fmtReset } from "./render.ts";
 
@@ -11,6 +12,7 @@ export async function cmdCheck(json = false): Promise<number> {
   try {
     d = await evaluateAndMaybeSwap(claude, now);
     await sampleOldestParked(loadConfig());
+    await maybeAutoUpdate();
   } catch (e) {
     const detail = e instanceof Error ? e.message : String(e);
     log("check.error", { err: detail });

package/src/entries/codexstophook.ts

@@ -11,7 +11,7 @@ import { isExhausted } from "../lib/picker.ts";
 import { livingCodexPresences } from "../lib/codexpresence.ts";
 import { loadAccounts } from "../lib/state.ts";
 import { CODEX_SUPERVISOR_ID_ENV } from "./codexsupervisor.ts";
-import { CodexReconcileMarkerSchema, CodexRespawnMarkerSchema, CodexStopStdinSchema } from "../lib/types.ts";
+import { CodexReconcileMarkerSchema, CodexRespawnMarkerSchema, CodexStopStdinSchema, JsonTextSchema } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
 
 const SupervisorIdSchema = z.string().min(1).optional().catch(undefined);
@@ -85,13 +85,7 @@ async function readStdin(): Promise<string> {
 }
 
 export async function handleCodexStop(input: { rawStdin: string }): Promise<void> {
-  const parsed = CodexStopStdinSchema.safeParse((() => {
-    try {
-      return JSON.parse(input.rawStdin);
-    } catch {
-      return {};
-    }
-  })());
+  const parsed = CodexStopStdinSchema.safeParse(JsonTextSchema.safeParse(input.rawStdin).data);
   const sessionId = parsed.success ? (parsed.data.session_id ?? null) : null;
 
   try {

package/src/entries/sessionstart.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
 import { log } from "../lib/log.ts";
+import { JsonTextSchema } from "../lib/types.ts";
 
 const SessionStartStdin = z.looseObject({
   source: z.string().optional(),
@@ -18,7 +19,7 @@ export async function runSessionStart(): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
   const raw = await readStdin();
-  const parsed = SessionStartStdin.safeParse((() => { try { return JSON.parse(raw); } catch { return {}; } })());
+  const parsed = SessionStartStdin.safeParse(JsonTextSchema.safeParse(raw).data);
   const source = parsed.success ? parsed.data.source : undefined;
 
   try {

package/src/entries/statusline.ts

@@ -10,6 +10,7 @@ import { makeColors, makeUsagePaint } from "../cli/render.ts";
 import { fmtResetShort } from "../lib/usage.ts";
 import {
   AccountsIndexSchema,
+  JsonTextSchema,
   StatusLineStdinSchema,
   WindowSchema,
   type Account,
@@ -118,12 +119,7 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
 }
 
 export async function runStatusline(): Promise<number> {
-  const raw = await readStdin();
-  let obj: unknown = null;
-  try {
-    obj = JSON.parse(raw);
-  } catch {
-  }
+  const obj = JsonTextSchema.safeParse(await readStdin()).data ?? null;
   const now = Date.now();
 
   let account: string | null = null;

package/src/entries/stopfailurehook.ts

@@ -9,7 +9,7 @@ import { withLock } from "../lib/lock.ts";
 import { claudePool } from "../lib/paths.ts";
 import { POST_SWAP_COOLDOWN_MS, loadConfig, loadLastSwapAt } from "../lib/state.ts";
 import { classifyEnforcedLimit, findEnforcedRow, parseErrorBody, readTranscriptTail } from "../lib/usage.ts";
-import { RespawnMarkerSchema, type EnforcedLimit } from "../lib/types.ts";
+import { JsonTextSchema, RespawnMarkerSchema, type EnforcedLimit } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
 
 const StopFailureStdin = z.looseObject({
@@ -35,7 +35,7 @@ export async function runStopFailureHook(): Promise<number> {
   const account = entry.account;
   const now = Date.now();
   const raw = await readStdin();
-  const parsed = StopFailureStdin.safeParse((() => { try { return JSON.parse(raw); } catch { return {}; } })());
+  const parsed = StopFailureStdin.safeParse(JsonTextSchema.safeParse(raw).data);
   const stdin = parsed.success ? parsed.data : {};
   if (stdin.error !== undefined && stdin.error !== "rate_limit") return 0;
 

package/src/entries/stophook.ts

@@ -4,7 +4,7 @@ import { paths } from "../lib/paths.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
 import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
-import { RespawnMarkerSchema } from "../lib/types.ts";
+import { JsonTextSchema, RespawnMarkerSchema } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
 
 const StopStdin = z.looseObject({ session_id: z.uuid().optional().catch(undefined) });
@@ -19,7 +19,7 @@ export async function runStopHook(): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
   const raw = await readStdin();
-  const parsed = StopStdin.safeParse((() => { try { return JSON.parse(raw); } catch { return {}; } })());
+  const parsed = StopStdin.safeParse(JsonTextSchema.safeParse(raw).data);
   const stdinSid = parsed.success ? parsed.data.session_id : undefined;
   const pinnedSid = process.env.TOKENMAXXING_SESSION_ID;
 

package/src/entries/subagentstatusline.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { makeColors, makeUsagePaint } from "../cli/render.ts";
 import { readStdin } from "./statusline.ts";
-import { SubagentStatusLineStdinSchema } from "../lib/types.ts";
+import { JsonTextSchema, SubagentStatusLineStdinSchema } from "../lib/types.ts";
 
 const RowCtxSchema = z.object({ color: z.boolean(), truecolor: z.boolean() });
 export type RowCtx = z.infer<typeof RowCtxSchema>;
@@ -43,12 +43,7 @@ export function renderSubagentRows(stdinObj: unknown, ctx: RowCtx): string[] {
 }
 
 export async function runSubagentStatusline(): Promise<number> {
-  const raw = await readStdin();
-  let obj: unknown = null;
-  try {
-    obj = JSON.parse(raw);
-  } catch {
-  }
+  const obj = JsonTextSchema.safeParse(await readStdin()).data ?? null;
   const colorterm = z.string().optional().parse(process.env.COLORTERM);
   const rows = renderSubagentRows(obj, {
     color: !process.env.NO_COLOR,

package/src/lib/atomic.ts

@@ -1,20 +1,14 @@
-import { closeSync, mkdirSync, openSync, renameSync, rmSync, writeSync, fsyncSync } from "node:fs";
+import { closeSync, mkdirSync, openSync, renameSync, rmSync, writeFileSync, fsyncSync } from "node:fs";
 import { dirname } from "node:path";
 
 export function writeFileAtomic(file: string, data: string | Uint8Array, mode = 0o600): void {
   const dir = dirname(file);
   mkdirSync(dir, { recursive: true });
   const tmp = `${file}.tmp.${process.pid}.${Math.floor(Math.random() * 1e9).toString(36)}`;
-  const bytes = data instanceof Uint8Array ? data : new TextEncoder().encode(data);
   const fd = openSync(tmp, "wx", mode);
   try {
     try {
-      let offset = 0;
-      while (offset < bytes.length) {
-        const written = writeSync(fd, bytes, offset);
-        if (written <= 0) throw new Error(`short write on ${tmp}: ${offset}/${bytes.length} bytes (disk full?)`);
-        offset += written;
-      }
+      writeFileSync(fd, data);
       fsyncSync(fd);
     } finally {
       closeSync(fd);

package/src/lib/claudelock.ts

@@ -1,9 +1,9 @@
 import { mkdirSync, realpathSync, rmdirSync, statSync, utimesSync } from "node:fs";
 import { join } from "node:path";
 import { delay } from "es-toolkit";
-import { z } from "zod";
 import { credDir } from "./paths.ts";
 import { log } from "./log.ts";
+import { ErrnoSchema } from "./types.ts";
 
 const STALE_MS = 60_000;
 const HEARTBEAT_MS = 5_000;
@@ -15,8 +15,7 @@ function tryAcquire(lockDir: string): boolean {
     mkdirSync(lockDir);
     return true;
   } catch (e) {
-    const errno = z.object({ code: z.string() }).safeParse(e);
-    if (!errno.success || errno.data.code !== "EEXIST") throw e;
+    if (ErrnoSchema.safeParse(e).data?.code !== "EEXIST") throw e;
   }
   try {
     if (Date.now() - statSync(lockDir).mtimeMs > STALE_MS) {

package/src/lib/codex.ts

@@ -259,16 +259,8 @@ async function importLive(): Promise<Harvest | null> {
 function storePinnedAwayFromFile(): boolean {
   const configToml = `${codexPaths.home}/config.toml`;
   if (!existsSync(configToml)) return false;
-  for (const rawLine of readFileSync(configToml, "utf8").split("\n")) {
-    const line = rawLine.trim();
-    if (!line.startsWith("cli_auth_credentials_store")) continue;
-    const rest = line.slice("cli_auth_credentials_store".length).trimStart();
-    if (!rest.startsWith("=")) continue;
-    const beforeComment = rest.slice(1).split("#", 1)[0]!;
-    const value = beforeComment.replaceAll('"', "").replaceAll("'", "").trim();
-    return value !== "file";
-  }
-  return false;
+  const config = Bun.TOML.parse(readFileSync(configToml, "utf8"));
+  return "cli_auth_credentials_store" in config && config.cli_auth_credentials_store !== "file";
 }
 
 function preflight(): void {

package/src/lib/codexauth.ts

@@ -3,18 +3,14 @@ import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { codexPaths } from "./paths.ts";
-import { CodexAuthJsonSchema, type CodexAuthJson } from "./types.ts";
-
-function isEnoent(e: unknown): boolean {
-  return e instanceof Error && "code" in e && e.code === "ENOENT";
-}
+import { CodexAuthJsonSchema, ErrnoSchema, type CodexAuthJson } from "./types.ts";
 
 export function readCodexAuthAt(input: { path: string }): CodexAuthJson | null {
   let raw: string;
   try {
     raw = readFileSync(input.path, "utf8");
   } catch (e) {
-    if (isEnoent(e)) return null;
+    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return null;
     throw e;
   }
   const parsed = JSON.parse(raw);
@@ -46,7 +42,7 @@ export function readParkedCodexAuth(input: { credFile: string }): CodexAuthJson
   try {
     raw = readFileSync(parkedPath(input), "utf8");
   } catch (e) {
-    if (isEnoent(e)) return null;
+    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return null;
     throw e;
   }
   return CodexAuthJsonSchema.parse(JSON.parse(raw));

package/src/lib/codexoauth.ts

@@ -1,10 +1,10 @@
 import { z } from "zod";
 import { http, oauthErrorCode, safeErrorDetail } from "./http.ts";
-import { CodexAuthJsonSchema, type CodexAuthJson } from "./types.ts";
+import { env } from "./paths.ts";
+import { CodexAuthJsonSchema, JsonTextSchema, type CodexAuthJson } from "./types.ts";
 
-const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
-const TOKEN_URL = EnvOverrideSchema.parse(process.env.TOKENMAXXING_CODEX_TOKEN_URL) ?? "https://auth.openai.com/oauth/token";
-const CLIENT_ID = EnvOverrideSchema.parse(process.env.TOKENMAXXING_CODEX_CLIENT_ID) ?? "app_EMoamEEZ73f0CkXaXp7hrann";
+const TOKEN_URL = env("TOKENMAXXING_CODEX_TOKEN_URL", "https://auth.openai.com/oauth/token");
+const CLIENT_ID = env("TOKENMAXXING_CODEX_CLIENT_ID", "app_EMoamEEZ73f0CkXaXp7hrann");
 
 export class CodexInvalidGrantError extends Error {
   constructor(detail: string) {
@@ -60,13 +60,7 @@ export async function refreshCodexAuth(input: { auth: CodexAuthJson; now?: numbe
     throw new CodexRefreshFailedError(`HTTP ${res.status}: ${detail}`);
   }
 
-  const parsed = CodexRefreshResponseSchema.safeParse((() => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return null;
-    }
-  })());
+  const parsed = CodexRefreshResponseSchema.safeParse(JsonTextSchema.safeParse(text).data);
   if (!parsed.success) {
     throw new CodexRefreshFailedError("endpoint returned an unexpected body shape (withheld: may carry tokens)");
   }

package/src/lib/codexpresence.ts

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { codexPaths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import { pidExists, pidStartTime } from "./proc.ts";
+import { ErrnoSchema, JsonTextSchema } from "./types.ts";
 
 const PresenceSchema = z.object({
   accountId: z.string(),
@@ -38,17 +39,10 @@ export function livingCodexPresences(): LivingPresence[] {
     try {
       raw = readFileSync(file, "utf8");
     } catch (e) {
-      const errno = z.object({ code: z.string() }).safeParse(e);
-      if (errno.success && errno.data.code === "ENOENT") continue;
+      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 codex session, refusing to treat it as absent; remove the file (or respawn that session) to proceed`);
     }

package/src/lib/codexusage.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
 import { http, safeErrorDetail } from "./http.ts";
-import { CodexUsageSchema, type CodexAuthJson, type CodexUsage, type Window } from "./types.ts";
+import { env } from "./paths.ts";
+import { CodexUsageSchema, JsonTextSchema, type CodexAuthJson, type CodexUsage, type Window } from "./types.ts";
 import { codexIdentityOf } from "./codexauth.ts";
 import { familyTokens } from "./usage.ts";
 
-const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
-const USAGE_URL = EnvOverrideSchema.parse(process.env.TOKENMAXXING_CODEX_USAGE_URL) ?? "https://chatgpt.com/backend-api/wham/usage";
+const USAGE_URL = env("TOKENMAXXING_CODEX_USAGE_URL", "https://chatgpt.com/backend-api/wham/usage");
 
 export class CodexUsageReadError extends Error {
   constructor(detail: string) {
@@ -70,13 +70,7 @@ export async function fetchCodexUsage(input: { auth: CodexAuthJson; at: number }
   if (!res.ok) {
     throw new CodexUsageReadError(`HTTP ${res.status}: ${safeErrorDetail({ text })}`);
   }
-  const parsed = WireUsageSchema.safeParse((() => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return null;
-    }
-  })());
+  const parsed = WireUsageSchema.safeParse(JsonTextSchema.safeParse(text).data);
   if (!parsed.success) {
     throw new CodexUsageReadError("endpoint returned an unexpected body shape (withheld)");
   }

package/src/lib/credstore.ts

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import * as kc from "./keychain.ts";
 import { credDir, keychain as kcNames, namespacedCredService, paths } from "./paths.ts";
-import { CredentialBlobSchema } from "./types.ts";
+import { CredentialBlobSchema, ErrnoSchema } from "./types.ts";
 
 const CredTargetSchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("keychain"), service: z.string(), account: z.string() }),
@@ -16,16 +16,12 @@ const darwin = process.platform === "darwin";
 
 const BlobRecordSchema = z.record(z.string(), z.unknown());
 
-function isEnoent(e: unknown): boolean {
-  return e instanceof Error && "code" in e && e.code === "ENOENT";
-}
-
 export async function readItem(t: CredTarget): Promise<string | null> {
   if (t.kind === "keychain") return kc.readItem(t);
   try {
     return readFileSync(t.path, "utf8");
   } catch (e) {
-    if (isEnoent(e)) return null;
+    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return null;
     throw e;
   }
 }
@@ -42,7 +38,7 @@ export async function deleteItem(t: CredTarget): Promise<boolean> {
     unlinkSync(t.path);
     return true;
   } catch (e) {
-    if (isEnoent(e)) return false;
+    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return false;
     throw e;
   }
 }

package/src/lib/http.ts

@@ -1,5 +1,6 @@
 import ky from "ky";
 import { z } from "zod";
+import { JsonTextSchema } from "./types.ts";
 
 const OAuthErrorBodySchema = z.looseObject({
   error: z.string(),
@@ -20,12 +21,8 @@ const ErrorDetailSchema = z.object({ code: z.string().nullable(), fields: z.arra
 type ErrorDetail = z.infer<typeof ErrorDetailSchema>;
 
 function parseErrorBody(text: string): ErrorDetail | null {
-  let json: unknown;
-  try {
-    json = JSON.parse(text);
-  } catch {
-    return null;
-  }
+  const json = JsonTextSchema.safeParse(text).data;
+  if (json === undefined) return null;
   const oauth = OAuthErrorBodySchema.safeParse(json);
   if (oauth.success) return { code: oauth.data.error, fields: [oauth.data.error, oauth.data.error_description ?? ""] };
   const nested = NestedErrorBodySchema.safeParse(json);

package/src/lib/install.ts

@@ -7,6 +7,7 @@ import { writeFileAtomic } from "./atomic.ts";
 import { installedBin, installSettings, isOurHookCommand, uninstallSettings } from "./settings.ts";
 import { resolveRealClaude } from "./claudebin.ts";
 import { loadConfig } from "./state.ts";
+import { ErrnoSchema } from "./types.ts";
 
 const InstallOutcomeSchema = z.object({
   claudeWrapper: z.string(),
@@ -49,10 +50,6 @@ function isNixStorePath(path: string): boolean {
   return path === "/nix/store" || path.startsWith("/nix/store/");
 }
 
-function isEacces(e: unknown): boolean {
-  return typeof e === "object" && e != null && "code" in e && e.code === "EACCES";
-}
-
 function cannotWriteRcTarget(target: string): boolean {
   if (EnvFlagSchema.parse(process.env.TOKENMAXXING_SKIP_SHELL_RC) != null) return true;
   if (isNixStorePath(target)) return true;
@@ -355,7 +352,7 @@ export function ensurePathInRc(rc: string): "added" | "present" | "skipped" {
     try {
       writeFileAtomic(target, `${body}${sep0}${addition}`, statSync(target).mode & 0o777);
     } catch (e) {
-      if (isEacces(e)) return "skipped";
+      if (ErrnoSchema.safeParse(e).data?.code === "EACCES") return "skipped";
       throw e;
     }
     return "added";
@@ -366,7 +363,7 @@ export function ensurePathInRc(rc: string): "added" | "present" | "skipped" {
   try {
     appendFileSync(target, `${sep}export PATH="${dir}:$PATH" ${PATH_LINE_MARK}\n`);
   } catch (e) {
-    if (isEacces(e)) return "skipped";
+    if (ErrnoSchema.safeParse(e).data?.code === "EACCES") return "skipped";
     throw e;
   }
   return "added";
@@ -411,7 +408,7 @@ export function removePathFromRc(rc: string): boolean {
   try {
     writeFileAtomic(target, kept.join("\n"), statSync(target).mode & 0o777);
   } catch (e) {
-    if (isEacces(e)) return false;
+    if (ErrnoSchema.safeParse(e).data?.code === "EACCES") return false;
     throw e;
   }
   return true;

package/src/lib/oauth.ts

@@ -1,11 +1,10 @@
-import { z } from "zod";
 import { http, oauthErrorCode, safeErrorDetail } from "./http.ts";
-import { ProfileResponseSchema, RefreshResponseSchema, TokenIdentitySchema, type OAuthCreds, type TokenIdentity } from "./types.ts";
+import { env } from "./paths.ts";
+import { JsonTextSchema, ProfileResponseSchema, RefreshResponseSchema, TokenIdentitySchema, type OAuthCreds, type TokenIdentity } from "./types.ts";
 
-const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
-const TOKEN_URL = EnvOverrideSchema.parse(process.env.TOKENMAXXING_OAUTH_TOKEN_URL) ?? "https://platform.claude.com/v1/oauth/token";
-const CLIENT_ID = EnvOverrideSchema.parse(process.env.TOKENMAXXING_OAUTH_CLIENT_ID) ?? "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-const PROFILE_URL = EnvOverrideSchema.parse(process.env.TOKENMAXXING_OAUTH_PROFILE_URL) ?? "https://api.anthropic.com/api/oauth/profile";
+const TOKEN_URL = env("TOKENMAXXING_OAUTH_TOKEN_URL", "https://platform.claude.com/v1/oauth/token");
+const CLIENT_ID = env("TOKENMAXXING_OAUTH_CLIENT_ID", "9d1c250a-e61b-44d9-88ed-5944d1962f5e");
+const PROFILE_URL = env("TOKENMAXXING_OAUTH_PROFILE_URL", "https://api.anthropic.com/api/oauth/profile");
 
 const DEFAULT_SCOPES = [
   "user:profile",
@@ -76,9 +75,7 @@ export async function refreshCredential(creds: OAuthCreds, now = Date.now(), sig
     throw new Error(`token refresh failed (HTTP ${res.status}): ${detail}`);
   }
 
-  const parsed = RefreshResponseSchema.safeParse((() => {
-    try { return JSON.parse(text); } catch { return null; }
-  })());
+  const parsed = RefreshResponseSchema.safeParse(JsonTextSchema.safeParse(text).data);
   if (!parsed.success) {
     throw new Error(`token endpoint returned an unrecognized body (${text.length} bytes, withheld)`);
   }
@@ -119,9 +116,7 @@ export async function fetchTokenIdentity(accessToken: string, signal?: AbortSign
     throw new IdentityUnavailableError(res.status, `profile response body unreadable: ${e instanceof Error ? e.message : String(e)}`);
   }
   if (!res.ok) throw new IdentityUnavailableError(res.status, safeErrorDetail({ text }));
-  const parsed = ProfileResponseSchema.safeParse((() => {
-    try { return JSON.parse(text); } catch { return null; }
-  })());
+  const parsed = ProfileResponseSchema.safeParse(JsonTextSchema.safeParse(text).data);
   if (!parsed.success) throw new IdentityUnavailableError(res.status, `profile endpoint returned an unrecognized body (${text.length} bytes, withheld)`);
   return TokenIdentitySchema.parse({
     accountUuid: parsed.data.account.uuid,

package/src/lib/paths.ts

@@ -6,7 +6,7 @@ const HOME = homedir();
 
 const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
 
-function env(name: string, fallback: string): string {
+export function env(name: string, fallback: string): string {
   return EnvOverrideSchema.parse(process.env[name]) ?? fallback;
 }
 

package/src/lib/proc.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { ErrnoSchema } from "./types.ts";
 
 export function pidStartTime(pid: number): string | null {
   const res = Bun.spawnSync(["ps", "-p", String(pid), "-o", "lstart="], { env: { ...process.env, LC_ALL: "C" } });
@@ -12,9 +12,9 @@ export function pidExists(pid: number): boolean {
     process.kill(pid, 0);
     return true;
   } catch (e) {
-    const errno = z.object({ code: z.string() }).safeParse(e);
-    if (errno.success && errno.data.code === "ESRCH") return false;
-    if (errno.success && errno.data.code === "EPERM") return true;
+    const code = ErrnoSchema.safeParse(e).data?.code;
+    if (code === "ESRCH") return false;
+    if (code === "EPERM") return true;
     throw e;
   }
 }

package/src/lib/state.ts

@@ -6,6 +6,7 @@ import { writeFileAtomic } from "./atomic.ts";
 import {
   AccountsIndexSchema,
   ConfigSchema,
+  ErrnoSchema,
   LastSwapSchema,
   UsageStateSchema,
   type Account,
@@ -181,8 +182,7 @@ export function writeUsage(input: UsageState, opts: { stamp?: boolean } = {}): b
     try {
       utimesSync(paths.usageJson, new Date(next.ts), new Date(next.ts));
     } catch (e) {
-      const errno = z.object({ code: z.string() }).safeParse(e);
-      if (!errno.success || errno.data.code !== "ENOENT") throw e;
+      if (ErrnoSchema.safeParse(e).data?.code !== "ENOENT") throw e;
     }
     return false;
   }

package/src/lib/types.ts

@@ -244,3 +244,17 @@ export const CodexReconcileMarkerSchema = z.object({
   accountId: z.string(),
   ts: z.number(),
 });
+
+export const ErrnoSchema = z.object({ code: z.string() });
+
+export const JsonTextSchema = z.codec(z.string(), z.unknown(), {
+  decode: (text, ctx) => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      ctx.issues.push({ code: "invalid_format", format: "json", input: text });
+      return z.NEVER;
+    }
+  },
+  encode: (value) => JSON.stringify(value),
+});

package/src/lib/update.ts

@@ -0,0 +1,133 @@
+import { existsSync, lstatSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { z } from "zod";
+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";
+
+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() });
+
+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 base = new URL(raw.endsWith("/") ? raw : `${raw}/`);
+  const authorization =
+    base.username !== "" || base.password !== "" ? `Basic ${btoa(`${decodeURIComponent(base.username)}:${decodeURIComponent(base.password)}`)}` : null;
+  base.username = "";
+  base.password = "";
+  return { base, authorization };
+}
+
+function realOrNull(path: string): string | null {
+  try {
+    return realpathSync(path);
+  } catch {
+    return null;
+  }
+}
+
+function globalRootCandidates(): string[] {
+  const globalDir = OverrideSchema.parse(process.env.BUN_INSTALL_GLOBAL_DIR);
+  const bunInstall = OverrideSchema.parse(process.env.BUN_INSTALL);
+  return [
+    ...(globalDir != null ? [globalDir] : []),
+    ...(bunInstall != null ? [join(bunInstall, "install", "global")] : []),
+    join(dirname(dirname(process.execPath)), "install", "global"),
+    join(HOME, ".bun", "install", "global"),
+  ].map((candidate) => resolve(candidate));
+}
+
+function packageDir(root: string): string {
+  return join(root, "node_modules", "tokenmaxxing");
+}
+
+function registryPackageDir(root: string): string | null {
+  const dir = packageDir(root);
+  try {
+    return lstatSync(dir).isSymbolicLink() ? null : dir;
+  } catch {
+    return null;
+  }
+}
+
+function detectGlobalRoot(): string | null {
+  if (isNixPackaged()) return null;
+  const entry = realOrNull(Bun.main);
+  if (entry == null) return null;
+  return (
+    globalRootCandidates().find((root) => {
+      const dir = registryPackageDir(root);
+      return dir != null && entry === realOrNull(join(dir, "src", "main.ts"));
+    }) ?? null
+  );
+}
+
+function installedVersion(root: string): string {
+  return VersionSchema.parse(JSON.parse(readFileSync(join(packageDir(root), "package.json"), "utf8"))).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;
+}
+
+async function updateToLatest(root: string): Promise<void> {
+  const current = installedVersion(root);
+  const { base, authorization } = registry();
+  const latestUrl = new URL("tokenmaxxing/latest", base).href;
+  const signal = AbortSignal.timeout(REGISTRY_DEADLINE_MS);
+  const response = await http.get(latestUrl, { signal, headers: authorization ? { authorization } : undefined });
+  if (!response.ok) throw new Error(`${latestUrl} answered HTTP ${response.status}`);
+  const latest = LatestSchema.parse(await response.json());
+  if (Bun.semver.order(latest.version, current) <= 0) return;
+  const floor = latest.engines?.bun;
+  if (floor != null && !Bun.semver.satisfies(Bun.version, floor)) {
+    throw new Error(`tokenmaxxing@${latest.version} needs bun ${floor}, this is bun ${Bun.version}`);
+  }
+  const child = Bun.spawn([process.execPath, "add", "-g", "--registry", base.href, `tokenmaxxing@${latest.version}`], {
+    cwd: paths.home,
+    env: { ...process.env, BUN_INSTALL_GLOBAL_DIR: root },
+    stdout: "ignore",
+    stderr: "inherit",
+    timeout: INSTALL_DEADLINE_MS,
+    killSignal: "SIGKILL",
+  });
+  await child.exited;
+  if (child.exitCode !== 0) throw new Error(`bun add -g tokenmaxxing@${latest.version} exited ${child.signalCode ?? child.exitCode}`);
+  const installed = installedVersion(root);
+  if (installed !== latest.version) throw new Error(`bun add -g tokenmaxxing@${latest.version} left ${installed} installed`);
+  log("update.done", { from: current, to: latest.version });
+}
+
+export async function maybeAutoUpdate(): Promise<void> {
+  const root = detectGlobalRoot();
+  if (root == null) return;
+  await withLock(updateLock, async () => {
+    const now = Date.now();
+    if (!isDue(now)) return;
+    writeFileAtomic(updateJson, JSON.stringify({ attemptedAt: now }) + "\n");
+    try {
+      await updateToLatest(root);
+    } catch (e) {
+      throw new Error(`self-update from npm failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  });
+}

package/src/lib/usage.ts

@@ -3,7 +3,7 @@ import { delay } from "es-toolkit";
 import { z } from "zod";
 import { MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealClaude } from "./claudebin.ts";
 import { log } from "./log.ts";
-import { RateLimitsStdinSchema, type ModelInfo, type UsageWindow, type UsageWindows, type Window } from "./types.ts";
+import { JsonTextSchema, RateLimitsStdinSchema, type ModelInfo, type UsageWindow, type UsageWindows, type Window } from "./types.ts";
 
 export function normalizeResetsAt(v: unknown): number | null {
   const num = z.number().finite().safeParse(v);
@@ -279,21 +279,16 @@ const SpawnResultSchema = z.object({
 type SpawnResult = z.infer<typeof SpawnResultSchema>;
 
 async function spawnClaudeBounded(cmd: string[], env: Record<string, string>): Promise<SpawnResult | null> {
-  const p = Bun.spawn(cmd, { env, stdout: "pipe", stderr: "pipe" });
-  const killer = setTimeout(() => p.kill("SIGKILL"), PROBE_KILL_MS);
-  try {
-    const reads = Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text()]);
-    const settled = await Promise.race([
-      reads,
-      p.exited.then(() => delay(PIPE_GRACE_MS)).then(() => null),
-    ]);
-    if (settled === null) return null;
-    const [stdout, stderr] = settled;
-    await p.exited;
-    return { exitCode: p.exitCode, stdout, stderr };
-  } finally {
-    clearTimeout(killer);
-  }
+  const p = Bun.spawn(cmd, { env, stdout: "pipe", stderr: "pipe", timeout: PROBE_KILL_MS, killSignal: "SIGKILL" });
+  const reads = Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text()]);
+  const settled = await Promise.race([
+    reads,
+    p.exited.then(() => delay(PIPE_GRACE_MS)).then(() => null),
+  ]);
+  if (settled === null) return null;
+  const [stdout, stderr] = settled;
+  await p.exited;
+  return { exitCode: p.exitCode, stdout, stderr };
 }
 
 async function probeUsageOnce(env: Record<string, string>, now: number): Promise<UsageWindows | null> {
@@ -314,7 +309,7 @@ async function probeUsageOnce(env: Record<string, string>, now: number): Promise
     return null;
   }
 
-  const j = z.object({ result: z.string() }).safeParse((() => { try { return JSON.parse(out); } catch { return null; } })());
+  const j = z.object({ result: z.string() }).safeParse(JsonTextSchema.safeParse(out).data);
   const text = j.success ? j.data.result : out;
   const full = parseUsageText(text, now);
   if (!full) {