tokenmaxxing 1.34.0 → 1.35.0

package/src/cli/rename.ts

@@ -1,73 +1,39 @@
 import { withLock } from "../lib/lock.ts";
-import { codexPaths, paths } from "../lib/paths.ts";
+import type { Provider } from "../lib/provider.ts";
 import { loadAccounts, saveAccounts } from "../lib/state.ts";
-import { loadCodexAccounts, saveCodexAccounts } from "../lib/codexstate.ts";
 import { c, emitError, plain } from "./render.ts";
-import type { Account, CodexAccount } from "../lib/types.ts";
+import type { Account } from "../lib/types.ts";
 
 export function findAccount(accounts: Account[], selector: string): Account | undefined {
-  const s = selector.toLowerCase();
-  return (
-    accounts.find((a) => a.email.toLowerCase() === s) ??
-    accounts.find((a) => a.label.toLowerCase() === s) ??
-    accounts.find((a) => a.accountUuid.toLowerCase().startsWith(s))
-  );
-}
-
-export function findCodexAccount(accounts: CodexAccount[], selector: string): CodexAccount | undefined {
   const s = selector.toLowerCase();
   return (
     accounts.find((a) => a.email?.toLowerCase() === s) ??
     accounts.find((a) => a.label.toLowerCase() === s) ??
-    accounts.find((a) => a.accountId.toLowerCase().startsWith(s))
+    accounts.find((a) => a.id.toLowerCase().startsWith(s))
   );
 }
 
-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({ 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({ 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 });
-    console.log(`renamed codex account ${c.dim(old)} → ${c.bold(newLabel)}`);
-    return 0;
-  });
-}
-
-export async function cmdRename(argv: string[]): Promise<number> {
-  const codex = argv.includes("--codex");
-  const [selector, newLabel] = argv.filter((a) => a !== "--codex");
+export async function cmdRename(p: Provider, argv: string[]): Promise<number> {
+  const [selector, newLabel] = argv;
   if (!selector || !newLabel) {
     emitError({ message: "usage: tokenmaxxing rename [--codex] <email|label|id> <new-label>", paint: plain });
     return 2;
   }
-  if (codex) return renameCodexAccount({ selector, newLabel });
-  return withLock(paths.lockFile, async () => {
-    const idx = loadAccounts();
+  return withLock(p.pool.lockFile, async () => {
+    const idx = loadAccounts(p.pool);
     const a = findAccount(idx.accounts, selector);
     if (!a) {
-      emitError({ message: `no claude account matches "${selector}" (codex accounts rename via --codex)` });
+      emitError({ message: `no ${p.name} account matches "${selector}"` });
       return 1;
     }
-    const taken = idx.accounts.find((x) => x.accountUuid !== a.accountUuid && x.label.toLowerCase() === newLabel.toLowerCase());
+    const taken = idx.accounts.find((x) => x.id !== a.id && x.label.toLowerCase() === newLabel.toLowerCase());
     if (taken) {
-      emitError({ 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 ?? taken.id.slice(0, 8)} - labels must be unique within the pool` });
       return 1;
     }
     const old = a.label;
     a.label = newLabel;
-    saveAccounts(idx);
+    saveAccounts(p.pool, idx);
     console.log(`renamed ${c.dim(old)} → ${c.bold(newLabel)}`);
     return 0;
   });

package/src/cli/render.ts

@@ -33,13 +33,6 @@ export function makeUsagePaint(input: { enabled: boolean; truecolor: boolean })
     };
 }
 
-export function claudeTierLabel(input: { subscriptionType?: string; rateLimitTier?: string }): string | null {
-  const segments = input.rateLimitTier?.split("_") ?? [];
-  const multiplier = segments.find((seg) => seg.length > 1 && seg.endsWith("x") && Number.isInteger(Number(seg.slice(0, -1))));
-  if (input.subscriptionType == null) return multiplier ?? null;
-  return multiplier ? `${input.subscriptionType} ${multiplier}` : input.subscriptionType;
-}
-
 export function count(input: { n: number; noun: string }): string {
   return `${input.n} ${input.noun}${input.n === 1 ? "" : "s"}`;
 }

package/src/cli/rm.ts

@@ -1,60 +1,45 @@
-import { rmSync } from "node:fs";
-import { join } from "node:path";
-import { deleteItem, isolatedTarget, liveTarget, parkedTarget, readItem } from "../lib/credstore.ts";
-import { fetchTokenIdentity } from "../lib/oauth.ts";
 import { withLock } from "../lib/lock.ts";
-import { credItemFor, paths } from "../lib/paths.ts";
-import { loadSetupTokens, saveSetupTokens } from "../lib/setuptokens.ts";
+import type { Provider } from "../lib/provider.ts";
 import { loadAccounts, saveAccounts } from "../lib/state.ts";
-import { CredentialBlobSchema } from "../lib/types.ts";
 import { findAccount } from "./rename.ts";
 import { c, emitError, plain } from "./render.ts";
 
-export async function cmdRm(selector?: string): Promise<number> {
+export async function cmdRm(p: Provider, selector?: string): Promise<number> {
   if (!selector) {
-    emitError({ message: "usage: tokenmaxxing rm <email|label|uuid>", paint: plain });
+    emitError({ message: `usage: tokenmaxxing rm${p.flag} <email|label|id>`, paint: plain });
     return 2;
   }
-  return withLock(paths.lockFile, async () => {
-    const idx = loadAccounts();
+  return withLock(p.pool.lockFile, async () => {
+    const idx = loadAccounts(p.pool);
     const a = findAccount(idx.accounts, selector);
     if (!a) {
       emitError({ message: `no account matches "${selector}"` });
       return 1;
     }
-    if (a.accountUuid === idx.activeAccountUuid) {
-      emitError({ message: `${a.email} is the ACTIVE account - switch away before removing it.` });
+    if (a.id === idx.activeId) {
+      emitError({ message: `${a.label} is the ACTIVE account - switch away before removing it.` });
       return 1;
     }
-    const live = await readItem(liveTarget());
-    if (live != null) {
-      let liveAccount: string;
-      try {
-        const liveCreds = CredentialBlobSchema.parse(JSON.parse(live)).claudeAiOauth;
-        liveAccount = (await fetchTokenIdentity(liveCreds.accessToken)).accountUuid;
-      } catch (e) {
-        emitError({
-          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({ 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;
-      }
+    let liveOwner: string | null;
+    try {
+      liveOwner = await p.liveOwner();
+    } catch (e) {
+      emitError({
+        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;
     }
-    const setupTokens = loadSetupTokens();
-    await deleteItem(parkedTarget(a.keychainItem));
-    const item = credItemFor(a.accountUuid);
-    for (const sampleDir of [join(paths.sampleDir, item), join(paths.sampleDir, `${item}-tick`)]) {
-      await deleteItem(isolatedTarget(sampleDir));
-      rmSync(sampleDir, { recursive: true, force: true });
+    if (liveOwner === a.id) {
+      emitError({ message: `${a.label}'s credential is currently LIVE (the active label is stale - a manual login drifted it); run \`tokenmaxxing switch${p.flag}\` to move off it first.` });
+      return 1;
     }
-    idx.accounts = idx.accounts.filter((x) => x.accountUuid !== a.accountUuid);
-    saveAccounts(idx);
-    if (setupTokens.tokens.some((t) => t.accountUuid === a.accountUuid)) {
-      saveSetupTokens({ ...setupTokens, tokens: setupTokens.tokens.filter((t) => t.accountUuid !== a.accountUuid) });
+    if (p.presentIds().has(a.id)) {
+      emitError({ message: `${a.label} is running in a live ${p.name} session - close that session before removing it.` });
+      return 1;
     }
+    await p.removeCredentials(a);
+    idx.accounts = idx.accounts.filter((x) => x.id !== a.id);
+    saveAccounts(p.pool, idx);
     console.log(`removed ${c.bold(a.label)} from the pool (${idx.accounts.length} left)`);
     return 0;
   });

package/src/cli/setuptoken.ts

@@ -2,7 +2,7 @@ import { mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { resolveRealClaude } from "../lib/claudebin.ts";
 import { withLock } from "../lib/lock.ts";
-import { paths } from "../lib/paths.ts";
+import { claudePool, credItemFor, paths } from "../lib/paths.ts";
 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";
@@ -53,19 +53,19 @@ async function mint(input: { real: string; item: string }): Promise<string | nul
 
 function currentTokens(tokens: SetupToken[], accounts: Account[]): { label: string; token: string }[] {
   return accounts.flatMap((a) => {
-    const stored = tokens.find((t) => t.accountUuid === a.accountUuid);
+    const stored = tokens.find((t) => t.accountUuid === a.id);
     return stored ? [{ label: a.label, token: stored.token }] : [];
   });
 }
 
 async function rmToken(selector: string): Promise<number> {
-  const outcome = await withLock(paths.lockFile, async (): Promise<{ error: string } | { kept: SetupToken[] }> => {
+  const outcome = await withLock(claudePool.lockFile, async (): Promise<{ error: string } | { kept: SetupToken[] }> => {
     const store = loadSetupTokens();
-    const accounts = loadAccounts().accounts;
+    const accounts = loadAccounts(claudePool).accounts;
     const pooled = accounts.find((a) => a.label === selector);
-    const orphan = (t: SetupToken) => !accounts.some((a) => a.accountUuid === t.accountUuid);
+    const orphan = (t: SetupToken) => !accounts.some((a) => a.id === t.accountUuid);
     const targets = store.tokens.filter((t) =>
-      t.accountUuid === selector || (pooled ? t.accountUuid === pooled.accountUuid : t.label === selector && orphan(t)),
+      t.accountUuid === selector || (pooled ? t.accountUuid === pooled.id : t.label === selector && orphan(t)),
     );
     if (targets.length === 0) return { error: `no setup token stored for "${selector}"` };
     if (targets.length > 1) return { error: `"${selector}" matches ${targets.length} stored tokens (${targets.map((t) => `${t.label} ${t.accountUuid}`).join(", ")}) - nothing removed` };
@@ -90,25 +90,25 @@ export async function cmdSetupToken(args: string[]): Promise<number> {
     return 2;
   }
   let store = loadSetupTokens();
-  let idx = loadAccounts();
+  let idx = loadAccounts(claudePool);
   if (!print) {
     if (idx.accounts.length === 0) {
       emitError({ message: "no accounts in the pool - run `tokenmaxxing init` first" });
       return 1;
     }
     const real = resolveRealClaude();
-    const missing = idx.accounts.filter((a) => !store.tokens.some((t) => t.accountUuid === a.accountUuid));
+    const missing = idx.accounts.filter((a) => !store.tokens.some((t) => t.accountUuid === a.id));
     if (missing.length === 0) console.log(c.dim("every pooled account already has a stored setup token (`setup-token rm <label>` drops one so it can be re-minted)"));
     for (const a of missing) {
       console.log();
-      console.log(`${c.bold(a.label)} - sign into this account in the browser (${a.email})`);
-      const token = await mint({ real, item: a.keychainItem });
+      console.log(`${c.bold(a.label)} - sign into this account in the browser (${a.email ?? a.label})`);
+      const token = await mint({ real, item: credItemFor(a.id) });
       if (!token) return 1;
-      const stored = await withLock(paths.lockFile, async () => {
-        if (!loadAccounts().accounts.some((x) => x.accountUuid === a.accountUuid)) return false;
+      const stored = await withLock(claudePool.lockFile, async () => {
+        if (!loadAccounts(claudePool).accounts.some((x) => x.id === a.id)) return false;
         const fresh = loadSetupTokens();
-        const tokens = fresh.tokens.filter((t) => t.accountUuid !== a.accountUuid);
-        saveSetupTokens({ ...fresh, tokens: [...tokens, { accountUuid: a.accountUuid, label: a.label, token, mintedAt: Date.now() }] });
+        const tokens = fresh.tokens.filter((t) => t.accountUuid !== a.id);
+        saveSetupTokens({ ...fresh, tokens: [...tokens, { accountUuid: a.id, label: a.label, token, mintedAt: Date.now() }] });
         return true;
       });
       if (!stored) {
@@ -118,7 +118,7 @@ export async function cmdSetupToken(args: string[]): Promise<number> {
       console.log(`${c.green("✓")} stored the setup token for ${c.bold(a.label)} ${c.dim("(ownership not verified: an inference-only token cannot read the profile endpoint, so the label is the sign-in you chose)")}`);
     }
     store = loadSetupTokens();
-    idx = loadAccounts();
+    idx = loadAccounts(claudePool);
   }
   if (store.tokens.length === 0) {
     emitError({ message: "no setup tokens stored - run `tokenmaxxing setup-token` to mint them" });
@@ -126,7 +126,7 @@ export async function cmdSetupToken(args: string[]): Promise<number> {
   }
   const tokens = currentTokens(store.tokens, idx.accounts);
   const orphaned = store.tokens
-    .filter((t) => !idx.accounts.some((a) => a.accountUuid === t.accountUuid))
+    .filter((t) => !idx.accounts.some((a) => a.id === t.accountUuid))
     .map((t) => ({ label: t.label, accountUuid: t.accountUuid }));
   if (tokens.length === 0) {
     emitError({ message: "no stored setup token belongs to a pooled account - run `tokenmaxxing setup-token` to mint them" });