tokenmaxxing 1.77.0 → 1.79.0

package/package.json

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

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
-import { verifyRealClaude } from "../lib/claudebin.ts";
+import { CLAUDE_BIN, verifyRealBin } from "../lib/claudebin.ts";
 import { checkSettings, installedBin } from "../lib/settings.ts";
-import { checkTimerHealthy, codexStoreHookTrust, findClaudeShadowers, hubServiceHealthy, isBinDirAhead, shellRcPath, skipImperativeHub, timerActivationHint } from "../lib/install.ts";
+import { activationHint, CHECK_JOB, codexStoreHookTrust, findClaudeShadowers, HUB_JOB, isBinDirAhead, jobHealthy, shellRcPath } from "../lib/install.ts";
 import { errorMessage } from "../lib/log.ts";
 import { claudePool, codexPool, paths } from "../lib/paths.ts";
 import { loadAccounts, loadConfig } from "../lib/state.ts";
@@ -29,10 +29,10 @@ export async function cmdDoctor(): Promise<number> {
   check(s.stopOk, "Stop hook installed in settings.json", "run `tokenmaxxing init`");
   check(s.stopFailureOk, "StopFailure hook installed in settings.json", "run `tokenmaxxing init`");
   check(s.sessionStartOk, "SessionStart hook installed in settings.json", "run `tokenmaxxing init`");
-  check(checkTimerHealthy(), "periodic check timer active", timerActivationHint());
+  check(jobHealthy(CHECK_JOB), "periodic check timer active", activationHint(CHECK_JOB));
   if (existsSync(paths.supervisorLink)) {
-    if (skipImperativeHub()) note("usage hub service is owned outside init (TOKENMAXXING_SKIP_HUB set) - not verified here");
-    else check(hubServiceHealthy(), "usage hub service active", "run `tokenmaxxing init` (it writes the unit and activates it)");
+    if (HUB_JOB.skip()) note("usage hub service is owned outside init (TOKENMAXXING_SKIP_HUB set) - not verified here");
+    else check(jobHealthy(HUB_JOB), "usage hub service active", "run `tokenmaxxing init` (it writes the unit and activates it)");
   }
 
   const idx = loadAccounts(claudePool);
@@ -95,7 +95,7 @@ export async function cmdDoctor(): Promise<number> {
   const cfg = loadConfig();
   check(!!cfg.claudeBin && existsSync(cfg.claudeBin), "real claude binary resolved", "set claudeBin in config.json");
   if (cfg.claudeBin && existsSync(cfg.claudeBin)) {
-    const fail = verifyRealClaude(cfg.claudeBin);
+    const fail = verifyRealBin({ ...CLAUDE_BIN, bin: cfg.claudeBin });
     check(fail === null, "claudeBin launches the real claude", fail ?? undefined);
   }
 

package/src/cli/serve.ts

@@ -7,7 +7,7 @@ import { claude } from "../lib/claude.ts";
 import { codex, observeCodex } from "../lib/codex.ts";
 import { CODEX_USAGE_URL } from "../lib/codexusage.ts";
 import { errorMessage, log } from "../lib/log.ts";
-import { hubDeactivationHint } from "../lib/install.ts";
+import { deactivationHint, HUB_JOB } from "../lib/install.ts";
 import { paths } from "../lib/paths.ts";
 import { isExhausted, thresholdBars } from "../lib/picker.ts";
 import type { Provider } from "../lib/provider.ts";
@@ -215,7 +215,7 @@ export async function cmdServe(args: string[]): Promise<number> {
       },
     });
   } catch (e) {
-    emitError({ message: `cannot bind localhost:${cfg.hub.port}: ${errorMessage(e)} (another \`tokenmaxxing serve\` or the usage hub service may already hold the port - stop it first: ${hubDeactivationHint()})` });
+    emitError({ message: `cannot bind localhost:${cfg.hub.port}: ${errorMessage(e)} (another \`tokenmaxxing serve\` or the usage hub service may already hold the port - stop it first: ${deactivationHint(HUB_JOB)})` });
     return 1;
   }
   console.log(`${c.green("✓")} serving the CLIProxyAPI-compatible usage API at http://localhost:${server.port}/v0/management`);

package/src/entries/codexstophook.ts

@@ -2,9 +2,8 @@ import { join } from "node:path";
 import type { z } from "zod";
 import { codexPaths, optionalEnv } from "../lib/paths.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
-import { MAX_WRAP_DEPTH, WRAP_DEPTH_ENV } from "../lib/claudebin.ts";
+import { CODEX_BIN, MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealBin } from "../lib/claudebin.ts";
 import { codex, codexPickCtx } from "../lib/codex.ts";
-import { resolveRealCodex } from "../lib/codexbin.ts";
 import { compactCodexThread } from "../lib/compact.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
 import { isExhausted } from "../lib/picker.ts";
@@ -26,7 +25,7 @@ async function compactBeforeMove(input: { sessionId: string | null; now: number
   const env: Record<string, string | undefined> = { ...process.env, TOKENMAXXING_PROBE: "1", [WRAP_DEPTH_ENV]: String(MAX_WRAP_DEPTH) };
   delete env[CODEX_SUPERVISOR_ID_ENV];
   log("codexstop.compact_start", { thread: sessionId.slice(0, 8), account: live.id.slice(0, 8) });
-  await compactCodexThread({ real: resolveRealCodex(), threadId: sessionId, env });
+  await compactCodexThread({ real: resolveRealBin(CODEX_BIN), threadId: sessionId, env });
 }
 
 async function handleCodexStop(rawStdin: string): Promise<void> {

package/src/entries/codexsupervisor.ts

@@ -3,8 +3,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { codexPaths, codexPool } from "../lib/paths.ts";
 import { withLock } from "../lib/lock.ts";
-import { UNMANAGED_ENV, WRAP_DEPTH_ENV, wrapDepth } from "../lib/claudebin.ts";
-import { resolveRealCodex } from "../lib/codexbin.ts";
+import { CODEX_BIN, UNMANAGED_ENV, WRAP_DEPTH_ENV, resolveRealBin, wrapDepth } from "../lib/claudebin.ts";
 import { codexStoreUsable, ensureCodexStoreHome } from "../lib/codexauth.ts";
 import { codexPickCtx, pickCodexSeat } from "../lib/codex.ts";
 import { clearPresence, livingPresences } from "../lib/presence.ts";
@@ -74,7 +73,7 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
   const { argv } = input;
   if (loopGuardTripped("codex")) return 1;
 
-  const real = resolveRealCodex();
+  const real = resolveRealBin(CODEX_BIN);
   const childEnv = { ...process.env, [WRAP_DEPTH_ENV]: String(wrapDepth() + 1) };
 
   if (!shouldManageCodex({ argv }) || process.env[UNMANAGED_ENV]) {

package/src/entries/supervisor.ts

@@ -4,7 +4,7 @@ import type { FileSink, Subprocess } from "bun";
 import { maxBy } from "es-toolkit";
 import { z } from "zod";
 import { claudePool, paths, storeDirFor } from "../lib/paths.ts";
-import { UNMANAGED_ENV, WRAP_DEPTH_ENV, resolveRealClaude, wrapDepth } from "../lib/claudebin.ts";
+import { CLAUDE_BIN, UNMANAGED_ENV, WRAP_DEPTH_ENV, resolveRealBin, wrapDepth } from "../lib/claudebin.ts";
 import { claude, pickSeat } from "../lib/claude.ts";
 import { compactClaudeSession } from "../lib/compact.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
@@ -353,7 +353,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
   }
   let real: string;
   try {
-    real = resolveRealClaude();
+    real = resolveRealBin(CLAUDE_BIN);
   } catch (e) {
     if (!earlyStream) throw e;
     process.stdout.write(systemLine(earlySid, `tokenmaxxing: ${errorMessage(e)}`));

package/src/lib/claude.ts

@@ -2,8 +2,8 @@ import { mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { readItem, writeItem, deleteItem, isolatedTarget, readStore, storeTarget, claudeAiOauthOnly } from "./credstore.ts";
-import { resolveRealClaude, resolveVerifiedClaude } from "./claudebin.ts";
-import { ensurePathInRc, hubActivationHint, installSupervisor, managedShellRcSkipLines, shellRcPath, timerActivationHint } from "./install.ts";
+import { CLAUDE_BIN, resolveRealBin, resolveVerifiedClaude } from "./claudebin.ts";
+import { activationHint, CHECK_JOB, ensurePathInRc, HUB_JOB, installSupervisor, managedShellRcSkipLines, shellRcPath } from "./install.ts";
 import { withLock } from "./lock.ts";
 import { errorMessage, log } from "./log.ts";
 import { claudeTierLabel, describeIdentity, fetchTokenIdentity, isDeadCredential, InvalidGrantError } from "./oauth.ts";
@@ -151,7 +151,7 @@ async function login(): Promise<Harvest | null> {
   const iso = isolatedTarget(onboardDir);
   await deleteItem(iso);
   const cjPath = join(onboardDir, ".claude.json");
-  const real = resolveRealClaude();
+  const real = resolveRealBin(CLAUDE_BIN);
 
   const savedTermios = saveTermios();
   const env = scrubCredentialEnv({ ...process.env, CLAUDE_CONFIG_DIR: onboardDir, TOKENMAXXING_PROBE: "1", TOKENMAXXING_SUPERVISED: "" });
@@ -256,9 +256,9 @@ function install(): void {
   const out = installSupervisor();
   console.log(`${c.green("✓")} installed ${c.bold("claude")} supervisor + statusLine/Stop/StopFailure/SessionStart hooks`);
   if (out.timerLoaded) console.log(`${c.green("✓")} periodic check timer active (every ${out.checkIntervalS}s)`);
-  else console.log(c.yellow(`⚠ check timer written but not activated - run: ${timerActivationHint()}`));
+  else console.log(c.yellow(`⚠ check timer written but not activated - run: ${activationHint(CHECK_JOB)}`));
   if (out.hubLoaded) console.log(`${c.green("✓")} usage hub service active`);
-  else console.log(c.yellow(`⚠ usage hub service written but not activated - run: ${hubActivationHint()}`));
+  else console.log(c.yellow(`⚠ usage hub service written but not activated - run: ${activationHint(HUB_JOB)}`));
   if (!out.pathAhead) {
     console.log();
     ensurePathAhead();

package/src/lib/claudebin.ts

@@ -4,7 +4,7 @@ import { uniq } from "es-toolkit";
 import { z } from "zod";
 import { errorMessage } from "./log.ts";
 import { paths } from "./paths.ts";
-import { loadConfig } from "./state.ts";
+import { loadConfig, type BinKey } from "./state.ts";
 import { writeFileAtomic } from "./atomic.ts";
 
 export const WRAP_DEPTH_ENV = "TOKENMAXXING_WRAP_DEPTH";
@@ -49,75 +49,70 @@ export function pointsBackAtUs(bin: string): boolean {
   return resolved != null && binDir != null && dirname(resolved) === binDir;
 }
 
-function scanPathForClaudeCandidates(): string[] {
+function scanPathCandidates(name: string): string[] {
   const seen = new Set<string>();
   const out: string[] = [];
   for (const d of (process.env.PATH ?? "").split(":")) {
     if (!d) continue;
-    const cand = join(d, "claude");
-    try {
-      if (existsSync(cand) && statSync(cand).isFile() && !pointsBackAtUs(cand)) {
-        const key = realpathOrNull(cand) ?? cand;
-        if (!seen.has(key)) {
-          seen.add(key);
-          out.push(cand);
-        }
-      }
-    } catch {  }
+    const cand = join(d, name);
+    if (!existsSync(cand) || !statSync(cand, { throwIfNoEntry: false })?.isFile() || pointsBackAtUs(cand)) continue;
+    const key = realpathOrNull(cand) ?? cand;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(cand);
   }
   return out;
 }
 
-export function scanPathForClaude(): string | null {
-  return scanPathForClaudeCandidates()[0] ?? null;
-}
-
-export function resolveRealClaude(): string {
-  const cfg = loadConfig();
-  if (cfg.claudeBin) {
-    if (!existsSync(cfg.claudeBin)) {
-      throw new Error(`configured claudeBin does not exist: ${cfg.claudeBin} - fix config.json`);
+export function resolveRealBin(input: { name: string; key: BinKey }): string {
+  const configured = loadConfig()[input.key];
+  if (configured) {
+    if (!existsSync(configured)) {
+      throw new Error(`configured ${input.key} does not exist: ${configured} - fix config.json`);
     }
-    if (pointsBackAtUs(cfg.claudeBin)) {
+    if (pointsBackAtUs(configured)) {
       throw new Error(
-        `configured claudeBin (${cfg.claudeBin}) is tokenmaxxing's own wrapper - spawning it recurses. Point claudeBin at the real claude binary in ${paths.configJson}`,
+        `configured ${input.key} (${configured}) is tokenmaxxing's own wrapper - spawning it recurses. Point ${input.key} at the real ${input.name} binary in ${paths.configJson}`,
       );
     }
-    return cfg.claudeBin;
+    return configured;
   }
-  const scanned = scanPathForClaude();
+  const scanned = scanPathCandidates(input.name)[0];
   if (scanned) return scanned;
-  throw new Error("could not locate the real `claude` binary (set claudeBin in config.json)");
+  throw new Error(`could not locate the real \`${input.name}\` binary (set ${input.key} in config.json)`);
 }
 
-export function verifyRealClaude(bin: string): string | null {
+export function verifyRealBin(input: { bin: string; name: string; versionOk: (versionOutput: string) => boolean }): string | null {
   const env = { ...process.env, [WRAP_DEPTH_ENV]: String(MAX_WRAP_DEPTH), TOKENMAXXING_PROBE: "1" };
   let p;
   try {
-    p = Bun.spawnSync([bin, "--version"], { env, stdout: "pipe", stderr: "pipe", timeout: 15_000, killSignal: "SIGKILL" });
+    p = Bun.spawnSync([input.bin, "--version"], { env, stdout: "pipe", stderr: "pipe", timeout: 15_000, killSignal: "SIGKILL" });
   } catch (e) {
     return errorMessage(e);
   }
   const outText = p.stdout.toString().trim();
   const err = p.stderr.toString().trim();
   if (p.exitCode === 0) {
-    if (/claude/i.test(outText)) return null;
-    return `--version output does not identify claude: "${outText.slice(0, 80)}"`;
+    if (input.versionOk(outText)) return null;
+    return `--version output does not identify ${input.name}: "${outText.slice(0, 80)}"`;
   }
   if (err.includes(LOOP_DIAGNOSIS)) return "it leads back into the tokenmaxxing wrapper (recursion)";
   return `--version exited ${p.exitCode ?? "on signal/timeout"}: ${(err || outText).slice(0, 160)}`;
 }
 
+export const CLAUDE_BIN = { name: "claude", key: "claudeBin", versionOk: (out: string) => out.toLowerCase().includes("claude") } as const;
+export const CODEX_BIN = { name: "codex", key: "codexBin", versionOk: (out: string) => out.toLowerCase().includes("codex") } as const;
+
 export function resolveVerifiedClaude(): string {
   const candidates: string[] = [];
   try {
-    candidates.push(resolveRealClaude());
+    candidates.push(resolveRealBin(CLAUDE_BIN));
   } catch {  }
-  candidates.push(...scanPathForClaudeCandidates());
+  candidates.push(...scanPathCandidates(CLAUDE_BIN.name));
 
   const failures: string[] = [];
   for (const cand of uniq(candidates)) {
-    const fail = verifyRealClaude(cand);
+    const fail = verifyRealBin({ ...CLAUDE_BIN, bin: cand });
     if (fail === null) return cand;
     failures.push(`${cand}: ${fail}`);
   }

package/src/lib/codex.ts

@@ -1,9 +1,8 @@
 import { existsSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { writeFileAtomic } from "./atomic.ts";
-import { MAX_WRAP_DEPTH, WRAP_DEPTH_ENV } from "./claudebin.ts";
+import { CODEX_BIN, MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealBin, verifyRealBin } from "./claudebin.ts";
 import { codexIdentityOf, codexStoreUsable, deleteCodexStoreAuth, isCodexAccessExpiring, readCodexAuthAt, readCodexStoreAuth, writeCodexStoreAuth } from "./codexauth.ts";
-import { resolveRealCodex, verifyRealCodex } from "./codexbin.ts";
 import { CodexInvalidGrantError, CodexRefreshFailedError, refreshCodexAuth } from "./codexoauth.ts";
 import { seatCounts } from "./presence.ts";
 import { CodexUsageReadError, codexLimitLabel, fetchCodexUsage } from "./codexusage.ts";
@@ -113,7 +112,7 @@ async function prepareMove(target: Account): Promise<void> {
 }
 
 async function login(): Promise<Harvest | null> {
-  const real = resolveRealCodex();
+  const real = resolveRealBin(CODEX_BIN);
   const onboardDir = codexPaths.onboardDir;
   rmSync(onboardDir, { recursive: true, force: true });
   writeFileAtomic(join(onboardDir, "config.toml"), 'cli_auth_credentials_store = "file"\n');
@@ -179,8 +178,8 @@ function storePinnedAwayFromFile(): boolean {
 }
 
 function preflight(): void {
-  const real = resolveRealCodex();
-  const fail = verifyRealCodex({ bin: real });
+  const real = resolveRealBin(CODEX_BIN);
+  const fail = verifyRealBin({ ...CODEX_BIN, bin: real });
   if (fail !== null) throw new Error(`codex binary failed verification: ${real}: ${fail}`);
   pinBinOverride({ key: "codexBin", bin: real });
   if (storePinnedAwayFromFile()) {

package/src/lib/grok.ts

@@ -133,7 +133,7 @@ const base = statusOnlyProvider({
   liveAuthPath: () => join(grokPaths.home, "auth.json"),
   readAuth,
   liveId: () => grokSeatFromEnv(loadAccounts(grokPool).accounts.map((a) => a.id)),
-  versionOk: (out) => out.trim().toLowerCase().includes("grok"),
+  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.`,
   installNotice: "grok pool is status-only: no supervisor or hooks installed. Use `tokenmaxxing status` to view pooled grok accounts.",

package/src/lib/install.ts

@@ -6,7 +6,7 @@ import { z } from "zod";
 import { codexPaths, codexStoreDirFor, HOME, optionalEnv, paths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import { installedBin, installSettings, isOurHookCommand, uninstallSettings } from "./settings.ts";
-import { resolveRealClaude } from "./claudebin.ts";
+import { CLAUDE_BIN, resolveRealBin } from "./claudebin.ts";
 import { loadConfig } from "./state.ts";
 import { ErrnoSchema } from "./types.ts";
 
@@ -17,7 +17,7 @@ export function isBinDirAhead(): boolean {
   const ourIdx = dirs.indexOf(paths.binDir);
   if (ourIdx < 0) return false;
   try {
-    const realDir = dirname(resolveRealClaude());
+    const realDir = dirname(resolveRealBin(CLAUDE_BIN));
     const realIdx = dirs.indexOf(realDir);
     return realIdx < 0 || ourIdx < realIdx;
   } catch {
@@ -36,11 +36,11 @@ export function isNixPackaged(): boolean {
   }
 }
 
-export function skipImperativeTimer(): boolean {
+function skipImperativeTimer(): boolean {
   return envFlag("TOKENMAXXING_SKIP_TIMER");
 }
 
-export function skipImperativeHub(): boolean {
+function skipImperativeHub(): boolean {
   return envFlag("TOKENMAXXING_SKIP_HUB");
 }
 
@@ -106,8 +106,8 @@ export function installSupervisor(): InstallOutcome {
     claudeWrapper: paths.supervisorLink,
     installedBin: target,
     pathAhead: isBinDirAhead(),
-    timerLoaded: installCheckTimer(checkIntervalS),
-    hubLoaded: installHubService(),
+    timerLoaded: installJob(CHECK_JOB, checkIntervalS),
+    hubLoaded: installJob(HUB_JOB, checkIntervalS),
     checkIntervalS,
   };
 }
@@ -205,9 +205,67 @@ export function uninstallCodexSupervisor(): void {
   if (existsSync(codexSupervisorLink())) rmSync(codexSupervisorLink(), { force: true });
 }
 
-const LAUNCHD_LABEL = "com.tokenmaxxing.check";
-const LAUNCHD_HUB_LABEL = "com.tokenmaxxing.hub";
-const HUB_UNIT = "tokenmaxxing-hub.service";
+export type UnitJob = {
+  label: string;
+  arg: string;
+  log: string;
+  skip: () => boolean;
+  unit: string;
+  launchd: (intervalS: number) => string;
+  systemd: Record<string, (exec: string, intervalS: number) => string>;
+};
+
+export const CHECK_JOB: UnitJob = {
+  label: "com.tokenmaxxing.check",
+  arg: "check",
+  log: "check.stderr.log",
+  skip: skipImperativeTimer,
+  unit: "tokenmaxxing-check.timer",
+  launchd: (intervalS) => `  <key>StartInterval</key><integer>${intervalS}</integer>\n`,
+  systemd: {
+    "tokenmaxxing-check.service": (exec) => `[Unit]
+Description=tokenmaxxing account-switch check
+
+[Service]
+Type=oneshot
+ExecStart=${exec}
+${systemdEnv()}`,
+    "tokenmaxxing-check.timer": (_exec, intervalS) => `[Unit]
+Description=tokenmaxxing periodic account-switch check
+
+[Timer]
+OnBootSec=${intervalS}
+OnUnitActiveSec=${intervalS}
+AccuracySec=${Math.max(1, Math.floor(intervalS / 12))}
+
+[Install]
+WantedBy=timers.target
+`,
+  },
+};
+
+export const HUB_JOB: UnitJob = {
+  label: "com.tokenmaxxing.hub",
+  arg: "serve",
+  log: "hub.stderr.log",
+  skip: skipImperativeHub,
+  unit: "tokenmaxxing-hub.service",
+  launchd: () => `  <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>\n  <key>RunAtLoad</key><true/>\n`,
+  systemd: {
+    "tokenmaxxing-hub.service": (exec) => `[Unit]
+Description=tokenmaxxing usage hub
+StartLimitIntervalSec=0
+
+[Service]
+ExecStart=${exec}
+${systemdEnv()}Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`,
+  },
+};
 
 function launchdPlist(label: string): string {
   return join(paths.launchdAgentsDir, `${label}.plist`);
@@ -233,110 +291,56 @@ function launchdEnv(): string {
   return `  <key>EnvironmentVariables</key><dict><key>TOKENMAXXING_HOME</key><string>${escape(paths.home)}</string></dict>\n`;
 }
 
-function installCheckTimer(intervalS: number): boolean {
-  if (skipImperativeTimer()) return true;
+function installJob(job: UnitJob, intervalS: number): boolean {
+  if (job.skip()) return true;
 
   if (process.platform === "darwin") {
-    const plist = launchdPlist(LAUNCHD_LABEL);
+    const plist = launchdPlist(job.label);
     writeFileAtomic(
       plist,
       `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-  <key>Label</key><string>${LAUNCHD_LABEL}</string>
-  <key>ProgramArguments</key><array><string>${escape(installedBin())}</string><string>check</string></array>
-  <key>StartInterval</key><integer>${intervalS}</integer>
-${launchdEnv()}  <key>StandardOutPath</key><string>/dev/null</string>
-  <key>StandardErrorPath</key><string>${escape(join(paths.home, "check.stderr.log"))}</string>
+  <key>Label</key><string>${job.label}</string>
+  <key>ProgramArguments</key><array><string>${escape(installedBin())}</string><string>${job.arg}</string></array>
+${job.launchd(intervalS)}${launchdEnv()}  <key>StandardOutPath</key><string>/dev/null</string>
+  <key>StandardErrorPath</key><string>${escape(join(paths.home, job.log))}</string>
 </dict>
 </plist>
 `,
       0o644,
     );
     const domain = launchdDomain();
-    run(["launchctl", "bootout", `${domain}/${LAUNCHD_LABEL}`]);
-    return run(["launchctl", "bootstrap", domain, plist]) || checkTimerHealthy();
-  }
-
-  const exec = `"${installedBin().replaceAll("%", "%%")}" check`;
-  writeFileAtomic(
-    join(paths.systemdUserDir, "tokenmaxxing-check.service"),
-    `[Unit]
-Description=tokenmaxxing account-switch check
-
-[Service]
-Type=oneshot
-ExecStart=${exec}
-${systemdEnv()}`,
-    0o644,
-  );
-  writeFileAtomic(
-    join(paths.systemdUserDir, "tokenmaxxing-check.timer"),
-    `[Unit]
-Description=tokenmaxxing periodic account-switch check
-
-[Timer]
-OnBootSec=${intervalS}
-OnUnitActiveSec=${intervalS}
-AccuracySec=${Math.max(1, Math.floor(intervalS / 12))}
-
-[Install]
-WantedBy=timers.target
-`,
-    0o644,
-  );
-  return (
-    run(["systemctl", "--user", "daemon-reload"]) &&
-    run(["systemctl", "--user", "enable", "--now", "tokenmaxxing-check.timer"])
-  );
-}
-
-export function timerActivationHint(): string {
-  if (process.platform === "darwin") {
-    return `launchctl bootstrap gui/$(id -u) ${launchdPlist(LAUNCHD_LABEL)}`;
-  }
-  return "systemctl --user daemon-reload && systemctl --user enable --now tokenmaxxing-check.timer";
-}
-
-export function hubActivationHint(): string {
-  if (process.platform === "darwin") {
-    return `launchctl bootstrap gui/$(id -u) ${launchdPlist(LAUNCHD_HUB_LABEL)}`;
+    run(["launchctl", "bootout", `${domain}/${job.label}`]);
+    return run(["launchctl", "bootstrap", domain, plist]) || jobHealthy(job);
   }
-  return `systemctl --user daemon-reload && systemctl --user enable --now ${HUB_UNIT}`;
-}
 
-export function checkTimerHealthy(): boolean {
-  if (skipImperativeTimer()) return true;
-  if (process.platform === "darwin") {
-    return existsSync(launchdPlist(LAUNCHD_LABEL)) && run(["launchctl", "print", `${launchdDomain()}/${LAUNCHD_LABEL}`]);
-  }
-  return (
-    existsSync(join(paths.systemdUserDir, "tokenmaxxing-check.timer")) &&
-    run(["systemctl", "--user", "is-active", "--quiet", "tokenmaxxing-check.timer"])
-  );
+  const exec = `"${installedBin().replaceAll("%", "%%")}" ${job.arg}`;
+  for (const [file, text] of Object.entries(job.systemd)) writeFileAtomic(join(paths.systemdUserDir, file), text(exec, intervalS), 0o644);
+  return run(["systemctl", "--user", "daemon-reload"]) && run(["systemctl", "--user", "enable", "--now", job.unit]);
 }
 
-export function hubServiceHealthy(): boolean {
-  if (skipImperativeHub()) return true;
+export function activationHint(job: UnitJob): string {
   if (process.platform === "darwin") {
-    return existsSync(launchdPlist(LAUNCHD_HUB_LABEL)) && run(["launchctl", "print", `${launchdDomain()}/${LAUNCHD_HUB_LABEL}`]);
+    return `launchctl bootstrap gui/$(id -u) ${launchdPlist(job.label)}`;
   }
-  return existsSync(join(paths.systemdUserDir, HUB_UNIT)) && run(["systemctl", "--user", "is-active", "--quiet", HUB_UNIT]);
+  return `systemctl --user daemon-reload && systemctl --user enable --now ${job.unit}`;
 }
 
-export function timerDeactivationHint(): string {
+export function jobHealthy(job: UnitJob): boolean {
+  if (job.skip()) return true;
   if (process.platform === "darwin") {
-    return `launchctl bootout gui/$(id -u)/${LAUNCHD_LABEL}`;
+    return existsSync(launchdPlist(job.label)) && run(["launchctl", "print", `${launchdDomain()}/${job.label}`]);
   }
-  return "systemctl --user disable --now tokenmaxxing-check.timer";
+  return existsSync(join(paths.systemdUserDir, job.unit)) && run(["systemctl", "--user", "is-active", "--quiet", job.unit]);
 }
 
-export function hubDeactivationHint(): string {
+export function deactivationHint(job: UnitJob): string {
   if (process.platform === "darwin") {
-    return `launchctl bootout gui/$(id -u)/${LAUNCHD_HUB_LABEL}`;
+    return `launchctl bootout gui/$(id -u)/${job.label}`;
   }
-  return `systemctl --user disable --now ${HUB_UNIT}`;
+  return `systemctl --user disable --now ${job.unit}`;
 }
 
 function launchdJobLoaded(label: string): "loaded" | "not-loaded" | "unavailable" {
@@ -361,108 +365,42 @@ function systemdUnitActive(unit: string): "active" | "not-active" | "unavailable
   }
 }
 
-function removeTimerUnits(): void {
-  if (process.platform === "darwin") {
-    rmSync(launchdPlist(LAUNCHD_LABEL), { force: true });
-    return;
-  }
-  rmSync(join(paths.systemdUserDir, "tokenmaxxing-check.timer"), { force: true });
-  rmSync(join(paths.systemdUserDir, "tokenmaxxing-check.service"), { force: true });
+function jobFiles(job: UnitJob): string[] {
+  if (process.platform === "darwin") return [launchdPlist(job.label)];
+  return Object.keys(job.systemd).map((file) => join(paths.systemdUserDir, file));
+}
+
+function removeJobFiles(job: UnitJob): void {
+  for (const file of jobFiles(job)) rmSync(file, { force: true });
 }
 
 type UnitOutcome = "removed" | "skipped" | "still-loaded";
 
-function uninstallCheckTimer(live: boolean): UnitOutcome {
-  if (skipImperativeTimer()) return "skipped";
+function uninstallJob(job: UnitJob, live: boolean): UnitOutcome {
+  if (job.skip()) return "skipped";
   if (!live) {
-    removeTimerUnits();
+    removeJobFiles(job);
     return "removed";
   }
   if (process.platform === "darwin") {
-    const loaded = launchdJobLoaded(LAUNCHD_LABEL);
-    const deactivated = loaded === "loaded" ? run(["launchctl", "bootout", `${launchdDomain()}/${LAUNCHD_LABEL}`]) : loaded === "not-loaded";
-    removeTimerUnits();
+    const loaded = launchdJobLoaded(job.label);
+    const deactivated = loaded === "loaded" ? run(["launchctl", "bootout", `${launchdDomain()}/${job.label}`]) : loaded === "not-loaded";
+    removeJobFiles(job);
     return deactivated ? "removed" : "still-loaded";
   }
-  const active = systemdUnitActive("tokenmaxxing-check.timer");
-  const deactivated = active !== "unavailable" && (run(["systemctl", "--user", "disable", "--now", "tokenmaxxing-check.timer"]) || active === "not-active");
-  removeTimerUnits();
+  const active = systemdUnitActive(job.unit);
+  const deactivated = active !== "unavailable" && (run(["systemctl", "--user", "disable", "--now", job.unit]) || active === "not-active");
+  removeJobFiles(job);
   run(["systemctl", "--user", "daemon-reload"]);
   return deactivated ? "removed" : "still-loaded";
 }
 
-function installHubService(): boolean {
-  if (skipImperativeHub()) return true;
-
-  if (process.platform === "darwin") {
-    const plist = launchdPlist(LAUNCHD_HUB_LABEL);
-    writeFileAtomic(
-      plist,
-      `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key><string>${LAUNCHD_HUB_LABEL}</string>
-  <key>ProgramArguments</key><array><string>${escape(installedBin())}</string><string>serve</string></array>
-  <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
-  <key>RunAtLoad</key><true/>
-${launchdEnv()}  <key>StandardOutPath</key><string>/dev/null</string>
-  <key>StandardErrorPath</key><string>${escape(join(paths.home, "hub.stderr.log"))}</string>
-</dict>
-</plist>
-`,
-      0o644,
-    );
-    const domain = launchdDomain();
-    run(["launchctl", "bootout", `${domain}/${LAUNCHD_HUB_LABEL}`]);
-    return run(["launchctl", "bootstrap", domain, plist]) || hubServiceHealthy();
-  }
-
-  const exec = `"${installedBin().replaceAll("%", "%%")}" serve`;
-  writeFileAtomic(
-    join(paths.systemdUserDir, HUB_UNIT),
-    `[Unit]
-Description=tokenmaxxing usage hub
-StartLimitIntervalSec=0
-
-[Service]
-ExecStart=${exec}
-${systemdEnv()}Restart=on-failure
-RestartSec=5
-
-[Install]
-WantedBy=default.target
-`,
-    0o644,
-  );
-  return run(["systemctl", "--user", "daemon-reload"]) && run(["systemctl", "--user", "enable", "--now", HUB_UNIT]);
-}
-
-function removeHubUnits(): void {
-  if (process.platform === "darwin") {
-    rmSync(launchdPlist(LAUNCHD_HUB_LABEL), { force: true });
-    return;
-  }
-  rmSync(join(paths.systemdUserDir, HUB_UNIT), { force: true });
-}
-
-function uninstallHubService(live: boolean): UnitOutcome {
-  if (skipImperativeHub()) return "skipped";
-  if (!live) {
-    removeHubUnits();
-    return "removed";
-  }
-  if (process.platform === "darwin") {
-    const loaded = launchdJobLoaded(LAUNCHD_HUB_LABEL);
-    const deactivated = loaded === "loaded" ? run(["launchctl", "bootout", `${launchdDomain()}/${LAUNCHD_HUB_LABEL}`]) : loaded === "not-loaded";
-    removeHubUnits();
-    return deactivated ? "removed" : "still-loaded";
-  }
-  const active = systemdUnitActive(HUB_UNIT);
-  const deactivated = active !== "unavailable" && (run(["systemctl", "--user", "disable", "--now", HUB_UNIT]) || active === "not-active");
-  removeHubUnits();
-  run(["systemctl", "--user", "daemon-reload"]);
-  return deactivated ? "removed" : "still-loaded";
+function uninstallTarget(job: UnitJob, live: boolean): string {
+  const files = jobFiles(job).join(" and ");
+  if (!live) return files;
+  return process.platform === "darwin"
+    ? `${files} (and launchctl bootout ${launchdDomain()}/${job.label})`
+    : `${files} (and systemctl --user disable --now ${job.unit})`;
 }
 
 export function shellRcPath(): string | null {
@@ -563,20 +501,11 @@ export function onLoginHome(): boolean {
 }
 
 export function uninstallTargets(live: boolean): string[] {
-  const timer =
-    process.platform === "darwin"
-      ? `${launchdPlist(LAUNCHD_LABEL)}${live ? ` (and launchctl bootout ${launchdDomain()}/${LAUNCHD_LABEL})` : ""}`
-      : `${join(paths.systemdUserDir, "tokenmaxxing-check.timer")} and .service${live ? " (and systemctl --user disable --now tokenmaxxing-check.timer)" : ""}`;
-  const hub =
-    process.platform === "darwin"
-      ? `${launchdPlist(LAUNCHD_HUB_LABEL)}${live ? ` (and launchctl bootout ${launchdDomain()}/${LAUNCHD_HUB_LABEL})` : ""}`
-      : `${join(paths.systemdUserDir, HUB_UNIT)}${live ? ` (and systemctl --user disable --now ${HUB_UNIT})` : ""}`;
   const rc = shellRcPath();
   return [
     `${paths.claudeSettings}: the hook and statusline entries`,
     `${codexPaths.hooksJson}: the codex Stop hook entry`,
-    ...(skipImperativeTimer() ? [] : [timer]),
-    ...(skipImperativeHub() ? [] : [hub]),
+    ...[CHECK_JOB, HUB_JOB].filter((job) => !job.skip()).map((job) => uninstallTarget(job, live)),
     paths.supervisorLink,
     codexSupervisorLink(),
     join(paths.binDir, "xx"),
@@ -587,8 +516,8 @@ export function uninstallTargets(live: boolean): string[] {
 
 export function uninstallSupervisor(input: { live: boolean }): UninstallOutcome {
   uninstallSettings();
-  const timer = uninstallCheckTimer(input.live);
-  const hub = uninstallHubService(input.live);
+  const timer = uninstallJob(CHECK_JOB, input.live);
+  const hub = uninstallJob(HUB_JOB, input.live);
   uninstallCodexSupervisor();
   for (const f of [paths.supervisorLink, join(paths.binDir, "xx"), installedBin()]) {
     if (existsSync(f)) rmSync(f, { force: true });

package/src/lib/opencodego.ts

@@ -63,7 +63,7 @@ export const opencodeGo: Provider = statusOnlyProvider({
   liveAuthPath,
   readAuth,
   liveId: () => null,
-  versionOk: (out) => out.trim() !== "",
+  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.`,
   installNotice: "opencode-go pool is status-only: no supervisor or hooks installed. Use `tokenmaxxing status` to view pooled keys.",

package/src/lib/state.ts

@@ -39,7 +39,9 @@ export function loadConfig(): Config {
   return cfg;
 }
 
-export function pinBinOverride(input: { key: "claudeBin" | "codexBin" | "grokBin" | "opencodeBin"; bin: string }): void {
+export type BinKey = "claudeBin" | "codexBin" | "grokBin" | "opencodeBin";
+
+export function pinBinOverride(input: { key: BinKey; bin: string }): void {
   let raw: Record<string, unknown> = {};
   if (existsSync(paths.configJson)) {
     raw = z.record(z.string(), z.unknown()).parse(JSON.parse(readFileSync(paths.configJson, "utf8")));

package/src/lib/statusonly.ts

@@ -1,8 +1,9 @@
-import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { resolveRealBin, verifyRealBin } from "./claudebin.ts";
 import type { PoolPaths } from "./paths.ts";
 import type { Provider, SampleReport } from "./provider.ts";
-import { loadConfig, pinBinOverride, type Harvest } from "./state.ts";
+import { pinBinOverride, type Harvest } from "./state.ts";
 import type { Account } from "./types.ts";
 import { c } from "../cli/render.ts";
 
@@ -31,23 +32,7 @@ export type StatusOnlySpec = {
 };
 
 export function statusOnlyProvider(spec: StatusOnlySpec): Provider {
-  function resolveBin(): string {
-    const configured = loadConfig()[spec.binKey];
-    if (configured) {
-      if (!existsSync(configured)) throw new Error(`configured ${spec.binKey} does not exist: ${configured} - fix config.json`);
-      return configured;
-    }
-    for (const d of (process.env.PATH ?? "").split(":")) {
-      if (!d) continue;
-      const cand = join(d, spec.binName);
-      try {
-        if (existsSync(cand)) return cand;
-      } catch {
-        continue;
-      }
-    }
-    throw new Error(`could not locate the real \`${spec.binName}\` binary (set ${spec.binKey} in config.json)`);
-  }
+  const bin = { name: spec.binName, key: spec.binKey, versionOk: spec.versionOk };
 
   async function storeUsable(a: Account): Promise<boolean> {
     try {
@@ -66,7 +51,7 @@ export function statusOnlyProvider(spec: StatusOnlySpec): Provider {
   }
 
   async function login(): Promise<Harvest | null> {
-    const real = resolveBin();
+    const real = resolveRealBin(bin);
     const onboardDir = spec.onboardDir;
     rmSync(onboardDir, { recursive: true, force: true });
     mkdirSync(onboardDir, { recursive: true });
@@ -102,11 +87,9 @@ export function statusOnlyProvider(spec: StatusOnlySpec): Provider {
   }
 
   function preflight(): void {
-    const real = resolveBin();
-    const p = Bun.spawnSync([real, "--version"], { stdout: "pipe", stderr: "pipe", timeout: 15_000 });
-    if (p.exitCode !== 0 || !spec.versionOk(p.stdout.toString())) {
-      throw new Error(`${spec.binName} binary failed verification: ${real}`);
-    }
+    const real = resolveRealBin(bin);
+    const fail = verifyRealBin({ ...bin, bin: real });
+    if (fail !== null) throw new Error(`${spec.binName} binary failed verification: ${real}: ${fail}`);
     pinBinOverride({ key: spec.binKey, bin: real });
   }
 

package/src/main.ts

@@ -23,7 +23,7 @@ import { cmdCheck } from "./cli/check.ts";
 import { cmdConfig } from "./cli/config.ts";
 import { cmdSeat } from "./cli/seat.ts";
 import { cmdServe } from "./cli/serve.ts";
-import { hubDeactivationHint, onLoginHome, timerDeactivationHint, uninstallSupervisor, uninstallTargets } from "./lib/install.ts";
+import { CHECK_JOB, deactivationHint, HUB_JOB, onLoginHome, uninstallSupervisor, uninstallTargets } from "./lib/install.ts";
 import { errorMessage } from "./lib/log.ts";
 import { HOME } from "./lib/paths.ts";
 import { c, emitError } from "./cli/render.ts";
@@ -177,8 +177,8 @@ async function main(): Promise<number> {
         ...(out.pathLineRemoved ? ["rc PATH line"] : []),
       ];
       console.log(`removed ${removed.join(", ")}`);
-      if (out.timer === "still-loaded") console.log(c.yellow(`⚠ the check job may still be loaded - run: ${timerDeactivationHint()}`));
-      if (out.hub === "still-loaded") console.log(c.yellow(`⚠ the usage hub job may still be loaded - run: ${hubDeactivationHint()}`));
+      if (out.timer === "still-loaded") console.log(c.yellow(`⚠ the check job may still be loaded - run: ${deactivationHint(CHECK_JOB)}`));
+      if (out.hub === "still-loaded") console.log(c.yellow(`⚠ the usage hub job may still be loaded - run: ${deactivationHint(HUB_JOB)}`));
       if (!out.pathLineRemoved) console.log(c.dim("(no tokenmaxxing PATH line found in the shell rc)"));
       console.log(`kept: accounts.json, config.json, and every account credential store (claude: stores/ and its keychain items on macOS; codex: codex-stores/; grok: grok-stores/; opencode-go: opencode-go-stores/) - remove accounts with \`xx rm\` to delete their credentials`);
       return 0;

package/src/lib/codexbin.ts

@@ -1,55 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { LOOP_DIAGNOSIS, MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, pointsBackAtUs } from "./claudebin.ts";
-import { errorMessage } from "./log.ts";
-import { loadConfig } from "./state.ts";
-import { paths } from "./paths.ts";
-
-function scanPathForCodex(): string | null {
-  for (const d of (process.env.PATH ?? "").split(":")) {
-    if (!d) continue;
-    const cand = join(d, "codex");
-    try {
-      if (existsSync(cand) && statSync(cand).isFile() && !pointsBackAtUs(cand)) return cand;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-
-export function resolveRealCodex(): string {
-  const cfg = loadConfig();
-  if (cfg.codexBin) {
-    if (!existsSync(cfg.codexBin)) {
-      throw new Error(`configured codexBin does not exist: ${cfg.codexBin} - fix config.json`);
-    }
-    if (pointsBackAtUs(cfg.codexBin)) {
-      throw new Error(
-        `configured codexBin (${cfg.codexBin}) is tokenmaxxing's own wrapper - spawning it recurses. Point codexBin at the real codex binary in ${paths.configJson}`,
-      );
-    }
-    return cfg.codexBin;
-  }
-  const scanned = scanPathForCodex();
-  if (scanned) return scanned;
-  throw new Error("could not locate the real `codex` binary (set codexBin in config.json)");
-}
-
-export function verifyRealCodex(input: { bin: string }): string | null {
-  const env = { ...process.env, [WRAP_DEPTH_ENV]: String(MAX_WRAP_DEPTH), TOKENMAXXING_PROBE: "1" };
-  let p;
-  try {
-    p = Bun.spawnSync([input.bin, "--version"], { env, stdout: "pipe", stderr: "pipe", timeout: 15_000, killSignal: "SIGKILL" });
-  } catch (e) {
-    return errorMessage(e);
-  }
-  const outText = p.stdout.toString().trim();
-  const err = p.stderr.toString().trim();
-  if (p.exitCode === 0) {
-    if (outText.toLowerCase().includes("codex")) return null;
-    return `--version output does not identify codex: "${outText.slice(0, 80)}"`;
-  }
-  if (err.includes(LOOP_DIAGNOSIS)) return "it leads back into the tokenmaxxing wrapper (recursion)";
-  return `--version exited ${p.exitCode ?? "on signal/timeout"}: ${(err || outText).slice(0, 160)}`;
-}