tokenmaxxing 1.56.0 → 1.58.0

package/src/lib/statusonly.ts

@@ -0,0 +1,143 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import type { PoolPaths } from "./paths.ts";
+import type { Provider, SampleReport } from "./provider.ts";
+import { loadConfig, pinBinOverride, type Harvest } from "./state.ts";
+import type { Account } from "./types.ts";
+import { c } from "../cli/render.ts";
+
+export type AuthEntry = { id: string; usable: boolean; harvest: Harvest | null };
+
+export type StatusOnlySpec = {
+  name: Provider["name"];
+  flag: string;
+  pool: PoolPaths;
+  binName: string;
+  binKey: "grokBin" | "opencodeBin";
+  storeDirFor: (accountId: string) => string;
+  authJsonFor: (accountId: string) => string;
+  onboardDir: string;
+  homeEnv: string;
+  loginArgs: string[];
+  onboardAuthRel: string;
+  liveAuthPath: () => string;
+  readAuth: (path: string) => AuthEntry[];
+  liveId: () => string | null;
+  versionOk: (versionOutput: string) => boolean;
+  importIntro: string;
+  foundLive: (count: number) => string;
+  installNotice: string;
+  loginStep: () => string;
+};
+
+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)`);
+  }
+
+  async function storeUsable(a: Account): Promise<boolean> {
+    try {
+      return spec.readAuth(spec.authJsonFor(a.id)).some((e) => e.id === a.id && e.usable);
+    } catch {
+      return false;
+    }
+  }
+
+  async function samplePool(accounts: Account[]): Promise<Map<string, SampleReport>> {
+    const reports = new Map<string, SampleReport>();
+    for (const a of accounts) {
+      reports.set(a.id, (await storeUsable(a)) ? { ok: true, source: "probe" } : { ok: false, reason: `no usable credential in this account's store - run \`tokenmaxxing auth${spec.flag}\`` });
+    }
+    return reports;
+  }
+
+  async function login(): Promise<Harvest | null> {
+    const real = resolveBin();
+    const onboardDir = spec.onboardDir;
+    rmSync(onboardDir, { recursive: true, force: true });
+    mkdirSync(onboardDir, { recursive: true });
+    const p = Bun.spawn([real, ...spec.loginArgs], {
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+      env: { ...process.env, [spec.homeEnv]: onboardDir, TOKENMAXXING_PROBE: "1" },
+    });
+    await p.exited;
+    try {
+      const first = p.exitCode === 0 ? spec.readAuth(join(onboardDir, spec.onboardAuthRel))[0] : undefined;
+      if (!first) {
+        console.error(c.red(`no ${spec.name} login landed in the isolated home - nothing added.`));
+        return null;
+      }
+      return first.harvest;
+    } finally {
+      rmSync(onboardDir, { recursive: true, force: true });
+    }
+  }
+
+  async function importLive(): Promise<Harvest | null> {
+    console.log(c.cyan(spec.importIntro));
+    console.log();
+    const live = spec.readAuth(spec.liveAuthPath());
+    const first = live[0];
+    if (first) {
+      console.log(c.dim(spec.foundLive(live.length)));
+      if (first.harvest) return first.harvest;
+    }
+    return login();
+  }
+
+  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}`);
+    }
+    pinBinOverride({ key: spec.binKey, bin: real });
+  }
+
+  return {
+    name: spec.name,
+    flag: spec.flag,
+    pool: spec.pool,
+    seats: "live",
+    waitsWhenDepleted: false,
+    statusOnly: true,
+    liveId: spec.liveId,
+    presence: () => new Map(),
+    gatedFamilies: () => null,
+    observeLive: async (account) => (account.lastUsageAt != null ? { windows: account.windows, at: account.lastUsageAt } : null),
+    samplePool,
+    mergeWindows: (next) => next,
+    swap: async () => {
+      throw new Error(`${spec.name} moves are not supported yet (status-only pool)`);
+    },
+    classifySwapError: () => "fatal",
+    removeCredentials: async (a) => {
+      rmSync(spec.storeDirFor(a.id), { recursive: true, force: true });
+    },
+    storeUsable,
+    login,
+    importLive,
+    preflight,
+    install: () => {
+      console.log(c.dim(spec.installNotice));
+    },
+    loginStep: spec.loginStep,
+    windowLabel: (name) => name.toLowerCase(),
+  };
+}

package/src/lib/supervise.ts

@@ -0,0 +1,111 @@
+import type { Subprocess } from "bun";
+import { LOOP_DIAGNOSIS, MAX_WRAP_DEPTH, WRAP_RATE_MAX, WRAP_RATE_WINDOW_MS, wrapDepth, wrapperEntryRateTripped } from "./claudebin.ts";
+import { errorMessage, log } from "./log.ts";
+import { paths } from "./paths.ts";
+import { writePresence } from "./presence.ts";
+import { restoreTermios } from "./tty.ts";
+
+export type WrappedProduct = "claude" | "codex";
+
+type ChildHandle = {
+  pid: number;
+  exitCode: number | null;
+  signalCode: string | null;
+  kill: () => void;
+  exited: Promise<unknown>;
+};
+
+const WRAPPED: Record<WrappedProduct, { setting: string; binary: string; events: string }> = {
+  claude: { setting: "claudeBin", binary: "Claude", events: "supervisor" },
+  codex: { setting: "codexBin", binary: "codex", events: "codexsupervisor" },
+};
+
+export function exitStatus(child: { exitCode: number | null; signalCode: string | null }): number {
+  return child.exitCode ?? (child.signalCode ? 1 : 0);
+}
+
+export function loopGuardTripped(product: WrappedProduct): boolean {
+  const { setting, binary, events } = WRAPPED[product];
+  const depth = wrapDepth();
+  if (depth >= MAX_WRAP_DEPTH) {
+    console.error(
+      `tokenmaxxing: ${LOOP_DIAGNOSIS} ${binary} (depth ${depth}) - ${setting} in ${paths.configJson} does not launch the real ${binary} binary. Fix ${setting}, then run \`tokenmaxxing doctor\`.`,
+    );
+    log(`${events}.loop_abort`, { depth });
+    return true;
+  }
+  if (wrapperEntryRateTripped(Date.now())) {
+    console.error(
+      `tokenmaxxing: ${LOOP_DIAGNOSIS} ${binary} (over ${WRAP_RATE_MAX} wrapper entries in ${WRAP_RATE_WINDOW_MS / 1000}s) - ${setting} in ${paths.configJson} does not launch the real ${binary} binary. Fix ${setting}, then run \`tokenmaxxing doctor\`.`,
+    );
+    log(`${events}.rate_abort`, { max: WRAP_RATE_MAX });
+    return true;
+  }
+  return false;
+}
+
+export async function runPassthrough(input: { real: string; argv: string[]; env: Record<string, string | undefined>; onSpawn?: (child: Subprocess) => void }): Promise<number> {
+  const p = Bun.spawn([input.real, ...input.argv], { stdin: "inherit", stdout: "inherit", stderr: "inherit", env: input.env });
+  input.onSpawn?.(p);
+  await p.exited;
+  return exitStatus(p);
+}
+
+export async function recordPresenceOrStop(input: { child: ChildHandle; dir: string; id: string; accountId: string; event: string; message: string; savedTermios: string | null }): Promise<void> {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      writePresence({ dir: input.dir, id: input.id, accountId: input.accountId, pid: input.child.pid });
+      return;
+    } catch (e) {
+      if (input.child.exitCode !== null || input.child.signalCode !== null) return;
+      if (attempt >= 9) {
+        log(input.event, { err: errorMessage(e) });
+        input.child.kill();
+        await input.child.exited;
+        restoreTermios(input.savedTermios);
+        throw new Error(input.message);
+      }
+      await Bun.sleep(100);
+    }
+  }
+}
+
+export async function raceMarkerOrExit(input: {
+  child: { exited: Promise<unknown>; kill: () => void };
+  tick: () => boolean | Promise<boolean>;
+  savedTermios: string | null;
+  onKill?: () => void;
+  onError?: () => void;
+  onExited?: () => void;
+}): Promise<void> {
+  let done = false;
+  const markerWatch = (async () => {
+    while (!done) {
+      if (await input.tick()) return true;
+      await Bun.sleep(150);
+    }
+    return false;
+  })();
+  const exited = input.child.exited.then(() => {
+    done = true;
+    return "exit" as const;
+  });
+  try {
+    const winner = await Promise.race([exited, markerWatch.then((found) => (found ? "marker" : "exit"))]);
+    if (winner === "marker") {
+      input.onKill?.();
+      input.child.kill();
+    }
+  } catch (e) {
+    input.onKill?.();
+    input.child.kill();
+    input.onError?.();
+    throw e;
+  } finally {
+    await input.child.exited;
+    input.onExited?.();
+    done = true;
+    await markerWatch.catch(() => false);
+    restoreTermios(input.savedTermios);
+  }
+}

package/src/lib/types.ts

@@ -36,10 +36,7 @@ const AggregateWindowsSchema = z.object({
   sevenDay: UsageWindowSchema,
 });
 
-export const UsageWindowsSchema = AggregateWindowsSchema.extend({
-  perModel: z.record(z.string(), UsageWindowSchema).default({}),
-});
-export type UsageWindows = z.infer<typeof UsageWindowsSchema>;
+export type UsageWindows = z.infer<typeof AggregateWindowsSchema> & { perModel: Record<string, UsageWindow> };
 
 export const WindowSchema = z.object({
   name: z.string().nullable(),
@@ -80,27 +77,19 @@ export type Account = z.infer<typeof AccountSchema>;
 
 export const AccountsIndexSchema = z.object({
   version: z.literal(2),
-  activeId: z.string().nullable(),
   accounts: z.array(AccountSchema).default([]),
 });
-
-export const LastSwapSchema = z.object({ ts: z.number() });
 export type AccountsIndex = z.infer<typeof AccountsIndexSchema>;
 
-export const EnforcedLimitSchema = z.object({
-  account: z.string(),
-  kind: z.enum(["session", "weekly", "model"]),
-  family: z.string().nullable(),
-  resetsAt: z.number().nullable(),
-  blind: z.boolean(),
-});
-export type EnforcedLimit = z.infer<typeof EnforcedLimitSchema>;
+export type EnforcedLimit = {
+  account: string;
+  kind: "session" | "weekly" | "model";
+  family: string | null;
+  resetsAt: number | null;
+  blind: boolean;
+};
 
-export const ThresholdsSchema = z.object({
-  session: z.number().min(0).max(100),
-  weekly: z.number().min(0).max(100),
-});
-export type Thresholds = z.infer<typeof ThresholdsSchema>;
+export type Thresholds = { session: number; weekly: number };
 
 export const ConfigSchema = z
   .object({
@@ -142,11 +131,15 @@ export const RespawnMarkerSchema = z.object({
   launchedAt: z.number().optional(),
 });
 
+export const EpochSecondsSchema = z.number().transform((seconds) => seconds * 1000);
+
+const StdinWindowSchema = z.looseObject({ used_percentage: z.number(), resets_at: EpochSecondsSchema.nullable().optional() });
+
 export const RateLimitsStdinSchema = z.looseObject({
   rate_limits: z
     .looseObject({
-      five_hour: z.looseObject({ used_percentage: z.number(), resets_at: z.number().nullable().optional() }).optional(),
-      seven_day: z.looseObject({ used_percentage: z.number(), resets_at: z.number().nullable().optional() }).optional(),
+      five_hour: StdinWindowSchema.optional(),
+      seven_day: StdinWindowSchema.optional(),
     })
     .optional(),
   model: z.looseObject({ id: z.string().optional(), display_name: z.string().optional() }).optional(),
@@ -196,13 +189,12 @@ export const ProfileResponseSchema = z.looseObject({
   organization: z.looseObject({ uuid: z.string(), name: z.string().nullish() }),
 });
 
-export const TokenIdentitySchema = z.object({
-  accountUuid: z.string(),
-  email: z.string().nullable(),
-  organizationUuid: z.string(),
-  organizationName: z.string().nullable(),
-});
-export type TokenIdentity = z.infer<typeof TokenIdentitySchema>;
+export type TokenIdentity = {
+  accountUuid: string;
+  email: string | null;
+  organizationUuid: string;
+  organizationName: string | null;
+};
 
 const CodexTokensSchema = z.looseObject({
   id_token: z.string(),
@@ -217,13 +209,12 @@ export const CodexAuthJsonSchema = z.looseObject({
 });
 export type CodexAuthJson = z.infer<typeof CodexAuthJsonSchema>;
 
-export const CodexUsageSchema = z.object({
-  accountId: z.string(),
-  email: z.string().nullable(),
-  planType: z.string().nullable(),
-  windows: z.array(WindowSchema),
-});
-export type CodexUsage = z.infer<typeof CodexUsageSchema>;
+export type CodexUsage = {
+  accountId: string;
+  email: string | null;
+  planType: string | null;
+  windows: Window[];
+};
 
 export const CodexStopStdinSchema = z.looseObject({
   session_id: z.string().optional(),

package/src/lib/update.ts

@@ -5,14 +5,13 @@ import { writeFileAtomic } from "./atomic.ts";
 import { http } from "./http.ts";
 import { isNixPackaged } from "./install.ts";
 import { withLock } from "./lock.ts";
-import { log } from "./log.ts";
-import { HOME, paths } from "./paths.ts";
+import { errorMessage, log } from "./log.ts";
+import { env, HOME, optionalEnv, paths } from "./paths.ts";
 
 const UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const INSTALL_DEADLINE_MS = 60_000;
 const REGISTRY_DEADLINE_MS = 15_000;
 
-const OverrideSchema = z.string().min(1).optional().catch(undefined);
 const AttemptSchema = z.object({ attemptedAt: z.number() });
 const VersionSchema = z.object({ version: z.string().min(1) });
 const LatestSchema = z.object({ version: z.string().min(1), engines: z.looseObject({ bun: z.string().min(1).optional() }).optional() });
@@ -21,7 +20,7 @@ const updateJson = join(paths.home, "update.json");
 const updateLock = join(paths.home, "update.lock");
 
 function registry(): { base: URL; authorization: string | null } {
-  const raw = OverrideSchema.parse(process.env.TOKENMAXXING_NPM_REGISTRY) ?? "https://registry.npmjs.org";
+  const raw = env("TOKENMAXXING_NPM_REGISTRY", "https://registry.npmjs.org");
   const base = new URL(raw.endsWith("/") ? raw : `${raw}/`);
   const authorization =
     base.username !== "" || base.password !== "" ? `Basic ${btoa(`${decodeURIComponent(base.username)}:${decodeURIComponent(base.password)}`)}` : null;
@@ -39,8 +38,8 @@ function realOrNull(path: string): string | null {
 }
 
 function globalRootCandidates(): string[] {
-  const globalDir = OverrideSchema.parse(process.env.BUN_INSTALL_GLOBAL_DIR);
-  const bunInstall = OverrideSchema.parse(process.env.BUN_INSTALL);
+  const globalDir = optionalEnv("BUN_INSTALL_GLOBAL_DIR");
+  const bunInstall = optionalEnv("BUN_INSTALL");
   return [
     ...(globalDir != null ? [globalDir] : []),
     ...(bunInstall != null ? [join(bunInstall, "install", "global")] : []),
@@ -127,7 +126,7 @@ export async function maybeAutoUpdate(): Promise<void> {
     try {
       await updateToLatest(root);
     } catch (e) {
-      throw new Error(`self-update from npm failed: ${e instanceof Error ? e.message : String(e)}`);
+      throw new Error(`self-update from npm failed: ${errorMessage(e)}`);
     }
   });
 }