tokenmaxxing 1.112.0 → 1.113.0

package/package.json

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