tokenmaxxing 1.130.0 → 1.132.0

package/src/lib/paths.ts

@@ -28,6 +28,8 @@ export const paths = {
   onboardDir: join(TM_HOME, "onboard"),
   storesDir: join(TM_HOME, "stores"),
   hubKeyFile: join(TM_HOME, "hub-key"),
+  apiKeysDir: join(TM_HOME, "api-keys"),
+  costDir: join(TM_HOME, "cost"),
 
   claudeSettings: env(
     "TOKENMAXXING_CLAUDE_SETTINGS",
@@ -43,6 +45,7 @@ export const claudePool = {
   accountsJson: join(TM_HOME, "accounts.json"),
   lockFile: join(TM_HOME, "lock"),
   waitQueueJson: join(TM_HOME, "wait-queue.json"),
+  apiKeysJson: join(TM_HOME, "api-keys.json"),
 } as const;
 
 export const codexPool = {
@@ -55,11 +58,6 @@ export const grokPool = {
   lockFile: join(TM_HOME, "grok-lock"),
 } as const;
 
-export const opencodeGoPool = {
-  accountsJson: join(TM_HOME, "opencode-go-accounts.json"),
-  lockFile: join(TM_HOME, "opencode-go-lock"),
-} as const;
-
 export type PoolPaths = { accountsJson: string; lockFile: string };
 
 const CODEX_HOME = env("TOKENMAXXING_CODEX_HOME", env("CODEX_HOME", join(HOME, ".codex")));
@@ -130,20 +128,6 @@ export function grokSeatFromEnv(accountIds: string[], env: Record<string, string
   return accountIds.find((id) => grokStoreDirFor(id) === home) ?? null;
 }
 
-export const opencodeGoPaths = {
-  storesDir: join(TM_HOME, "opencode-go-stores"),
-  onboardDir: join(TM_HOME, "opencode-go-onboard"),
-  presenceDir: join(TM_HOME, "opencode-go-live"),
-} as const;
-
-export function opencodeGoStoreDirFor(accountId: string): string {
-  return join(opencodeGoPaths.storesDir, shortId(accountId));
-}
-
-export function opencodeGoAuthJsonFor(accountId: string): string {
-  return join(opencodeGoStoreDirFor(accountId), "auth.json");
-}
-
 const CLAUDE_KEYCHAIN_ACCOUNT_PATTERN = /^[a-zA-Z0-9._-]+$/;
 
 function claudeKeychainAccount(): string {

package/src/lib/pi.ts

@@ -98,6 +98,7 @@ export async function piLogin(pool: PiPool): Promise<PiLogin | null> {
 function piMover(base: Provider, pool: PiPool): Provider {
   return {
     ...base,
+    apiKeys: undefined,
     swap: async (target) => {
       if (!piStoreUsable(pool, target.id)) {
         throw new StoreUnusableError(`${target.label} has no pi login - run \`tokenmaxxing auth --pi${base.flag} ${target.label}\``);

package/src/lib/presence.ts

@@ -13,12 +13,13 @@ const PresenceSchema = z.object({
   accountId: z.string(),
   pid: z.number(),
   startedAt: z.string(),
+  apiKeyId: z.string().optional(),
 });
 
-export function writePresence(input: { dir: string; id: string; accountId: string; pid: number }): void {
+export function writePresence(input: { dir: string; id: string; accountId: string; pid: number; apiKeyId?: string }): void {
   const startedAt = pidStartTimes([input.pid]).get(input.pid);
   if (startedAt == null) throw new Error(`could not read pid ${input.pid}'s start time (ps lstart) - refusing to write an unverifiable presence file`);
-  writeFileAtomic(join(input.dir, input.id), JSON.stringify(PresenceSchema.parse({ accountId: input.accountId, pid: input.pid, startedAt })));
+  writeFileAtomic(join(input.dir, input.id), JSON.stringify(PresenceSchema.parse({ accountId: input.accountId, pid: input.pid, startedAt, ...(input.apiKeyId != null ? { apiKeyId: input.apiKeyId } : {}) })));
 }
 
 export function presencePid(input: { dir: string; id: string }): number | null {
@@ -34,7 +35,7 @@ export function clearPresence(input: { dir: string; id: string }): void {
   rmSync(join(input.dir, input.id), { force: true });
 }
 
-export type LivingPresence = { id: string; accountId: string };
+export type LivingPresence = { id: string; accountId: string; apiKeyId?: string };
 
 export function livingPresences(dir: string): LivingPresence[] {
   if (!existsSync(dir)) return [];
@@ -65,11 +66,11 @@ export function livingPresences(dir: string): LivingPresence[] {
       rmSync(file, { force: true });
       continue;
     }
-    living.push({ id: name, accountId: record.accountId });
+    living.push({ id: name, accountId: record.accountId, ...(record.apiKeyId != null ? { apiKeyId: record.apiKeyId } : {}) });
   }
   return living;
 }
 
 export function seatCounts(dir: string): Map<string, number> {
-  return new Map(Object.entries(countBy(livingPresences(dir), (p) => p.accountId)));
+  return new Map(Object.entries(countBy(livingPresences(dir).filter((p) => p.apiKeyId == null), (p) => p.accountId)));
 }

package/src/lib/provider.ts

@@ -1,6 +1,12 @@
 import type { PoolPaths } from "./paths.ts";
 import type { Harvest } from "./state.ts";
-import type { Account, Config, Window } from "./types.ts";
+import type { Account, ApiKey, Config, Window } from "./types.ts";
+
+export type ApiKeyPool = {
+  liveId(): string | null;
+  holds(id: string): boolean;
+  pick(exclude: string[]): ApiKey | null;
+};
 
 export type Observation = { windows: Window[]; at: number };
 
@@ -20,12 +26,13 @@ export class StoreUnusableError extends Error {
 }
 
 export type Provider = {
-  name: "claude" | "codex" | "grok" | "opencode-go";
+  name: "claude" | "codex" | "grok";
   flag: string;
   pool: PoolPaths;
   seats: "shared" | "live";
   waitsWhenDepleted: boolean;
   statusOnly: boolean;
+  apiKeys?: ApiKeyPool;
   liveId(): string | null;
   presence(): Map<string, number>;
   gatedFamilies(cfg: Config): string[] | null;

package/src/lib/sessions.ts

@@ -2,7 +2,7 @@ import { existsSync, readdirSync, realpathSync, rmSync, statSync, type Dirent }
 import { basename, join, sep } from "node:path";
 import { z } from "zod";
 import { errorMessage, log } from "./log.ts";
-import { codexPaths, grokPaths, opencodeGoPaths, paths, piPaths } from "./paths.ts";
+import { codexPaths, grokPaths, paths, piPaths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import { presencePid } from "./presence.ts";
 import { readJsonFile } from "./state.ts";
@@ -45,7 +45,7 @@ function recordLiveSession(sid: string, current: string): void {
 const TMP_MARKER = ".tmp.";
 const TMP_GRACE_MS = 3600 * 1000;
 
-const STORE_PARENTS = [paths.storesDir, codexPaths.storesDir, grokPaths.storesDir, opencodeGoPaths.storesDir, join(piPaths.storesDir, "claude"), join(piPaths.storesDir, "codex")];
+const STORE_PARENTS = [paths.storesDir, codexPaths.storesDir, grokPaths.storesDir, join(piPaths.storesDir, "claude"), join(piPaths.storesDir, "codex")];
 
 function listDir(dir: string, root: string): Dirent[] {
   if (!existsSync(dir)) return [];
@@ -60,7 +60,7 @@ function listDir(dir: string, root: string): Dirent[] {
 }
 
 function tmpSweepDirs(root: string): string[] {
-  const dirs = [paths.home, paths.usageDir, paths.presenceDir, paths.respawnDir, sessionsDir(), paths.binDir, codexPaths.presenceDir, codexPaths.respawnDir, codexPaths.onboardDir, opencodeGoPaths.presenceDir];
+  const dirs = [paths.home, paths.usageDir, paths.presenceDir, paths.respawnDir, sessionsDir(), paths.binDir, paths.apiKeysDir, paths.costDir, codexPaths.presenceDir, codexPaths.respawnDir, codexPaths.onboardDir];
   for (const parent of STORE_PARENTS) {
     for (const child of listDir(parent, root)) {
       if (child.isDirectory()) dirs.push(join(parent, child.name));
@@ -113,6 +113,10 @@ export function supervisedSession(env: Record<string, string | undefined> = proc
   return { sid, launchedAt: LaunchedAtSchema.parse(env.TOKENMAXXING_LAUNCHED_AT) ?? null, live: liveSessionId(sid) };
 }
 
+export function keyMovesSupported(env: Record<string, string | undefined> = process.env): boolean {
+  return env.TOKENMAXXING_API_KEY_ID !== undefined;
+}
+
 export function refusedAccounts(env: Record<string, string | undefined> = process.env): string[] {
   return RefusedSchema.parse(env.TOKENMAXXING_REFUSED);
 }
@@ -129,9 +133,10 @@ export function adoptLiveSession(session: SupervisedSession, stdinSid: string |
   return { ...session, live: stdinSid };
 }
 
-export function writeRespawnMarker(input: { session: SupervisedSession; accountId: string; waitUntil: number; compact: boolean; origin: z.infer<typeof RespawnMarkerSchema>["origin"]; refused?: string[] }): void {
+export function writeRespawnMarker(input: { session: SupervisedSession; accountId: string; apiKeyId?: string; waitUntil: number; compact: boolean; origin: z.infer<typeof RespawnMarkerSchema>["origin"]; refused?: string[] }): void {
   const payload: z.infer<typeof RespawnMarkerSchema> = {
     accountId: input.accountId,
+    ...(input.apiKeyId != null ? { apiKeyId: input.apiKeyId } : {}),
     ts: Date.now(),
     waitUntil: input.waitUntil,
     sessionId: input.session.live,

package/src/lib/state.ts

@@ -34,12 +34,11 @@ export function loadConfig(): Config {
   cfg.claudeBin = optionalEnv("TOKENMAXXING_CLAUDE_BIN") ?? cfg.claudeBin;
   cfg.codexBin = optionalEnv("TOKENMAXXING_CODEX_BIN") ?? cfg.codexBin;
   cfg.grokBin = optionalEnv("TOKENMAXXING_GROK_BIN") ?? cfg.grokBin;
-  cfg.opencodeBin = optionalEnv("TOKENMAXXING_OPENCODE_BIN") ?? cfg.opencodeBin;
   cfg.piBin = optionalEnv("TOKENMAXXING_PI_BIN") ?? cfg.piBin;
   return cfg;
 }
 
-export type BinKey = "claudeBin" | "codexBin" | "grokBin" | "opencodeBin" | "piBin";
+export type BinKey = "claudeBin" | "codexBin" | "grokBin" | "piBin";
 
 export function pinBinOverride(input: { key: BinKey; bin: string }): void {
   const raw: Record<string, unknown> = existsSync(paths.configJson) ? readJsonFile(paths.configJson, z.record(z.string(), z.unknown())) : {};

package/src/lib/statusonly.ts

@@ -14,7 +14,7 @@ export type StatusOnlySpec = {
   flag: string;
   pool: PoolPaths;
   binName: string;
-  binKey: "grokBin" | "opencodeBin";
+  binKey: "grokBin";
   storeDirFor: (accountId: string) => string;
   authJsonFor: (accountId: string) => string;
   onboardDir: string;

package/src/lib/supervise.ts

@@ -82,10 +82,10 @@ export async function runPassthrough(input: { real: string; argv: string[]; env:
   return exitStatus(p);
 }
 
-export async function recordPresenceOrStop(input: { child: ChildHandle; dir: string; id: string; accountId: string; event: string; message: string; savedTermios: string | null }): Promise<void> {
+export async function recordPresenceOrStop(input: { child: ChildHandle; dir: string; id: string; accountId: string; apiKeyId?: string; event: string; message: string; savedTermios: string | null }): Promise<void> {
   for (let attempt = 0; ; attempt++) {
     try {
-      writePresence({ dir: input.dir, id: input.id, accountId: input.accountId, pid: input.child.pid });
+      writePresence({ dir: input.dir, id: input.id, accountId: input.accountId, pid: input.child.pid, ...(input.apiKeyId != null ? { apiKeyId: input.apiKeyId } : {}) });
       return;
     } catch (e) {
       if (input.child.exitCode !== null || input.child.signalCode !== null) return;

package/src/lib/types.ts

@@ -116,7 +116,6 @@ export const ConfigSchema = z
     claudeBin: z.string().default(""),
     codexBin: z.string().default(""),
     grokBin: z.string().default(""),
-    opencodeBin: z.string().default(""),
     piBin: z.string().default(""),
     policy: z
       .object({
@@ -170,8 +169,38 @@ export const RespawnMarkerSchema = z.object({
   origin: z.enum(["stop", "sessionstart", "stopfailure", "seatwatch"]),
   launchedAt: z.number().optional(),
   refused: z.array(z.string()).optional(),
+  apiKeyId: z.string().optional(),
 });
 
+export const ApiKeySchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  workspaceId: z.string().optional(),
+  creditUsd: z.number().optional(),
+  spentUsd: z.number(),
+  creditSetAt: z.number(),
+  refusedAt: z.number().optional(),
+  addedAt: z.number(),
+});
+export type ApiKey = z.infer<typeof ApiKeySchema>;
+
+export const ApiKeysIndexSchema = z.object({
+  version: z.literal(1),
+  keys: z.array(ApiKeySchema).default([]),
+  baselines: z.record(z.string(), z.object({ usd: z.number(), at: z.number() })).default({}),
+});
+export type ApiKeysIndex = z.infer<typeof ApiKeysIndexSchema>;
+
+export const SessionCostSchema = z.object({ sessionId: z.string(), usd: z.number() });
+export type SessionCost = z.infer<typeof SessionCostSchema>;
+
+export const CostLineSchema = z
+  .looseObject({ session_id: z.string(), total_cost_usd: z.number().optional(), cost: z.looseObject({ total_cost_usd: z.number() }).nullable().optional() })
+  .transform((line): SessionCost | null => {
+    const usd = line.total_cost_usd ?? line.cost?.total_cost_usd;
+    return usd == null ? null : { sessionId: line.session_id, usd };
+  });
+
 export const EpochSecondsSchema = z.number().transform((seconds) => seconds * 1000);
 
 export const InstantSchema = z.iso.datetime({ offset: true }).transform((iso) => Date.parse(iso));

package/src/lib/usage.ts

@@ -105,7 +105,7 @@ export function transcriptRowText(row: TranscriptRow): string {
   return blocks.data.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n").trim();
 }
 
-export const ENFORCED_ERRORS = ["rate_limit", "oauth_org_not_allowed"];
+export const ENFORCED_ERRORS = ["rate_limit", "oauth_org_not_allowed", "billing_error"];
 
 export function findEnforcedRow(input: { rows: TranscriptRow[]; error: string; lastAssistantMessage: string | undefined }): TranscriptRow | null {
   const { rows, error, lastAssistantMessage } = input;

package/src/main.ts

@@ -13,7 +13,6 @@ import { runPiSupervisor } from "./entries/pisupervisor.ts";
 import { claude } from "./lib/claude.ts";
 import { codex } from "./lib/codex.ts";
 import { grok } from "./lib/grok.ts";
-import { opencodeGo } from "./lib/opencodego.ts";
 import { cmdInit, cmdInitPi } from "./cli/init.ts";
 import { cmdAdd } from "./cli/add.ts";
 import { cmdAuth } from "./cli/auth.ts";
@@ -21,6 +20,7 @@ import { cmdStatus } from "./cli/status.ts";
 import { cmdDoctor } from "./cli/doctor.ts";
 import { cmdRm } from "./cli/rm.ts";
 import { cmdRename } from "./cli/rename.ts";
+import { cmdKey } from "./cli/key.ts";
 import { cmdCheck } from "./cli/check.ts";
 import { cmdConfig } from "./cli/config.ts";
 import { cmdSeat } from "./cli/seat.ts";
@@ -28,19 +28,18 @@ import { cmdServe } from "./cli/serve.ts";
 import { CHECK_JOB, deactivationHint, HUB_JOB, onLoginHome, uninstallSupervisor, uninstallTargets } from "./lib/install.ts";
 import { errorMessage } from "./lib/log.ts";
 import { HOME } from "./lib/paths.ts";
-import { c, emitError } from "./cli/render.ts";
+import { c, count, emitError } from "./cli/render.ts";
 
 const JSON_FLAG = "--json";
 const CACHED_FLAG = "--cached";
 const YES_FLAG = "--yes";
 const CODEX_FLAG = "--codex";
 const GROK_FLAG = "--grok";
-const OPENCODE_GO_FLAG = "--opencode-go";
 const PI_FLAG = "--pi";
 const JSON_COMMANDS = new Set(["status", "config", "check"]);
 const CODEX_COMMANDS = new Set(["init", "add", "auth", "rm", "rename", "seat"]);
 const STATUS_ONLY_COMMANDS = new Set(["init", "add", "auth", "rm", "rename"]);
-const OPENCODE_GO_COMMANDS = new Set([...STATUS_ONLY_COMMANDS, "seat"]);
+const MAX_OPERANDS = new Map([["init", 0], ["add", 0], ["rm", 1], ["rename", 2], ["key", 4]]);
 
 function printHelp(): void {
   console.log(`${c.bold("tokenmaxxing")} - automatic Claude Code account switching
@@ -51,19 +50,20 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing init --codex")}  same for codex: log in the first account, isolated, install codex supervisor + Stop hook
   ${c.cyan("tokenmaxxing init --pi")}     install the pi supervisor: pi sessions run on pooled Claude or ChatGPT accounts that are logged into pi
   ${c.cyan("tokenmaxxing init --grok")}   pool grok Build logins (status-only: no supervisor yet)
-  ${c.cyan("tokenmaxxing init --opencode-go")}  pool opencode-go API keys (status-only: no supervisor yet)
   ${c.cyan("tokenmaxxing add")}        register an additional account (isolated login)
-  ${c.cyan("tokenmaxxing add")} --codex | --grok | --opencode-go   same for the codex, grok, or opencode-go pool
-  ${c.cyan("tokenmaxxing auth")} [--codex | --grok | --opencode-go] [sel | --all]  reauthenticate a pooled account in place (bare = pick from a list; --all = every account that is flagged or has no usable credential in its store, one by one)
+  ${c.cyan("tokenmaxxing add")} --codex | --grok   same for the codex or grok pool
+  ${c.cyan("tokenmaxxing auth")} [--codex | --grok] [sel | --all]  reauthenticate a pooled account in place (bare = pick from a list; --all = every account that is flagged or has no usable credential in its store, one by one)
   ${c.cyan("tokenmaxxing auth --pi")} [--codex] [sel | --all]  log a pooled Claude account (or a codex account with --codex) into pi, isolated (bare = pick from a list; --all = every account without a pi login)
   ${c.cyan("tokenmaxxing status")} [--cached]  accounts with 5h / weekly / per-model usage bars (--cached: the stored figures, no sampling)
   ${c.cyan("tokenmaxxing config")}     print the config path and the effective values (edit the file in an editor)
   ${c.cyan("tokenmaxxing doctor")}     verify the install is intact
-  ${c.cyan("tokenmaxxing rename")} [--codex | --grok | --opencode-go] <sel> <label>
-  ${c.cyan("tokenmaxxing rm")} [--codex | --grok | --opencode-go] <sel>
+  ${c.cyan("tokenmaxxing rename")} [--codex | --grok] <sel> <label>
+  ${c.cyan("tokenmaxxing rm")} [--codex | --grok] <sel>
+  ${c.cyan("tokenmaxxing key add")} <label> [credit-usd] [workspace-id]  store an Anthropic API key read from stdin; Claude sessions run on it only while every pooled Claude account is at its limit (workspace-id: for a key that spans several workspaces)
+  ${c.cyan("tokenmaxxing key credit")} <label> <usd>  set the key's balance as the Console shows it and restart its spend count
+  ${c.cyan("tokenmaxxing key rm")} <label>  delete the key and its stored secret (refused while a session runs on it)
   ${c.cyan("tokenmaxxing seat")} <pid>  lend one pooled Claude account to an unattended consumer until <pid> exits: prints the store directory to set as CLAUDE_SECURESTORAGE_CONFIG_DIR (the directory itself, as its owner, never a copy of its credential); host sessions and other borrowers share the account; exit 1 = none usable
   ${c.cyan("tokenmaxxing seat --codex")} <pid>  borrow one pooled codex account for an unattended consumer (plugin, script): prints the CODEX_HOME to set, lent to <pid> until it exits; codex sessions and other borrowers share the account, and a refresh race between them can sign it out until auth --codex runs again; exit 1 = none usable, fall back to the ambient login
-  ${c.cyan("tokenmaxxing seat --opencode-go")} <pid>  lend one pooled opencode-go key to an unattended consumer until <pid> exits: prints the store directory, whose auth.json is an opencode auth file (mount it at $XDG_DATA_HOME/opencode/auth.json, then run a model such as opencode-go/mimo-v2.6-pro); other borrowers share the key; exit 1 = none usable
   ${c.cyan("tokenmaxxing serve")}      serve the CLIProxyAPI-compatible usage API on http://localhost:<hub.port> (default 8317) so a dashboard such as T3 Code's "Add a CLIProxyAPI hub" shows every pooled Claude and Codex account's quota; the management key is the contents of hub-key in the state directory
   ${c.cyan("tokenmaxxing uninstall")} [--yes]  print the targets, then remove supervisor + settings entries (refused without ${c.cyan("--yes")} when HOME is the login home)
 
@@ -97,14 +97,14 @@ async function main(): Promise<number> {
   const json = jsonMode;
   const cached = argv.includes(CACHED_FLAG);
   const yes = argv.includes(YES_FLAG);
-  const providerFlags = [CODEX_FLAG, GROK_FLAG, OPENCODE_GO_FLAG].filter((f) => argv.includes(f));
+  const providerFlags = [CODEX_FLAG, GROK_FLAG].filter((f) => argv.includes(f));
   if (providerFlags.length > 1) {
     emitError({ json, message: `${providerFlags.join(" and ")} are mutually exclusive - pick one pool` });
     return 2;
   }
-  const provider = argv.includes(CODEX_FLAG) ? codex : argv.includes(GROK_FLAG) ? grok : argv.includes(OPENCODE_GO_FLAG) ? opencodeGo : claude;
+  const provider = argv.includes(CODEX_FLAG) ? codex : argv.includes(GROK_FLAG) ? grok : claude;
   const pi = argv.includes(PI_FLAG);
-  const args = argv.filter((a) => a !== JSON_FLAG && a !== CACHED_FLAG && a !== YES_FLAG && a !== CODEX_FLAG && a !== GROK_FLAG && a !== OPENCODE_GO_FLAG && a !== PI_FLAG);
+  const args = argv.filter((a) => a !== JSON_FLAG && a !== CACHED_FLAG && a !== YES_FLAG && a !== CODEX_FLAG && a !== GROK_FLAG && a !== PI_FLAG);
   const sub = args[0];
 
   if (pi && sub !== "init" && sub !== "auth") {
@@ -132,19 +132,21 @@ async function main(): Promise<number> {
     return 2;
   }
 
-  if (provider === grok || provider === opencodeGo) {
-    const flag = provider === grok ? GROK_FLAG : OPENCODE_GO_FLAG;
-    const commands = provider === grok ? STATUS_ONLY_COMMANDS : OPENCODE_GO_COMMANDS;
-    if (sub == null || !commands.has(sub)) {
-      emitError({ json, message: `${flag} applies to ${[...commands].join(", ")}, not ${sub ?? "status"}` });
-      return 2;
-    }
+  if (provider === grok && (sub == null || !STATUS_ONLY_COMMANDS.has(sub))) {
+    emitError({ json, message: `${GROK_FLAG} applies to ${[...STATUS_ONLY_COMMANDS].join(", ")}, not ${sub ?? "status"}` });
+    return 2;
   }
 
   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;
   }
+
+  const maxOperands = sub == null ? undefined : MAX_OPERANDS.get(sub);
+  if (maxOperands != null && args.length - 1 > maxOperands) {
+    emitError({ json, message: `${sub} takes at most ${count({ n: maxOperands, noun: "argument" })}, got: ${args.slice(1).join(" ")}` });
+    return 2;
+  }
   switch (sub) {
     case "__statusline": return runStatusline();
     case "__subagent-statusline": return runSubagentStatusline();
@@ -175,7 +177,8 @@ async function main(): Promise<number> {
     case "doctor": return cmdDoctor();
     case "rm": return cmdRm(provider, args[1]);
     case "rename": return cmdRename(provider, args.slice(1));
-    case "seat": return cmdSeat(provider === codex ? "codex" : provider === opencodeGo ? "opencode-go" : "claude", args[1], args.slice(2));
+    case "key": return cmdKey(args.slice(1));
+    case "seat": return cmdSeat(provider === codex ? "codex" : "claude", args[1], args.slice(2));
     case "serve": return cmdServe(args.slice(1));
     case "uninstall": {
       if (args.length > 1) {
@@ -200,7 +203,7 @@ async function main(): Promise<number> {
       if (out.timer === "still-loaded") console.log(c.yellow(`⚠ the check job may still be loaded - run: ${deactivationHint(CHECK_JOB)}`));
       if (out.hub === "still-loaded") console.log(c.yellow(`⚠ the usage hub job may still be loaded - run: ${deactivationHint(HUB_JOB)}`));
       if (!out.pathLineRemoved) console.log(c.dim("(no tokenmaxxing PATH line found in the shell rc)"));
-      console.log(`kept: accounts.json, config.json, and every account credential store (claude: stores/ and its keychain items on macOS; codex: codex-stores/; pi: pi-stores/; grok: grok-stores/; opencode-go: opencode-go-stores/) - remove accounts with \`xx rm\` to delete their credentials`);
+      console.log(`kept: accounts.json, config.json, and every account credential store (claude: stores/ and its keychain items on macOS; codex: codex-stores/; pi: pi-stores/; grok: grok-stores/), plus api-keys.json and the API keys in api-keys/ - remove accounts with \`xx rm\` and keys with \`xx key rm\` to delete their credentials`);
       return 0;
     }
     case "help":

package/src/lib/opencodego.ts

@@ -1,99 +0,0 @@
-import { join } from "node:path";
-import { countBy, minBy } from "es-toolkit";
-import { z } from "zod";
-import { writeFileAtomic } from "./atomic.ts";
-import { env, HOME, opencodeGoAuthJsonFor, opencodeGoPaths, opencodeGoPool, opencodeGoStoreDirFor } from "./paths.ts";
-import { withLock } from "./lock.ts";
-import { log } from "./log.ts";
-import { livingPresences, seatCounts, writePresence } from "./presence.ts";
-import type { Provider, SeatBorrow } from "./provider.ts";
-import { loadAccounts, readJsonFile, type Harvest } from "./state.ts";
-import { statusOnlyProvider, type AuthEntry } from "./statusonly.ts";
-import { ErrnoSchema } from "./types.ts";
-import { c } from "../cli/render.ts";
-
-const OpencodeAuthEntrySchema = z.looseObject({ type: z.string(), key: z.string().optional() });
-const OpencodeAuthFileSchema = z.record(z.string(), z.unknown());
-
-function liveAuthPath(): string {
-  return join(env("XDG_DATA_HOME", join(HOME, ".local", "share")), "opencode", "auth.json");
-}
-
-function idOfKey(key: string): string {
-  const h = new Bun.CryptoHasher("sha256");
-  h.update(`opencode-go:${key}`);
-  return h.digest("hex");
-}
-
-function harvestOf(key: string): Harvest {
-  const id = idOfKey(key);
-  return {
-    id,
-    email: null,
-    tier: "go",
-    sample: null,
-    park: async () => {
-      writeFileAtomic(opencodeGoAuthJsonFor(id), JSON.stringify({ "opencode-go": { type: "api", key } }, null, 2), 0o600);
-    },
-  };
-}
-
-function readAuth(path: string): AuthEntry[] {
-  let map: z.infer<typeof OpencodeAuthFileSchema>;
-  try {
-    map = readJsonFile(path, OpencodeAuthFileSchema);
-  } catch (e) {
-    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return [];
-    throw e;
-  }
-  const entry = OpencodeAuthEntrySchema.safeParse(map["opencode-go"]);
-  if (!entry.success || entry.data.type !== "api" || !entry.data.key) return [];
-  return [{ id: idOfKey(entry.data.key), usable: true, harvest: harvestOf(entry.data.key) }];
-}
-
-export async function borrowOpencodeGoSeat(pid: number): Promise<SeatBorrow> {
-  const seatId = `seat-${pid}`;
-  const granted = await withLock(opencodeGoPool.lockFile, async (): Promise<SeatBorrow> => {
-    const accounts = loadAccounts(opencodeGoPool).accounts;
-    const living = livingPresences(opencodeGoPaths.presenceDir);
-    const held = living.find((p) => p.id === seatId);
-    const heldAccount = held ? (accounts.find((a) => a.id === held.accountId) ?? null) : null;
-    if (heldAccount) {
-      if (!(await opencodeGo.storeUsable(heldAccount))) {
-        return { denied: "the key this pid holds is no longer usable in its store - run `tokenmaxxing auth --opencode-go` and borrow again" };
-      }
-      return { store: opencodeGoStoreDirFor(heldAccount.id), id: heldAccount.id, reused: true };
-    }
-    const lent = countBy(living, (p) => p.accountId);
-    const usable = await Promise.all(accounts.map(opencodeGo.storeUsable));
-    const picked = minBy(accounts.filter((_, i) => usable[i]), (a) => lent[a.id] ?? 0);
-    if (!picked) return null;
-    writePresence({ dir: opencodeGoPaths.presenceDir, id: seatId, accountId: picked.id, pid });
-    return { store: opencodeGoStoreDirFor(picked.id), id: picked.id, reused: false };
-  });
-  if (granted && !("denied" in granted)) log("seat.grant", { account: granted.id.slice(0, 8), pid, reused: granted.reused });
-  return granted;
-}
-
-export const opencodeGo: Provider = statusOnlyProvider({
-  name: "opencode-go",
-  flag: " --opencode-go",
-  pool: opencodeGoPool,
-  binName: "opencode",
-  binKey: "opencodeBin",
-  storeDirFor: opencodeGoStoreDirFor,
-  authJsonFor: opencodeGoAuthJsonFor,
-  onboardDir: opencodeGoPaths.onboardDir,
-  homeEnv: "XDG_DATA_HOME",
-  loginArgs: ["providers", "login", "-p", "opencode-go"],
-  onboardAuthRel: join("opencode", "auth.json"),
-  liveAuthPath,
-  readAuth,
-  liveId: () => null,
-  presence: () => seatCounts(opencodeGoPaths.presenceDir),
-  versionOk: (out) => out !== "",
-  importIntro: "Pooling your opencode-go API key - your existing opencode auth stays as it is.",
-  foundLive: () => `found an opencode-go credential in ${liveAuthPath()} - pooling it; use \`tokenmaxxing add --opencode-go\` for more keys.`,
-  installNotice: "opencode-go pool is status-only: no supervisor or hooks installed. Use `tokenmaxxing status` to view pooled keys.",
-  loginStep: () => `Paste the opencode-go API key from ${c.bold("opencode.ai/zen")} when opencode asks for it.`,
-});