tokenmaxxing 1.132.0 → 1.134.0

package/package.json

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

@@ -10,7 +10,7 @@ import { codexStoreUsable, ensureCodexStoreHome } from "../lib/codexauth.ts";
 import { CODEX_CRED_ENV, CODEX_SUPERVISOR_ID_ENV, 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";
+import { childStdout, exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, relayStdout, runPassthrough } from "../lib/supervise.ts";
 import { saveTermios } from "../lib/tty.ts";
 import { loadAccounts, readJsonFile } from "../lib/state.ts";
 import { CodexRespawnMarkerSchema, type Account } from "../lib/types.ts";
@@ -137,14 +137,14 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
     if (existsSync(marker)) rmSync(marker, { force: true });
 
     const launchedAt = Date.now();
-    const { child, seat } = await withLock(codexPool.lockFile, async () => {
+    const { child, seat, drain } = 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], {
         stdin: "inherit",
-        stdout: "inherit",
+        stdout: childStdout(),
         stderr: "inherit",
         env: {
           ...(store ? omit(childEnv, CODEX_CRED_ENV) : childEnv),
@@ -152,6 +152,7 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
           ...(store ? { CODEX_HOME: store } : {}),
         },
       });
+      const drain = spawned.stdout instanceof ReadableStream ? relayStdout(spawned.stdout) : null;
       if (picked) {
         await recordPresenceOrStop({
           child: spawned,
@@ -163,10 +164,10 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
           savedTermios,
         });
       }
-      return { child: spawned, seat: picked };
+      return { child: spawned, seat: picked, drain };
     });
     if (respawns > 0) {
-      process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: switched codex to ${seat?.label ?? "the ambient codex login"} - resuming...\x1b[0m\n`);
+      process.stderr.write(`\n\x1b[36m↻ tokenmaxxing: switched codex to ${seat?.label ?? "the ambient codex login"} - resuming...\x1b[0m\n`);
     }
 
     await raceMarkerOrExit({
@@ -178,6 +179,7 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
       },
       savedTermios,
     });
+    await drain?.();
 
     const payload = existsSync(marker) ? readCodexMarker(marker) : null;
     if (payload) {

package/src/entries/supervisor.ts

@@ -1,4 +1,3 @@
-import { once } from "node:events";
 import { existsSync, mkdirSync, rmSync, readdirSync, statSync } from "node:fs";
 import { basename, join } from "node:path";
 import type { FileSink, Subprocess } from "bun";
@@ -15,7 +14,7 @@ import { thresholdBars, usableAt } from "../lib/picker.ts";
 import { clearPresence } from "../lib/presence.ts";
 import { readLines } from "../lib/proc.ts";
 import { teeObservation } from "../lib/sample.ts";
-import { countdownWait, exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough, SEAT_POLL_MS, SEAT_RETRY_MS, type Say } from "../lib/supervise.ts";
+import { countdownWait, exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, relayStdout, runPassthrough, SEAT_POLL_MS, SEAT_RETRY_MS, type Say } from "../lib/supervise.ts";
 import { saveTermios } from "../lib/tty.ts";
 import { liveSessionId, loadSessionFlags, pruneStaleSessions, saveSessionFlags, writeRespawnMarker } from "../lib/sessions.ts";
 import { loadAccounts, loadConfig, readJsonFile, releaseWaitClaim, writeUsage } from "../lib/state.ts";
@@ -325,8 +324,6 @@ function userLine(text: string): string {
   return `${JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text }] } })}\n`;
 }
 
-const STDOUT_QUIET_MS = 1000;
-
 const TaskLineSchema = z.discriminatedUnion("subtype", [
   z.looseObject({ type: z.literal("system"), subtype: z.literal("task_started"), task_id: z.string(), description: z.string(), session_id: z.string() }),
   z.looseObject({ type: z.literal("system"), subtype: z.literal("task_notification"), task_id: z.string() }),
@@ -361,42 +358,6 @@ function seatTee(seatId: string | null, model: ModelInfo | null, open: OpenTasks
   };
 }
 
-function relayStdout(source: ReadableStream<Uint8Array>, onLine: (line: string) => void): () => Promise<void> {
-  let ended = false;
-  let blocked = false;
-  let readAt = Date.now();
-  const forwarded = source.pipeThrough(
-    new TransformStream<Uint8Array, Uint8Array>({
-      async transform(chunk, controller) {
-        readAt = Date.now();
-        if (!process.stdout.write(chunk)) {
-          blocked = true;
-          await once(process.stdout, "drain");
-          blocked = false;
-        }
-        controller.enqueue(chunk);
-      },
-    }),
-  );
-  void (async () => {
-    for await (const line of readLines(forwarded)) {
-      try {
-        onLine(line);
-      } catch (e) {
-        log("supervisor.tee_failed", { err: errorMessage(e) });
-      }
-    }
-  })()
-    .catch((e: unknown) => log("supervisor.stdout_relay_failed", { err: errorMessage(e) }))
-    .finally(() => {
-      ended = true;
-    });
-  return async () => {
-    const exitedAt = Date.now();
-    while (!ended && (blocked || Date.now() - Math.max(readAt, exitedAt) < STDOUT_QUIET_MS)) await Bun.sleep(50);
-  };
-}
-
 const REPLAYED_REQUESTS = new Set(["initialize", "set_max_thinking_tokens", "set_model", "set_permission_mode"]);
 
 const RelayLineSchema = z.discriminatedUnion("type", [

package/src/lib/decide.ts

@@ -235,10 +235,11 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), canRes
       const ctx: PickCtx = { now, thresholds: bars, currentId: current?.id ?? null, families: switchFamilies, seats };
       const others = liveWaitClaims(now).filter((c) => c.sessionId !== waiterId);
       const waiters = new Map(Object.entries(countBy(others, (c) => c.accountId)));
-      const target = pickWaitTarget(usable(fresh.accounts), ctx, waiters, MAX_WAITERS_PER_ACCOUNT, now + cfg.policy.maxWaitMs, now + 2 * cfg.policy.maxWaitMs);
+      const waitable = usable(fresh.accounts).filter((a) => keyId == null || !opts.refused?.includes(a.id));
+      const target = pickWaitTarget(waitable, ctx, waiters, MAX_WAITERS_PER_ACCOUNT, now + cfg.policy.maxWaitMs, now + 2 * cfg.policy.maxWaitMs);
 
       if (!target) {
-        const soonest = pickWaitTarget(usable(fresh.accounts), ctx, new Map(), MAX_WAITERS_PER_ACCOUNT, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+        const soonest = pickWaitTarget(waitable, ctx, new Map(), MAX_WAITERS_PER_ACCOUNT, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
         const waitUntil = soonest?.availableAt ?? Number.POSITIVE_INFINITY;
         log("decide.depleted", { waitUntil: Number.isFinite(waitUntil) ? waitUntil : 0 });
         return { swapped: false, account: null, reason: "all-depleted", ...(Number.isFinite(waitUntil) ? { waitUntil } : {}) };

package/src/lib/supervise.ts

@@ -1,7 +1,10 @@
+import { once } from "node:events";
+import { isatty } from "node:tty";
 import type { Subprocess } from "bun";
 import { LOOP_DIAGNOSIS, MAX_WRAP_DEPTH, WRAP_RATE_WINDOW_MS, wrapDepth, wrapperChainTripped } from "./claudebin.ts";
 import { errorMessage, log } from "./log.ts";
 import { paths } from "./paths.ts";
+import { readLines } from "./proc.ts";
 import { writePresence } from "./presence.ts";
 import { restoreTermios } from "./tty.ts";
 
@@ -75,10 +78,57 @@ export function loopGuardTripped(product: WrappedProduct): boolean {
   return false;
 }
 
+const STDOUT_QUIET_MS = 1000;
+
+export function childStdout(): "inherit" | "pipe" {
+  return isatty(1) ? "inherit" : "pipe";
+}
+
+export function relayStdout(source: ReadableStream<Uint8Array>, onLine?: (line: string) => void): (abandoned?: () => boolean) => Promise<void> {
+  let ended = false;
+  let blocked = false;
+  let readAt = Date.now();
+  const forwarded = source.pipeThrough(
+    new TransformStream<Uint8Array, Uint8Array>({
+      async transform(chunk, controller) {
+        readAt = Date.now();
+        if (!process.stdout.write(chunk)) {
+          blocked = true;
+          await once(process.stdout, "drain");
+          blocked = false;
+        }
+        controller.enqueue(chunk);
+      },
+    }),
+  );
+  void (async () => {
+    if (onLine == null) return forwarded.pipeTo(new WritableStream());
+    for await (const line of readLines(forwarded)) {
+      try {
+        onLine(line);
+      } catch (e) {
+        log("supervisor.tee_failed", { err: errorMessage(e) });
+      }
+    }
+  })()
+    .catch((e: unknown) => log("supervisor.stdout_relay_failed", { err: errorMessage(e) }))
+    .finally(() => {
+      ended = true;
+    });
+  return async (abandoned = () => false) => {
+    const exitedAt = Date.now();
+    while (!ended && (blocked ? !abandoned() : Date.now() - Math.max(readAt, exitedAt) < STDOUT_QUIET_MS)) await Bun.sleep(50);
+  };
+}
+
 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 });
+  let terminated = false;
+  process.on("SIGTERM", () => { terminated = true; });
+  const p = Bun.spawn([input.real, ...input.argv], { stdin: "inherit", stdout: childStdout(), stderr: "inherit", env: input.env });
+  const drain = p.stdout instanceof ReadableStream ? relayStdout(p.stdout) : null;
   await input.onSpawn?.(p);
   await p.exited;
+  await drain?.(() => terminated);
   return exitStatus(p);
 }