tokenmaxxing 1.69.0 → 1.71.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.69.0",
+  "version": "1.71.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,10 +1,10 @@
-import { observeCodex } from "../lib/codex.ts";
+import { codexPickCtx, 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 { livingPresences, seatCounts, writePresence } from "../lib/presence.ts";
+import { isExhausted, pickBest } from "../lib/picker.ts";
 import { loadAccounts, loadConfig } from "../lib/state.ts";
 import { emitError } from "./render.ts";
 
@@ -23,10 +23,9 @@ export async function cmdSeat(pidRaw: string | undefined, extra: string[]): Prom
       .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 ctx = codexPickCtx(now, null);
     const idx = loadAccounts(codexPool);
-    const living = livingPresences(codexPaths.presenceDir);
-    const held = living.find((p) => p.id === seatId);
+    const held = livingPresences(codexPaths.presenceDir).find((p) => p.id === seatId);
     const heldAccount = held ? (idx.accounts.find((x) => x.id === held.accountId) ?? null) : null;
     if (heldAccount) {
       if (heldAccount.needsReauth === true) {
@@ -37,8 +36,7 @@ export async function cmdSeat(pidRaw: string | undefined, extra: string[]): Prom
       }
       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 present = seatCounts(codexPaths.presenceDir);
     const usable = idx.accounts.filter(
       (a) => a.needsReauth !== true && !isExhausted(a, ctx) && !present.has(a.id) && codexStoreUsable(a.id)
     );

package/src/entries/supervisor.ts

@@ -169,7 +169,7 @@ function latestSessionForCwd(): string | null {
       .filter((f) => f.endsWith(".jsonl"))
       .map((f) => ({ f, m: statSync(join(projDir, f)).mtimeMs }));
     const newest = maxBy(files, (x) => x.m);
-    return newest ? newest.f.replace(/\.jsonl$/, "") : null;
+    return newest ? basename(newest.f, ".jsonl") : null;
   } catch {
     return null;
   }

package/src/lib/claude.ts

@@ -11,7 +11,7 @@ import { claudeTierLabel, describeIdentity, fetchTokenIdentity, isDeadCredential
 import { claudePool, env, paths, seatFromEnv, storeDirFor } from "./paths.ts";
 import { pickBest, pickEarliestReset, thresholdBars, type PickCtx } from "./picker.ts";
 import { seatCounts } from "./presence.ts";
-import type { Observation, Provider, SampleReport } from "./provider.ts";
+import { StoreUnusableError, type Observation, type Provider, type SampleReport } from "./provider.ts";
 import { foldTee, sampleAccountUsage, teeObservation, usageBlockedUntil } from "./sample.ts";
 import { clearUsageSnapshot, loadAccounts, loadConfig, loadUsageSnapshot, pinBinOverride, saveAccounts, type Harvest } from "./state.ts";
 import { saveTermios, restoreTermios } from "./tty.ts";
@@ -19,13 +19,6 @@ import { fetchUsageDirect, gatedFamilies, mergeWindows, modelFromFlag, scrubCred
 import { CredentialBlobSchema, JsonTextSchema, OAuthAccountSchema, type Account, type Config, type ModelInfo } from "./types.ts";
 import { c } from "../cli/render.ts";
 
-class StoreUnusableError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "StoreUnusableError";
-  }
-}
-
 function liveId(): string | null {
   return seatFromEnv(loadAccounts(claudePool).accounts.map((a) => a.id));
 }

package/src/lib/claudebin.ts

@@ -36,7 +36,7 @@ export function wrapperEntryRateTripped(now: number): boolean {
   return entries.length > WRAP_RATE_MAX;
 }
 
-function realpathOrNull(p: string): string | null {
+export function realpathOrNull(p: string): string | null {
   try {
     return realpathSync(p);
   } catch {

package/src/lib/codex.ts

@@ -12,19 +12,12 @@ 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 type { Observation, Provider, SampleReport } from "./provider.ts";
+import { StoreUnusableError, type Observation, type Provider, type SampleReport } 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";
 import { c } from "../cli/render.ts";
 
-class StoreUnusableError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "StoreUnusableError";
-  }
-}
-
 function liveId(): string | null {
   return codexSeatFromEnv(loadAccounts(codexPool).accounts.map((a) => a.id));
 }

package/src/lib/codexauth.ts

@@ -1,4 +1,4 @@
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, rmSync, symlinkSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
@@ -45,25 +45,11 @@ export function ensureCodexStoreHome(accountId: string): string {
   mkdirSync(store, { recursive: true });
   mkdirSync(codexPaths.home, { recursive: true });
   mkdirSync(join(codexPaths.home, "sessions"), { recursive: true });
-  let names: string[] = [];
-  try {
-    names = readdirSync(codexPaths.home);
-  } catch (e) {
-    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return store;
-    throw e;
-  }
-  for (const name of names) {
+  for (const name of readdirSync(codexPaths.home)) {
     if (name === "auth.json") continue;
     const target = join(codexPaths.home, name);
     const link = join(store, name);
-    if (existsSync(link)) {
-      try {
-        if (lstatSync(link).isSymbolicLink()) continue;
-      } catch {
-        continue;
-      }
-      continue;
-    }
+    if (existsSync(link)) continue;
     try {
       symlinkSync(target, link);
     } catch (e) {

package/src/lib/compact.ts

@@ -1,7 +1,6 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import { delay } from "es-toolkit";
 import { z } from "zod";
+import pkg from "../../package.json" with { type: "json" };
 import { errorMessage, log } from "./log.ts";
 import { readLines } from "./proc.ts";
 import { JsonTextSchema } from "./types.ts";
@@ -20,7 +19,7 @@ export async function compactClaudeSession(input: { real: string; sid: string; e
     timeout: CLAUDE_COMPACT_KILL_MS,
     killSignal: "SIGKILL",
   });
-  const reads = Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text()]);
+  const reads = Promise.all([p.stdout.text(), p.stderr.text()]);
   const settled = await Promise.race([reads, p.exited.then(() => delay(PIPE_GRACE_MS)).then(() => null)]);
   await p.exited;
   if (settled === null) return { ok: false, reason: "output pipes still open after child exit (leaked descendant)" };
@@ -48,9 +47,6 @@ const INIT_ID = 1;
 const RESUME_ID = 2;
 const COMPACT_ID = 3;
 
-const packageVersion = (): string =>
-  z.object({ version: z.string().min(1) }).parse(JSON.parse(readFileSync(join(import.meta.dir, "..", "..", "package.json"), "utf8"))).version;
-
 export async function compactCodexThread(input: { real: string; threadId: string; env: Record<string, string | undefined> }): Promise<CompactOutcome> {
   const p = Bun.spawn([input.real, "app-server"], {
     env: input.env,
@@ -64,7 +60,7 @@ export async function compactCodexThread(input: { real: string; threadId: string
     p.stdin.write(`${JSON.stringify(msg)}\n`);
     p.stdin.flush();
   };
-  const stderrText = new Response(p.stderr).text();
+  const stderrText = p.stderr.text();
 
   const outcome = await new Promise<CompactOutcome>((resolve) => {
     let finished = false;
@@ -109,7 +105,7 @@ export async function compactCodexThread(input: { real: string; threadId: string
       const err = (await stderrText).trim().slice(0, 200);
       finish({ ok: false, reason: p.exitCode === null ? `app-server killed after ${CODEX_COMPACT_KILL_MS / 1000}s` : `app-server exited ${p.exitCode}: ${err}` });
     })().catch((e) => finish({ ok: false, reason: errorMessage(e) }));
-    send({ id: INIT_ID, method: "initialize", params: { clientInfo: { name: "tokenmaxxing", version: packageVersion() } } });
+    send({ id: INIT_ID, method: "initialize", params: { clientInfo: { name: "tokenmaxxing", version: pkg.version } } });
   });
 
   try {

package/src/lib/install.ts

@@ -171,7 +171,7 @@ export function codexStopHookGroupIndex(): number | null {
   } catch {
     return null;
   }
-  const idx = parsed.hooks.Stop.findIndex((group) => group.hooks.some((hook) => (hook.command ?? "").includes(CODEX_STOP_HOOK_SUBCOMMAND)));
+  const idx = parsed.hooks.Stop.findIndex((group) => group.hooks.some((hook) => isOurHookCommand(hook.command ?? "", CODEX_STOP_HOOK_SUBCOMMAND)));
   return idx >= 0 ? idx : null;
 }
 

package/src/lib/keychain.ts

@@ -16,7 +16,7 @@ export async function readItem(t: KeychainTarget): Promise<string | null> {
     stdout: "pipe",
     stderr: "pipe",
   });
-  const [out, err] = await Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text()]);
+  const [out, err] = await Promise.all([p.stdout.text(), p.stderr.text()]);
   await p.exited;
   if (p.exitCode === 44) return null;
   if (p.exitCode !== 0) {
@@ -38,7 +38,7 @@ async function writeViaInteractive(encodedLine: Uint8Array): Promise<void> {
     stdout: "ignore",
     stderr: "pipe",
   });
-  const err = await new Response(p.stderr).text();
+  const err = await p.stderr.text();
   await p.exited;
   if (p.exitCode !== 0) throw new Error(`keychain write (interactive) failed (exit ${p.exitCode}): ${err.trim()}`);
 }
@@ -48,7 +48,7 @@ async function writeViaArgv(t: KeychainTarget, secret: string): Promise<void> {
     stdout: "ignore",
     stderr: "pipe",
   });
-  const err = await new Response(p.stderr).text();
+  const err = await p.stderr.text();
   await p.exited;
   if (p.exitCode !== 0) throw new Error(`keychain write (argv) failed (exit ${p.exitCode}): ${err.trim()}`);
 }

package/src/lib/opencodego.ts

@@ -1,9 +1,8 @@
 import { mkdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
-import { opencodeGoAuthJsonFor, opencodeGoPaths, opencodeGoPool, opencodeGoStoreDirFor } from "./paths.ts";
+import { env, HOME, opencodeGoAuthJsonFor, opencodeGoPaths, opencodeGoPool, opencodeGoStoreDirFor } from "./paths.ts";
 import type { Provider } from "./provider.ts";
 import { type Harvest } from "./state.ts";
 import { statusOnlyProvider, type AuthEntry } from "./statusonly.ts";
@@ -12,12 +11,8 @@ import { c } from "../cli/render.ts";
 const OpencodeAuthEntrySchema = z.looseObject({ type: z.string(), key: z.string().optional() });
 const OpencodeAuthFileSchema = z.record(z.string(), z.unknown());
 
-function dataHome(): string {
-  return process.env.XDG_DATA_HOME && process.env.XDG_DATA_HOME.length > 0 ? process.env.XDG_DATA_HOME : join(homedir(), ".local", "share");
-}
-
 function liveAuthPath(): string {
-  return join(dataHome(), "opencode", "auth.json");
+  return join(env("XDG_DATA_HOME", join(HOME, ".local", "share")), "opencode", "auth.json");
 }
 
 function idOfKey(key: string): string {

package/src/lib/provider.ts

@@ -8,6 +8,13 @@ export type SampleReport = { ok: true; source: "statusline" | "probe" } | { ok:
 
 export type SwapFailure = "dead-grant" | "skip" | "fatal";
 
+export class StoreUnusableError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "StoreUnusableError";
+  }
+}
+
 export type Provider = {
   name: "claude" | "codex" | "grok" | "opencode-go";
   flag: string;

package/src/lib/sample.ts

@@ -11,7 +11,7 @@ import type { Account, Config, UsageWindows } from "./types.ts";
 
 export type SampleOutcome = { ok: true; usage: UsageWindows; via: "get" } | { ok: false; reason: string; retryAt?: number };
 
-type PreparedSample = { ok: true; token: string | null } | { ok: false; reason: string };
+type PreparedSample = { ok: true; token: string } | { ok: false; reason: string };
 
 export function teeObservation(account: Account): Observation | null {
   const stored = account.lastUsageAt != null ? { windows: account.windows, at: account.lastUsageAt } : null;
@@ -56,8 +56,7 @@ function rateLimitedReason(retryAt: number, now: number): string {
   return `the usage endpoint rate limited this account, next read in ${Math.ceil((retryAt - now) / 60_000)}m`;
 }
 
-export async function runSample(account: Account, token: string | null): Promise<SampleOutcome> {
-  if (!token) return { ok: false, reason: "no usable access token in the store - run `tokenmaxxing auth`" };
+export async function runSample(account: Account, token: string): Promise<SampleOutcome> {
   const read = await fetchUsageDirect(token);
   if (read.ok) return { ok: true, usage: read.usage, via: "get" };
   if (read.retryAt == null) return { ok: false, reason: "usage read failed (see log)" };
@@ -91,7 +90,7 @@ export async function sampleOldest(cfg: Config): Promise<void> {
       if (dirty) saveAccounts(claudePool, idx);
       return [];
     }
-    const batch: { account: Account; token: string | null }[] = [];
+    const batch: { account: Account; token: string }[] = [];
     for (const target of stale) {
       target.lastProbeAt = now;
       const prepared = await prepareSample(target);

package/src/lib/update.ts

@@ -1,7 +1,8 @@
-import { existsSync, lstatSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
+import { realpathOrNull } from "./claudebin.ts";
 import { http } from "./http.ts";
 import { isNixPackaged } from "./install.ts";
 import { withLock } from "./lock.ts";
@@ -29,14 +30,6 @@ function registry(): { base: URL; authorization: string | null } {
   return { base, authorization };
 }
 
-function realOrNull(path: string): string | null {
-  try {
-    return realpathSync(path);
-  } catch {
-    return null;
-  }
-}
-
 function globalRootCandidates(): string[] {
   const globalDir = optionalEnv("BUN_INSTALL_GLOBAL_DIR");
   const bunInstall = optionalEnv("BUN_INSTALL");
@@ -63,12 +56,12 @@ function registryPackageDir(root: string): string | null {
 
 function detectGlobalRoot(): string | null {
   if (isNixPackaged()) return null;
-  const entry = realOrNull(Bun.main);
+  const entry = realpathOrNull(Bun.main);
   if (entry == null) return null;
   return (
     globalRootCandidates().find((root) => {
       const dir = registryPackageDir(root);
-      return dir != null && entry === realOrNull(join(dir, "src", "main.ts"));
+      return dir != null && entry === realpathOrNull(join(dir, "src", "main.ts"));
     }) ?? null
   );
 }