tokenmaxxing 1.106.0 → 1.108.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.106.0",
+  "version": "1.108.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,15 +1,36 @@
+import { borrowClaudeSeat } from "../lib/claude.ts";
 import { borrowCodexSeat } from "../lib/codex.ts";
+import { borrowOpencodeGoSeat } from "../lib/opencodego.ts";
 import { emitError } from "./render.ts";
 
-export async function cmdSeat(pidRaw: string | undefined, extra: string[]): Promise<number> {
+const POOLS = {
+  claude: {
+    borrow: borrowClaudeSeat,
+    usage: "usage: tokenmaxxing seat <pid> - print the CLAUDE_SECURESTORAGE_CONFIG_DIR of one pooled claude account, lent to <pid> alone until it exits",
+    none: "no usable claude account (pool empty, every account lent to another borrower, or every account at a limit or flagged for reauthentication)",
+  },
+  codex: {
+    borrow: borrowCodexSeat,
+    usage: "usage: tokenmaxxing seat --codex <pid> - print the CODEX_HOME of one pooled account, reserved until <pid> exits",
+    none: "no usable codex account (pool empty, every account live in another session, or every account at a limit) - use the ambient codex login",
+  },
+  "opencode-go": {
+    borrow: borrowOpencodeGoSeat,
+    usage: "usage: tokenmaxxing seat --opencode-go <pid> - print the store directory of one pooled opencode-go key, whose auth.json is an opencode auth file, lent to <pid> alone until it exits",
+    none: "no usable opencode-go key (pool empty, every key lent to another borrower, or no store holds a usable key)",
+  },
+};
+
+export async function cmdSeat(pool: keyof typeof POOLS, pidRaw: string | undefined, extra: string[]): Promise<number> {
+  const seat = POOLS[pool];
   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" });
+    emitError({ message: seat.usage });
     return 2;
   }
-  const granted = await borrowCodexSeat(pid);
+  const granted = await seat.borrow(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" });
+    emitError({ message: seat.none });
     return 1;
   }
   if ("denied" in granted) {

package/src/entries/stopfailurehook.ts

@@ -1,3 +1,5 @@
+import { existsSync, readdirSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
 import { z } from "zod";
 import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
@@ -20,10 +22,18 @@ const StopFailureStdin = z.looseObject({
 const ROW_WAIT_MS = 3_000;
 const ROW_POLL_MS = 200;
 
-async function awaitEnforcedRow(input: { transcriptPath: string; error: string; lastAssistantMessage: string | undefined }): Promise<TranscriptRow | null> {
+function subagentTranscript(transcriptPath: string, agentId: string): string {
+  const dir = join(dirname(transcriptPath), basename(transcriptPath, ".jsonl"), "subagents");
+  const name = `agent-${agentId}.jsonl`;
+  const found = existsSync(dir) ? readdirSync(dir, { recursive: true, encoding: "utf8" }).find((p) => basename(p) === name) : undefined;
+  return join(dir, found ?? name);
+}
+
+async function awaitEnforcedRow(input: { transcriptPath: string; agentId: string | undefined; error: string; lastAssistantMessage: string | undefined }): Promise<TranscriptRow | null> {
   const deadline = Date.now() + ROW_WAIT_MS;
   while (true) {
-    const row = findEnforcedRow({ rows: await readTranscriptTail(input.transcriptPath), error: input.error, lastAssistantMessage: input.lastAssistantMessage });
+    const path = input.agentId === undefined ? input.transcriptPath : subagentTranscript(input.transcriptPath, input.agentId);
+    const row = findEnforcedRow({ rows: await readTranscriptTail(path), error: input.error, lastAssistantMessage: input.lastAssistantMessage });
     if (row || Date.now() >= deadline) return row;
     await Bun.sleep(ROW_POLL_MS);
   }
@@ -52,7 +62,7 @@ export async function runStopFailureHook(): Promise<number> {
     const canRespawn = session != null && mainLoop;
     const cfg = loadConfig();
     const row = stdin.transcript_path
-      ? await awaitEnforcedRow({ transcriptPath: stdin.transcript_path, error, lastAssistantMessage: stdin.last_assistant_message })
+      ? await awaitEnforcedRow({ transcriptPath: stdin.transcript_path, agentId: stdin.agent_id, error, lastAssistantMessage: stdin.last_assistant_message })
       : null;
     const limit = row ? classifyEnforcedLimit(row, cfg.policy.switchModels) : null;
 

package/src/lib/claude.ts

@@ -11,8 +11,8 @@ import { claudeTierLabel, describeIdentity, fetchTokenIdentity, isDeadCredential
 import { claudePool, env, paths, seatFromEnv, storeDirFor } from "./paths.ts";
 import { landWindows, pickBest, pickEarliestReset, thresholdBars, type PickCtx } from "./picker.ts";
 import { deletePiStore } from "./piauth.ts";
-import { livingPresences } from "./presence.ts";
-import { StoreUnusableError, type Observation, type Provider, type SampleReport } from "./provider.ts";
+import { livingPresences, writePresence } from "./presence.ts";
+import { StoreUnusableError, type Observation, type Provider, type SampleReport, type SeatBorrow } from "./provider.ts";
 import { foldTee, readyToSample, runSample, sampleAccountUsage, sampleDue, sampleIntervalMs, teeObservation, usageBlockedUntil } from "./sample.ts";
 import { clearUsageSnapshot, liveWaitClaims, loadAccounts, loadConfig, loadUsageSnapshot, pinBinOverride, readJsonFile, saveAccounts, type Harvest } from "./state.ts";
 import { saveTermios, restoreTermios } from "./tty.ts";
@@ -142,6 +142,40 @@ export function pickSeat(now: number, model: ModelInfo | null, eligible: (a: Acc
   return pickBest(candidates, ctx) ?? pickEarliestReset(candidates, ctx)?.account ?? null;
 }
 
+export async function borrowClaudeSeat(pid: number): Promise<SeatBorrow> {
+  const seatId = `seat-${pid}`;
+  const cfg = loadConfig();
+  const bars = thresholdBars(cfg);
+  const granted = await withLock(claudePool.lockFile, async (): Promise<SeatBorrow> => {
+    const idx = loadAccounts(claudePool);
+    let dirty = false;
+    for (const a of idx.accounts) dirty = foldTee(a, bars) || dirty;
+    if (dirty) saveAccounts(claudePool, idx);
+    const living = livingPresences(paths.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` and borrow again" };
+      }
+      if (!(await storeUsable(heldAccount))) {
+        return { denied: "the account this pid holds has no usable credential in its store - refusing to hand back a credential-less seat" };
+      }
+      return { store: storeDirFor(heldAccount.id), id: heldAccount.id, reused: true };
+    }
+    const lent = new Set(living.filter((p) => p.id.startsWith("seat-")).map((p) => p.accountId));
+    const open = idx.accounts.filter((a) => a.needsReauth !== true && !lent.has(a.id));
+    const usable = await Promise.all(open.map(storeUsable));
+    const ctx: PickCtx = { now: Date.now(), thresholds: bars, currentId: null, families: gatedFamilies(null, cfg.policy.switchModels), seats: presence() };
+    const picked = pickBest(open.filter((_, i) => usable[i]), ctx);
+    if (!picked) return null;
+    writePresence({ dir: paths.presenceDir, id: seatId, accountId: picked.id, pid });
+    return { store: storeDirFor(picked.id), 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;
+}
+
 async function removeCredentials(a: Account): Promise<void> {
   await deleteItem(storeTarget(a.id));
   rmSync(storeDirFor(a.id), { recursive: true, force: true });

package/src/lib/codex.ts

@@ -13,7 +13,7 @@ import { withLock } from "./lock.ts";
 import { errorMessage, log } from "./log.ts";
 import { codexPaths, codexPool, codexSeatFromEnv } from "./paths.ts";
 import { isExhausted, pickBest, pickEarliestReset, thresholdBars, type PickCtx } from "./picker.ts";
-import { StoreUnusableError, type Observation, type Provider, type SampleReport } from "./provider.ts";
+import { StoreUnusableError, type Observation, type Provider, type SampleReport, type SeatBorrow } from "./provider.ts";
 import { loadAccounts, loadConfig, pinBinOverride, saveAccounts, type Harvest } from "./state.ts";
 import { restoreTermios, saveTermios } from "./tty.ts";
 import type { Account, CodexAuthJson, CodexUsage, Config } from "./types.ts";
@@ -239,9 +239,7 @@ 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> {
+export async function borrowCodexSeat(pid: number): Promise<SeatBorrow> {
   const now = Date.now();
   const seatId = `seat-${pid}`;
   const cfg = loadConfig();
@@ -250,7 +248,7 @@ export async function borrowCodexSeat(pid: number): Promise<CodexBorrow> {
       .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 granted = await withLock(codexPool.lockFile, (): SeatBorrow => {
     const ctx = codexPickCtx(now, null);
     const idx = loadAccounts(codexPool);
     const held = livingPresences(codexPaths.presenceDir).find((p) => p.id === seatId);

package/src/lib/grok.ts

@@ -131,6 +131,7 @@ const base = statusOnlyProvider({
   liveAuthPath: () => join(grokPaths.home, "auth.json"),
   readAuth,
   liveId: () => grokSeatFromEnv(loadAccounts(grokPool).accounts.map((a) => a.id)),
+  presence: () => new Map(),
   versionOk: (out) => out.toLowerCase().includes("grok"),
   importIntro: "Opening an isolated grok login for your first pooled account - the login you already have stays as it is.",
   foundLive: (count) => `found ${count} grok login(s) in ${grokPaths.home} - pooling the first; use \`tokenmaxxing add --grok\` for the rest.`,

package/src/lib/opencodego.ts

@@ -2,8 +2,11 @@ import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { env, HOME, opencodeGoAuthJsonFor, opencodeGoPaths, opencodeGoPool, opencodeGoStoreDirFor } from "./paths.ts";
-import type { Provider } from "./provider.ts";
-import { readJsonFile, type Harvest } from "./state.ts";
+import { withLock } from "./lock.ts";
+import { log } from "./log.ts";
+import { livingPresences, seatCounts, writePresence } from "./presence.ts";
+import type { Provider, SeatBorrow } from "./provider.ts";
+import { loadAccounts, readJsonFile, type Harvest } from "./state.ts";
 import { statusOnlyProvider, type AuthEntry } from "./statusonly.ts";
 import { ErrnoSchema } from "./types.ts";
 import { c } from "../cli/render.ts";
@@ -47,6 +50,31 @@ function readAuth(path: string): AuthEntry[] {
   return [{ id: idOfKey(entry.data.key), usable: true, harvest: harvestOf(entry.data.key) }];
 }
 
+export async function borrowOpencodeGoSeat(pid: number): Promise<SeatBorrow> {
+  const seatId = `seat-${pid}`;
+  const granted = await withLock(opencodeGoPool.lockFile, async (): Promise<SeatBorrow> => {
+    const accounts = loadAccounts(opencodeGoPool).accounts;
+    const living = livingPresences(opencodeGoPaths.presenceDir);
+    const held = living.find((p) => p.id === seatId);
+    const heldAccount = held ? (accounts.find((a) => a.id === held.accountId) ?? null) : null;
+    if (heldAccount) {
+      if (!(await opencodeGo.storeUsable(heldAccount))) {
+        return { denied: "the key this pid holds is no longer usable in its store - run `tokenmaxxing auth --opencode-go` and borrow again" };
+      }
+      return { store: opencodeGoStoreDirFor(heldAccount.id), id: heldAccount.id, reused: true };
+    }
+    const lent = new Set(living.map((p) => p.accountId));
+    const open = accounts.filter((a) => !lent.has(a.id));
+    const usable = await Promise.all(open.map(opencodeGo.storeUsable));
+    const picked = open.find((_, i) => usable[i]);
+    if (!picked) return null;
+    writePresence({ dir: opencodeGoPaths.presenceDir, id: seatId, accountId: picked.id, pid });
+    return { store: opencodeGoStoreDirFor(picked.id), 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 opencodeGo: Provider = statusOnlyProvider({
   name: "opencode-go",
   flag: " --opencode-go",
@@ -62,6 +90,7 @@ export const opencodeGo: Provider = statusOnlyProvider({
   liveAuthPath,
   readAuth,
   liveId: () => null,
+  presence: () => seatCounts(opencodeGoPaths.presenceDir),
   versionOk: (out) => out !== "",
   importIntro: "Pooling your opencode-go API key - your existing opencode auth stays as it is.",
   foundLive: () => `found an opencode-go credential in ${liveAuthPath()} - pooling it; use \`tokenmaxxing add --opencode-go\` for more keys.`,

package/src/lib/paths.ts

@@ -133,6 +133,7 @@ export function grokSeatFromEnv(accountIds: string[], env: Record<string, string
 export const opencodeGoPaths = {
   storesDir: join(TM_HOME, "opencode-go-stores"),
   onboardDir: join(TM_HOME, "opencode-go-onboard"),
+  presenceDir: join(TM_HOME, "opencode-go-live"),
 } as const;
 
 export function opencodeGoStoreDirFor(accountId: string): string {

package/src/lib/provider.ts

@@ -8,6 +8,8 @@ export type SampleReport = { ok: true; source: "statusline" | "probe" | "cached"
 
 export type SwapFailure = "dead-grant" | "skip" | "fatal";
 
+export type SeatBorrow = { store: string; id: string; reused: boolean } | { denied: string } | null;
+
 export class StoreUnusableError extends Error {
   constructor(message: string) {
     super(message);

package/src/lib/sessions.ts

@@ -60,7 +60,7 @@ function listDir(dir: string, root: string): Dirent[] {
 }
 
 function tmpSweepDirs(root: string): string[] {
-  const dirs = [paths.home, paths.usageDir, paths.presenceDir, paths.respawnDir, sessionsDir(), paths.binDir, codexPaths.presenceDir, codexPaths.respawnDir, codexPaths.onboardDir];
+  const dirs = [paths.home, paths.usageDir, paths.presenceDir, paths.respawnDir, sessionsDir(), paths.binDir, codexPaths.presenceDir, codexPaths.respawnDir, codexPaths.onboardDir, opencodeGoPaths.presenceDir];
   for (const parent of STORE_PARENTS) {
     for (const child of listDir(parent, root)) {
       if (child.isDirectory()) dirs.push(join(parent, child.name));

package/src/lib/statusonly.ts

@@ -24,6 +24,7 @@ export type StatusOnlySpec = {
   liveAuthPath: () => string;
   readAuth: (path: string) => AuthEntry[];
   liveId: () => string | null;
+  presence: () => Map<string, number>;
   versionOk: (versionOutput: string) => boolean;
   importIntro: string;
   foundLive: (count: number) => string;
@@ -101,7 +102,7 @@ export function statusOnlyProvider(spec: StatusOnlySpec): Provider {
     waitsWhenDepleted: false,
     statusOnly: true,
     liveId: spec.liveId,
-    presence: () => new Map(),
+    presence: spec.presence,
     gatedFamilies: () => null,
     observeLive: async (account) => (account.lastUsageAt != null ? { windows: account.windows, at: account.lastUsageAt } : null),
     samplePool,

package/src/main.ts

@@ -39,6 +39,7 @@ const PI_FLAG = "--pi";
 const JSON_COMMANDS = new Set(["status", "config", "check"]);
 const CODEX_COMMANDS = new Set(["init", "add", "auth", "rm", "rename", "seat"]);
 const STATUS_ONLY_COMMANDS = new Set(["init", "add", "auth", "rm", "rename"]);
+const OPENCODE_GO_COMMANDS = new Set([...STATUS_ONLY_COMMANDS, "seat"]);
 
 function printHelp(): void {
   console.log(`${c.bold("tokenmaxxing")} - automatic Claude Code account switching
@@ -59,7 +60,9 @@ 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")} <pid>  lend one pooled Claude account to an unattended consumer until <pid> exits: prints the store directory to set as CLAUDE_SECURESTORAGE_CONFIG_DIR (the directory itself, as its owner, never a copy of its credential); host sessions keep using the account, other borrowers do not; exit 1 = none usable
   ${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 seat --opencode-go")} <pid>  lend one pooled opencode-go key to an unattended consumer until <pid> exits: prints the store directory, whose auth.json is an opencode auth file (mount it at $XDG_DATA_HOME/opencode/auth.json, then run a model such as opencode-go/mimo-v2.6-pro); other borrowers do not get the key; exit 1 = none usable
   ${c.cyan("tokenmaxxing serve")}      serve the CLIProxyAPI-compatible usage API on http://localhost:<hub.port> (default 8317) so a dashboard such as T3 Code's "Add a CLIProxyAPI hub" shows every pooled Claude and Codex account's quota; the management key is the contents of hub-key in the state directory
   ${c.cyan("tokenmaxxing uninstall")} [--yes]  print the targets, then remove supervisor + settings entries (refused without ${c.cyan("--yes")} when HOME is the login home)
 
@@ -127,10 +130,13 @@ async function main(): Promise<number> {
     return 2;
   }
 
-  if ((provider === grok || provider === opencodeGo) && (sub == null || !STATUS_ONLY_COMMANDS.has(sub))) {
+  if (provider === grok || provider === opencodeGo) {
     const flag = provider === grok ? GROK_FLAG : OPENCODE_GO_FLAG;
-    emitError({ json, message: `${flag} applies to ${[...STATUS_ONLY_COMMANDS].join(", ")}, not ${sub ?? "status"}` });
-    return 2;
+    const commands = provider === grok ? STATUS_ONLY_COMMANDS : OPENCODE_GO_COMMANDS;
+    if (sub == null || !commands.has(sub)) {
+      emitError({ json, message: `${flag} applies to ${[...commands].join(", ")}, not ${sub ?? "status"}` });
+      return 2;
+    }
   }
 
   if (json && sub != null && !JSON_COMMANDS.has(sub)) {
@@ -167,13 +173,7 @@ 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 "seat": return cmdSeat(provider === codex ? "codex" : provider === opencodeGo ? "opencode-go" : "claude", args[1], args.slice(2));
     case "serve": return cmdServe(args.slice(1));
     case "uninstall": {
       if (args.length > 1) {