tokenmaxxing 1.111.0 → 1.113.0

package/DESIGN.md

@@ -66,7 +66,7 @@ The supervisor sees `respawn/<sid>`, SIGTERMs its child at the already-committed
 
 ### 3.4 Placement (supervisor, under the pool lock)
 1. Fold every account's tee into the index.
-2. Rank the usable accounts (§5) with the live session counts from `live/`, or the soonest-recovering account when none is usable; with no pooled account or every account needing re-auth, launch without a store (still supervised, on whatever login the environment names). Print mode, the non-interactive subcommands, the bare resume picker, an invalid `--session-id`, and `--fork-session` with a resume are passed through unmanaged.
+2. Rank the usable accounts (§5) with the live session counts from `live/`, or the soonest-recovering account when none is usable; with no pooled account or every account needing re-auth, launch without a store (still supervised, on whatever login the environment names). Print mode, every subcommand, the bare resume picker, an invalid `--session-id`, and `--fork-session` with a resume are passed through unmanaged.
 3. Spawn claude with the store env set, then write `live/<sid>` with the child's pid and start time. The lock covers the pick and the presence write, so concurrent launches see each other.
 
 ### 3.5 Multiple concurrent sessions

package/README.md

@@ -14,7 +14,7 @@ $ claude
 
 ## Why
 
-Every pooled account owns one Claude Code credential store under `~/.config/tokenmaxxing/stores/`. A thin `claude` supervisor on your PATH picks an account for each session and points `CLAUDE_SECURESTORAGE_CONFIG_DIR` at its store, so sessions on different accounts never share a credential, while sessions on the same account share its store and Claude Code's own refresh keeps them in step. A session moves only by respawn: the supervisor stops it at a committed turn boundary (the transcript is already on disk, nothing is lost) and runs `claude --resume <id>` under another store. tokenmaxxing writes a store once at onboarding and never again; it never copies a credential between stores, because a refresh rotation revokes the previous access token and two copies of one grant break each other. Everything else about `claude` is unchanged - all flags, MCP, hooks, and skills pass through. Print mode and the non-interactive subcommands run without a seat, on whatever login the environment names.
+Every pooled account owns one Claude Code credential store under `~/.config/tokenmaxxing/stores/`. A thin `claude` supervisor on your PATH picks an account for each session and points `CLAUDE_SECURESTORAGE_CONFIG_DIR` at its store, so sessions on different accounts never share a credential, while sessions on the same account share its store and Claude Code's own refresh keeps them in step. A session moves only by respawn: the supervisor stops it at a committed turn boundary (the transcript is already on disk, nothing is lost) and runs `claude --resume <id>` under another store. tokenmaxxing writes a store once at onboarding and never again; it never copies a credential between stores, because a refresh rotation revokes the previous access token and two copies of one grant break each other. Everything else about `claude` is unchanged - all flags, MCP, hooks, and skills pass through. Print mode and every `claude` subcommand run without a seat, on whatever login the environment names.
 
 ## Install
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.111.0",
+  "version": "1.113.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/entries/supervisor.ts

@@ -21,10 +21,15 @@ import { gatedFamilies, modelFromFlag, scrubCredEnv } from "../lib/usage.ts";
 import { RespawnMarkerSchema, type Account, type Config, type ModelInfo } from "../lib/types.ts";
 import { errorMessage, log } from "../lib/log.ts";
 
-const NONINTERACTIVE_SUBCMDS = new Set([
-  "mcp", "config", "doctor", "update", "install", "migrate-installer",
-  "setup-token", "plugin", "agents", "completion", "help",
+const SUBCOMMANDS = new Set([
+  "agents", "attach", "auth", "auto-mode", "daemon", "design-login", "doctor",
+  "drop-worktree-registrations", "edit-chrome-settings", "edit-hook", "edit-memory-settings",
+  "edit-permission-rules", "edit-sandbox-settings", "edit-skill-overrides", "gateway", "help",
+  "import", "import-conversations", "install", "kill", "logs", "mcp", "plugin", "plugins",
+  "project", "rc", "remote-control", "respawn", "rm", "sandbox", "setup-token", "stop",
+  "ultrareview", "update", "upgrade",
 ]);
+const SOLE_UPDATE_FLAGS = new Set(["--update", "--upgrade"]);
 
 const VALUE_TAKING_ROOT_FLAGS = new Set([
   "--agent", "--agents", "--append-system-prompt", "--append-system-prompt-file",
@@ -115,7 +120,7 @@ export function analyzeArgs(argv: string[]): Analysis {
     }
   }
 
-  const isSubcmd = firstPositional !== null && NONINTERACTIVE_SUBCMDS.has(firstPositional);
+  const isSubcmd = (firstPositional !== null && SUBCOMMANDS.has(firstPositional)) || (argv.length === 1 && SOLE_UPDATE_FLAGS.has(argv[0]!));
   const forkResume = forkSession && (resumeId !== null || continueLatest);
   const manage = !printMode && !isSubcmd && !invalidSessionArg && !pickerResume && !forkResume && !process.env.TOKENMAXXING_PROBE;
   return { manage, sessionId, resumeId, continueLatest, streamInput, streamOutput, model };

package/src/lib/claude.ts

@@ -24,8 +24,8 @@ function liveId(): string | null {
   return seatFromEnv(loadAccounts(claudePool).accounts.map((a) => a.id));
 }
 
-function presence(): Map<string, number> {
-  const seats = new Map(livingPresences(paths.presenceDir).map((s) => [s.id, s.accountId]));
+function presence(living = livingPresences(paths.presenceDir)): Map<string, number> {
+  const seats = new Map(living.map((s) => [s.id, s.accountId]));
   for (const claim of liveWaitClaims(Date.now())) seats.set(claim.sessionId, claim.accountId);
   return new Map(Object.entries(countBy([...seats.values()], (id) => id)));
 }
@@ -165,7 +165,7 @@ export async function borrowClaudeSeat(pid: number): Promise<SeatBorrow> {
     }
     const open = idx.accounts.filter((a) => a.needsReauth !== true);
     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 ctx: PickCtx = { now: Date.now(), thresholds: bars, currentId: null, families: gatedFamilies(null, cfg.policy.switchModels), seats: presence(living) };
     const picked = pickBest(open.filter((_, i) => usable[i]), ctx);
     if (!picked) return null;
     writePresence({ dir: paths.presenceDir, id: seatId, accountId: picked.id, pid });

package/src/lib/presence.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { countBy } from "es-toolkit";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
-import { pidExists, pidStartTime } from "./proc.ts";
+import { pidExists, pidStartTimes } from "./proc.ts";
 import { readJsonFile } from "./state.ts";
 import { ErrnoSchema, JsonTextSchema } from "./types.ts";
 
@@ -16,7 +16,7 @@ const PresenceSchema = z.object({
 });
 
 export function writePresence(input: { dir: string; id: string; accountId: string; pid: number }): void {
-  const startedAt = pidStartTime(input.pid);
+  const startedAt = pidStartTimes([input.pid]).get(input.pid);
   if (startedAt == null) throw new Error(`could not read pid ${input.pid}'s start time (ps lstart) - refusing to write an unverifiable presence file`);
   writeFileAtomic(join(input.dir, input.id), JSON.stringify(PresenceSchema.parse({ accountId: input.accountId, pid: input.pid, startedAt })));
 }
@@ -37,8 +37,8 @@ export function clearPresence(input: { dir: string; id: string }): void {
 export type LivingPresence = { id: string; accountId: string };
 
 export function livingPresences(dir: string): LivingPresence[] {
-  const living: LivingPresence[] = [];
-  if (!existsSync(dir)) return living;
+  if (!existsSync(dir)) return [];
+  const records: { name: string; file: string; record: z.infer<typeof PresenceSchema> }[] = [];
   for (const name of readdirSync(dir)) {
     const file = join(dir, name);
     let raw: string;
@@ -52,15 +52,20 @@ export function livingPresences(dir: string): LivingPresence[] {
     if (!parsed.success) {
       throw new Error(`${file} is not a readable presence record - it may belong to a RUNNING session, refusing to treat it as absent; remove the file (or respawn that session) to proceed`);
     }
-    const observed = pidStartTime(parsed.data.pid);
-    if (observed !== parsed.data.startedAt) {
-      if (observed == null && pidExists(parsed.data.pid)) {
-        throw new Error(`ps could not read the start time of live pid ${parsed.data.pid} (${file}) - refusing to clear a presence file that may guard a RUNNING session`);
+    records.push({ name, file, record: parsed.data });
+  }
+  const started = pidStartTimes(records.map((r) => r.record.pid));
+  const living: LivingPresence[] = [];
+  for (const { name, file, record } of records) {
+    const observed = started.get(record.pid);
+    if (observed !== record.startedAt) {
+      if (observed == null && pidExists(record.pid)) {
+        throw new Error(`ps could not read the start time of live pid ${record.pid} (${file}) - refusing to clear a presence file that may guard a RUNNING session`);
       }
       rmSync(file, { force: true });
       continue;
     }
-    living.push({ id: name, accountId: parsed.data.accountId });
+    living.push({ id: name, accountId: record.accountId });
   }
   return living;
 }

package/src/lib/proc.ts

@@ -38,11 +38,17 @@ export function ancestorPids(): number[] {
   return out;
 }
 
-export function pidStartTime(pid: number): string | null {
-  const res = Bun.spawnSync(["ps", "-p", String(pid), "-o", "lstart="], { env: { ...process.env, LC_ALL: "C" } });
-  if (res.exitCode !== 0) return null;
-  const lstart = res.stdout.toString().trim();
-  return lstart === "" ? null : lstart;
+export function pidStartTimes(pids: number[]): Map<number, string> {
+  const started = new Map<number, string>();
+  if (pids.length === 0) return started;
+  const res = Bun.spawnSync(["ps", "-p", pids.join(","), "-o", "pid=", "-o", "lstart="], { env: { ...process.env, LC_ALL: "C" } });
+  if (res.exitCode !== 0) return started;
+  for (const row of res.stdout.toString().split("\n")) {
+    const line = row.trim();
+    const cut = line.indexOf(" ");
+    if (cut !== -1) started.set(Number(line.slice(0, cut)), line.slice(cut).trim());
+  }
+  return started;
 }
 
 export async function readStdin(): Promise<string> {