tokenmaxxing 1.56.0 → 1.58.0

package/src/entries/codexsupervisor.ts

@@ -1,17 +1,18 @@
 import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
-import { codexPaths, codexPool, paths } from "../lib/paths.ts";
+import { codexPaths, codexPool } from "../lib/paths.ts";
 import { withLock } from "../lib/lock.ts";
-import { LOOP_DIAGNOSIS, MAX_WRAP_DEPTH, UNMANAGED_ENV, WRAP_DEPTH_ENV, WRAP_RATE_MAX, WRAP_RATE_WINDOW_MS, wrapDepth, wrapperEntryRateTripped } from "../lib/claudebin.ts";
+import { UNMANAGED_ENV, WRAP_DEPTH_ENV, wrapDepth } from "../lib/claudebin.ts";
 import { resolveRealCodex } from "../lib/codexbin.ts";
 import { ensureCodexStoreHome } from "../lib/codexauth.ts";
 import { pickCodexSeat } from "../lib/codex.ts";
-import { clearPresence, writePresence } from "../lib/presence.ts";
-import { saveTermios, restoreTermios } from "../lib/tty.ts";
+import { clearPresence } from "../lib/presence.ts";
+import { exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough } from "../lib/supervise.ts";
+import { saveTermios } from "../lib/tty.ts";
 import { loadAccounts } from "../lib/state.ts";
 import { CodexRespawnMarkerSchema } from "../lib/types.ts";
-import { log } from "../lib/log.ts";
+import { errorMessage, log } from "../lib/log.ts";
 
 export const CODEX_SUPERVISOR_ID_ENV = "TOKENMAXXING_CODEX_SUPERVISOR_ID";
 
@@ -27,7 +28,7 @@ function readCodexMarker(marker: string): z.infer<typeof CodexRespawnMarkerSchem
   try {
     return CodexRespawnMarkerSchema.parse(JSON.parse(readFileSync(marker, "utf8")));
   } catch (e) {
-    log("codexsupervisor.marker_invalid", { err: e instanceof Error ? e.message : String(e) });
+    log("codexsupervisor.marker_invalid", { err: errorMessage(e) });
     throw new Error(
       `${marker} is corrupt (unparsable JSON or off-schema) - the codex session was stopped instead of resumed on a stale target; inspect and remove the marker, then run \`codex resume\``,
     );
@@ -54,52 +55,17 @@ export function shouldManageCodex(input: { argv: string[] }): boolean {
   return firstPositional === null || !NONINTERACTIVE_SUBCMDS.has(firstPositional);
 }
 
-async function recordCodexPresence(child: { pid: number; exitCode: number | null; signalCode: string | null; kill: () => void; exited: Promise<unknown> }, supervisorId: string, seat: { id: string }, savedTermios: string | null): Promise<void> {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      writePresence({ dir: codexPaths.presenceDir, id: supervisorId, accountId: seat.id, pid: child.pid });
-      return;
-    } catch (e) {
-      if (child.exitCode !== null || child.signalCode !== null) return;
-      if (attempt >= 9) {
-        log("codexsupervisor.presence_failed", { err: e instanceof Error ? e.message : String(e) });
-        child.kill();
-        await child.exited;
-        restoreTermios(savedTermios);
-        throw new Error("could not write the codex presence file - refusing to run an unprotected session (its account would look like a swap target)");
-      }
-      await Bun.sleep(100);
-    }
-  }
-}
-
 export async function runCodexSupervisor(input: { argv: string[] }): Promise<number> {
   const { argv } = input;
-  const depth = wrapDepth();
-  if (depth >= MAX_WRAP_DEPTH) {
-    console.error(
-      `tokenmaxxing: ${LOOP_DIAGNOSIS} (depth ${depth}) - codexBin in ${paths.configJson} does not launch the real codex binary. Fix codexBin, then run \`tokenmaxxing doctor\`.`,
-    );
-    log("codexsupervisor.loop_abort", { depth });
-    return 1;
-  }
-  if (wrapperEntryRateTripped(Date.now())) {
-    console.error(
-      `tokenmaxxing: ${LOOP_DIAGNOSIS} (over ${WRAP_RATE_MAX} wrapper entries in ${WRAP_RATE_WINDOW_MS / 1000}s) - codexBin in ${paths.configJson} does not launch the real codex binary. Fix codexBin, then run \`tokenmaxxing doctor\`.`,
-    );
-    log("codexsupervisor.rate_abort", { max: WRAP_RATE_MAX });
-    return 1;
-  }
+  if (loopGuardTripped("codex")) return 1;
 
   const real = resolveRealCodex();
-  const childEnv = { ...process.env, [WRAP_DEPTH_ENV]: String(depth + 1) };
+  const childEnv = { ...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 p = Bun.spawn([real, ...argv], { stdin: "inherit", stdout: "inherit", stderr: "inherit", env: passthroughEnv });
-    await p.exited;
-    return p.exitCode ?? (p.signalCode ? 1 : 0);
+    return runPassthrough({ real, argv, env: passthroughEnv });
   }
 
   const supervisorId = crypto.randomUUID();
@@ -131,37 +97,29 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
           ...(store ? { CODEX_HOME: store } : {}),
         },
       });
-      if (picked) await recordCodexPresence(spawned, supervisorId, picked, savedTermios);
+      if (picked) {
+        await recordPresenceOrStop({
+          child: spawned,
+          dir: codexPaths.presenceDir,
+          id: supervisorId,
+          accountId: picked.id,
+          event: "codexsupervisor.presence_failed",
+          message: "could not write the codex presence file - refusing to run an unprotected session (its account would look like a swap target)",
+          savedTermios,
+        });
+      }
       return { child: spawned, seat: picked };
     });
 
-    let done = false;
-    const markerWatch = (async () => {
-      while (!done) {
-        if (existsSync(marker)) {
-          readCodexMarker(marker);
-          return true;
-        }
-        await Bun.sleep(150);
-      }
-      return false;
-    })();
-    const exited = child.exited.then(() => {
-      done = true;
-      return "exit";
+    await raceMarkerOrExit({
+      child,
+      tick: () => {
+        if (!existsSync(marker)) return false;
+        readCodexMarker(marker);
+        return true;
+      },
+      savedTermios,
     });
-    try {
-      const winner = await Promise.race([exited, markerWatch.then((found) => (found ? "marker" : "exit"))]);
-      if (winner === "marker") child.kill();
-    } catch (e) {
-      child.kill();
-      throw e;
-    } finally {
-      await child.exited;
-      done = true;
-      await markerWatch.catch(() => false);
-      restoreTermios(savedTermios);
-    }
 
     const payload = existsSync(marker) ? readCodexMarker(marker) : null;
     if (payload) {
@@ -175,6 +133,6 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
     }
     clearPresence({ dir: codexPaths.presenceDir, id: supervisorId });
     log("codexsupervisor.exit", { supervisorId: supervisorId.slice(0, 8), respawns, code: child.exitCode, signal: child.signalCode });
-    return child.exitCode ?? (child.signalCode ? 1 : 0);
+    return exitStatus(child);
   }
 }

package/src/entries/statusline.ts

@@ -1,39 +1,32 @@
 import { sortBy } from "es-toolkit";
-import { z } from "zod";
 import { claudePool, seatFromEnv } from "../lib/paths.ts";
+import { errorMessage } from "../lib/log.ts";
 import { loadAccounts, loadConfig, writeUsage } from "../lib/state.ts";
 import { familyTokens, matchedFamily, parseStatusLineStdin, parseStatusLineModel } from "../lib/usage.ts";
 import { earliestReset, limitWindows, weeklyExpiry, weeklyWindow } from "../lib/picker.ts";
+import { readStdin } from "../lib/proc.ts";
 import { worktreeName } from "../lib/worktree.ts";
-import { makeColors, makeUsagePaint } from "../cli/render.ts";
-import { fmtResetShort } from "../lib/usage.ts";
+import { fmtResetShort, makeColors, makeUsagePaint, statuslineColor } from "../cli/render.ts";
 import {
-  AccountsIndexSchema,
   JsonTextSchema,
   StatusLineStdinSchema,
-  WindowSchema,
   type Account,
+  type AccountsIndex,
   type UsageState,
   type UsageWindow,
+  type Window,
 } from "../lib/types.ts";
 
-const RenderCtxSchema = z.object({
-  accounts: AccountsIndexSchema,
-  perModel: z.record(z.string(), WindowSchema),
-  switchModels: z.array(z.string()),
-  worktree: z.string().nullable(),
-  liveAccount: z.string().nullable(),
-  now: z.number(),
-  color: z.boolean(),
-  truecolor: z.boolean(),
-});
-export type RenderCtx = z.infer<typeof RenderCtxSchema>;
-
-export async function readStdin(): Promise<string> {
-  const chunks: Uint8Array[] = [];
-  for await (const c of Bun.stdin.stream()) chunks.push(c);
-  return Buffer.concat(chunks).toString("utf8");
-}
+export type RenderCtx = {
+  accounts: AccountsIndex;
+  perModel: Record<string, Window>;
+  switchModels: string[];
+  worktree: string | null;
+  liveAccount: string | null;
+  now: number;
+  color: boolean;
+  truecolor: boolean;
+};
 
 export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
   const col = makeColors(ctx.color);
@@ -134,7 +127,6 @@ export async function runStatusline(): Promise<number> {
     const accounts = loadAccounts(claudePool);
     const stdin = StatusLineStdinSchema.safeParse(obj);
     const dir = stdin.success ? (stdin.data.workspace?.current_dir ?? stdin.data.workspace?.project_dir ?? null) : null;
-    const colorterm = z.string().optional().parse(process.env.COLORTERM);
     const live = accounts.accounts.find((a) => a.id === account);
     const ctx: RenderCtx = {
       accounts,
@@ -143,12 +135,11 @@ export async function runStatusline(): Promise<number> {
       worktree: dir == null ? null : worktreeName(dir),
       liveAccount: account,
       now,
-      color: !process.env.NO_COLOR,
-      truecolor: colorterm != null && (colorterm.includes("truecolor") || colorterm.includes("24bit")),
+      ...statuslineColor(),
     };
     line = renderStatusline(obj, ctx);
   } catch (e) {
-    line = `tokenmaxxing: ${e instanceof Error ? e.message : String(e)}`;
+    line = `tokenmaxxing: ${errorMessage(e)}`;
   }
   process.stdout.write(line + "\n");
   return 0;

package/src/entries/stopfailurehook.ts

@@ -1,13 +1,13 @@
 import { z } from "zod";
 import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
+import { readStdin } from "../lib/proc.ts";
 import { supervisedSession, writeRespawnMarker } from "../lib/sessions.ts";
 import { loadConfig } from "../lib/state.ts";
 import { classifyEnforcedLimit, findEnforcedRow, parseErrorBody, readTranscriptTail, type TranscriptRow } from "../lib/usage.ts";
 import { paths } from "../lib/paths.ts";
 import { JsonTextSchema, type EnforcedLimit } from "../lib/types.ts";
-import { log } from "../lib/log.ts";
-import { readStdin } from "./statusline.ts";
+import { errorMessage, log } from "../lib/log.ts";
 
 const StopFailureStdin = z.looseObject({
   session_id: z.uuid().optional().catch(undefined),
@@ -34,8 +34,7 @@ export async function runStopFailureHook(): Promise<number> {
 
   const account = claude.liveId();
   const now = Date.now();
-  const raw = await readStdin();
-  const parsed = StopFailureStdin.safeParse(JsonTextSchema.safeParse(raw).data);
+  const parsed = StopFailureStdin.safeParse(JsonTextSchema.safeParse(await readStdin()).data);
   const stdin = parsed.success ? parsed.data : {};
   if (stdin.error !== undefined && stdin.error !== "rate_limit") return 0;
 
@@ -84,7 +83,7 @@ export async function runStopFailureHook(): Promise<number> {
       log("stopfailure.decision", { reason: decision.reason, swapped: decision.swapped, account: decision.account?.id.slice(0, 8), waitUntil: decision.waitUntil });
     }
   } catch (e) {
-    log("stopfailure.error", { err: e instanceof Error ? e.message : String(e) });
+    log("stopfailure.error", { err: errorMessage(e) });
   }
   return 0;
 }

package/src/entries/stophook.ts

@@ -1,29 +1,31 @@
 import { z } from "zod";
 import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
+import { readStdin } from "../lib/proc.ts";
 import { supervisedSession, writeRespawnMarker } from "../lib/sessions.ts";
 import { JsonTextSchema } from "../lib/types.ts";
-import { log } from "../lib/log.ts";
-import { readStdin } from "./statusline.ts";
+import { errorMessage, log } from "../lib/log.ts";
 
-const StopStdin = z.looseObject({ session_id: z.uuid().optional().catch(undefined) });
+const BoundaryStdin = z.looseObject({
+  source: z.string().optional(),
+  session_id: z.uuid().optional().catch(undefined),
+});
 
-export async function runStopHook(): Promise<number> {
+export async function runBoundaryHook(event: "stop" | "sessionstart"): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
-  const raw = await readStdin();
-  const parsed = StopStdin.safeParse(JsonTextSchema.safeParse(raw).data);
-  const stdinSid = parsed.success ? parsed.data.session_id : undefined;
+  const parsed = BoundaryStdin.safeParse(JsonTextSchema.safeParse(await readStdin()).data);
+  const stdin = parsed.success ? parsed.data : {};
   const session = supervisedSession();
 
   try {
     const decision = await evaluateAndMaybeSwap(claude, Date.now(), session != null);
     if (session && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
-      writeRespawnMarker({ session, sessionId: stdinSid ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? Date.now(), compact: true });
-      log(decision.waitUntil !== undefined ? "stop.wait" : "stop.move", { account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil, session: session.sid.slice(0, 8) });
+      writeRespawnMarker({ session, sessionId: stdin.session_id ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? Date.now(), compact: true });
+      log(`${event}.${decision.waitUntil !== undefined ? "wait" : "move"}`, { source: stdin.source, account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil, session: session.sid.slice(0, 8) });
     }
   } catch (e) {
-    log("stop.error", { err: e instanceof Error ? e.message : String(e) });
+    log(`${event}.error`, { err: errorMessage(e) });
   }
   return 0;
 }

package/src/entries/subagentstatusline.ts

@@ -1,10 +1,8 @@
-import { z } from "zod";
-import { makeColors, makeUsagePaint } from "../cli/render.ts";
-import { readStdin } from "./statusline.ts";
+import { makeColors, makeUsagePaint, statuslineColor } from "../cli/render.ts";
+import { readStdin } from "../lib/proc.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>;
+export type RowCtx = { color: boolean; truecolor: boolean };
 
 function modelFamily(id: string): string {
   const [head, family] = id.split("-");
@@ -44,11 +42,7 @@ export function renderSubagentRows(stdinObj: unknown, ctx: RowCtx): string[] {
 
 export async function runSubagentStatusline(): Promise<number> {
   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,
-    truecolor: colorterm != null && (colorterm.includes("truecolor") || colorterm.includes("24bit")),
-  });
+  const rows = renderSubagentRows(obj, statuslineColor());
   if (rows.length > 0) process.stdout.write(rows.join("\n") + "\n");
   return 0;
 }