tokenmaxxing 0.11.0 → 0.12.0

package/README.md

@@ -40,6 +40,7 @@ claude                  # use claude as always
 | `tokenmaxxing ls` | list pooled accounts |
 | `tokenmaxxing status` | accounts with 5h / weekly usage bars, active + exhausted-until-reset |
 | `tokenmaxxing status --force` | additionally ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh |
+| `tokenmaxxing watch [seconds]` | live status: re-render every N seconds (default 120, floor 30; never pings) |
 | `tokenmaxxing doctor` | verify the supervisor + settings entries survived |
 | `tokenmaxxing rename <sel> <label>` · `rm <sel>` | manage the pool |
 | `tokenmaxxing uninstall` | remove supervisor + settings entries (accounts/credentials kept) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "0.11.0",
+  "version": "0.12.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/status.ts

@@ -22,7 +22,10 @@ import { bar, c, fmtAgo, fmtReset } from "./render.ts";
 import type { FullUsage } from "../lib/usage.ts";
 import type { UsageWindow } from "../lib/types.ts";
 
-export async function cmdStatus(force = false): Promise<number> {
+/** `preRender` runs after sampling, right before the first output line: `watch`
+ *  keeps the previous frame on screen through the multi-second sample and
+ *  clears only when the fresh frame is ready to paint (watch(1) semantics). */
+export async function cmdStatus(force = false, preRender?: () => void): Promise<number> {
   let idx = loadAccounts();
   const cfg = loadConfig();
   const now = Date.now();
@@ -89,6 +92,7 @@ export async function cmdStatus(force = false): Promise<number> {
     saveAccounts(idx);
   });
 
+  preRender?.();
   console.log(c.dim(`threshold 5h ${cfg.thresholds.session}% · week ${cfg.thresholds.weekly}%  ·  ${idx.accounts.length} account(s)`));
   console.log();
 

package/src/cli/watch.ts

@@ -0,0 +1,57 @@
+// `tokenmaxxing watch [seconds]`: native live status (issue #3) - re-render
+// `status` on an interval instead of `watch -n 120 'tokenmaxxing status'`.
+// Plain `status` per tick, never `--force`: a ping meters real quota and starts
+// 5h session windows, so watching must stay free; each refresh costs only the
+// parked accounts' `/usage` probes the one-shot status already does.
+
+import { delay } from "es-toolkit";
+import { loadAccounts } from "../lib/state.ts";
+import { cmdStatus } from "./status.ts";
+import { c } from "./render.ts";
+
+const DEFAULT_INTERVAL_S = 120;
+/** Floor: each tick spawns a `/usage` probe per parked account (seconds each,
+ *  under the flock); anything faster than this just queues probes. */
+const MIN_INTERVAL_S = 30;
+/** Cap: past ~24.8 days the setTimeout ms overflow collapses the sleep to ~1ms
+ *  and the loop runs hot; a day is already beyond any sane watch cadence. */
+const MAX_INTERVAL_S = 86_400;
+
+/** Seconds between refreshes, clamped; null when the argument is not a positive number. */
+export function resolveWatchInterval(arg?: string): number | null {
+  if (arg === undefined) return DEFAULT_INTERVAL_S;
+  const n = Number(arg);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  return Math.min(Math.max(n, MIN_INTERVAL_S), MAX_INTERVAL_S);
+}
+
+/** Home + clear screen + clear scrollback. Written only once the fresh frame is
+ *  ready to paint (cmdStatus preRender), so the previous frame stays readable
+ *  through the multi-second sample instead of blanking - watch(1) semantics. */
+const CLEAR = "\x1b[H\x1b[2J\x1b[3J";
+
+export async function cmdWatch(intervalArg?: string): Promise<number> {
+  const intervalS = resolveWatchInterval(intervalArg);
+  if (intervalS === null) {
+    console.error(c.red(`watch interval must be a positive number of seconds, got: ${intervalArg}`));
+    return 2;
+  }
+  if (loadAccounts().accounts.length === 0) return cmdStatus();
+
+  const paintHeader = () => {
+    process.stdout.write(process.stdout.isTTY ? CLEAR : "\n");
+    console.log(c.dim(`watch · every ${intervalS}s · ${new Date().toLocaleTimeString()} · ctrl-c to quit`));
+  };
+  while (true) {
+    // One failed tick (a mid-write ~/.claude.json read, a transient probe or
+    // lock error) must not kill an hours-long monitor: report it and keep the
+    // cadence, exactly like watch(1) showing a failing command's output.
+    try {
+      await cmdStatus(false, paintHeader);
+    } catch (e) {
+      paintHeader();
+      console.error(c.red(`status failed this tick: ${String((e as Error).message ?? e)}`));
+    }
+    await delay(intervalS * 1000);
+  }
+}

package/src/main.ts

@@ -12,6 +12,7 @@ import { cmdInit } from "./cli/init.ts";
 import { cmdAdd } from "./cli/add.ts";
 import { cmdLs } from "./cli/ls.ts";
 import { cmdStatus } from "./cli/status.ts";
+import { cmdWatch } from "./cli/watch.ts";
 import { cmdDoctor } from "./cli/doctor.ts";
 import { cmdRm } from "./cli/rm.ts";
 import { cmdRename } from "./cli/rename.ts";
@@ -31,6 +32,7 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing ls")}         list pooled accounts
   ${c.cyan("tokenmaxxing status")}     accounts with 5h / weekly / per-model usage bars
   ${c.cyan("tokenmaxxing status --force")}  ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh; ${c.cyan("xx --force")} works too
+  ${c.cyan("tokenmaxxing watch")} [seconds]  live status: re-render every N seconds (default 120, never pings)
   ${c.cyan("tokenmaxxing doctor")}     verify the install is intact
   ${c.cyan("tokenmaxxing rename")} <sel> <label>
   ${c.cyan("tokenmaxxing rm")} <sel>
@@ -65,6 +67,7 @@ async function main(): Promise<number> {
     case "add": return cmdAdd();
     case "ls": return cmdLs();
     case "status": return cmdStatus(args.includes("--force"));
+    case "watch": return cmdWatch(args[1]);
     case "doctor": return cmdDoctor();
     case "rm": return cmdRm(args[1]);
     case "rename": return cmdRename(args[1], args[2]);