tokenmaxxing 1.91.0 → 1.92.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.91.0",
+  "version": "1.92.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/cli/seat.ts

@@ -1,11 +1,4 @@
-import { codexPickCtx, observeCodex } from "../lib/codex.ts";
-import { codexStoreUsable, ensureCodexStoreHome } from "../lib/codexauth.ts";
-import { withLock } from "../lib/lock.ts";
-import { log } from "../lib/log.ts";
-import { codexPaths, codexPool } from "../lib/paths.ts";
-import { livingPresences, seatCounts, writePresence } from "../lib/presence.ts";
-import { isExhausted, pickBest } from "../lib/picker.ts";
-import { loadAccounts, loadConfig } from "../lib/state.ts";
+import { borrowCodexSeat } from "../lib/codex.ts";
 import { emitError } from "./render.ts";
 
 export async function cmdSeat(pidRaw: string | undefined, extra: string[]): Promise<number> {
@@ -14,38 +7,7 @@ export async function cmdSeat(pidRaw: string | undefined, extra: string[]): Prom
     emitError({ message: "usage: tokenmaxxing seat --codex <pid> - print the CODEX_HOME of one pooled account, reserved until <pid> exits" });
     return 2;
   }
-  const now = Date.now();
-  const seatId = `seat-${pid}`;
-  const cfg = loadConfig();
-  await Promise.all(
-    loadAccounts(codexPool)
-      .accounts.filter((a) => a.needsReauth !== true && codexStoreUsable(a.id))
-      .map((a) => observeCodex(a, cfg, now, { probe: true, refresh: false })),
-  );
-  const granted = await withLock(codexPool.lockFile, (): { store: string; id: string; reused: boolean } | { denied: string } | null => {
-    const ctx = codexPickCtx(now, null);
-    const idx = loadAccounts(codexPool);
-    const held = livingPresences(codexPaths.presenceDir).find((p) => p.id === seatId);
-    const heldAccount = held ? (idx.accounts.find((x) => x.id === held.accountId) ?? null) : null;
-    if (heldAccount) {
-      if (heldAccount.needsReauth === true) {
-        return { denied: "the account this pid holds needs reauthentication - run `tokenmaxxing auth --codex` and borrow again" };
-      }
-      if (!codexStoreUsable(heldAccount.id)) {
-        return { denied: "the account this pid holds has no usable credential in its store - refusing to hand back a credential-less seat" };
-      }
-      return { store: ensureCodexStoreHome(heldAccount.id), id: heldAccount.id, reused: true };
-    }
-    const present = seatCounts(codexPaths.presenceDir);
-    const usable = idx.accounts.filter(
-      (a) => a.needsReauth !== true && !isExhausted(a, ctx) && !present.has(a.id) && codexStoreUsable(a.id)
-    );
-    const picked = pickBest(usable, ctx);
-    if (!picked) return null;
-    const store = ensureCodexStoreHome(picked.id);
-    writePresence({ dir: codexPaths.presenceDir, id: seatId, accountId: picked.id, pid });
-    return { store, id: picked.id, reused: false };
-  });
+  const granted = await borrowCodexSeat(pid);
   if (!granted) {
     emitError({ message: "no usable codex account (pool empty, every account live in another session, or every account at a limit) - use the ambient codex login" });
     return 1;
@@ -54,7 +16,6 @@ export async function cmdSeat(pidRaw: string | undefined, extra: string[]): Prom
     emitError({ message: granted.denied });
     return 1;
   }
-  log("seat.grant", { account: granted.id.slice(0, 8), pid, reused: granted.reused });
   console.log(granted.store);
   return 0;
 }

package/src/entries/codexsupervisor.ts

@@ -1,3 +1,4 @@
+import type { Subprocess } from "bun";
 import { existsSync, mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
@@ -5,7 +6,7 @@ import { codexPaths, codexPool } from "../lib/paths.ts";
 import { withLock } from "../lib/lock.ts";
 import { CODEX_BIN, UNMANAGED_ENV, WRAP_DEPTH_ENV, resolveRealBin, wrapDepth } from "../lib/claudebin.ts";
 import { codexStoreUsable, ensureCodexStoreHome } from "../lib/codexauth.ts";
-import { codexPickCtx, pickCodexSeat } from "../lib/codex.ts";
+import { borrowCodexSeat, codexPickCtx, pickCodexSeat } from "../lib/codex.ts";
 import { clearPresence, livingPresences } from "../lib/presence.ts";
 import { isExhausted } from "../lib/picker.ts";
 import { exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough } from "../lib/supervise.ts";
@@ -17,11 +18,13 @@ import { errorMessage, log } from "../lib/log.ts";
 export const CODEX_SUPERVISOR_ID_ENV = "TOKENMAXXING_CODEX_SUPERVISOR_ID";
 
 const NONINTERACTIVE_SUBCMDS = new Set([
-  "exec", "review", "login", "logout", "mcp", "plugin", "mcp-server", "app-server",
+  "exec", "e", "review", "login", "logout", "mcp", "plugin", "mcp-server", "app-server",
   "remote-control", "app", "completion", "update", "doctor", "sandbox", "debug",
   "apply", "archive", "delete", "unarchive", "cloud", "exec-server", "features", "help",
 ]);
 
+const BORROWING_SUBCMDS = new Set(["exec", "e", "review", "app-server"]);
+
 const PASSTHROUGH_FLAGS = new Set(["--version", "-V", "--help", "-h"]);
 
 function readCodexMarker(marker: string): z.infer<typeof CodexRespawnMarkerSchema> {
@@ -40,19 +43,32 @@ const VALUE_TAKING_ROOT_FLAGS = new Set([
   "-s", "--sandbox", "-a", "--ask-for-approval", "-C", "--cd", "--add-dir", "--enable",
 ]);
 
-export function shouldManageCodex(input: { argv: string[] }): boolean {
-  if (process.env.TOKENMAXXING_PROBE) return false;
-  let firstPositional: string | null = null;
-  for (let i = 0; i < input.argv.length; i++) {
-    const arg = input.argv[i]!;
-    if (PASSTHROUGH_FLAGS.has(arg)) return false;
+function scanCodexArgs(argv: string[]): { help: boolean; positionals: string[] } {
+  const positionals: string[] = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    if (arg === "--") break;
+    if (PASSTHROUGH_FLAGS.has(arg)) return { help: true, positionals };
     if (VALUE_TAKING_ROOT_FLAGS.has(arg)) {
       i++;
       continue;
     }
-    if (!arg.startsWith("-") && firstPositional === null) firstPositional = arg;
+    if (!arg.startsWith("-")) positionals.push(arg);
   }
-  return firstPositional === null || !NONINTERACTIVE_SUBCMDS.has(firstPositional);
+  return { help: false, positionals };
+}
+
+export function shouldManageCodex(input: { argv: string[] }): boolean {
+  if (process.env.TOKENMAXXING_PROBE) return false;
+  const { help, positionals: [sub] } = scanCodexArgs(input.argv);
+  return !help && (sub === undefined || !NONINTERACTIVE_SUBCMDS.has(sub));
+}
+
+function borrowsCodexSeat(input: { argv: string[] }): boolean {
+  if (process.env.TOKENMAXXING_PROBE || process.env[UNMANAGED_ENV] || process.env.CODEX_HOME) return false;
+  const { help, positionals: [sub, ...rest] } = scanCodexArgs(input.argv);
+  if (help || sub === undefined || !BORROWING_SUBCMDS.has(sub)) return false;
+  return sub !== "app-server" || rest.length === 0;
 }
 
 function validWanted(input: { wanted: string | null; now: number; supervisorId: string }): Account | null {
@@ -79,7 +95,34 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
   if (!shouldManageCodex({ argv }) || process.env[UNMANAGED_ENV]) {
     const passthroughEnv: Record<string, string | undefined> = { ...childEnv };
     delete passthroughEnv[CODEX_SUPERVISOR_ID_ENV];
-    return runPassthrough({ real, argv, env: passthroughEnv });
+    let child: Subprocess | null = null;
+    process.on("SIGTERM", () => {
+      if (child) child.kill("SIGTERM");
+      else process.exit(143);
+    });
+    const granted = borrowsCodexSeat({ argv }) ? await borrowCodexSeat(process.pid) : undefined;
+    const seat = granted && !("denied" in granted) ? granted : null;
+    if (seat) passthroughEnv.CODEX_HOME = seat.store;
+    else if (granted !== undefined) log("codexsupervisor.borrow_none", { reason: granted && "denied" in granted ? granted.denied : "no usable account" });
+    return runPassthrough({
+      real,
+      argv,
+      env: passthroughEnv,
+      onSpawn: (p) => {
+        child = p;
+        return seat
+          ? recordPresenceOrStop({
+              child: p,
+              dir: codexPaths.presenceDir,
+              id: `seat-${process.pid}`,
+              accountId: seat.id,
+              event: "codexsupervisor.borrow_presence_failed",
+              message: "could not key the borrowed codex seat to its child - refusing to run on an unreserved store",
+              savedTermios: null,
+            })
+          : undefined;
+      },
+    });
   }
 
   const supervisorId = crypto.randomUUID();

package/src/lib/codex.ts

@@ -2,10 +2,10 @@ import { existsSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { writeFileAtomic } from "./atomic.ts";
 import { CODEX_BIN, MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealBin, verifyRealBin } from "./claudebin.ts";
-import { codexIdentityOf, codexStoreUsable, deleteCodexStoreAuth, isCodexAccessExpiring, readCodexAuthAt, readCodexStoreAuth, writeCodexStoreAuth } from "./codexauth.ts";
+import { codexIdentityOf, codexStoreUsable, deleteCodexStoreAuth, ensureCodexStoreHome, isCodexAccessExpiring, readCodexAuthAt, readCodexStoreAuth, writeCodexStoreAuth } from "./codexauth.ts";
 import { CodexInvalidGrantError, CodexRefreshFailedError, refreshCodexAuth } from "./codexoauth.ts";
 import { deletePiStore } from "./piauth.ts";
-import { livingPresences, seatCounts } from "./presence.ts";
+import { livingPresences, seatCounts, writePresence } from "./presence.ts";
 import { CodexUsageReadError, codexLimitLabel, fetchCodexUsage } from "./codexusage.ts";
 import { codexSupervisorLink, ensurePathInRc, installCodexSupervisor, managedShellRcSkipLines, shellRcPath } from "./install.ts";
 import { withLock } from "./lock.ts";
@@ -236,6 +236,45 @@ export function pickCodexSeat(now: number, eligible: (a: Account) => boolean = (
   return pickBest(open.filter((a) => !isExhausted(a, ctx)), ctx) ?? pickEarliestReset(open, ctx)?.account ?? null;
 }
 
+export type CodexBorrow = { store: string; id: string; reused: boolean } | { denied: string } | null;
+
+export async function borrowCodexSeat(pid: number): Promise<CodexBorrow> {
+  const now = Date.now();
+  const seatId = `seat-${pid}`;
+  const cfg = loadConfig();
+  await Promise.all(
+    loadAccounts(codexPool)
+      .accounts.filter((a) => a.needsReauth !== true && codexStoreUsable(a.id))
+      .map((a) => observeCodex(a, cfg, now, { probe: true, refresh: false })),
+  );
+  const granted = await withLock(codexPool.lockFile, (): CodexBorrow => {
+    const ctx = codexPickCtx(now, null);
+    const idx = loadAccounts(codexPool);
+    const held = livingPresences(codexPaths.presenceDir).find((p) => p.id === seatId);
+    const heldAccount = held ? (idx.accounts.find((x) => x.id === held.accountId) ?? null) : null;
+    if (heldAccount) {
+      if (heldAccount.needsReauth === true) {
+        return { denied: "the account this pid holds needs reauthentication - run `tokenmaxxing auth --codex` and borrow again" };
+      }
+      if (!codexStoreUsable(heldAccount.id)) {
+        return { denied: "the account this pid holds has no usable credential in its store - refusing to hand back a credential-less seat" };
+      }
+      return { store: ensureCodexStoreHome(heldAccount.id), id: heldAccount.id, reused: true };
+    }
+    const present = seatCounts(codexPaths.presenceDir);
+    const usable = idx.accounts.filter(
+      (a) => a.needsReauth !== true && !isExhausted(a, ctx) && !present.has(a.id) && codexStoreUsable(a.id)
+    );
+    const picked = pickBest(usable, ctx);
+    if (!picked) return null;
+    const store = ensureCodexStoreHome(picked.id);
+    writePresence({ dir: codexPaths.presenceDir, id: seatId, accountId: picked.id, pid });
+    return { store, id: picked.id, reused: false };
+  });
+  if (granted && !("denied" in granted)) log("seat.grant", { account: granted.id.slice(0, 8), pid, reused: granted.reused });
+  return granted;
+}
+
 export const codex: Provider = {
   name: "codex",
   flag: " --codex",

package/src/lib/supervise.ts

@@ -75,9 +75,9 @@ export function loopGuardTripped(product: WrappedProduct): boolean {
   return false;
 }
 
-export async function runPassthrough(input: { real: string; argv: string[]; env: Record<string, string | undefined>; onSpawn?: (child: Subprocess) => void }): Promise<number> {
+export async function runPassthrough(input: { real: string; argv: string[]; env: Record<string, string | undefined>; onSpawn?: (child: Subprocess) => void | Promise<void> }): Promise<number> {
   const p = Bun.spawn([input.real, ...input.argv], { stdin: "inherit", stdout: "inherit", stderr: "inherit", env: input.env });
-  input.onSpawn?.(p);
+  await input.onSpawn?.(p);
   await p.exited;
   return exitStatus(p);
 }