tokenmaxxing 1.33.0 → 1.34.0

package/README.md

@@ -76,7 +76,7 @@ claude                  # use claude as always
 | `tokenmaxxing setup-token [--print \| rm <label\|uuid>]` | Cursor Cloud only: mint one `claude setup-token` per pooled account (a browser sign-in each) and print the `TOKENMAXXING_TOKENS` secret value; `--print` prints the stored set, `rm` drops one |
 | `tokenmaxxing cursor init [dir]` | write the Claude relay subagent and `.cursor/environment.json` into a repo |
 | `tokenmaxxing cloud run [--session <id>] [--max-turns <n>] "<prompt>"` | on a Cursor Cloud VM: run `claude -p` on a setup token, rotate to the next token on a usage limit |
-| `--json` | machine-readable output: one JSON document on stdout for `status`, `config`, `doctor`, `check`, `switch`, `rename`, `rm`, `uninstall`, `setup-token --print`, `cursor init`, and `cloud run` (`ok` mirrors the exit code, failures add `error`) |
+| `--json` | machine-readable output: one JSON document on stdout for `status`, `config`, `check`, and `switch` (`ok` mirrors the exit code, failures add `error`) |
 
 ## How switching decides
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.33.0",
+  "version": "1.34.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/cloudrun.ts

@@ -12,7 +12,7 @@ import {
   spawnCloudClaude,
   transcriptBytes,
 } from "../lib/cloud.ts";
-import { c, emitError, emitJson, fmtReset } from "./render.ts";
+import { c, emitError, fmtReset } from "./render.ts";
 
 const USAGE = "usage: tokenmaxxing cloud run [--session <id>] [--max-turns <n>] \"<prompt>\" (the prompt is also read from stdin)";
 
@@ -39,15 +39,15 @@ function parseFlags(args: string[]): { session: string | null; maxTurns: number
   return { session, maxTurns, prompt: positional.length > 0 ? positional.join(" ") : null };
 }
 
-export async function cmdCloudRun(args: string[], json = false): Promise<number> {
+export async function cmdCloudRun(args: string[]): Promise<number> {
   const flags = parseFlags(args);
   if ("error" in flags) {
-    emitError({ json, message: `${flags.error} - ${USAGE}` });
+    emitError({ message: `${flags.error} - ${USAGE}` });
     return 2;
   }
   const prompt = flags.prompt ?? (process.stdin.isTTY ? null : await Bun.stdin.text());
   if (prompt == null || prompt.trim() === "") {
-    emitError({ json, message: USAGE });
+    emitError({ message: USAGE });
     return 2;
   }
   const tokens = readCloudTokens();
@@ -61,11 +61,7 @@ export async function cmdCloudRun(args: string[], json = false): Promise<number>
       return picked;
     });
     if (!pick.ok) {
-      emitError({
-        json,
-        message: `every token is at its limit - earliest ${fmtReset(pick.earliestReset)}`,
-        extra: { earliestReset: pick.earliestReset, session_id: sessionId },
-      });
+      emitError({ message: `every token is at its limit - earliest ${fmtReset(pick.earliestReset)}` });
       return 1;
     }
     const label = pick.token.label;
@@ -99,17 +95,11 @@ export async function cmdCloudRun(args: string[], json = false): Promise<number>
       }
       const errors = result.subtype === "success" ? [result.result] : result.errors;
       emitError({
-        json,
         message: `claude exited ${exitCode ?? "on signal"} (${result.subtype}): ${errors.join("; ")}`,
         notes: [`session ${result.session_id}`],
-        extra: { session_id: result.session_id, subtype: result.subtype, errors },
       });
       return 1;
     }
-    if (json) {
-      emitJson({ ok: true, session_id: result.session_id, result: result.result, num_turns: result.num_turns, total_cost_usd: result.total_cost_usd });
-      return 0;
-    }
     console.log(result.result);
     console.log(`session ${result.session_id}`);
     return 0;

package/src/cli/codexrm.ts

@@ -5,33 +5,32 @@ import { deleteParkedCodexAuth } from "../lib/codexauth.ts";
 import { liveCodexAccountId } from "../lib/codexsample.ts";
 import { presentCodexAccountIds } from "../lib/codexpresence.ts";
 import { findCodexAccount } from "./rename.ts";
-import { c, emitError, emitJson, plain } from "./render.ts";
+import { c, emitError, plain } from "./render.ts";
 
-export async function cmdCodexRm(selector?: string, json = false): Promise<number> {
+export async function cmdCodexRm(selector?: string): Promise<number> {
   if (!selector) {
-    emitError({ json, message: "usage: tokenmaxxing rm --codex <email|label|id>", paint: plain });
+    emitError({ message: "usage: tokenmaxxing rm --codex <email|label|id>", paint: plain });
     return 2;
   }
   return withLock(codexPaths.lockFile, async () => {
     const index = loadCodexAccounts();
     const account = findCodexAccount(index.accounts, selector);
     if (!account) {
-      emitError({ json, message: `no codex account matches "${selector}"` });
+      emitError({ message: `no codex account matches "${selector}"` });
       return 1;
     }
     if (liveCodexAccountId() === account.accountId) {
-      emitError({ json, message: `${account.label} is the LIVE codex account - run \`tokenmaxxing switch --codex\` to move off it first.` });
+      emitError({ message: `${account.label} is the LIVE codex account - run \`tokenmaxxing switch --codex\` to move off it first.` });
       return 1;
     }
     if (presentCodexAccountIds().has(account.accountId)) {
-      emitError({ json, message: `${account.label} is running in a live codex session - close that session before removing it.` });
+      emitError({ message: `${account.label} is running in a live codex session - close that session before removing it.` });
       return 1;
     }
     deleteParkedCodexAuth({ credFile: account.credFile });
     index.accounts = index.accounts.filter((x) => x.accountId !== account.accountId);
     saveCodexAccounts({ index });
-    if (json) emitJson({ ok: true, pool: "codex", removed: account.label, remaining: index.accounts.length });
-    else console.log(`removed codex account ${c.bold(account.label)} from the pool (${index.accounts.length} left)`);
+    console.log(`removed codex account ${c.bold(account.label)} from the pool (${index.accounts.length} left)`);
     return 0;
   });
 }

package/src/cli/cursorinit.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "../lib/atomic.ts";
-import { c, emitError, emitJson } from "./render.ts";
+import { c, emitError } from "./render.ts";
 
 export const CLOUD_INSTALL_LINE =
   'curl -fsSL https://bun.sh/install | bash && curl -fsSL https://claude.ai/install.sh | bash && "$HOME/.bun/bin/bun" add -g tokenmaxxing && test -x "$HOME/.bun/bin/bun" && test -x "$HOME/.local/bin/claude" && test -e "$HOME/.bun/bin/tokenmaxxing"';
@@ -42,14 +42,14 @@ const ExistingEnvironmentSchema = z.looseObject({ user: z.string().optional() })
 const REPO_FILE_MODE = 0o644;
 const USAGE = "usage: tokenmaxxing cursor init [dir]";
 
-export function cmdCursorInit(args: string[], json = false): number {
+export function cmdCursorInit(args: string[]): number {
   if (args.length > 1) {
-    emitError({ json, message: USAGE });
+    emitError({ message: USAGE });
     return 2;
   }
   const dir = resolve(args[0] ?? ".");
   if (!existsSync(dir)) {
-    emitError({ json, message: `no such directory: ${dir}` });
+    emitError({ message: `no such directory: ${dir}` });
     return 1;
   }
   const agentFile = join(dir, ".cursor", "agents", "claude.md");
@@ -64,10 +64,6 @@ export function cmdCursorInit(args: string[], json = false): number {
   } else if (existing.user === "root" || existing.user === "0") {
     warnings.push(".cursor/environment.json sets user to root; Claude Code refuses --dangerously-skip-permissions under root, so every relay call fails until user is a non-root account");
   }
-  if (json) {
-    emitJson({ ok: true, dir, agent, environment, install: CLOUD_INSTALL_LINE, warnings });
-    return 0;
-  }
   console.log(`${c.green("✓")} .cursor/agents/claude.md ${agent}`);
   if (environment === "written") {
     console.log(`${c.green("✓")} .cursor/environment.json written`);

package/src/cli/doctor.ts

@@ -8,7 +8,7 @@ import { readItem, liveTarget, parkedTarget } from "../lib/credstore.ts";
 import { isAccessTokenExpiring, fetchTokenIdentity, describeIdentity } from "../lib/oauth.ts";
 import { CredentialBlobSchema, type TokenIdentity } from "../lib/types.ts";
 import { SETUP_TOKEN_STALE_MS, loadSetupTokens } from "../lib/setuptokens.ts";
-import { c, emitJson, fmtAgo } from "./render.ts";
+import { c, fmtAgo } from "./render.ts";
 
 async function blobIdentity(raw: string): Promise<TokenIdentity | null> {
   const creds = CredentialBlobSchema.parse(JSON.parse(raw)).claudeAiOauth;
@@ -16,22 +16,14 @@ async function blobIdentity(raw: string): Promise<TokenIdentity | null> {
   return fetchTokenIdentity(creds.accessToken);
 }
 
-export async function cmdDoctor(json = false): Promise<number> {
-  const checks: { ok: boolean; label: string; hint: string | null }[] = [];
-  const notes: string[] = [];
-  const warnings: string[] = [];
+export async function cmdDoctor(): Promise<number> {
+  let failed = 0;
   const check = (cond: boolean, label: string, hint?: string) => {
-    checks.push({ ok: cond, label, hint: cond ? null : (hint ?? null) });
-    if (!json) console.log(`${cond ? c.green("✓") : c.red("✗")} ${label}${!cond && hint ? c.dim(`  - ${hint}`) : ""}`);
-  };
-  const note = (text: string) => {
-    notes.push(text);
-    if (!json) console.log(c.dim(`  - ${text}`));
-  };
-  const warn = (text: string) => {
-    warnings.push(text);
-    if (!json) console.log(c.yellow(`⚠ ${text}`));
+    if (!cond) failed++;
+    console.log(`${cond ? c.green("✓") : c.red("✗")} ${label}${!cond && hint ? c.dim(`  - ${hint}`) : ""}`);
   };
+  const note = (text: string) => console.log(c.dim(`  - ${text}`));
+  const warn = (text: string) => console.log(c.yellow(`⚠ ${text}`));
 
   check(existsSync(paths.supervisorLink), "claude supervisor wrapper present", "run `tokenmaxxing init`");
   check(existsSync(installedBin()), "tokenmaxxing binary installed", "run `tokenmaxxing init`");
@@ -102,13 +94,7 @@ export async function cmdDoctor(json = false): Promise<number> {
     }
   }
 
-  const failed = checks.filter((entry) => !entry.ok).length;
-  const ok = failed === 0;
-  if (json) {
-    emitJson(ok ? { ok, checks, notes, warnings } : { ok, error: `issues found - ${failed} of ${checks.length} checks failed`, checks, notes, warnings });
-    return ok ? 0 : 1;
-  }
   console.log();
-  console.log(ok ? c.green("all good ✓") : c.yellow("issues found - see above"));
-  return ok ? 0 : 1;
+  console.log(failed === 0 ? c.green("all good ✓") : c.yellow("issues found - see above"));
+  return failed === 0 ? 0 : 1;
 }

package/src/cli/rename.ts

@@ -2,7 +2,7 @@ import { withLock } from "../lib/lock.ts";
 import { codexPaths, paths } from "../lib/paths.ts";
 import { loadAccounts, saveAccounts } from "../lib/state.ts";
 import { loadCodexAccounts, saveCodexAccounts } from "../lib/codexstate.ts";
-import { c, emitError, emitJson, plain } from "./render.ts";
+import { c, emitError, plain } from "./render.ts";
 import type { Account, CodexAccount } from "../lib/types.ts";
 
 export function findAccount(accounts: Account[], selector: string): Account | undefined {
@@ -23,54 +23,52 @@ export function findCodexAccount(accounts: CodexAccount[], selector: string): Co
   );
 }
 
-async function renameCodexAccount(input: { selector: string; newLabel: string; json: boolean }): Promise<number> {
-  const { selector, newLabel, json } = input;
+async function renameCodexAccount(input: { selector: string; newLabel: string }): Promise<number> {
+  const { selector, newLabel } = input;
   return withLock(codexPaths.lockFile, async () => {
     const index = loadCodexAccounts();
     const account = findCodexAccount(index.accounts, selector);
     if (!account) {
-      emitError({ json, message: `no codex account matches "${selector}"` });
+      emitError({ message: `no codex account matches "${selector}"` });
       return 1;
     }
     const taken = index.accounts.find((x) => x.accountId !== account.accountId && x.label.toLowerCase() === newLabel.toLowerCase());
     if (taken) {
-      emitError({ json, message: `label "${newLabel}" is already used by ${taken.accountId.slice(0, 8)} - labels must be unique within the pool` });
+      emitError({ message: `label "${newLabel}" is already used by ${taken.accountId.slice(0, 8)} - labels must be unique within the pool` });
       return 1;
     }
     const old = account.label;
     account.label = newLabel;
     saveCodexAccounts({ index });
-    if (json) emitJson({ ok: true, pool: "codex", from: old, to: newLabel });
-    else console.log(`renamed codex account ${c.dim(old)} → ${c.bold(newLabel)}`);
+    console.log(`renamed codex account ${c.dim(old)} → ${c.bold(newLabel)}`);
     return 0;
   });
 }
 
-export async function cmdRename(argv: string[], json = false): Promise<number> {
+export async function cmdRename(argv: string[]): Promise<number> {
   const codex = argv.includes("--codex");
   const [selector, newLabel] = argv.filter((a) => a !== "--codex");
   if (!selector || !newLabel) {
-    emitError({ json, message: "usage: tokenmaxxing rename [--codex] <email|label|id> <new-label>", paint: plain });
+    emitError({ message: "usage: tokenmaxxing rename [--codex] <email|label|id> <new-label>", paint: plain });
     return 2;
   }
-  if (codex) return renameCodexAccount({ selector, newLabel, json });
+  if (codex) return renameCodexAccount({ selector, newLabel });
   return withLock(paths.lockFile, async () => {
     const idx = loadAccounts();
     const a = findAccount(idx.accounts, selector);
     if (!a) {
-      emitError({ json, message: `no claude account matches "${selector}" (codex accounts rename via --codex)` });
+      emitError({ message: `no claude account matches "${selector}" (codex accounts rename via --codex)` });
       return 1;
     }
     const taken = idx.accounts.find((x) => x.accountUuid !== a.accountUuid && x.label.toLowerCase() === newLabel.toLowerCase());
     if (taken) {
-      emitError({ json, message: `label "${newLabel}" is already used by ${taken.email} - labels must be unique within the pool` });
+      emitError({ message: `label "${newLabel}" is already used by ${taken.email} - labels must be unique within the pool` });
       return 1;
     }
     const old = a.label;
     a.label = newLabel;
     saveAccounts(idx);
-    if (json) emitJson({ ok: true, pool: "claude", from: old, to: newLabel });
-    else console.log(`renamed ${c.dim(old)} → ${c.bold(newLabel)}`);
+    console.log(`renamed ${c.dim(old)} → ${c.bold(newLabel)}`);
     return 0;
   });
 }

package/src/cli/render.ts

@@ -82,7 +82,7 @@ export function emitJson(value: unknown): void {
 }
 
 export function emitError(input: {
-  json: boolean;
+  json?: boolean;
   message: string;
   notes?: string[];
   extra?: Record<string, unknown>;

package/src/cli/rm.ts

@@ -8,22 +8,22 @@ import { loadSetupTokens, saveSetupTokens } from "../lib/setuptokens.ts";
 import { loadAccounts, saveAccounts } from "../lib/state.ts";
 import { CredentialBlobSchema } from "../lib/types.ts";
 import { findAccount } from "./rename.ts";
-import { c, emitError, emitJson, plain } from "./render.ts";
+import { c, emitError, plain } from "./render.ts";
 
-export async function cmdRm(selector?: string, json = false): Promise<number> {
+export async function cmdRm(selector?: string): Promise<number> {
   if (!selector) {
-    emitError({ json, message: "usage: tokenmaxxing rm <email|label|uuid>", paint: plain });
+    emitError({ message: "usage: tokenmaxxing rm <email|label|uuid>", paint: plain });
     return 2;
   }
   return withLock(paths.lockFile, async () => {
     const idx = loadAccounts();
     const a = findAccount(idx.accounts, selector);
     if (!a) {
-      emitError({ json, message: `no account matches "${selector}"` });
+      emitError({ message: `no account matches "${selector}"` });
       return 1;
     }
     if (a.accountUuid === idx.activeAccountUuid) {
-      emitError({ json, message: `${a.email} is the ACTIVE account - switch away before removing it.` });
+      emitError({ message: `${a.email} is the ACTIVE account - switch away before removing it.` });
       return 1;
     }
     const live = await readItem(liveTarget());
@@ -34,13 +34,12 @@ export async function cmdRm(selector?: string, json = false): Promise<number> {
         liveAccount = (await fetchTokenIdentity(liveCreds.accessToken)).accountUuid;
       } catch (e) {
         emitError({
-          json,
           message: `cannot verify which account the LIVE credential belongs to (${e instanceof Error ? e.message : String(e)}) - refusing to remove while the live owner is unknown; repair the live credential or retry once the profile endpoint is reachable.`,
         });
         return 1;
       }
       if (liveAccount === a.accountUuid) {
-        emitError({ json, message: `${a.email}'s credential is currently LIVE (the active label is stale - a manual /login drifted it); run \`tokenmaxxing switch\` to move off it first.` });
+        emitError({ message: `${a.email}'s credential is currently LIVE (the active label is stale - a manual /login drifted it); run \`tokenmaxxing switch\` to move off it first.` });
         return 1;
       }
     }
@@ -56,8 +55,7 @@ export async function cmdRm(selector?: string, json = false): Promise<number> {
     if (setupTokens.tokens.some((t) => t.accountUuid === a.accountUuid)) {
       saveSetupTokens({ ...setupTokens, tokens: setupTokens.tokens.filter((t) => t.accountUuid !== a.accountUuid) });
     }
-    if (json) emitJson({ ok: true, pool: "claude", removed: a.label, remaining: idx.accounts.length });
-    else console.log(`removed ${c.bold(a.label)} from the pool (${idx.accounts.length} left)`);
+    console.log(`removed ${c.bold(a.label)} from the pool (${idx.accounts.length} left)`);
     return 0;
   });
 }

package/src/cli/setuptoken.ts

@@ -7,7 +7,7 @@ import { loadAccounts } from "../lib/state.ts";
 import { scrubCredentialEnv } from "../lib/usage.ts";
 import { CURSOR_SECRET_VALUE_CAP_BYTES, cursorSecretValue, loadSetupTokens, saveSetupTokens, type SetupToken } from "../lib/setuptokens.ts";
 import type { Account } from "../lib/types.ts";
-import { c, emitError, emitJson } from "./render.ts";
+import { c, emitError } from "./render.ts";
 
 const TOKEN_BEGIN_MARKER = "Your OAuth token (valid for";
 const TOKEN_END_MARKER = "Store this token securely";
@@ -58,7 +58,7 @@ function currentTokens(tokens: SetupToken[], accounts: Account[]): { label: stri
   });
 }
 
-async function rmToken(selector: string, json: boolean): Promise<number> {
+async function rmToken(selector: string): Promise<number> {
   const outcome = await withLock(paths.lockFile, async (): Promise<{ error: string } | { kept: SetupToken[] }> => {
     const store = loadSetupTokens();
     const accounts = loadAccounts().accounts;
@@ -74,35 +74,26 @@ async function rmToken(selector: string, json: boolean): Promise<number> {
     return { kept };
   });
   if ("error" in outcome) {
-    emitError({ json, message: outcome.error });
+    emitError({ message: outcome.error });
     return 1;
   }
-  const remaining = outcome.kept;
-  if (json) {
-    emitJson({ ok: true, removed: selector, remaining: remaining.map((t) => t.label) });
-    return 0;
-  }
   console.log(`removed the setup token for ${selector} (local only: Claude Code documents no revocation for setup tokens)`);
   return 0;
 }
 
-export async function cmdSetupToken(args: string[], json = false): Promise<number> {
+export async function cmdSetupToken(args: string[]): Promise<number> {
   const [sub, label] = args;
-  if (sub === "rm" && label !== undefined && args.length === 2) return rmToken(label, json);
+  if (sub === "rm" && label !== undefined && args.length === 2) return rmToken(label);
   const print = sub === "--print" && args.length === 1;
   if (args.length > 0 && !print) {
-    emitError({ json, message: USAGE });
-    return 2;
-  }
-  if (json && !print) {
-    emitError({ json, message: "setup-token mints through a browser login flow and has no --json form; `setup-token --print --json` prints the stored set" });
+    emitError({ message: USAGE });
     return 2;
   }
   let store = loadSetupTokens();
   let idx = loadAccounts();
   if (!print) {
     if (idx.accounts.length === 0) {
-      emitError({ json, message: "no accounts in the pool - run `tokenmaxxing init` first" });
+      emitError({ message: "no accounts in the pool - run `tokenmaxxing init` first" });
       return 1;
     }
     const real = resolveRealClaude();
@@ -130,7 +121,7 @@ export async function cmdSetupToken(args: string[], json = false): Promise<numbe
     idx = loadAccounts();
   }
   if (store.tokens.length === 0) {
-    emitError({ json, message: "no setup tokens stored - run `tokenmaxxing setup-token` to mint them" });
+    emitError({ message: "no setup tokens stored - run `tokenmaxxing setup-token` to mint them" });
     return 1;
   }
   const tokens = currentTokens(store.tokens, idx.accounts);
@@ -138,15 +129,11 @@ export async function cmdSetupToken(args: string[], json = false): Promise<numbe
     .filter((t) => !idx.accounts.some((a) => a.accountUuid === t.accountUuid))
     .map((t) => ({ label: t.label, accountUuid: t.accountUuid }));
   if (tokens.length === 0) {
-    emitError({ json, message: "no stored setup token belongs to a pooled account - run `tokenmaxxing setup-token` to mint them" });
+    emitError({ message: "no stored setup token belongs to a pooled account - run `tokenmaxxing setup-token` to mint them" });
     return 1;
   }
   const secret = cursorSecretValue(tokens);
   const bytes = Buffer.byteLength(secret);
-  if (json) {
-    emitJson({ ok: true, tokens, orphaned, bytes, cap: CURSOR_SECRET_VALUE_CAP_BYTES });
-    return 0;
-  }
   console.log();
   if (orphaned.length > 0) {
     console.log(c.dim(`left out of the secret (no longer in the pool): ${orphaned.map((t) => `${t.label} (${t.accountUuid})`).join(", ")}; \`setup-token rm <label|uuid>\` drops one`));

package/src/main.ts

@@ -27,11 +27,11 @@ import { cmdSetupToken } from "./cli/setuptoken.ts";
 import { cmdCloudRun } from "./cli/cloudrun.ts";
 import { cmdCursorInit } from "./cli/cursorinit.ts";
 import { timerDeactivationHint, uninstallSupervisor } from "./lib/install.ts";
-import { c, emitError, emitJson } from "./cli/render.ts";
+import { c, emitError } from "./cli/render.ts";
 
 const JSON_FLAG = "--json";
 const CACHED_FLAG = "--cached";
-const INTERACTIVE_COMMANDS = new Set(["init", "add", "auth"]);
+const JSON_COMMANDS = new Set(["status", "config", "check", "switch"]);
 
 function printHelp(): void {
   console.log(`${c.bold("tokenmaxxing")} - automatic Claude Code account switching
@@ -55,7 +55,7 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing cursor init")} [dir]  write the Claude relay subagent (.cursor/agents/claude.md) and .cursor/environment.json into a repo
   ${c.cyan("tokenmaxxing cloud run")} [--session <id>] [--max-turns <n>] "<prompt>"  on a Cursor Cloud VM: run claude -p on a setup token from TOKENMAXXING_TOKENS, rotate to the next token on a usage limit
 
-  ${c.cyan("--json")}                  print one JSON document on stdout instead of text (status, config, doctor, check, switch, rename, rm, uninstall, setup-token --print, cursor init, cloud run); every document carries ${c.bold("ok")}, failures add ${c.bold("error")}
+  ${c.cyan("--json")}                  print one JSON document on stdout instead of text (status, config, check, switch); every document carries ${c.bold("ok")}, failures add ${c.bold("error")}
 
   ${c.dim("(aliased as")} ${c.cyan("xx")}${c.dim(")")} - then just run ${c.bold("claude")} as always; it switches accounts near quota automatically.`);
 }
@@ -88,8 +88,8 @@ async function main(): Promise<number> {
     return 2;
   }
 
-  if (json && sub != null && INTERACTIVE_COMMANDS.has(sub)) {
-    emitError({ json, message: `${sub} is interactive (it runs a login flow) and has no --json form` });
+  if (json && sub != null && !JSON_COMMANDS.has(sub)) {
+    emitError({ json, message: `${sub} has no ${JSON_FLAG} form (${JSON_FLAG} applies to ${[...JSON_COMMANDS].join(", ")})` });
     return 2;
   }
   if (!(sub != null && sub.startsWith("__")) && !process.env.TOKENMAXXING_PROBE) {
@@ -135,21 +135,21 @@ async function main(): Promise<number> {
     case "init": return args.includes("--codex") ? cmdCodexInit() : cmdInit();
     case "add": return args.includes("--codex") ? cmdCodexAdd() : cmdAdd();
     case "auth": return cmdAuth(args.slice(1));
-    case "doctor": return cmdDoctor(json);
+    case "doctor": return cmdDoctor();
     case "rm": {
       const rest = args.slice(1).filter((a) => a !== "--codex");
-      return args.includes("--codex") ? cmdCodexRm(rest[0], json) : cmdRm(rest[0], json);
+      return args.includes("--codex") ? cmdCodexRm(rest[0]) : cmdRm(rest[0]);
     }
-    case "rename": return cmdRename(args.slice(1), json);
-    case "setup-token": return cmdSetupToken(args.slice(1), json);
+    case "rename": return cmdRename(args.slice(1));
+    case "setup-token": return cmdSetupToken(args.slice(1));
     case "cursor": {
-      if (args[1] === "init") return cmdCursorInit(args.slice(2), json);
-      emitError({ json, message: "usage: tokenmaxxing cursor init [dir]" });
+      if (args[1] === "init") return cmdCursorInit(args.slice(2));
+      emitError({ message: "usage: tokenmaxxing cursor init [dir]" });
       return 2;
     }
     case "cloud": {
-      if (args[1] === "run") return cmdCloudRun(args.slice(2), json);
-      emitError({ json, message: 'usage: tokenmaxxing cloud run [--session <id>] [--max-turns <n>] "<prompt>"' });
+      if (args[1] === "run") return cmdCloudRun(args.slice(2));
+      emitError({ message: 'usage: tokenmaxxing cloud run [--session <id>] [--max-turns <n>] "<prompt>"' });
       return 2;
     }
     case "uninstall": {
@@ -160,10 +160,6 @@ async function main(): Promise<number> {
         ...(out.timerDeactivated ? ["check timer"] : []),
         ...(out.pathLineRemoved ? ["rc PATH line"] : []),
       ];
-      if (json) {
-        emitJson({ ok: true, removed, timerDeactivated: out.timerDeactivated, pathLineRemoved: out.pathLineRemoved });
-        return 0;
-      }
       console.log(`removed ${removed.join(", ")}`);
       if (!out.timerDeactivated) console.log(c.yellow(`⚠ the check job may still be loaded - run: ${timerDeactivationHint()}`));
       if (!out.pathLineRemoved) console.log(c.dim("(no tokenmaxxing PATH line found in the shell rc)"));
@@ -176,8 +172,8 @@ async function main(): Promise<number> {
       printHelp();
       return 0;
     default:
-      emitError({ json, message: `unknown command: ${sub}` });
-      if (!json) printHelp();
+      emitError({ message: `unknown command: ${sub}` });
+      printHelp();
       return 2;
   }
 }