oc-auth-switcher 0.1.0

package/dist/cli.js

@@ -0,0 +1,689 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/accounts.ts
+import fs from "fs";
+import path2 from "path";
+
+// src/constants.ts
+import path from "path";
+import os from "os";
+var configDir = path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "opencode");
+var ACCOUNTS_FILE = path.join(configDir, "auth-switcher-accounts.json");
+var STATE_FILE = path.join(configDir, "auth-switcher-state.json");
+var DEFAULT_THRESHOLD = 0.9;
+var DEFAULT_CHECK_INTERVAL = 60 * 60 * 1000;
+var AUTH_FAILURE_COOLDOWN = 60 * 60 * 1000;
+
+// src/accounts.ts
+function normalizeAccount(raw) {
+  const name = raw.name || "unnamed";
+  const access = raw.access || raw.accessToken || "";
+  const refresh = raw.refresh || raw.refreshToken || "";
+  let expires = 0;
+  const rawExpires = raw.expires ?? raw.expiresAt;
+  if (typeof rawExpires === "number") {
+    expires = rawExpires;
+  } else if (typeof rawExpires === "string") {
+    const parsed = Date.parse(rawExpires);
+    if (!isNaN(parsed))
+      expires = parsed;
+  }
+  return { name, access, refresh, expires };
+}
+function ensureDir(filePath) {
+  const dir = path2.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function safeReadJSON(filePath, fallback) {
+  for (const p of [filePath, filePath + ".bak"]) {
+    try {
+      const raw = fs.readFileSync(p, "utf-8");
+      return JSON.parse(raw);
+    } catch {}
+  }
+  return fallback;
+}
+function safeWriteJSON(filePath, data) {
+  ensureDir(filePath);
+  const content = JSON.stringify(data, null, 2);
+  const tmpPath = filePath + ".tmp";
+  const bakPath = filePath + ".bak";
+  if (fs.existsSync(filePath)) {
+    try {
+      fs.copyFileSync(filePath, bakPath);
+    } catch {}
+  }
+  fs.writeFileSync(tmpPath, content, { mode: 384 });
+  fs.renameSync(tmpPath, filePath);
+}
+function loadAccounts() {
+  const raw = safeReadJSON(ACCOUNTS_FILE, {
+    accounts: []
+  });
+  const accounts = (raw.accounts || []).map((a) => normalizeAccount(a));
+  return { accounts };
+}
+function saveAccounts(data) {
+  safeWriteJSON(ACCOUNTS_FILE, data);
+}
+function addAccount(account) {
+  const data = loadAccounts();
+  const idx = data.accounts.findIndex((a) => a.name === account.name);
+  if (idx >= 0) {
+    data.accounts[idx] = account;
+  } else {
+    data.accounts.push(account);
+  }
+  saveAccounts(data);
+  return data;
+}
+function removeAccount(name) {
+  const data = loadAccounts();
+  data.accounts = data.accounts.filter((a) => a.name !== name);
+  saveAccounts(data);
+  return data;
+}
+
+// src/state.ts
+var EMPTY_METRIC = { utilization: 0, reset: 0, status: "" };
+var EMPTY_USAGE = {
+  session5h: { ...EMPTY_METRIC },
+  weekly7d: { ...EMPTY_METRIC },
+  weekly7dSonnet: { ...EMPTY_METRIC }
+};
+function defaultState() {
+  return {
+    currentAccount: null,
+    lastRotationCheck: 0,
+    requestCount: 0,
+    config: {
+      threshold: DEFAULT_THRESHOLD,
+      checkInterval: DEFAULT_CHECK_INTERVAL
+    },
+    usage: {},
+    authFailures: {}
+  };
+}
+function loadState() {
+  const raw = safeReadJSON(STATE_FILE, {});
+  const defaults = defaultState();
+  return {
+    currentAccount: raw.currentAccount ?? defaults.currentAccount,
+    lastRotationCheck: raw.lastRotationCheck ?? defaults.lastRotationCheck,
+    requestCount: raw.requestCount ?? defaults.requestCount,
+    config: {
+      threshold: raw.config?.threshold ?? defaults.config.threshold,
+      checkInterval: raw.config?.checkInterval ?? defaults.config.checkInterval
+    },
+    usage: raw.usage ?? defaults.usage,
+    authFailures: raw.authFailures ?? defaults.authFailures
+  };
+}
+function saveState(state) {
+  safeWriteJSON(STATE_FILE, state);
+}
+function getThresholds(config) {
+  if (typeof config.threshold === "number") {
+    return {
+      session5h: config.threshold,
+      weekly7d: config.threshold,
+      weekly7dSonnet: config.threshold
+    };
+  }
+  return config.threshold;
+}
+function resolveStaleMetrics(state) {
+  const now = Date.now() / 1000;
+  for (const accountName of Object.keys(state.usage)) {
+    const usage = state.usage[accountName];
+    const metrics = ["session5h", "weekly7d", "weekly7dSonnet"];
+    for (const key of metrics) {
+      const metric = usage[key];
+      if (metric.reset > 0 && metric.reset <= now) {
+        metric.utilization = 0;
+        metric.reset = 0;
+        metric.status = "";
+      }
+    }
+  }
+}
+function ensureAccountsInState(state, accountNames) {
+  for (const name of accountNames) {
+    if (!state.usage[name]) {
+      state.usage[name] = {
+        session5h: { ...EMPTY_METRIC },
+        weekly7d: { ...EMPTY_METRIC },
+        weekly7dSonnet: { ...EMPTY_METRIC }
+      };
+    }
+  }
+}
+
+// src/rotation.ts
+function clearAuthFailure(state, accountName) {
+  delete state.authFailures[accountName];
+}
+
+// node_modules/@ex-machina/opencode-anthropic-auth/dist/constants.js
+var CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+var AUTHORIZE_URLS = {
+  console: "https://platform.claude.com/oauth/authorize",
+  max: "https://claude.ai/oauth/authorize"
+};
+var CODE_CALLBACK_URL = "https://platform.claude.com/oauth/code/callback";
+var TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+var OAUTH_SCOPES = [
+  "org:create_api_key",
+  "user:profile",
+  "user:inference",
+  "user:sessions:claude_code",
+  "user:mcp_servers",
+  "user:file_upload"
+];
+
+// node_modules/@ex-machina/opencode-anthropic-auth/dist/pkce.js
+function base64UrlEncode(bytes) {
+  let bin = "";
+  for (const byte of bytes)
+    bin += String.fromCharCode(byte);
+  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+async function generatePKCE() {
+  const buf = new Uint8Array(64);
+  crypto.getRandomValues(buf);
+  const verifier = base64UrlEncode(buf);
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return {
+    verifier,
+    challenge: base64UrlEncode(new Uint8Array(digest)),
+    method: "S256"
+  };
+}
+
+// node_modules/@ex-machina/opencode-anthropic-auth/dist/auth.js
+function generateState() {
+  return crypto.randomUUID().replace(/-/g, "");
+}
+function parseCallbackInput(input) {
+  const trimmed = input.trim();
+  try {
+    const url = new URL(trimmed);
+    const code2 = url.searchParams.get("code");
+    const state2 = url.searchParams.get("state");
+    if (code2 && state2) {
+      return { code: code2, state: state2 };
+    }
+  } catch {}
+  const hashSplits = trimmed.split("#");
+  if (hashSplits.length === 2 && hashSplits[0] && hashSplits[1]) {
+    return { code: hashSplits[0], state: hashSplits[1] };
+  }
+  const params = new URLSearchParams(trimmed);
+  const code = params.get("code");
+  const state = params.get("state");
+  if (code && state) {
+    return { code, state };
+  }
+  return null;
+}
+async function exchangeCode(callback, verifier, redirectUri) {
+  const result = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/plain, */*",
+      "User-Agent": "axios/1.13.6"
+    },
+    body: JSON.stringify({
+      code: callback.code,
+      state: callback.state,
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      redirect_uri: redirectUri,
+      code_verifier: verifier
+    })
+  });
+  if (!result.ok) {
+    return {
+      type: "failed"
+    };
+  }
+  const json = await result.json();
+  return {
+    type: "success",
+    refresh: json.refresh_token,
+    access: json.access_token,
+    expires: Date.now() + json.expires_in * 1000
+  };
+}
+async function authorize(mode) {
+  const pkce = await generatePKCE();
+  const state = generateState();
+  const url = new URL(AUTHORIZE_URLS[mode], import.meta.url);
+  url.searchParams.set("code", "true");
+  url.searchParams.set("client_id", CLIENT_ID);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("redirect_uri", CODE_CALLBACK_URL);
+  url.searchParams.set("scope", OAUTH_SCOPES.join(" "));
+  url.searchParams.set("code_challenge", pkce.challenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("state", state);
+  return {
+    url: url.toString(),
+    redirectUri: CODE_CALLBACK_URL,
+    state,
+    verifier: pkce.verifier
+  };
+}
+async function exchange(input, verifier, redirectUri, expectedState) {
+  const callback = parseCallbackInput(input);
+  if (!callback) {
+    return {
+      type: "failed"
+    };
+  }
+  if (expectedState && callback.state !== expectedState) {
+    return {
+      type: "failed"
+    };
+  }
+  return exchangeCode(callback, verifier, redirectUri);
+}
+
+// src/cli.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var BLUE = "\x1B[34m";
+var CYAN = "\x1B[36m";
+function progressBar(value, threshold, width = 30) {
+  const pct = Math.min(value, 1);
+  const filled = Math.round(pct * width);
+  const empty = width - filled;
+  let color = GREEN;
+  if (value >= threshold)
+    color = RED;
+  else if (value >= threshold * 0.8)
+    color = YELLOW;
+  const bar = color + "\u2588".repeat(filled) + DIM + "\u2591".repeat(empty) + RESET;
+  const label = `${(value * 100).toFixed(1)}%`;
+  return `${bar} ${color}${label}${RESET}`;
+}
+async function prompt(question) {
+  process.stdout.write(question);
+  const buf = [];
+  return new Promise((resolve) => {
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    const onData = (chunk) => {
+      const str = chunk.toString();
+      if (str.includes(`
+`)) {
+        process.stdin.removeListener("data", onData);
+        process.stdin.pause();
+        buf.push(Buffer.from(str));
+        resolve(Buffer.concat(buf).toString().trim());
+      } else {
+        buf.push(Buffer.from(str));
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+async function cmdAdd(args) {
+  const name = args[0] || await prompt(`${CYAN}Account name: ${RESET}`);
+  if (!name) {
+    console.error(`${RED}Account name is required${RESET}`);
+    process.exit(1);
+  }
+  console.log(`
+${BOLD}Starting OAuth flow for account: ${CYAN}${name}${RESET}
+`);
+  const authResult = await authorize("max");
+  console.log(`${BOLD}Open this URL in your browser:${RESET}
+`);
+  console.log(`  ${BLUE}${authResult.url}${RESET}
+`);
+  console.log(`${DIM}After authorizing, paste the callback URL or code below:${RESET}
+`);
+  const callbackInput = await prompt(`${CYAN}Callback: ${RESET}`);
+  const exchangeResult = await exchange(callbackInput, authResult.verifier, authResult.redirectUri, authResult.state);
+  if (exchangeResult.type === "failed") {
+    console.error(`
+${RED}Authentication failed${RESET}`);
+    process.exit(1);
+  }
+  addAccount({
+    name,
+    access: exchangeResult.access,
+    refresh: exchangeResult.refresh,
+    expires: exchangeResult.expires
+  });
+  console.log(`
+${GREEN}Account "${name}" added successfully.${RESET}`);
+  console.log(`${DIM}Stored in: ${ACCOUNTS_FILE}${RESET}`);
+  const data = loadAccounts();
+  if (data.accounts.length === 1) {
+    const state = loadState();
+    state.currentAccount = name;
+    saveState(state);
+    console.log(`
+${YELLOW}This is the only account \u2014 set as active.${RESET}`);
+  }
+}
+async function cmdReauth(args) {
+  const data = loadAccounts();
+  if (data.accounts.length === 0) {
+    console.error(`${RED}No accounts configured.${RESET}`);
+    process.exit(1);
+  }
+  const name = args[0];
+  if (!name) {
+    console.log(`
+${BOLD}Available accounts:${RESET}`);
+    for (const a of data.accounts) {
+      console.log(`  - ${a.name}`);
+    }
+    console.error(`
+${RED}Usage: oc-auth-switcher reauth <account-name>${RESET}`);
+    process.exit(1);
+  }
+  const account = data.accounts.find((a) => a.name === name);
+  if (!account) {
+    console.error(`${RED}Account "${name}" not found${RESET}`);
+    process.exit(1);
+  }
+  console.log(`
+${BOLD}Re-authenticating account: ${CYAN}${name}${RESET}
+`);
+  const authResult = await authorize("max");
+  console.log(`${BOLD}Open this URL in your browser:${RESET}
+`);
+  console.log(`  ${BLUE}${authResult.url}${RESET}
+`);
+  const callbackInput = await prompt(`${CYAN}Callback: ${RESET}`);
+  const exchangeResult = await exchange(callbackInput, authResult.verifier, authResult.redirectUri, authResult.state);
+  if (exchangeResult.type === "failed") {
+    console.error(`
+${RED}Re-authentication failed${RESET}`);
+    process.exit(1);
+  }
+  account.access = exchangeResult.access;
+  account.refresh = exchangeResult.refresh;
+  account.expires = exchangeResult.expires;
+  saveAccounts(data);
+  const state = loadState();
+  clearAuthFailure(state, name);
+  saveState(state);
+  console.log(`
+${GREEN}Account "${name}" re-authenticated successfully.${RESET}`);
+}
+function cmdUsage(args) {
+  const watch = args.includes("--watch") || args.includes("-w");
+  const showUsage = () => {
+    const data = loadAccounts();
+    const state = loadState();
+    resolveStaleMetrics(state);
+    ensureAccountsInState(state, data.accounts.map((a) => a.name));
+    const thresholds = getThresholds(state.config);
+    if (watch) {
+      process.stdout.write("\x1B[2J\x1B[H");
+    }
+    console.log(`
+${BOLD}${CYAN}=== Auth Switcher Usage Dashboard ===${RESET}
+`);
+    console.log(`  Active account: ${BOLD}${state.currentAccount || "(none)"}${RESET}`);
+    console.log(`  Total accounts: ${data.accounts.length}`);
+    console.log(`  Thresholds:     5h=${(thresholds.session5h * 100).toFixed(0)}%  7d=${(thresholds.weekly7d * 100).toFixed(0)}%  7d-sonnet=${(thresholds.weekly7dSonnet * 100).toFixed(0)}%`);
+    console.log();
+    if (data.accounts.length === 0) {
+      console.log(`  ${DIM}No accounts configured. Run 'oc-auth-switcher add' to add one.${RESET}
+`);
+      return;
+    }
+    for (const account of data.accounts) {
+      const usage = state.usage[account.name];
+      const isActive = account.name === state.currentAccount;
+      const isCooling = !!state.authFailures[account.name] && state.authFailures[account.name] > Date.now();
+      const tag = isActive ? `${GREEN} [ACTIVE]${RESET}` : isCooling ? `${RED} [COOLDOWN]${RESET}` : "";
+      console.log(`  ${BOLD}${account.name}${RESET}${tag}`);
+      if (usage) {
+        console.log(`    5h session:  ${progressBar(usage.session5h.utilization, thresholds.session5h)}`);
+        console.log(`    7d weekly:   ${progressBar(usage.weekly7d.utilization, thresholds.weekly7d)}`);
+        console.log(`    7d sonnet:   ${progressBar(usage.weekly7dSonnet.utilization, thresholds.weekly7dSonnet)}`);
+        if (usage.timestamp) {
+          console.log(`    ${DIM}Last updated: ${usage.timestamp}${RESET}`);
+        }
+      } else {
+        console.log(`    ${DIM}No usage data \u2014 metrics update automatically on each API request${RESET}`);
+      }
+      const tokenExpiry = new Date(account.expires);
+      const isExpired = account.expires <= Date.now();
+      const tokenStatus = isExpired ? `${RED}EXPIRED${RESET}` : `${GREEN}valid until ${tokenExpiry.toLocaleString()}${RESET}`;
+      console.log(`    Token: ${tokenStatus}`);
+      console.log();
+    }
+  };
+  showUsage();
+  if (watch) {
+    console.log(`${DIM}Refreshing every 5 seconds. Press Ctrl+C to stop.${RESET}
+`);
+    setInterval(showUsage, 5000);
+    new Promise(() => {});
+  }
+}
+function cmdConfig(args) {
+  const state = loadState();
+  if (args.length === 0) {
+    const thresholds = getThresholds(state.config);
+    console.log(`
+${BOLD}${CYAN}=== Auth Switcher Configuration ===${RESET}
+`);
+    console.log(`  Threshold (5h):        ${(thresholds.session5h * 100).toFixed(0)}%`);
+    console.log(`  Threshold (7d):        ${(thresholds.weekly7d * 100).toFixed(0)}%`);
+    console.log(`  Threshold (7d sonnet): ${(thresholds.weekly7dSonnet * 100).toFixed(0)}%`);
+    console.log(`  Check interval:        ${state.config.checkInterval / 60000} min`);
+    console.log();
+    console.log(`${DIM}  Config file: ${STATE_FILE}${RESET}`);
+    console.log();
+    return;
+  }
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--threshold" && args[i + 1]) {
+      const val = parseFloat(args[++i]);
+      if (isNaN(val) || val < 0 || val > 1) {
+        console.error(`${RED}Threshold must be between 0 and 1 (e.g., 0.90)${RESET}`);
+        process.exit(1);
+      }
+      state.config.threshold = val;
+      console.log(`${GREEN}Set uniform threshold to ${(val * 100).toFixed(0)}%${RESET}`);
+    } else if (arg === "--thresholds" && args[i + 1]) {
+      const parts = args[++i].split(",").map((s) => parseFloat(s.trim()));
+      if (parts.length !== 3 || parts.some(isNaN)) {
+        console.error(`${RED}--thresholds requires 3 comma-separated values (e.g., 90,80,70)${RESET}`);
+        process.exit(1);
+      }
+      const normalized = parts.map((v) => v > 1 ? v / 100 : v);
+      state.config.threshold = {
+        session5h: normalized[0],
+        weekly7d: normalized[1],
+        weekly7dSonnet: normalized[2]
+      };
+      console.log(`${GREEN}Set per-metric thresholds: 5h=${(normalized[0] * 100).toFixed(0)}% 7d=${(normalized[1] * 100).toFixed(0)}% 7d-sonnet=${(normalized[2] * 100).toFixed(0)}%${RESET}`);
+    } else if (arg === "--interval" && args[i + 1]) {
+      const minutes = parseInt(args[++i], 10);
+      if (isNaN(minutes) || minutes < 1) {
+        console.error(`${RED}Interval must be a positive number of minutes${RESET}`);
+        process.exit(1);
+      }
+      state.config.checkInterval = minutes * 60 * 1000;
+      console.log(`${GREEN}Set check interval to ${minutes} minutes${RESET}`);
+    } else if (arg === "--reset") {
+      state.config.threshold = DEFAULT_THRESHOLD;
+      state.config.checkInterval = DEFAULT_CHECK_INTERVAL;
+      console.log(`${GREEN}Reset to defaults: threshold=${(DEFAULT_THRESHOLD * 100).toFixed(0)}% interval=${DEFAULT_CHECK_INTERVAL / 60000}min${RESET}`);
+    }
+  }
+  saveState(state);
+}
+function cmdSwitch(args) {
+  const data = loadAccounts();
+  if (data.accounts.length === 0) {
+    console.error(`${RED}No accounts configured.${RESET}`);
+    process.exit(1);
+  }
+  const name = args[0];
+  if (!name) {
+    console.log(`
+${BOLD}Available accounts:${RESET}`);
+    const state2 = loadState();
+    for (const a of data.accounts) {
+      const tag = a.name === state2.currentAccount ? ` ${GREEN}[ACTIVE]${RESET}` : "";
+      console.log(`  - ${a.name}${tag}`);
+    }
+    console.error(`
+${RED}Usage: oc-auth-switcher switch <account-name>${RESET}`);
+    process.exit(1);
+  }
+  const account = data.accounts.find((a) => a.name === name);
+  if (!account) {
+    console.error(`${RED}Account "${name}" not found${RESET}`);
+    process.exit(1);
+  }
+  console.log(`${CYAN}Switching to account: ${name}...${RESET}`);
+  const state = loadState();
+  state.currentAccount = name;
+  state.lastRotationCheck = Date.now();
+  saveState(state);
+  console.log(`${GREEN}Switched to "${name}". Will take effect on the next API request.${RESET}`);
+}
+function cmdStatus() {
+  const data = loadAccounts();
+  const state = loadState();
+  resolveStaleMetrics(state);
+  console.log(`
+${BOLD}${CYAN}=== Auth Switcher Status ===${RESET}
+`);
+  console.log(`  Active account:    ${BOLD}${state.currentAccount || "(none)"}${RESET}`);
+  console.log(`  Total accounts:    ${data.accounts.length}`);
+  console.log(`  Request count:     ${state.requestCount}`);
+  console.log(`  Last rotation:     ${state.lastRotationCheck ? new Date(state.lastRotationCheck).toLocaleString() : "never"}`);
+  console.log();
+  const failures = Object.entries(state.authFailures).filter(([_, until]) => until > Date.now());
+  if (failures.length > 0) {
+    console.log(`  ${RED}Auth cooldowns:${RESET}`);
+    for (const [name, until] of failures) {
+      const remaining = Math.ceil((until - Date.now()) / 60000);
+      console.log(`    - ${name}: ${remaining} min remaining`);
+    }
+    console.log();
+  }
+  console.log(`  ${DIM}Accounts file: ${ACCOUNTS_FILE}${RESET}`);
+  console.log(`  ${DIM}State file:    ${STATE_FILE}${RESET}`);
+  console.log();
+}
+function cmdRemove(args) {
+  const name = args[0];
+  if (!name) {
+    console.error(`${RED}Usage: oc-auth-switcher remove <account-name>${RESET}`);
+    process.exit(1);
+  }
+  const data = loadAccounts();
+  const found = data.accounts.find((a) => a.name === name);
+  if (!found) {
+    console.error(`${RED}Account "${name}" not found${RESET}`);
+    process.exit(1);
+  }
+  removeAccount(name);
+  console.log(`${GREEN}Account "${name}" removed.${RESET}`);
+  const state = loadState();
+  if (state.currentAccount === name) {
+    state.currentAccount = null;
+    saveState(state);
+    console.log(`${YELLOW}This was the active account. Rotation will pick a new one automatically.${RESET}`);
+  }
+}
+function showHelp() {
+  console.log(`
+${BOLD}oc-auth-switcher${RESET} \u2014 Multi-account Anthropic Claude Max rotation plugin
+
+${BOLD}USAGE:${RESET}
+  oc-auth-switcher <command> [options]
+
+${BOLD}COMMANDS:${RESET}
+  ${CYAN}add${RESET} [name]          Add a new Anthropic account via OAuth
+  ${CYAN}reauth${RESET} <name>       Re-authenticate an existing account
+  ${CYAN}usage${RESET} [--watch]     Show usage dashboard with utilization metrics
+  ${CYAN}config${RESET} [options]    View or modify threshold/interval configuration
+  ${CYAN}switch${RESET} <name>       Manually switch to a specific account
+  ${CYAN}status${RESET}              Show current active account and rotation state
+  ${CYAN}remove${RESET} <name>       Remove an account from the pool
+
+${BOLD}CONFIG OPTIONS:${RESET}
+  --threshold <0-1>          Set uniform threshold (e.g., 0.90)
+  --thresholds <a,b,c>       Set per-metric thresholds (5h,7d,7d-sonnet)
+  --interval <minutes>       Set primary recovery check interval
+  --reset                    Reset to defaults
+
+${BOLD}EXAMPLES:${RESET}
+  oc-auth-switcher add primary
+  oc-auth-switcher add fallback-1
+  oc-auth-switcher usage --watch
+  oc-auth-switcher config --threshold 0.90
+  oc-auth-switcher switch fallback-1
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const commandArgs = args.slice(1);
+  switch (command) {
+    case "add":
+    case "a":
+      await cmdAdd(commandArgs);
+      break;
+    case "reauth":
+      await cmdReauth(commandArgs);
+      break;
+    case "usage":
+    case "u":
+      cmdUsage(commandArgs);
+      break;
+    case "config":
+    case "c":
+      cmdConfig(commandArgs);
+      break;
+    case "switch":
+    case "s":
+      cmdSwitch(commandArgs);
+      break;
+    case "status":
+      cmdStatus();
+      break;
+    case "remove":
+    case "rm":
+      cmdRemove(commandArgs);
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+    case undefined:
+      showHelp();
+      break;
+    default:
+      console.error(`${RED}Unknown command: ${command}${RESET}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(`${RED}Fatal error:${RESET}`, err);
+  process.exit(1);
+});