tokenmaxxing 1.26.0 → 1.27.0

package/README.md

@@ -70,8 +70,7 @@ claude                  # use claude as always
 | `tokenmaxxing switch --codex [sel]` | switch the codex pool (takes effect on the next codex start) |
 | `tokenmaxxing ls` | list pooled accounts |
 | `tokenmaxxing status` | accounts with 5h / weekly usage bars, active + exhausted-until-reset |
-| `tokenmaxxing status --ping [--count N]` | additionally ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh; `--count N` pings N randomly picked accounts instead, to stagger the resets |
-| `tokenmaxxing watch [seconds]` | live status: re-render every N seconds (default 120, floor 30; never pings) |
+| `tokenmaxxing watch [seconds]` | live status: re-render every N seconds (default 120, floor 30) |
 | `tokenmaxxing config` | effective config with sources; `get`/`set`/`unset` dotted keys, `tidy` prunes unknown keys |
 | `tokenmaxxing doctor` | verify the supervisor + settings entries survived |
 | `tokenmaxxing rename [--codex] <sel> <label>` / `rm [--codex] <sel>` | manage the pool (`--codex` targets the codex pool: one email can hold both a claude and a codex account) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.26.0",
+  "version": "1.27.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts and hot-swap when quota fills, resuming your session on the fresh account.",
   "type": "module",
   "license": "MIT",

package/src/cli/init.ts

@@ -37,7 +37,6 @@ export function printUsage(): void {
   console.log(`  ${c.bold("how to use")} - ${c.cyan("xx")} is shorthand for ${c.cyan("tokenmaxxing")}:`);
   console.log(`    ${c.cyan("claude")}             use claude as always; it switches accounts near quota automatically`);
   console.log(`    ${c.cyan("xx")}                 show the pool with usage bars (same as ${c.cyan("xx status")})`);
-  console.log(`    ${c.cyan("xx status --ping")}   ping every account (one tiny haiku request each) so all 5h timers start now, then sample fresh; ${c.cyan("--count N")} pings N random accounts instead`);
   console.log(`    ${c.cyan("xx add")}             log in and pool another account`);
   console.log(`    ${c.cyan("xx switch")}          hop to the best account right now (the automatic switching needs no command)`);
   console.log(`    ${c.cyan("xx help")}            everything else`);

package/src/cli/status.ts

@@ -1,4 +1,4 @@
-import { chunk, sampleSize, sortBy } from "es-toolkit";
+import { chunk, sortBy } from "es-toolkit";
 import { z } from "zod";
 import { loadAccounts, loadConfig, loadUsage, loadUsageSnapshot, loadModelUsage, saveAccounts } from "../lib/state.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
@@ -32,9 +32,6 @@ const ClaudeStatusAccountSchema = z.object({
   perModel: z.record(z.string(), UsageWindowSchema),
   usageAt: z.number().nullable(),
   sample: SampleReportSchema,
-  pingError: z.string().nullable(),
-  pingRejected: z.boolean(),
-  pinged: z.boolean(),
 });
 type ClaudeStatusAccount = z.infer<typeof ClaudeStatusAccountSchema>;
 
@@ -86,31 +83,14 @@ function currentCodexWindow(w: CodexWindow, now: number): CodexWindow {
   return { ...currentWindow(w, !isSessionWindow({ window: w }), now), windowSeconds: w.windowSeconds };
 }
 
-function pickForPing(accounts: Account[], pingCount: number | undefined): Account[] {
-  if (pingCount == null) return accounts;
-  const usable = accounts.filter((a) => a.needsReauth !== true);
-  return sampleSize(usable, Math.min(pingCount, usable.length));
-}
-
-function progressNote(input: { ping: boolean; pingCount: number | undefined; picked: Account[]; total: number }): string {
-  const { ping, pingCount, picked, total } = input;
-  if (!ping) return "sampling live usage...";
-  if (pingCount == null) return "pinging every account (starts each 5h session timer) + sampling live usage...";
-  if (picked.length === 0) return "no account to ping (every account needs reauth), sampling live usage...";
-  return `pinging ${picked.length} of ${count({ n: total, noun: "account" })} (${picked.map((a) => a.label || a.email).join(", ")}) so their 5h session timers start now + sampling live usage...`;
-}
-
-async function collectClaude(input: { cfg: Config; ping: boolean; pingCount: number | undefined; now: number }): Promise<StatusReport["claude"]> {
-  const { cfg, ping, pingCount, now } = input;
+async function collectClaude(input: { cfg: Config; now: number }): Promise<StatusReport["claude"]> {
+  const { cfg, now } = input;
   let idx = loadAccounts();
   const samples = new Map<string, { outcome: SampleOutcome; viaTee: boolean }>();
-  let pings = new Set<string>();
   if (idx.accounts.length > 0) {
     await withLock(paths.lockFile, async () => {
       idx = loadAccounts();
-      const picked = ping ? pickForPing(idx.accounts, pingCount) : [];
-      pings = new Set(picked.map((a) => a.accountUuid));
-      console.error(c.dim(progressNote({ ping, pingCount, picked, total: idx.accounts.length })));
+      console.error(c.dim("sampling live usage..."));
       const tee = loadUsageSnapshot();
       const live = tee?.state ?? null;
       const teeAt = tee?.at ?? null;
@@ -129,27 +109,12 @@ async function collectClaude(input: { cfg: Config; ping: boolean; pingCount: num
                 perModel: modelUsage && modelUsage.account === a.accountUuid ? modelUsage.perModel : {},
               }
             : null;
-        let viaTee = false;
-        let outcome: SampleOutcome;
-        if (pings.has(a.accountUuid)) {
-          outcome = isActive ? await probeActiveUsage(a, { ping: true }) : await probeParkedUsage(a, { ping: true });
-          if (!outcome.ok && fromStatusLine && outcome.reason.includes("no limit data")) {
-            const failed = outcome;
-            outcome = { ok: true, usage: fromStatusLine };
-            if (failed.pingError != null) {
-              outcome.pingError = failed.pingError;
-              outcome.pingRejected = failed.pingRejected;
-            }
-            viaTee = true;
-          }
-        } else {
-          viaTee = fromStatusLine != null;
-          outcome = fromStatusLine
-            ? { ok: true, usage: fromStatusLine }
-            : isActive
-              ? await probeActiveUsage(a)
-              : await probeParkedUsage(a);
-        }
+        const viaTee = fromStatusLine != null;
+        const outcome: SampleOutcome = fromStatusLine
+          ? { ok: true, usage: fromStatusLine }
+          : isActive
+            ? await probeActiveUsage(a)
+            : await probeParkedUsage(a);
         samples.set(a.accountUuid, { outcome, viaTee });
         if (!outcome.ok) return;
         a.lastUsage = { fiveHour: outcome.usage.session, sevenDay: outcome.usage.weekAll };
@@ -192,9 +157,6 @@ async function collectClaude(input: { cfg: Config; ping: boolean; pingCount: num
       perModel: Object.fromEntries(Object.entries(perModel).map(([name, w]) => [name, currentWindow(w, true, now)])),
       usageAt: a.lastUsageAt ?? null,
       sample: sampled.outcome.ok ? { ok: true, source: sampled.viaTee ? "statusline" : "probe" } : { ok: false, reason: sampled.outcome.reason },
-      pingError: sampled.outcome.pingError ?? null,
-      pingRejected: sampled.outcome.pingRejected === true,
-      pinged: pings.has(a.accountUuid) && sampled.outcome.ok && sampled.outcome.pingError == null && aggregate != null && aggregate.fiveHour.resetsAt == null,
     };
   });
   return {
@@ -383,18 +345,6 @@ function claudeCard(a: ClaudeStatusAccount, now: number, staleAfterMs: number):
   if (!a.sample.ok) {
     notes.push(...sampleFailedNotes({ cached: a.usage != null || Object.keys(a.perModel).length > 0, usageAt: a.usageAt, reason: a.sample.reason, now }));
   }
-  if (a.pingError != null && a.pingRejected) {
-    const at = a.pingError.indexOf(": ");
-    const head = at >= 0 ? a.pingError.slice(0, at) : a.pingError;
-    const tail = at >= 0 ? a.pingError.slice(at + 2) : "";
-    notes.push({ paint: c.yellow, text: `ping ${head}${tail ? ":" : ""}` });
-    if (tail) notes.push({ paint: c.dim, text: tail });
-  } else if (a.pingError != null) {
-    notes.push({ paint: c.yellow, text: "ping failed (5h timer may not have started):" }, { paint: c.dim, text: a.pingError });
-  }
-  if (a.pinged) {
-    notes.push({ paint: c.dim, text: "pinged - 5h timer started this run; the usage feed lags, re-run status shortly for the fresh window" });
-  }
   return { lines, notes };
 }
 
@@ -415,11 +365,11 @@ function renderClaude(input: { claude: StatusReport["claude"]; codexPooled: bool
   renderGrid(claude.accounts.map((a) => claudeCard(a, now, staleAfterMs)));
 }
 
-export async function cmdStatus(opts: { ping?: boolean; pingCount?: number; json?: boolean; preRender?: () => void } = {}): Promise<number> {
-  const { ping = false, pingCount, json = false } = opts;
+export async function cmdStatus(opts: { json?: boolean; preRender?: () => void } = {}): Promise<number> {
+  const { json = false } = opts;
   const cfg = loadConfig();
   const now = Date.now();
-  const claude = await collectClaude({ cfg, ping, pingCount, now });
+  const claude = await collectClaude({ cfg, now });
   if (!json) {
     opts.preRender?.();
     const at = Date.now();

package/src/lib/sample.ts

@@ -5,15 +5,15 @@ import { readItem, writeItem, deleteItem, liveTarget, parkedTarget, isolatedTarg
 import { credItemFor, paths } from "./paths.ts";
 import { withClaudeRefreshLock } from "./claudelock.ts";
 import { refreshCredential, isAccessTokenExpiring, isDeadCredential, fetchTokenIdentity, describeIdentity, IdentityUnavailableError, InvalidGrantError } from "./oauth.ts";
-import { FullUsageSchema, pingSession, probeUsage } from "./usage.ts";
+import { FullUsageSchema, probeUsage } from "./usage.ts";
 import { loadAccounts } from "./state.ts";
 import { keepRotatedPair } from "./swap.ts";
 import { log } from "./log.ts";
 import { CredentialBlobSchema, TokenIdentitySchema, type Account, type OAuthCreds, type TokenIdentity } from "./types.ts";
 
 const SampleOutcomeSchema = z.discriminatedUnion("ok", [
-  z.object({ ok: z.literal(true), usage: FullUsageSchema, pingError: z.string().optional(), pingRejected: z.boolean().optional() }),
-  z.object({ ok: z.literal(false), reason: z.string(), pingError: z.string().optional(), pingRejected: z.boolean().optional() }),
+  z.object({ ok: z.literal(true), usage: FullUsageSchema }),
+  z.object({ ok: z.literal(false), reason: z.string() }),
 ]);
 export type SampleOutcome = z.infer<typeof SampleOutcomeSchema>;
 
@@ -46,7 +46,7 @@ function refreshPlanFields(account: Account, creds: OAuthCreds): void {
 
 export async function probeParkedUsage(
   account: Account,
-  opts: { ping?: boolean; retries?: number; refreshParked?: boolean; killMs?: number; signal?: AbortSignal } = {},
+  opts: { retries?: number; refreshParked?: boolean; killMs?: number; signal?: AbortSignal } = {},
 ): Promise<SampleOutcome> {
   const backup = parkedTarget(account.keychainItem);
   const parkedRaw = await readItem(backup);
@@ -165,16 +165,8 @@ export async function probeParkedUsage(
   try {
     await writeItem(isoTarget, installed);
     writeFileSync(join(dir, ".claude.json"), JSON.stringify({ oauthAccount: account.oauthAccount, hasCompletedOnboarding: true }));
-    const ping = opts.ping ? await pingSession(dir) : null;
     const usage = await probeUsage(dir, Date.now(), opts);
-    const outcome: SampleOutcome = usage
-      ? { ok: true, usage }
-      : { ok: false, reason: "`/usage` returned no limit data (see log)" };
-    if (ping != null) {
-      outcome.pingError = ping.reason;
-      outcome.pingRejected = ping.rejected;
-    }
-    return outcome;
+    return usage ? { ok: true, usage } : { ok: false, reason: "`/usage` returned no limit data (see log)" };
   } finally {
     try {
       if (opts.refreshParked !== false) {
@@ -211,7 +203,7 @@ export async function ensureLiveTokenFresh(): Promise<void> {
   });
 }
 
-export async function probeActiveUsage(account: Account, opts: { ping?: boolean } = {}): Promise<SampleOutcome> {
+export async function probeActiveUsage(account: Account): Promise<SampleOutcome> {
   try {
     await ensureLiveTokenFresh();
   } catch (e) {
@@ -232,12 +224,6 @@ export async function probeActiveUsage(account: Account, opts: { ping?: boolean
   if (identity.status === "unavailable") return { ok: false, reason: identity.reason };
   refreshPlanFields(account, creds);
 
-  const ping = opts.ping ? await pingSession() : null;
   const usage = await probeUsage();
-  const outcome: SampleOutcome = usage ? { ok: true, usage } : { ok: false, reason: "`/usage` returned no limit data (see log)" };
-  if (ping != null) {
-    outcome.pingError = ping.reason;
-    outcome.pingRejected = ping.rejected;
-  }
-  return outcome;
+  return usage ? { ok: true, usage } : { ok: false, reason: "`/usage` returned no limit data (see log)" };
 }

package/src/lib/usage.ts

@@ -1,10 +1,8 @@
-import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readSync } from "node:fs";
-import { join } from "node:path";
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
 import { delay } from "es-toolkit";
 import { z } from "zod";
 import { MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealClaude } from "./claudebin.ts";
 import { log } from "./log.ts";
-import { paths } from "./paths.ts";
 import { RateLimitsStdinSchema, UsageWindowSchema, type ModelInfo, type UsageWindow, type UsageWindows } from "./types.ts";
 
 export function normalizeResetsAt(v: unknown): number | null {
@@ -285,12 +283,11 @@ type SpawnResult = z.infer<typeof SpawnResultSchema>;
 async function spawnClaudeBounded(
   cmd: string[],
   env: Record<string, string>,
-  cwd?: string,
   killMs = PROBE_KILL_MS,
   signal?: AbortSignal,
 ): Promise<SpawnResult | null> {
   signal?.throwIfAborted();
-  const p = Bun.spawn(cmd, { env, cwd, stdout: "pipe", stderr: "pipe" });
+  const p = Bun.spawn(cmd, { env, stdout: "pipe", stderr: "pipe" });
   const abort = () => p.kill("SIGKILL");
   signal?.addEventListener("abort", abort, { once: true });
   const killer = setTimeout(() => p.kill("SIGKILL"), killMs);
@@ -313,7 +310,7 @@ async function spawnClaudeBounded(
 async function probeUsageOnce(env: Record<string, string>, now: number, killMs: number, signal?: AbortSignal): Promise<FullUsage | null> {
   let out: string;
   try {
-    const r = await spawnClaudeBounded([resolveRealClaude(), "-p", "/usage", "--output-format", "json"], env, undefined, killMs, signal);
+    const r = await spawnClaudeBounded([resolveRealClaude(), "-p", "/usage", "--output-format", "json"], env, killMs, signal);
     if (r === null) {
       log("usage.probe_failed", { err: "output pipes still open after child exit (leaked descendant)" });
       return null;
@@ -364,68 +361,3 @@ export async function probeUsage(configDir?: string, now = Date.now(), opts: { r
     await delay(PROBE_RETRY_DELAYS_MS[Math.min(attempt, PROBE_RETRY_DELAYS_MS.length - 1)]!);
   }
 }
-
-const PING_ARGS = [
-  "-p", "Reply with exactly: ok",
-  "--model", "haiku",
-  "--settings", '{"disableAllHooks":true}',
-  "--output-format", "json",
-];
-
-const PingResultSchema = z.looseObject({ is_error: z.boolean().optional(), result: z.string().optional(), session_id: z.string().optional() });
-
-export const PingFailureSchema = z.object({ reason: z.string(), rejected: z.boolean() });
-export type PingFailure = z.infer<typeof PingFailureSchema>;
-
-export function transcriptSlug(cwd: string): string {
-  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
-}
-
-export function pingTranscriptPath(input: { configDir: string; cwd: string; sessionId: string }): string {
-  return join(input.configDir, "projects", transcriptSlug(input.cwd), `${input.sessionId}.jsonl`);
-}
-
-const LIMIT_LABELS: Record<string, string> = { five_hour: "5h", seven_day: "weekly" };
-
-export function pingRejection(rows: TranscriptRow[]): string | null {
-  const row = rows.findLast((r) => r.isApiErrorMessage === true);
-  if (!row || row.error !== "rate_limit" || row.apiErrorIsTransient === true) return null;
-  const type = row.quotaLimits?.rateLimitType ?? "";
-  if (type === "" && parseErrorBody(row.errorDetails)?.error?.type !== "rate_limit_error") return null;
-  const label = LIMIT_LABELS[type] ?? (type !== "" ? type.replace(/_/g, " ") : "usage");
-  const text = transcriptRowText(row);
-  return `${label} limit${text ? `: ${text}` : ""}`;
-}
-
-export async function pingSession(configDir?: string): Promise<PingFailure | null> {
-  const cwd = join(paths.sampleDir, "ping-cwd");
-  const fail = (reason: string, rejected = false): PingFailure => {
-    log("usage.ping_failed", { dir: configDir ?? "live", rejected, reason: reason.slice(0, 200) });
-    return { reason, rejected };
-  };
-  let r: SpawnResult | null;
-  try {
-    mkdirSync(cwd, { recursive: true });
-    r = await spawnClaudeBounded([resolveRealClaude(), ...PING_ARGS], probeEnv(configDir), cwd);
-  } catch (e) {
-    return fail(e instanceof Error ? e.message : String(e));
-  }
-  if (r === null) return fail("output pipes still open after child exit (leaked descendant)");
-  const parsed = PingResultSchema.safeParse((() => { try { return JSON.parse(r.stdout); } catch { return null; } })());
-  const result = parsed.success ? parsed.data : null;
-  if (r.exitCode === 0 && result?.is_error === false) {
-    log("usage.ping_ok", { dir: configDir ?? "live" });
-    return null;
-  }
-  if (result?.session_id) {
-    const transcript = pingTranscriptPath({ configDir: configDir ?? paths.claudeDir, cwd, sessionId: result.session_id });
-    const rejection = existsSync(transcript) ? pingRejection(readTranscriptTail(transcript)) : null;
-    if (rejection) return fail(`rejected at the ${rejection}`.slice(0, 200), true);
-  }
-  if (r.exitCode !== 0) {
-    const detail = result?.result?.trim() || r.stderr.trim() || r.stdout.trim();
-    return fail(`claude exited ${r.exitCode ?? "on signal"}: ${detail.slice(0, 160)}`);
-  }
-  if (result?.is_error === true) return fail((result.result?.trim() || "request errored").slice(0, 160));
-  return fail(`unrecognized ping output: ${r.stdout.trim().slice(0, 120)}`);
-}

package/src/main.ts

@@ -45,8 +45,7 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing switch --codex")} [sel]  switch the codex pool (takes effect on next codex start)
   ${c.cyan("tokenmaxxing ls")}         list pooled accounts
   ${c.cyan("tokenmaxxing status")}     accounts with 5h / weekly / per-model usage bars
-  ${c.cyan("tokenmaxxing status --ping")} [--count N]  ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh; ${c.cyan("--count N")} pings N randomly picked accounts instead, to stagger the resets; ${c.cyan("xx --ping")} works too
-  ${c.cyan("tokenmaxxing watch")} [seconds]  live status: re-render every N seconds (default 120, never pings)
+  ${c.cyan("tokenmaxxing watch")} [seconds]  live status: re-render every N seconds (default 120)
   ${c.cyan("tokenmaxxing config")} [get|set|unset|tidy]  inspect and edit config.json (bare = effective config with sources)
   ${c.cyan("tokenmaxxing doctor")}     verify the install is intact
   ${c.cyan("tokenmaxxing rename")} [--codex] <sel> <label>
@@ -60,28 +59,6 @@ function printHelp(): void {
 
 let jsonMode = false;
 
-function statusFlags(rest: string[]): { ping: boolean; pingCount: number | undefined } | { error: string } {
-  let ping = false;
-  let pingCount: number | undefined;
-  for (let i = 0; i < rest.length; i++) {
-    const arg = rest[i]!;
-    if (arg === "--ping") {
-      ping = true;
-      continue;
-    }
-    if (arg === "--count") {
-      if (pingCount != null) return { error: "--count may only be given once" };
-      const raw = rest[++i];
-      pingCount = Number(raw);
-      if (!Number.isInteger(pingCount) || pingCount < 1) return { error: `--count needs a positive whole number of accounts, got: ${raw ?? "nothing"}` };
-      continue;
-    }
-    return { error: `unknown status option: ${arg} (status takes --ping and --count N)` };
-  }
-  if (pingCount != null && !ping) return { error: "--count only applies together with --ping" };
-  return { ping, pingCount };
-}
-
 async function main(): Promise<number> {
   if (process.platform !== "darwin" && process.platform !== "linux") {
     console.error(`tokenmaxxing supports macOS and Linux only (this is ${process.platform})`);
@@ -126,15 +103,13 @@ async function main(): Promise<number> {
     case "__session-start": return runSessionStart();
     case "__codex-stop-hook": return runCodexStopHook();
     case undefined:
-    case "status":
-    case "--ping":
-    case "--count": {
-      const flags = statusFlags(sub === "status" ? args.slice(1) : args);
-      if ("error" in flags) {
-        emitError({ json, message: flags.error });
+    case "status": {
+      const extra = args[1];
+      if (extra != null) {
+        emitError({ json, message: `unknown status option: ${extra} (status takes no options)` });
         return 2;
       }
-      return cmdStatus({ ...flags, json });
+      return cmdStatus({ json });
     }
     case "switch": {
       const rest = args.slice(1).filter((a) => a !== "--codex");