tokenmaxxing 1.61.0 → 1.62.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.61.0",
+  "version": "1.62.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

@@ -0,0 +1,62 @@
+import { 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, writePresence } from "../lib/presence.ts";
+import { isExhausted, pickBest, thresholdBars, type PickCtx } from "../lib/picker.ts";
+import { loadAccounts, loadConfig } from "../lib/state.ts";
+import { emitError } from "./render.ts";
+
+export async function cmdSeat(pidRaw: string | undefined, extra: string[]): Promise<number> {
+  const pid = pidRaw != null && /^(0|[1-9][0-9]*)$/.test(pidRaw) ? Number(pidRaw) : NaN;
+  if (!Number.isSafeInteger(pid) || pid < 2 || extra.length > 0) {
+    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: PickCtx = { now, thresholds: thresholdBars(loadConfig()), currentId: null, families: null, seats: null };
+    const idx = loadAccounts(codexPool);
+    const living = livingPresences(codexPaths.presenceDir);
+    const held = living.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 = new Map<string, number>();
+    for (const p of living) present.set(p.accountId, (present.get(p.accountId) ?? 0) + 1);
+    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) {
+    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;
+  }
+  if ("denied" in granted) {
+    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/codexstophook.ts

@@ -9,6 +9,7 @@ import { resolveRealCodex } from "../lib/codexbin.ts";
 import { compactCodexThread } from "../lib/compact.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
 import { isExhausted } from "../lib/picker.ts";
+import { livingPresences } from "../lib/presence.ts";
 import { readStdin } from "../lib/proc.ts";
 import { loadAccounts, loadConfig } from "../lib/state.ts";
 import { CODEX_SUPERVISOR_ID_ENV } from "./codexsupervisor.ts";
@@ -39,6 +40,12 @@ async function handleCodexStop(rawStdin: string): Promise<void> {
       log("codexstop.unsupervised_skip", {});
       return;
     }
+    const own = livingPresences(codexPaths.presenceDir).find((p) => p.id === supervisorId);
+    const seat = codex.liveId();
+    if (!own || own.accountId !== seat) {
+      log("codexstop.foreign_seat", { supervisorId: supervisorId.slice(0, 8), seat: seat?.slice(0, 8) ?? null });
+      return;
+    }
     const now = Date.now();
     await compactBeforeMove({ sessionId, now });
     const decision = await evaluateAndMaybeSwap(codex, now);

package/src/entries/codexsupervisor.ts

@@ -5,13 +5,14 @@ import { codexPaths, codexPool } from "../lib/paths.ts";
 import { withLock } from "../lib/lock.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 } from "../lib/presence.ts";
+import { codexStoreUsable, ensureCodexStoreHome } from "../lib/codexauth.ts";
+import { 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";
 import { saveTermios } from "../lib/tty.ts";
 import { loadAccounts } from "../lib/state.ts";
-import { CodexRespawnMarkerSchema } from "../lib/types.ts";
+import { CodexRespawnMarkerSchema, type Account } from "../lib/types.ts";
 import { errorMessage, log } from "../lib/log.ts";
 
 export const CODEX_SUPERVISOR_ID_ENV = "TOKENMAXXING_CODEX_SUPERVISOR_ID";
@@ -55,6 +56,20 @@ export function shouldManageCodex(input: { argv: string[] }): boolean {
   return firstPositional === null || !NONINTERACTIVE_SUBCMDS.has(firstPositional);
 }
 
+function validWanted(input: { wanted: string | null; now: number; supervisorId: string }): Account | null {
+  if (input.wanted == null) return null;
+  const a = loadAccounts(codexPool).accounts.find((x) => x.id === input.wanted);
+  if (!a || a.needsReauth === true) return null;
+  if (isExhausted(a, codexPickCtx(input.now, input.wanted))) return null;
+  if (!codexStoreUsable(a.id)) return null;
+  const foreign = livingPresences(codexPaths.presenceDir).some((p) => p.accountId === a.id && p.id !== input.supervisorId);
+  if (foreign) {
+    log("codexsupervisor.wanted_present", { account: a.id.slice(0, 8) });
+    return null;
+  }
+  return a;
+}
+
 export async function runCodexSupervisor(input: { argv: string[] }): Promise<number> {
   const { argv } = input;
   if (loopGuardTripped("codex")) return 1;
@@ -83,8 +98,9 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
     if (existsSync(marker)) rmSync(marker, { force: true });
 
     const launchedAt = Date.now();
-    const { child } = await withLock(codexPool.lockFile, async () => {
-      const picked = (wanted == null ? null : (loadAccounts(codexPool).accounts.find((a) => a.id === wanted) ?? null)) ?? pickCodexSeat(launchedAt, wanted);
+    const { child, seat } = await withLock(codexPool.lockFile, async () => {
+      clearPresence({ dir: codexPaths.presenceDir, id: supervisorId });
+      const picked = validWanted({ wanted, now: launchedAt, supervisorId }) ?? pickCodexSeat(launchedAt);
       log("codexsupervisor.launch", { supervisorId: supervisorId.slice(0, 8), respawns, seat: picked?.id.slice(0, 8) ?? null, args: launchArgs.join(" ") });
       const store = picked ? ensureCodexStoreHome(picked.id) : undefined;
       const spawned = Bun.spawn([real, ...launchArgs], {
@@ -110,6 +126,9 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
       }
       return { child: spawned, seat: picked };
     });
+    if (respawns > 0) {
+      process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: switched codex to ${seat?.label ?? "the ambient codex login"} - resuming...\x1b[0m\n`);
+    }
 
     await raceMarkerOrExit({
       child,
@@ -125,8 +144,6 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
     if (payload) {
       rmSync(marker, { force: true });
       respawns++;
-      const label = loadAccounts(codexPool).accounts.find((a) => a.id === payload.accountId)?.label ?? payload.accountId.slice(0, 8);
-      process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: switched codex to ${label} - resuming...\x1b[0m\n`);
       wanted = payload.accountId;
       launchArgs = payload.sessionId ? ["resume", payload.sessionId] : ["resume", "--last"];
       continue;

package/src/lib/codex.ts

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { writeFileAtomic } from "./atomic.ts";
 import { MAX_WRAP_DEPTH, WRAP_DEPTH_ENV } from "./claudebin.ts";
-import { codexIdentityOf, deleteCodexStoreAuth, isCodexAccessExpiring, readCodexAuthAt, readCodexStoreAuth, writeCodexStoreAuth } from "./codexauth.ts";
+import { codexIdentityOf, codexStoreUsable, deleteCodexStoreAuth, isCodexAccessExpiring, readCodexAuthAt, readCodexStoreAuth, writeCodexStoreAuth } from "./codexauth.ts";
 import { resolveRealCodex, verifyRealCodex } from "./codexbin.ts";
 import { CodexInvalidGrantError, CodexRefreshFailedError, refreshCodexAuth } from "./codexoauth.ts";
 import { seatCounts } from "./presence.ts";
@@ -42,7 +42,7 @@ function applyUsage(account: Account, usage: CodexUsage, at: number): void {
 
 type CodexReadOutcome = { ok: true; usage: CodexUsage; at: number } | { ok: false; reason: string; deadGrant: boolean };
 
-async function readCodexUsage(account: Account, now: number): Promise<CodexReadOutcome> {
+async function readCodexUsage(account: Account, now: number, refresh: boolean): Promise<CodexReadOutcome> {
   let auth: CodexAuthJson | null;
   try {
     auth = readCodexStoreAuth(account.id);
@@ -52,6 +52,9 @@ async function readCodexUsage(account: Account, now: number): Promise<CodexReadO
   if (!auth) return { ok: false, reason: "no credential in this account's store - run `tokenmaxxing auth --codex`", deadGrant: false };
   try {
     if (isCodexAccessExpiring({ auth, now })) {
+      if (!refresh) {
+        return { ok: false, reason: "stored access token is expiring and this read never refreshes a store", deadGrant: false };
+      }
       if (seatCounts(codexPaths.presenceDir).has(account.id)) {
         return { ok: false, reason: "running in a live codex session (store refresh unsafe)", deadGrant: false };
       }
@@ -67,9 +70,9 @@ async function readCodexUsage(account: Account, now: number): Promise<CodexReadO
   }
 }
 
-async function observeLive(account: Account, cfg: Config, now: number, opts: { probe: boolean }): Promise<Observation | null> {
+export async function observeCodex(account: Account, cfg: Config, now: number, opts: { probe: boolean; refresh: boolean }): Promise<Observation | null> {
   if (opts.probe && (account.lastUsageAt == null || now - account.lastUsageAt > cfg.policy.usagePollTtlMs)) {
-    const outcome = await readCodexUsage(account, now);
+    const outcome = await readCodexUsage(account, now, opts.refresh);
     await withLock(codexPool.lockFile, () => {
       const idx = loadAccounts(codexPool);
       const a = idx.accounts.find((x) => x.id === account.id);
@@ -92,7 +95,7 @@ async function samplePool(accounts: Account[], _liveId: string | null, now: numb
   const reports = new Map<string, SampleReport>();
   await Promise.all(
     accounts.map(async (account) => {
-      const outcome = await readCodexUsage(account, now);
+      const outcome = await readCodexUsage(account, now, true);
       if (outcome.ok) {
         applyUsage(account, outcome.usage, outcome.at);
         reports.set(account.id, { ok: true, source: "probe" });
@@ -216,17 +219,11 @@ export function codexPickCtx(now: number, currentId: string | null): PickCtx {
   return { now, thresholds: thresholdBars(loadConfig()), currentId, families: null, seats: null };
 }
 
-export function pickCodexSeat(now: number, wantedId: string | null = null): Account | null {
-  const cfg = loadConfig();
-  const idx = loadAccounts(codexPool);
-  const ctx: PickCtx = { now, thresholds: thresholdBars(cfg), currentId: null, families: null, seats: null };
-  if (wantedId != null) {
-    const wanted = idx.accounts.find((a) => a.id === wantedId && a.needsReauth !== true && !isExhausted(a, { ...ctx, currentId: wantedId }));
-    if (wanted) return wanted;
-  }
+export function pickCodexSeat(now: number): Account | null {
+  const ctx = codexPickCtx(now, null);
   const present = seatCounts(codexPaths.presenceDir);
-  const usable = idx.accounts.filter((a) => a.needsReauth !== true && !isExhausted(a, ctx) && !present.has(a.id));
-  return pickBest(usable, ctx) ?? pickEarliestReset(idx.accounts.filter((a) => a.needsReauth !== true && !present.has(a.id)), ctx)?.account ?? null;
+  const open = loadAccounts(codexPool).accounts.filter((a) => a.needsReauth !== true && !present.has(a.id) && codexStoreUsable(a.id));
+  return pickBest(open.filter((a) => !isExhausted(a, ctx)), ctx) ?? pickEarliestReset(open, ctx)?.account ?? null;
 }
 
 export const codex: Provider = {
@@ -239,19 +236,13 @@ export const codex: Provider = {
   liveId,
   presence,
   gatedFamilies: () => null,
-  observeLive,
+  observeLive: (account, cfg, now, opts) => observeCodex(account, cfg, now, { probe: opts.probe, refresh: true }),
   samplePool,
   mergeWindows: (next) => next,
   swap: prepareMove,
   classifySwapError: (e) => (e instanceof CodexInvalidGrantError ? "dead-grant" : e instanceof StoreUnusableError ? "skip" : "fatal"),
   removeCredentials: async (a) => deleteCodexStoreAuth(a.id),
-  storeUsable: async (a) => {
-    try {
-      return readCodexStoreAuth(a.id) != null;
-    } catch {
-      return false;
-    }
-  },
+  storeUsable: async (a) => codexStoreUsable(a.id),
   login,
   importLive,
   preflight,

package/src/lib/codexauth.ts

@@ -23,6 +23,14 @@ export function readCodexStoreAuth(accountId: string): CodexAuthJson | null {
   return readCodexAuthAt({ path: codexAuthJsonFor(accountId) });
 }
 
+export function codexStoreUsable(accountId: string): boolean {
+  try {
+    return readCodexStoreAuth(accountId) != null;
+  } catch {
+    return false;
+  }
+}
+
 export function writeCodexStoreAuth(accountId: string, auth: CodexAuthJson): void {
   mkdirSync(codexStoreDirFor(accountId), { recursive: true });
   writeFileAtomic(codexAuthJsonFor(accountId), JSON.stringify(CodexAuthJsonSchema.parse(auth), null, 2), 0o600);

package/src/main.ts

@@ -21,6 +21,7 @@ import { cmdRm } from "./cli/rm.ts";
 import { cmdRename } from "./cli/rename.ts";
 import { cmdCheck } from "./cli/check.ts";
 import { cmdConfig } from "./cli/config.ts";
+import { cmdSeat } from "./cli/seat.ts";
 import { cmdSetupToken } from "./cli/setuptoken.ts";
 import { cmdCloudRun } from "./cli/cloudrun.ts";
 import { cmdCursorInit } from "./cli/cursorinit.ts";
@@ -36,7 +37,7 @@ const CODEX_FLAG = "--codex";
 const GROK_FLAG = "--grok";
 const OPENCODE_GO_FLAG = "--opencode-go";
 const JSON_COMMANDS = new Set(["status", "config", "check"]);
-const CODEX_COMMANDS = new Set(["init", "add", "auth", "rm", "rename"]);
+const CODEX_COMMANDS = new Set(["init", "add", "auth", "rm", "rename", "seat"]);
 const STATUS_ONLY_COMMANDS = new Set(["init", "add", "auth", "rm", "rename"]);
 
 function printHelp(): void {
@@ -56,6 +57,7 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing doctor")}     verify the install is intact
   ${c.cyan("tokenmaxxing rename")} [--codex | --grok | --opencode-go] <sel> <label>
   ${c.cyan("tokenmaxxing rm")} [--codex | --grok | --opencode-go] <sel>
+  ${c.cyan("tokenmaxxing seat --codex")} <pid>  borrow one pooled codex account for an unattended consumer (plugin, script): prints the CODEX_HOME to set, reserved until <pid> exits; exit 1 = none usable, fall back to the ambient login
   ${c.cyan("tokenmaxxing uninstall")} [--yes]  print the targets, then remove supervisor + settings entries (refused without ${c.cyan("--yes")} when HOME is the login home)
   ${c.cyan("tokenmaxxing setup-token")} [--print | rm <label|uuid>]  Cursor Cloud only: mint one \`claude setup-token\` per pooled account (browser sign-in each) and print the TOKENMAXXING_TOKENS secret value; ${c.cyan("--print")} prints the stored set, ${c.cyan("rm")} drops one
   ${c.cyan("tokenmaxxing cursor init")} [dir]  write the Claude relay subagent (.cursor/agents/claude.md) and .cursor/environment.json into a repo
@@ -151,6 +153,13 @@ async function main(): Promise<number> {
     case "doctor": return cmdDoctor();
     case "rm": return cmdRm(provider, args[1]);
     case "rename": return cmdRename(provider, args.slice(1));
+    case "seat": {
+      if (provider !== codex) {
+        emitError({ message: `seat borrows a pooled codex account - pass ${CODEX_FLAG} (usage: tokenmaxxing seat ${CODEX_FLAG} <pid>)` });
+        return 2;
+      }
+      return cmdSeat(args[1], args.slice(2));
+    }
     case "setup-token": return cmdSetupToken(args.slice(1));
     case "cursor": {
       if (args[1] === "init") return cmdCursorInit(args.slice(2));