tokenmaxxing 1.10.0 → 1.12.0

package/src/cli/doctor.ts

@@ -7,7 +7,7 @@ import { loadAccounts, loadConfig } from "../lib/state.ts";
 import { readItem, liveTarget, parkedTarget } from "../lib/credstore.ts";
 import { isAccessTokenExpiring, fetchTokenOrg } from "../lib/oauth.ts";
 import { CredentialBlobSchema, type RolesResponse } from "../lib/types.ts";
-import { c } from "./render.ts";
+import { c, emitJson } from "./render.ts";
 
 async function blobOrg(raw: string): Promise<RolesResponse | null> {
   const creds = CredentialBlobSchema.parse(JSON.parse(raw)).claudeAiOauth;
@@ -15,11 +15,21 @@ async function blobOrg(raw: string): Promise<RolesResponse | null> {
   return fetchTokenOrg(creds.accessToken);
 }
 
-export async function cmdDoctor(): Promise<number> {
-  let ok = true;
+export async function cmdDoctor(json = false): Promise<number> {
+  const checks: { ok: boolean; label: string; hint: string | null }[] = [];
+  const notes: string[] = [];
+  const warnings: string[] = [];
   const check = (cond: boolean, label: string, hint?: string) => {
-    console.log(`${cond ? c.green("✓") : c.red("✗")} ${label}${!cond && hint ? c.dim(`  - ${hint}`) : ""}`);
-    if (!cond) ok = false;
+    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}`));
   };
 
   check(existsSync(paths.supervisorLink), "claude supervisor wrapper present", "run `tokenmaxxing init`");
@@ -46,7 +56,7 @@ export async function cmdDoctor(): Promise<number> {
     try {
       const org = await blobOrg(live);
       if (org) check(org.organization_uuid === active.organizationUuid, `live credential identity matches active (${active.email})`, `token belongs to ${org.organization_name} - run \`tokenmaxxing switch\``);
-      else console.log(c.dim(`  - live credential identity unverifiable (access token expired)`));
+      else note("live credential identity unverifiable (access token expired)");
     } catch (e) {
       check(false, `live credential identity matches active (${active.email})`, (e instanceof Error ? e.message : String(e)).slice(0, 100));
     }
@@ -59,7 +69,7 @@ export async function cmdDoctor(): Promise<number> {
       try {
         const org = await blobOrg(parked);
         if (org) check(org.organization_uuid === a.organizationUuid, `parked credential identity matches ${a.email}`, `token belongs to ${org.organization_name} - run \`tokenmaxxing auth ${a.label}\``);
-        else console.log(c.dim(`  - ${a.email} identity unverifiable (access token expired)`));
+        else note(`${a.email} identity unverifiable (access token expired)`);
       } catch (e) {
         check(false, `parked credential identity matches ${a.email}`, (e instanceof Error ? e.message : String(e)).slice(0, 100));
       }
@@ -77,11 +87,17 @@ export async function cmdDoctor(): Promise<number> {
   const rc = shellRcPath();
   if (rc && existsSync(rc)) {
     for (const s of findClaudeShadowers(readFileSync(rc, "utf8"))) {
-      if (s.kind === "shadow") console.log(c.yellow(`⚠ ${rc}: \`${s.line}\` shadows the supervised claude wrapper - launches through it skip tokenmaxxing`));
-      else console.log(c.yellow(`⚠ ${rc}: alias \`${s.name}\` hardcodes a claude path and bypasses the supervisor - use plain \`claude\` in its body instead`));
+      if (s.kind === "shadow") warn(`${rc}: ${s.line.startsWith("alias ") ? "alias" : "function"} \`claude\` shadows the supervised claude wrapper - launches through it skip tokenmaxxing`);
+      else warn(`${rc}: alias \`${s.name}\` hardcodes a claude path and bypasses the supervisor - use plain \`claude\` in its body instead`);
     }
   }
 
+  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;

package/src/cli/ls.ts

@@ -1,10 +1,45 @@
 import { loadAccounts } from "../lib/state.ts";
 import { loadCodexAccounts } from "../lib/codexstate.ts";
 import { liveCodexAccountId } from "../lib/codexsample.ts";
-import { c, claudeTierLabel } from "./render.ts";
+import { c, claudeTierLabel, emitJson } from "./render.ts";
 
-export function cmdLs(): number {
+export function cmdLs(json = false): number {
   const idx = loadAccounts();
+
+  if (json) {
+    const codex = loadCodexAccounts();
+    const liveId = codex.accounts.length > 0 ? liveCodexAccountId() : null;
+    emitJson({
+      ok: true,
+      claude: {
+        activeAccountUuid: idx.activeAccountUuid,
+        accounts: idx.accounts.map((a) => ({
+          label: a.label,
+          email: a.email,
+          accountUuid: a.accountUuid,
+          organizationUuid: a.organizationUuid,
+          tier: claudeTierLabel(a),
+          active: a.accountUuid === idx.activeAccountUuid,
+          needsReauth: a.needsReauth === true,
+          addedAt: a.addedAt,
+        })),
+      },
+      codex: {
+        activeAccountId: liveId,
+        accounts: codex.accounts.map((account) => ({
+          label: account.label,
+          email: account.email,
+          accountId: account.accountId,
+          planType: account.planType,
+          active: account.accountId === liveId,
+          needsReauth: account.needsReauth === true,
+          addedAt: account.addedAt,
+        })),
+      },
+    });
+    return 0;
+  }
+
   if (idx.accounts.length === 0) {
     console.log(c.dim("no accounts yet - run `tokenmaxxing init` then `tokenmaxxing add`"));
   }

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

package/src/cli/render.ts

@@ -75,3 +75,23 @@ export function fmtAgo(epochMs: number, now = Date.now()): string {
   return `${m}m ago`;
 }
 
+export const plain = (s: string): string => s;
+
+export function emitJson(value: unknown): void {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+export function emitError(input: {
+  json: boolean;
+  message: string;
+  notes?: string[];
+  extra?: Record<string, unknown>;
+  paint?: (s: string) => string;
+}): void {
+  if (input.json) {
+    emitJson({ ok: false, error: input.message, ...input.extra });
+    return;
+  }
+  console.error((input.paint ?? c.red)(input.message));
+  for (const note of input.notes ?? []) console.error(c.dim(note));
+}

package/src/cli/rm.ts

@@ -7,22 +7,22 @@ import { credItemFor, paths } from "../lib/paths.ts";
 import { loadAccounts, saveAccounts } from "../lib/state.ts";
 import { CredentialBlobSchema } from "../lib/types.ts";
 import { findAccount } from "./rename.ts";
-import { c } from "./render.ts";
+import { c, emitError, emitJson, plain } from "./render.ts";
 
-export async function cmdRm(selector?: string): Promise<number> {
+export async function cmdRm(selector?: string, json = false): Promise<number> {
   if (!selector) {
-    console.error("usage: tokenmaxxing rm <email|label|uuid>");
+    emitError({ json, 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) {
-      console.error(c.red(`no account matches "${selector}"`));
+      emitError({ json, message: `no account matches "${selector}"` });
       return 1;
     }
     if (a.accountUuid === idx.activeAccountUuid) {
-      console.error(c.red(`${a.email} is the ACTIVE account - switch away before removing it.`));
+      emitError({ json, message: `${a.email} is the ACTIVE account - switch away before removing it.` });
       return 1;
     }
     const live = await readItem(liveTarget());
@@ -32,11 +32,14 @@ export async function cmdRm(selector?: string): Promise<number> {
         const liveCreds = CredentialBlobSchema.parse(JSON.parse(live)).claudeAiOauth;
         liveOrg = (await fetchTokenOrg(liveCreds.accessToken)).organization_uuid;
       } catch (e) {
-        console.error(c.red(`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 roles endpoint is reachable.`));
+        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 roles endpoint is reachable.`,
+        });
         return 1;
       }
       if (liveOrg === a.organizationUuid) {
-        console.error(c.red(`${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({ 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.` });
         return 1;
       }
     }
@@ -46,7 +49,8 @@ export async function cmdRm(selector?: string): Promise<number> {
     rmSync(sampleDir, { recursive: true, force: true });
     idx.accounts = idx.accounts.filter((x) => x.accountUuid !== a.accountUuid);
     saveAccounts(idx);
-    console.log(`removed ${c.bold(a.label)} from the pool (${idx.accounts.length} left)`);
+    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)`);
     return 0;
   });
 }