tokenmaxxing 1.43.0 → 1.44.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.43.0",
+  "version": "1.44.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts, start each session on its own account, and resume a session on a fresher account when quota fills.",
   "type": "module",
   "license": "MIT",

package/src/cli/auth.ts

@@ -8,7 +8,7 @@ import { usageNote } from "./add.ts";
 import { c, count } from "./render.ts";
 import type { Account, AccountsIndex } from "../lib/types.ts";
 
-const AUTH_USAGE = "usage: tokenmaxxing auth [--codex] [<email|label|id> | --all]";
+const AUTH_USAGE = "usage: tokenmaxxing auth [--codex | --grok | --opencode-go] [<email|label|id> | --all]";
 
 const AuthPlanSchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("usage") }),

package/src/cli/init.ts

@@ -8,7 +8,11 @@ import { c, count } from "./render.ts";
 export function printUsage(p: Provider): void {
   console.log();
   console.log(`  ${c.bold("how to use")} - ${c.cyan("xx")} is shorthand for ${c.cyan("tokenmaxxing")}:`);
-  console.log(`    ${c.cyan(p.name)}             use ${p.name} as always; it switches accounts near quota automatically`);
+  if (p.statusOnly) {
+    console.log(`    ${c.cyan(`xx status`)}         view pooled ${p.name} accounts (status-only pool: no automatic switching yet)`);
+  } else {
+    console.log(`    ${c.cyan(p.name)}             use ${p.name} as always; it switches accounts near quota automatically`);
+  }
   console.log(`    ${c.cyan("xx")}                 show the pool with usage bars (same as ${c.cyan("xx status")})`);
   console.log(`    ${c.cyan(`xx add${p.flag}`)}             log in and pool another account`);
   console.log(`    ${c.cyan(`xx switch${p.flag}`)}          hop to the best account right now (the automatic switching needs no command)`);
@@ -37,7 +41,7 @@ export async function cmdInit(p: Provider): Promise<number> {
     await harvested.park();
     const idx = loadAccounts(p.pool);
     const imported = upsertAccount(idx, harvested, p.mergeWindows);
-    idx.activeId = p.seats === "live" ? harvested.id : null;
+    idx.activeId = !p.statusOnly && p.seats === "live" ? harvested.id : null;
     saveAccounts(p.pool, idx);
     return imported;
   });

package/src/cli/status.ts

@@ -2,9 +2,11 @@ import { chunk, sortBy } from "es-toolkit";
 import { z } from "zod";
 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 { loadAccounts, loadConfig, saveAccounts } from "../lib/state.ts";
 import { withLock } from "../lib/lock.ts";
-import { codexPool } from "../lib/paths.ts";
+import { codexPool, grokPool, opencodeGoPool } from "../lib/paths.ts";
 import { earliestReset, isExhausted, isSessionWindow, limitWindows, nextWeeklyReset, sessionWindow, thresholdBars, weeklyWindow } from "../lib/picker.ts";
 import type { Provider, SampleReport } from "../lib/provider.ts";
 import { bar, c, count, emitJson, fmtAgo } from "./render.ts";
@@ -52,7 +54,7 @@ const PoolReportSchema = z.object({
 });
 type PoolReport = z.infer<typeof PoolReportSchema>;
 
-const StatusReportSchema = z.object({ now: z.number(), claude: PoolReportSchema, codex: PoolReportSchema });
+const StatusReportSchema = z.object({ now: z.number(), claude: PoolReportSchema, codex: PoolReportSchema, grok: PoolReportSchema, opencodeGo: PoolReportSchema });
 export type StatusReport = z.infer<typeof StatusReportSchema>;
 
 function currentWindow(w: Window, now: number): WindowReport {
@@ -239,9 +241,11 @@ export async function cmdStatus(opts: { json?: boolean; cached?: boolean } = {})
   const claudeReport = await collect(claude, cfg, now, cached);
   if (!json) {
     const codexPooled = loadAccounts(codexPool).accounts.length > 0;
+    const grokPooled = loadAccounts(grokPool).accounts.length > 0;
+    const opencodeGoPooled = loadAccounts(opencodeGoPool).accounts.length > 0;
     if (claudeReport.accounts.length === 0) {
-      if (!codexPooled) {
-        console.log(c.dim("no accounts yet, run `tokenmaxxing init` (or `tokenmaxxing init --codex`)"));
+      if (!codexPooled && !grokPooled && !opencodeGoPooled) {
+        console.log(c.dim("no accounts yet, run `tokenmaxxing init` (or `tokenmaxxing init --codex`, `--grok`, `--opencode-go`)"));
         return 0;
       }
       console.log(c.dim("no claude accounts (run `tokenmaxxing init` to pool claude too)"));
@@ -252,13 +256,21 @@ export async function cmdStatus(opts: { json?: boolean; cached?: boolean } = {})
     }
   }
   const codexReport = await collect(codex, cfg, now, cached);
+  const grokReport = await collect(grok, cfg, now, cached);
+  const opencodeGoReport = await collect(opencodeGo, cfg, now, cached);
   if (json) {
-    const report: StatusReport = { now, claude: claudeReport, codex: codexReport };
+    const report: StatusReport = { now, claude: claudeReport, codex: codexReport, grok: grokReport, opencodeGo: opencodeGoReport };
     emitJson({ ok: true, ...report });
     return 0;
   }
   if (codexReport.accounts.length > 0) {
     renderPool(codex, codexReport, `codex  (${count({ n: codexReport.accounts.length, noun: "account" })})`, Date.now(), cfg.policy.usagePollTtlMs);
   }
+  if (grokReport.accounts.length > 0) {
+    renderPool(grok, grokReport, `grok  (${count({ n: grokReport.accounts.length, noun: "account" })}, status-only)`, Date.now(), cfg.policy.usagePollTtlMs);
+  }
+  if (opencodeGoReport.accounts.length > 0) {
+    renderPool(opencodeGo, opencodeGoReport, `opencode-go  (${count({ n: opencodeGoReport.accounts.length, noun: "account" })}, status-only)`, Date.now(), cfg.policy.usagePollTtlMs);
+  }
   return 0;
 }

package/src/lib/claude.ts

@@ -274,6 +274,7 @@ export const claude: Provider = {
   pool: claudePool,
   seats: "shared",
   waitsWhenDepleted: true,
+  statusOnly: false,
   liveId,
   presence,
   gatedFamilies: (cfg) => {

package/src/lib/codex.ts

@@ -325,6 +325,7 @@ export const codex: Provider = {
   pool: codexPool,
   seats: "live",
   waitsWhenDepleted: false,
+  statusOnly: false,
   liveId: liveCodexAccountId,
   presence: () => seatCounts(codexPaths.presenceDir),
   gatedFamilies: () => null,

package/src/lib/grok.ts

@@ -0,0 +1,188 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.ts";
+import { grokAuthJsonFor, grokPaths, grokPool, grokSeatFromEnv, grokStoreDirFor } from "./paths.ts";
+import type { Observation, Provider, SampleReport } from "./provider.ts";
+import { loadAccounts, loadConfig, pinBinOverride, type Harvest } from "./state.ts";
+import type { Account } from "./types.ts";
+import { c } from "../cli/render.ts";
+
+const GrokAuthEntrySchema = z.looseObject({
+  user_id: z.string().optional(),
+  principal_id: z.string().optional(),
+  email: z.string().nullish(),
+  first_name: z.string().nullish(),
+  refresh_token: z.string().optional(),
+  expires_at: z.string().nullish(),
+});
+type GrokAuthEntry = z.infer<typeof GrokAuthEntrySchema>;
+
+function parseGrokAuthFile(path: string): { key: string; entry: GrokAuthEntry }[] {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return [];
+  }
+  const map = z.record(z.string(), z.unknown()).safeParse(raw);
+  if (!map.success) return [];
+  const out: { key: string; entry: GrokAuthEntry }[] = [];
+  for (const [key, value] of Object.entries(map.data)) {
+    const parsed = GrokAuthEntrySchema.safeParse(value);
+    if (parsed.success) out.push({ key, entry: parsed.data });
+  }
+  return out;
+}
+
+function identityOf(key: string, entry: GrokAuthEntry): { id: string; email: string | null } {
+  const id = entry.user_id ?? entry.principal_id ?? key;
+  return { id, email: entry.email ?? null };
+}
+
+function resolveRealGrok(): string {
+  const cfg = loadConfig();
+  if (cfg.grokBin) {
+    if (!existsSync(cfg.grokBin)) throw new Error(`configured grokBin does not exist: ${cfg.grokBin} - fix config.json`);
+    return cfg.grokBin;
+  }
+  for (const d of (process.env.PATH ?? "").split(":")) {
+    if (!d) continue;
+    const cand = join(d, "grok");
+    try {
+      if (existsSync(cand)) return cand;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("could not locate the real `grok` binary (set grokBin in config.json)");
+}
+
+function liveId(): string | null {
+  return grokSeatFromEnv(loadAccounts(grokPool).accounts.map((a) => a.id));
+}
+
+function presence(): Map<string, number> {
+  return new Map();
+}
+
+async function observeLive(account: Account): Promise<Observation | null> {
+  return account.lastUsageAt != null ? { windows: account.windows, at: account.lastUsageAt } : null;
+}
+
+async function samplePool(accounts: Account[]): Promise<Map<string, SampleReport>> {
+  const reports = new Map<string, SampleReport>();
+  for (const a of accounts) {
+    reports.set(a.id, (await storeUsable(a)) ? { ok: true, source: "probe" } : { ok: false, reason: "no usable credential in this account's store - run `tokenmaxxing auth --grok`" });
+  }
+  return reports;
+}
+
+async function storeUsable(a: Account): Promise<boolean> {
+  try {
+    const entries = parseGrokAuthFile(grokAuthJsonFor(a.id));
+    return entries.some((e) => identityOf(e.key, e.entry).id === a.id && (e.entry.refresh_token ?? "") !== "");
+  } catch {
+    return false;
+  }
+}
+
+async function removeCredentials(a: Account): Promise<void> {
+  rmSync(grokStoreDirFor(a.id), { recursive: true, force: true });
+}
+
+function harvestOf(key: string, entry: GrokAuthEntry): Harvest | null {
+  const { id, email } = identityOf(key, entry);
+  if (!id) return null;
+  return {
+    id,
+    email,
+    tier: null,
+    sample: null,
+    park: async () => {
+      mkdirSync(grokStoreDirFor(id), { recursive: true });
+      writeFileAtomic(grokAuthJsonFor(id), JSON.stringify({ [key]: entry }, null, 2), 0o600);
+    },
+  };
+}
+
+async function login(): Promise<Harvest | null> {
+  const real = resolveRealGrok();
+  const onboardDir = grokPaths.onboardDir;
+  rmSync(onboardDir, { recursive: true, force: true });
+  mkdirSync(onboardDir, { recursive: true });
+  const p = Bun.spawn([real, "login"], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env: { ...process.env, GROK_HOME: onboardDir, TOKENMAXXING_PROBE: "1" },
+  });
+  await p.exited;
+  try {
+    if (p.exitCode !== 0) {
+      console.error(c.red("no grok login landed in the isolated home - nothing added."));
+      return null;
+    }
+    const entries = parseGrokAuthFile(join(onboardDir, "auth.json"));
+    if (entries.length === 0) {
+      console.error(c.red("no grok login landed in the isolated home - nothing added."));
+      return null;
+    }
+    return harvestOf(entries[0]!.key, entries[0]!.entry);
+  } finally {
+    rmSync(onboardDir, { recursive: true, force: true });
+  }
+}
+
+async function importLive(): Promise<Harvest | null> {
+  console.log(c.cyan("Opening an isolated grok login for your first pooled account - the login you already have stays as it is."));
+  console.log();
+  const live = parseGrokAuthFile(join(grokPaths.home, "auth.json"));
+  if (live.length > 0) {
+    console.log(c.dim(`found ${live.length} grok login(s) in ${grokPaths.home} - pooling the first; use \`tokenmaxxing add --grok\` for the rest.`));
+    const h = harvestOf(live[0]!.key, live[0]!.entry);
+    if (h) return h;
+  }
+  return login();
+}
+
+function preflight(): void {
+  const real = resolveRealGrok();
+  const p = Bun.spawnSync([real, "--version"], { stdout: "pipe", stderr: "pipe", timeout: 15_000 });
+  const out = (p.stdout?.toString() ?? "").trim().toLowerCase();
+  if (p.exitCode !== 0 || !out.includes("grok")) {
+    throw new Error(`grok binary failed verification: ${real}`);
+  }
+  pinBinOverride({ key: "grokBin", bin: real });
+}
+
+function install(): void {
+  console.log(c.dim("grok pool is status-only: no supervisor or hooks installed. Use `tokenmaxxing status` to view pooled grok accounts."));
+}
+
+export const grok: Provider = {
+  name: "grok",
+  flag: " --grok",
+  pool: grokPool,
+  seats: "live",
+  waitsWhenDepleted: false,
+  statusOnly: true,
+  liveId,
+  presence,
+  gatedFamilies: () => null,
+  observeLive,
+  samplePool,
+  mergeWindows: (next) => next,
+  swap: async () => {
+    throw new Error("grok moves are not supported yet (status-only pool)");
+  },
+  classifySwapError: () => "fatal",
+  removeCredentials,
+  storeUsable,
+  login,
+  importLive,
+  preflight,
+  install,
+  loginStep: () => `Sign in in the browser session that opens (or run ${c.bold("grok login --device-auth")} on headless hosts first).`,
+  windowLabel: (name) => name.toLowerCase(),
+};

package/src/lib/opencodego.ts

@@ -0,0 +1,186 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.ts";
+import { opencodeGoAuthJsonFor, opencodeGoPaths, opencodeGoPool, opencodeGoStoreDirFor } from "./paths.ts";
+import type { Observation, Provider, SampleReport } from "./provider.ts";
+import { loadConfig, pinBinOverride, type Harvest } from "./state.ts";
+import type { Account } 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 dataHome(): string {
+  return process.env.XDG_DATA_HOME && process.env.XDG_DATA_HOME.length > 0 ? process.env.XDG_DATA_HOME : join(homedir(), ".local", "share");
+}
+
+function liveAuthPath(): string {
+  return join(dataHome(), "opencode", "auth.json");
+}
+
+function parseAuthFile(path: string): { provider: string; key: string } | null {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+  const map = OpencodeAuthFileSchema.safeParse(raw);
+  if (!map.success) return null;
+  const entry = OpencodeAuthEntrySchema.safeParse(map.data["opencode-go"]);
+  if (!entry.success || entry.data.type !== "api" || !entry.data.key) return null;
+  return { provider: "opencode-go", key: entry.data.key };
+}
+
+function idOfKey(key: string): string {
+  const h = new Bun.CryptoHasher("sha256");
+  h.update(`opencode-go:${key}`);
+  return `opencode-go-${h.digest("hex")}`;
+}
+
+function resolveRealOpencode(): string {
+  const cfg = loadConfig();
+  if (cfg.opencodeBin) {
+    if (!existsSync(cfg.opencodeBin)) throw new Error(`configured opencodeBin does not exist: ${cfg.opencodeBin} - fix config.json`);
+    return cfg.opencodeBin;
+  }
+  for (const d of (process.env.PATH ?? "").split(":")) {
+    if (!d) continue;
+    const cand = join(d, "opencode");
+    try {
+      if (existsSync(cand)) return cand;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("could not locate the real `opencode` binary (set opencodeBin in config.json)");
+}
+
+function liveId(): string | null {
+  return null;
+}
+
+function presence(): Map<string, number> {
+  return new Map();
+}
+
+async function observeLive(account: Account): Promise<Observation | null> {
+  return account.lastUsageAt != null ? { windows: account.windows, at: account.lastUsageAt } : null;
+}
+
+async function samplePool(accounts: Account[]): Promise<Map<string, SampleReport>> {
+  const reports = new Map<string, SampleReport>();
+  for (const a of accounts) {
+    reports.set(a.id, (await storeUsable(a)) ? { ok: true, source: "probe" } : { ok: false, reason: "no usable credential in this account's store - run `tokenmaxxing auth --opencode-go`" });
+  }
+  return reports;
+}
+
+async function storeUsable(a: Account): Promise<boolean> {
+  try {
+    const found = parseAuthFile(opencodeGoAuthJsonFor(a.id));
+    return found != null && idOfKey(found.key) === a.id;
+  } catch {
+    return false;
+  }
+}
+
+async function removeCredentials(a: Account): Promise<void> {
+  rmSync(opencodeGoStoreDirFor(a.id), { recursive: true, force: true });
+}
+
+function harvestOf(key: string): Harvest {
+  const id = idOfKey(key);
+  return {
+    id,
+    email: null,
+    tier: "go",
+    sample: null,
+    park: async () => {
+      mkdirSync(opencodeGoStoreDirFor(id), { recursive: true });
+      writeFileAtomic(opencodeGoAuthJsonFor(id), JSON.stringify({ "opencode-go": { type: "api", key } }, null, 2), 0o600);
+    },
+  };
+}
+
+async function login(): Promise<Harvest | null> {
+  const real = resolveRealOpencode();
+  const onboardDir = opencodeGoPaths.onboardDir;
+  rmSync(onboardDir, { recursive: true, force: true });
+  mkdirSync(onboardDir, { recursive: true });
+  const p = Bun.spawn([real, "providers", "login", "-p", "opencode-go"], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env: { ...process.env, XDG_DATA_HOME: onboardDir, TOKENMAXXING_PROBE: "1" },
+  });
+  await p.exited;
+  try {
+    if (p.exitCode !== 0) {
+      console.error(c.red("no opencode-go login landed in the isolated home - nothing added."));
+      return null;
+    }
+    const found = parseAuthFile(join(onboardDir, "opencode", "auth.json"));
+    if (!found) {
+      console.error(c.red("no opencode-go login landed in the isolated home - nothing added."));
+      return null;
+    }
+    return harvestOf(found.key);
+  } finally {
+    rmSync(onboardDir, { recursive: true, force: true });
+  }
+}
+
+async function importLive(): Promise<Harvest | null> {
+  console.log(c.cyan("Pooling your opencode-go API key - your existing opencode auth stays as it is."));
+  console.log();
+  const found = parseAuthFile(liveAuthPath());
+  if (found) {
+    console.log(c.dim(`found an opencode-go credential in ${liveAuthPath()} - pooling it; use \`tokenmaxxing add --opencode-go\` for more keys.`));
+    return harvestOf(found.key);
+  }
+  return login();
+}
+
+function preflight(): void {
+  const real = resolveRealOpencode();
+  const p = Bun.spawnSync([real, "--version"], { stdout: "pipe", stderr: "pipe", timeout: 15_000 });
+  const out = (p.stdout?.toString() ?? "").trim();
+  if (p.exitCode !== 0 || out === "") {
+    throw new Error(`opencode binary failed verification: ${real}`);
+  }
+  pinBinOverride({ key: "opencodeBin", bin: real });
+}
+
+function install(): void {
+  console.log(c.dim("opencode-go pool is status-only: no supervisor or hooks installed. Use `tokenmaxxing status` to view pooled keys."));
+}
+
+export const opencodeGo: Provider = {
+  name: "opencode-go",
+  flag: " --opencode-go",
+  pool: opencodeGoPool,
+  seats: "live",
+  waitsWhenDepleted: false,
+  statusOnly: true,
+  liveId,
+  presence,
+  gatedFamilies: () => null,
+  observeLive,
+  samplePool,
+  mergeWindows: (next) => next,
+  swap: async () => {
+    throw new Error("opencode-go moves are not supported yet (status-only pool)");
+  },
+  classifySwapError: () => "fatal",
+  removeCredentials,
+  storeUsable,
+  login,
+  importLive,
+  preflight,
+  install,
+  loginStep: () => `Paste the opencode-go API key from ${c.bold("opencode.ai/zen")} when opencode asks for it.`,
+  windowLabel: (name) => name.toLowerCase(),
+};

package/src/lib/paths.ts

@@ -52,6 +52,18 @@ export const codexPool = {
   lockFile: join(TM_HOME, "codex-lock"),
 } as const;
 
+export const grokPool = {
+  accountsJson: join(TM_HOME, "grok-accounts.json"),
+  lastSwapJson: null,
+  lockFile: join(TM_HOME, "grok-lock"),
+} as const;
+
+export const opencodeGoPool = {
+  accountsJson: join(TM_HOME, "opencode-go-accounts.json"),
+  lastSwapJson: null,
+  lockFile: join(TM_HOME, "opencode-go-lock"),
+} as const;
+
 export type PoolPaths = { accountsJson: string; lastSwapJson: string | null; lockFile: string };
 
 const CODEX_HOME = env("TOKENMAXXING_CODEX_HOME", env("CODEX_HOME", join(HOME, ".codex")));
@@ -71,6 +83,41 @@ export function codexCredItemFor(accountId: string): string {
   return `tokenmaxxing-codex-${accountId.slice(0, 8)}`;
 }
 
+const GROK_HOME_DEFAULT = join(HOME, ".grok");
+
+export const grokPaths = {
+  home: env("GROK_HOME", GROK_HOME_DEFAULT),
+  storesDir: join(TM_HOME, "grok-stores"),
+  onboardDir: join(TM_HOME, "grok-onboard"),
+} as const;
+
+export function grokStoreDirFor(accountId: string): string {
+  return join(grokPaths.storesDir, shortId(accountId));
+}
+
+export function grokAuthJsonFor(accountId: string): string {
+  return join(grokStoreDirFor(accountId), "auth.json");
+}
+
+export function grokSeatFromEnv(accountIds: string[], env: Record<string, string | undefined> = process.env): string | null {
+  const home = env.GROK_HOME;
+  if (home == null || home === "") return null;
+  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"),
+} 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");
+}
+
 export const keychain = {
   account: env("TOKENMAXXING_KEYCHAIN_ACCOUNT", process.env.USER ?? "unknown"),
 } as const;
@@ -111,4 +158,12 @@ export function realCodexBinFromEnv(): string | undefined {
   return EnvOverrideSchema.parse(process.env.TOKENMAXXING_CODEX_BIN);
 }
 
+export function realGrokBinFromEnv(): string | undefined {
+  return EnvOverrideSchema.parse(process.env.TOKENMAXXING_GROK_BIN);
+}
+
+export function realOpencodeBinFromEnv(): string | undefined {
+  return EnvOverrideSchema.parse(process.env.TOKENMAXXING_OPENCODE_BIN);
+}
+
 export { HOME };

package/src/lib/provider.ts

@@ -9,11 +9,12 @@ export type SampleReport = { ok: true; source: "statusline" | "probe" } | { ok:
 export type SwapFailure = "dead-grant" | "skip" | "fatal";
 
 export type Provider = {
-  name: "claude" | "codex";
+  name: "claude" | "codex" | "grok" | "opencode-go";
   flag: string;
   pool: PoolPaths;
   seats: "shared" | "live";
   waitsWhenDepleted: boolean;
+  statusOnly: boolean;
   liveId(): string | null;
   presence(): Map<string, number>;
   gatedFamilies(cfg: Config): string[] | null;

package/src/lib/state.ts

@@ -1,7 +1,7 @@
 import { closeSync, existsSync, fstatSync, openSync, readFileSync, rmSync, utimesSync } from "node:fs";
 import { isEqual } from "es-toolkit";
 import { z } from "zod";
-import { paths, realClaudeBinFromEnv, realCodexBinFromEnv, usageJsonFor, type PoolPaths } from "./paths.ts";
+import { paths, realClaudeBinFromEnv, realCodexBinFromEnv, realGrokBinFromEnv, realOpencodeBinFromEnv, usageJsonFor, type PoolPaths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import {
   AccountsIndexSchema,
@@ -35,10 +35,14 @@ export function loadConfig(): Config {
   if (envBin) cfg.claudeBin = envBin;
   const envCodexBin = realCodexBinFromEnv();
   if (envCodexBin) cfg.codexBin = envCodexBin;
+  const envGrokBin = realGrokBinFromEnv();
+  if (envGrokBin) cfg.grokBin = envGrokBin;
+  const envOpencodeBin = realOpencodeBinFromEnv();
+  if (envOpencodeBin) cfg.opencodeBin = envOpencodeBin;
   return cfg;
 }
 
-export function pinBinOverride(input: { key: "claudeBin" | "codexBin"; bin: string }): void {
+export function pinBinOverride(input: { key: "claudeBin" | "codexBin" | "grokBin" | "opencodeBin"; bin: string }): void {
   let raw: Record<string, unknown> = {};
   if (existsSync(paths.configJson)) {
     raw = z.record(z.string(), z.unknown()).parse(JSON.parse(readFileSync(paths.configJson, "utf8")));

package/src/lib/types.ts

@@ -110,6 +110,8 @@ export const ConfigSchema = z
       .prefault({}),
     claudeBin: z.string().default(""),
     codexBin: z.string().default(""),
+    grokBin: z.string().default(""),
+    opencodeBin: z.string().default(""),
     policy: z
       .object({
         projectionMargin: z.number().min(0).max(100).default(0),

package/src/main.ts

@@ -11,6 +11,8 @@ import { runCodexSupervisor } from "./entries/codexsupervisor.ts";
 import { runCodexStopHook } from "./entries/codexstophook.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 } from "./cli/init.ts";
 import { cmdAdd } from "./cli/add.ts";
 import { cmdAuth } from "./cli/auth.ts";
@@ -30,8 +32,11 @@ import { c, emitError } from "./cli/render.ts";
 const JSON_FLAG = "--json";
 const CACHED_FLAG = "--cached";
 const CODEX_FLAG = "--codex";
+const GROK_FLAG = "--grok";
+const OPENCODE_GO_FLAG = "--opencode-go";
 const JSON_COMMANDS = new Set(["status", "config", "check", "switch"]);
 const CODEX_COMMANDS = new Set(["init", "add", "auth", "switch", "rm", "rename"]);
+const STATUS_ONLY_COMMANDS = new Set(["init", "add", "auth", "rm", "rename"]);
 
 function printHelp(): void {
   console.log(`${c.bold("tokenmaxxing")} - automatic Claude Code account switching
@@ -40,15 +45,17 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing check")}      sample the account whose usage figure is oldest (run by the periodic timer)
   ${c.cyan("tokenmaxxing init")}       log in the first account (isolated) + install supervisor & hooks
   ${c.cyan("tokenmaxxing init --codex")}  same for codex: import login, install codex supervisor + Stop hook (trust it via /hooks)
+  ${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")}   register an additional codex account (isolated login)
-  ${c.cyan("tokenmaxxing auth")} [--codex] [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")} [--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 switch --codex")} [sel]  switch the codex pool (takes effect on next codex start)
   ${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] <sel> <label>
-  ${c.cyan("tokenmaxxing rm")} [--codex] <sel>
+  ${c.cyan("tokenmaxxing rename")} [--codex | --grok | --opencode-go] <sel> <label>
+  ${c.cyan("tokenmaxxing rm")} [--codex | --grok | --opencode-go] <sel>
   ${c.cyan("tokenmaxxing uninstall")}  remove supervisor + settings entries
   ${c.cyan("tokenmaxxing setup-token")} [--print | rm <label|uuid>]  Cursor Cloud only: mint one \`claude setup-token\` per pooled account (browser sign-in each) and print the TOKENMAXXING_TOKENS secret value; ${c.cyan("--print")} prints the stored set, ${c.cyan("rm")} drops one
   ${c.cyan("tokenmaxxing cursor init")} [dir]  write the Claude relay subagent (.cursor/agents/claude.md) and .cursor/environment.json into a repo
@@ -79,8 +86,13 @@ async function main(): Promise<number> {
   jsonMode = argv.includes(JSON_FLAG);
   const json = jsonMode;
   const cached = argv.includes(CACHED_FLAG);
-  const provider = argv.includes(CODEX_FLAG) ? codex : claude;
-  const args = argv.filter((a) => a !== JSON_FLAG && a !== CACHED_FLAG && a !== CODEX_FLAG);
+  const providerFlags = [CODEX_FLAG, GROK_FLAG, OPENCODE_GO_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 args = argv.filter((a) => a !== JSON_FLAG && a !== CACHED_FLAG && a !== CODEX_FLAG && a !== GROK_FLAG && a !== OPENCODE_GO_FLAG);
   const sub = args[0];
 
   if (cached && sub != null && sub !== "status") {
@@ -93,6 +105,12 @@ async function main(): Promise<number> {
     return 2;
   }
 
+  if ((provider === grok || provider === opencodeGo) && (sub == null || !STATUS_ONLY_COMMANDS.has(sub))) {
+    const flag = provider === grok ? GROK_FLAG : OPENCODE_GO_FLAG;
+    emitError({ json, message: `${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;