apispoof 3.0.0

package/dist/cli.js

@@ -0,0 +1,2034 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/server.ts
+var import_http = require("http");
+var import_crypto2 = require("crypto");
+
+// src/config.ts
+var import_fs = require("fs");
+var import_crypto = require("crypto");
+var import_os = require("os");
+var import_path = require("path");
+var CONFIG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".apispoof");
+var CONFIG_FILE = (0, import_path.join)(CONFIG_DIR, "config.json");
+function configDir() {
+  return CONFIG_DIR;
+}
+function loadConfig() {
+  try {
+    if ((0, import_fs.existsSync)(CONFIG_FILE)) {
+      return JSON.parse((0, import_fs.readFileSync)(CONFIG_FILE, "utf8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function saveConfig(cfg) {
+  (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
+  (0, import_fs.writeFileSync)(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
+}
+function getOrCreateApiKey() {
+  const cfg = loadConfig();
+  if (cfg.apiKey) return cfg.apiKey;
+  const key = `sk-spoof-${(0, import_crypto.randomBytes)(24).toString("hex")}`;
+  saveConfig({ ...cfg, apiKey: key });
+  return key;
+}
+function getAccount(provider) {
+  const cfg = loadConfig();
+  return (cfg.accounts ?? []).find((a) => a.provider === provider && a.enabled);
+}
+function saveAccount(account) {
+  const cfg = loadConfig();
+  const accounts = (cfg.accounts ?? []).filter((a) => a.provider !== account.provider);
+  accounts.push(account);
+  saveConfig({ ...cfg, accounts });
+}
+function removeAccount(provider) {
+  const cfg = loadConfig();
+  const before = (cfg.accounts ?? []).length;
+  const accounts = (cfg.accounts ?? []).filter((a) => a.provider !== provider);
+  if (accounts.length === before) return false;
+  saveConfig({ ...cfg, accounts });
+  return true;
+}
+function listAccounts() {
+  const cfg = loadConfig();
+  return cfg.accounts ?? [];
+}
+
+// src/routing.ts
+var registeredProviders = [];
+function registerProviders(providers) {
+  registeredProviders = providers;
+}
+function availableProviders() {
+  return registeredProviders.filter((p) => p.available());
+}
+function pickProvider(model) {
+  const cfg = loadConfig();
+  const m = model.toLowerCase();
+  const apiProviders = registeredProviders.filter((p) => p.type !== "cli" && p.available());
+  for (const p of apiProviders) {
+    if (p.prefixes.some((pfx) => m.startsWith(pfx))) return p;
+  }
+  const cliProviders = registeredProviders.filter((p) => p.type === "cli" && p.available());
+  const override = process.env.APISPOOF_BACKEND?.toLowerCase() ?? cfg.backend?.toLowerCase();
+  if (override) {
+    const forced = cliProviders.find((p) => p.name === override);
+    if (forced) return forced;
+  }
+  for (const p of cliProviders) {
+    if (p.prefixes.some((pfx) => m.startsWith(pfx))) return p;
+  }
+  const anyAvailable = registeredProviders.find((p) => p.available());
+  if (anyAvailable) return anyAvailable;
+  throw new Error("No providers available. Run: apispoof connect <provider>");
+}
+var MODEL_CACHE_TTL = 5 * 60 * 1e3;
+var modelCache = null;
+async function allModels() {
+  if (modelCache && Date.now() < modelCache.expiresAt) return modelCache.models;
+  const available = registeredProviders.filter((p) => p.available());
+  const results = [];
+  for (const p of available) {
+    const ids = await p.models();
+    for (const id of ids) results.push({ id, provider: p.displayName });
+  }
+  modelCache = { models: results, expiresAt: Date.now() + MODEL_CACHE_TTL };
+  return results;
+}
+function providerStatus() {
+  return registeredProviders.map((p) => ({
+    name: p.name,
+    type: p.type,
+    available: p.available(),
+    displayName: p.displayName
+  }));
+}
+
+// src/server.ts
+function sse(data) {
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+function chunk(id, ts, model, delta, finish) {
+  return sse({
+    id,
+    object: "chat.completion.chunk",
+    created: ts,
+    model,
+    choices: [{ index: 0, delta, finish_reason: finish ?? null }]
+  });
+}
+function completionResponse(id, ts, model, text, usage) {
+  const pt = usage ? (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.promptTokenCount ?? 0) + (usage.prompt_tokens ?? 0) : 0;
+  const ct = usage ? (usage.output_tokens ?? 0) + (usage.candidatesTokenCount ?? 0) + (usage.completion_tokens ?? 0) : 0;
+  return {
+    id,
+    object: "chat.completion",
+    created: ts,
+    model,
+    choices: [{ index: 0, message: { role: "assistant", content: text }, finish_reason: "stop" }],
+    usage: { prompt_tokens: pt, completion_tokens: ct, total_tokens: pt + ct }
+  };
+}
+function setCors(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+}
+function sendJson(res, statusCode, body) {
+  const payload = Buffer.from(JSON.stringify(body));
+  setCors(res);
+  res.writeHead(statusCode, {
+    "Content-Type": "application/json",
+    "Content-Length": payload.byteLength
+  });
+  res.end(payload);
+}
+async function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
+function validateApiKey(req) {
+  const expected = getOrCreateApiKey();
+  const auth = req.headers.authorization ?? "";
+  if (auth.startsWith("Bearer ")) {
+    return auth.slice(7).trim() === expected;
+  }
+  return false;
+}
+async function handleModels(res) {
+  const ts = Math.floor(Date.now() / 1e3);
+  const models = await allModels();
+  sendJson(res, 200, {
+    object: "list",
+    data: models.map((m) => ({
+      id: m.id,
+      object: "model",
+      created: ts,
+      owned_by: m.provider
+    }))
+  });
+}
+function handleHealth(res, port) {
+  const status = providerStatus();
+  const providers = {};
+  for (const s of status) providers[s.displayName] = { type: s.type, available: s.available };
+  sendJson(res, 200, {
+    status: "ok",
+    version: "3.0.0",
+    port,
+    providers
+  });
+}
+async function handleChat(req, res) {
+  let body;
+  try {
+    body = JSON.parse(await readBody(req));
+  } catch {
+    sendJson(res, 400, { error: { message: "invalid JSON", type: "invalid_request_error" } });
+    return;
+  }
+  const messages = body?.messages;
+  if (!Array.isArray(messages) || messages.length === 0) {
+    sendJson(res, 400, { error: { message: "messages required", type: "invalid_request_error" } });
+    return;
+  }
+  const model = body.model ?? "claude-sonnet-4-6";
+  const streaming = Boolean(body.stream);
+  let provider;
+  try {
+    provider = pickProvider(model);
+  } catch (err) {
+    sendJson(res, 503, { error: { message: err.message, type: "server_error" } });
+    return;
+  }
+  const id = `chatcmpl-${(0, import_crypto2.randomUUID)().replace(/-/g, "").slice(0, 20)}`;
+  const ts = Math.floor(Date.now() / 1e3);
+  console.log(`  ${provider.displayName}  model=${model}  stream=${streaming}  turns=${messages.length}`);
+  if (streaming) {
+    setCors(res);
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "X-Accel-Buffering": "no"
+    });
+    res.flushHeaders();
+    res.write(chunk(id, ts, model, { role: "assistant" }));
+    try {
+      for await (const raw of provider.stream(messages, model)) {
+        res.write(chunk(id, ts, model, { content: raw.toString("utf8") }));
+      }
+    } catch (err) {
+      const msg = err.message ?? String(err);
+      console.error(`  stream error [${provider.name}]: ${msg}`);
+      res.write(chunk(id, ts, model, { content: `
+
+[apispoof] ${provider.name} error: ${msg}` }));
+    }
+    res.write(chunk(id, ts, model, {}, "stop"));
+    res.write("data: [DONE]\n\n");
+    res.end();
+  } else {
+    try {
+      const [text, usage] = await provider.runBlocking(messages, model);
+      sendJson(res, 200, completionResponse(id, ts, model, text, usage));
+    } catch (err) {
+      console.error(`  error [${provider.name}]: ${err.message}`);
+      sendJson(res, 500, { error: { message: err.message, type: "server_error" } });
+    }
+  }
+}
+function createSpoofServer(port) {
+  return (0, import_http.createServer)(async (req, res) => {
+    try {
+      const path = (req.url ?? "/").split("?")[0];
+      const method = req.method ?? "GET";
+      if (method === "OPTIONS") {
+        setCors(res);
+        res.writeHead(200);
+        res.end();
+        return;
+      }
+      if (method === "GET" && path === "/health") {
+        handleHealth(res, port);
+        return;
+      }
+      if (!validateApiKey(req)) {
+        sendJson(res, 401, { error: { message: "Invalid API key", type: "authentication_error" } });
+        return;
+      }
+      if (method === "GET" && (path === "/v1/models" || path === "/models")) {
+        await handleModels(res);
+        return;
+      }
+      if (method === "POST" && (path === "/v1/chat/completions" || path === "/chat/completions")) {
+        await handleChat(req, res);
+        return;
+      }
+      sendJson(res, 404, { error: { message: "not found", type: "not_found_error" } });
+    } catch (err) {
+      console.error("  unhandled server error:", err.message);
+      if (!res.headersSent) {
+        sendJson(res, 500, { error: { message: "internal server error", type: "server_error" } });
+      }
+    }
+  });
+}
+
+// src/service.ts
+var import_child_process = require("child_process");
+var import_fs2 = require("fs");
+var import_os2 = require("os");
+var import_path2 = require("path");
+var HOME = (0, import_os2.homedir)();
+var LABEL = "com.apispoof.server";
+function plistPath() {
+  return (0, import_path2.join)(HOME, "Library/LaunchAgents", `${LABEL}.plist`);
+}
+function writePlist(port, scriptPath, nodePath) {
+  const logDir = (0, import_path2.join)(HOME, ".apispoof");
+  (0, import_fs2.mkdirSync)(logDir, { recursive: true });
+  (0, import_fs2.mkdirSync)((0, import_path2.join)(HOME, "Library/LaunchAgents"), { recursive: true });
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${scriptPath}</string>
+    <string>start</string>
+  </array>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>APISPOOF_PORT</key>
+    <string>${port}</string>
+    <key>PATH</key>
+    <string>${HOME}/.local/bin:/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
+    <key>HOME</key>
+    <string>${HOME}</string>
+  </dict>
+
+  <key>StandardOutPath</key>
+  <string>${logDir}/server.log</string>
+  <key>StandardErrorPath</key>
+  <string>${logDir}/server.log</string>
+  <key>WorkingDirectory</key>
+  <string>${HOME}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+</dict>
+</plist>`;
+  (0, import_fs2.writeFileSync)(plistPath(), plist);
+}
+function unitPath() {
+  const configHome = process.env.XDG_CONFIG_HOME ?? (0, import_path2.join)(HOME, ".config");
+  return (0, import_path2.join)(configHome, "systemd/user/apispoof.service");
+}
+function writeUnit(port, scriptPath, nodePath) {
+  const logDir = (0, import_path2.join)(HOME, ".apispoof");
+  (0, import_fs2.mkdirSync)(logDir, { recursive: true });
+  (0, import_fs2.mkdirSync)((0, import_path2.join)(HOME, ".config/systemd/user"), { recursive: true });
+  const unit = `[Unit]
+Description=apispoof \u2014 AI API Bridge
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${scriptPath} start
+Environment=APISPOOF_PORT=${port}
+Environment=HOME=${HOME}
+Environment=PATH=${HOME}/.local/bin:/usr/local/bin:/usr/bin:/bin
+Restart=always
+StandardOutput=append:${logDir}/server.log
+StandardError=append:${logDir}/server.log
+
+[Install]
+WantedBy=default.target
+`;
+  (0, import_fs2.writeFileSync)(unitPath(), unit);
+}
+function installService(port) {
+  const scriptPath = process.argv[1];
+  const nodePath = process.execPath;
+  const os = (0, import_os2.platform)();
+  if (os === "darwin") {
+    try {
+      (0, import_child_process.execSync)(`launchctl unload "${plistPath()}" 2>/dev/null`, { stdio: "ignore" });
+    } catch {
+    }
+    writePlist(port, scriptPath, nodePath);
+    (0, import_child_process.execSync)(`launchctl load -w "${plistPath()}"`);
+    console.log(`  LaunchAgent installed -> ${plistPath()}`);
+  } else if (os === "linux") {
+    writeUnit(port, scriptPath, nodePath);
+    try {
+      (0, import_child_process.execSync)("systemctl --user daemon-reload");
+    } catch {
+    }
+    (0, import_child_process.execSync)("systemctl --user enable --now apispoof");
+    console.log("  systemd user service installed");
+  } else {
+    throw new Error(`Auto-install not supported on ${os}. Run 'apispoof start' manually.`);
+  }
+}
+function uninstallService() {
+  const os = (0, import_os2.platform)();
+  if (os === "darwin") {
+    const p = plistPath();
+    if ((0, import_fs2.existsSync)(p)) {
+      try {
+        (0, import_child_process.execSync)(`launchctl unload "${p}"`);
+      } catch {
+      }
+      (0, import_fs2.unlinkSync)(p);
+      console.log("  LaunchAgent removed");
+    } else {
+      console.log("  apispoof service is not installed");
+    }
+  } else if (os === "linux") {
+    const p = unitPath();
+    try {
+      (0, import_child_process.execSync)("systemctl --user disable --now apispoof");
+    } catch {
+    }
+    if ((0, import_fs2.existsSync)(p)) {
+      (0, import_fs2.unlinkSync)(p);
+      try {
+        (0, import_child_process.execSync)("systemctl --user daemon-reload");
+      } catch {
+      }
+    }
+    console.log("  systemd service removed");
+  } else {
+    throw new Error(`Not supported on ${os}`);
+  }
+}
+function serviceStatus() {
+  const os = (0, import_os2.platform)();
+  try {
+    if (os === "darwin") {
+      const out = (0, import_child_process.execSync)(`launchctl list ${LABEL} 2>/dev/null`, { encoding: "utf8" });
+      const pid = parseInt(out.match(/"PID"\s*=\s*(\d+)/)?.[1] ?? "0");
+      return { running: pid > 0, pid: pid || void 0 };
+    } else if (os === "linux") {
+      (0, import_child_process.execSync)("systemctl --user is-active apispoof", { stdio: "ignore" });
+      return { running: true };
+    }
+  } catch {
+  }
+  return { running: false };
+}
+
+// src/auth.ts
+var import_http2 = require("http");
+var import_crypto3 = require("crypto");
+var import_child_process2 = require("child_process");
+var import_os3 = require("os");
+function base64url(buf) {
+  return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function generatePKCE() {
+  const verifier = base64url((0, import_crypto3.randomBytes)(32));
+  const challenge = base64url((0, import_crypto3.createHash)("sha256").update(verifier).digest());
+  return { verifier, challenge };
+}
+var ANTHROPIC_OAUTH = {
+  authUrl: "https://claude.ai/oauth/authorize",
+  tokenUrl: "https://api.anthropic.com/v1/oauth/token",
+  clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+  scopes: "user:inference user:profile"
+};
+function openBrowser(url) {
+  try {
+    const cmd = (0, import_os3.platform)() === "darwin" ? "open" : (0, import_os3.platform)() === "win32" ? "start" : "xdg-open";
+    (0, import_child_process2.execSync)(`${cmd} "${url}"`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function waitForCallback(port, state) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("OAuth callback timed out after 5 minutes"));
+    }, 3e5);
+    const server = (0, import_http2.createServer)((req, res) => {
+      const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+      if (!url.pathname.endsWith("/callback")) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const returnedState = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      if (error) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(callbackPage("Authentication Failed", `Error: ${error}. You can close this tab.`));
+        clearTimeout(timeout);
+        server.close();
+        reject(new Error(`OAuth error: ${error}`));
+        return;
+      }
+      if (!code || returnedState !== state) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(callbackPage("Error", "Invalid callback. Please try again."));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(callbackPage("Connected!", "Authentication successful. You can close this tab."));
+      clearTimeout(timeout);
+      server.close();
+      resolve(code);
+    });
+    server.listen(port, "127.0.0.1");
+    server.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+}
+function callbackPage(title, message) {
+  return `<!DOCTYPE html><html><head><title>apispoof - ${title}</title>
+<style>body{font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#0a0a0a;color:#fafafa}
+.card{text-align:center;padding:3rem;border-radius:12px;background:#1a1a1a;border:1px solid #333}
+h1{margin:0 0 1rem;font-size:1.5rem}p{color:#888;margin:0}</style></head>
+<body><div class="card"><h1>${title}</h1><p>${message}</p></div></body></html>`;
+}
+async function exchangeCode(config, code, verifier, redirectUri) {
+  const res = await fetch(config.tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      code,
+      client_id: config.clientId,
+      code_verifier: verifier,
+      redirect_uri: redirectUri
+    })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Token exchange failed (${res.status}): ${text}`);
+  }
+  const data = await res.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresIn: data.expires_in,
+    email: data.account?.email_address,
+    orgId: data.organization?.uuid
+  };
+}
+async function refreshAnthropicToken(account) {
+  if (!account.refreshToken) throw new Error("No refresh token available");
+  const res = await fetch(ANTHROPIC_OAUTH.tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "refresh_token",
+      refresh_token: account.refreshToken,
+      client_id: ANTHROPIC_OAUTH.clientId
+    })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Token refresh failed (${res.status}): ${text}`);
+  }
+  const data = await res.json();
+  const updated = {
+    ...account,
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token ?? account.refreshToken,
+    expiresAt: Date.now() + (data.expires_in ?? 28800) * 1e3
+  };
+  saveAccount(updated);
+  return updated;
+}
+async function getValidAnthropicToken() {
+  const account = getAccount("anthropic");
+  if (!account) return null;
+  const bufferMs = 5 * 60 * 1e3;
+  if (account.expiresAt && Date.now() > account.expiresAt - bufferMs) {
+    try {
+      const refreshed = await refreshAnthropicToken(account);
+      return refreshed.accessToken;
+    } catch {
+      return null;
+    }
+  }
+  return account.accessToken;
+}
+async function connectAnthropic() {
+  const callbackPort = 18920 + Math.floor(Math.random() * 100);
+  const redirectUri = `http://127.0.0.1:${callbackPort}/callback`;
+  const { verifier, challenge } = generatePKCE();
+  const state = (0, import_crypto3.randomBytes)(16).toString("hex");
+  const authUrl = new URL(ANTHROPIC_OAUTH.authUrl);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", ANTHROPIC_OAUTH.clientId);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("scope", ANTHROPIC_OAUTH.scopes);
+  authUrl.searchParams.set("code_challenge", challenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  authUrl.searchParams.set("state", state);
+  console.log("\n  Opening browser for Anthropic authentication...");
+  const opened = openBrowser(authUrl.toString());
+  if (!opened) {
+    console.log("\n  Could not open browser. Visit this URL manually:");
+    console.log(`  ${authUrl.toString()}
+`);
+  }
+  console.log("  Waiting for authorization...");
+  const code = await waitForCallback(callbackPort, state);
+  const tokens = await exchangeCode(ANTHROPIC_OAUTH, code, verifier, redirectUri);
+  const account = {
+    provider: "anthropic",
+    accessToken: tokens.accessToken,
+    refreshToken: tokens.refreshToken,
+    expiresAt: tokens.expiresIn ? Date.now() + tokens.expiresIn * 1e3 : void 0,
+    email: tokens.email,
+    orgId: tokens.orgId,
+    enabled: true,
+    connectedAt: Date.now()
+  };
+  saveAccount(account);
+  return account;
+}
+async function connectOpenAI(apiKey) {
+  const res = await fetch("https://api.openai.com/v1/models", {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`OpenAI API key invalid (${res.status}): ${text}`);
+  }
+  const account = {
+    provider: "openai",
+    accessToken: apiKey,
+    enabled: true,
+    connectedAt: Date.now()
+  };
+  saveAccount(account);
+  return account;
+}
+async function connectGoogle(apiKey) {
+  const res = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`
+  );
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Google API key invalid (${res.status}): ${text}`);
+  }
+  const account = {
+    provider: "google",
+    accessToken: apiKey,
+    enabled: true,
+    connectedAt: Date.now()
+  };
+  saveAccount(account);
+  return account;
+}
+
+// src/providers-api.ts
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content))
+    return content.filter((p) => p.type === "text").map((p) => p.text ?? "").join(" ");
+  return String(content ?? "");
+}
+function toAnthropicPayload(messages, model, stream) {
+  const system = [];
+  const anthropicMsgs = [];
+  for (const m of messages) {
+    const text = extractText(m.content).trim();
+    if (!text) continue;
+    if (m.role === "system") {
+      system.push(text);
+      continue;
+    }
+    const role = m.role === "assistant" ? "assistant" : "user";
+    const last = anthropicMsgs[anthropicMsgs.length - 1];
+    if (last && last.role === role) {
+      anthropicMsgs[anthropicMsgs.length - 1] = { ...last, content: last.content + "\n" + text };
+    } else {
+      anthropicMsgs.push({ role, content: text });
+    }
+  }
+  if (anthropicMsgs.length === 0 || anthropicMsgs[0].role !== "user") {
+    anthropicMsgs.unshift({ role: "user", content: "Hello" });
+  }
+  return {
+    model,
+    max_tokens: 8192,
+    stream,
+    ...system.length > 0 ? { system: system.join("\n") } : {},
+    messages: anthropicMsgs
+  };
+}
+function toGooglePayload(messages, stream) {
+  const systemParts = [];
+  const contents = [];
+  for (const m of messages) {
+    const text = extractText(m.content).trim();
+    if (!text) continue;
+    if (m.role === "system") {
+      systemParts.push(text);
+      continue;
+    }
+    const role = m.role === "assistant" ? "model" : "user";
+    contents.push({ role, parts: [{ text }] });
+  }
+  return {
+    contents,
+    ...systemParts.length > 0 ? { systemInstruction: { parts: [{ text: systemParts.join("\n") }] } } : {},
+    generationConfig: { maxOutputTokens: 8192 }
+  };
+}
+async function* parseSSELines(response) {
+  const reader = response.body?.getReader();
+  if (!reader) return;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("data: ")) {
+          yield trimmed.slice(6);
+        }
+      }
+    }
+    if (buffer.trim().startsWith("data: ")) {
+      yield buffer.trim().slice(6);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+var AnthropicProvider = class {
+  constructor() {
+    this.name = "anthropic";
+    this.displayName = "Anthropic (OAuth)";
+    this.type = "oauth";
+    this.prefixes = ["claude"];
+  }
+  available() {
+    return Boolean(getAccount("anthropic"));
+  }
+  async models() {
+    return [
+      "claude-opus-4-6",
+      "claude-sonnet-4-6",
+      "claude-haiku-4-5-20251001"
+    ];
+  }
+  async headers() {
+    const token = await getValidAnthropicToken();
+    if (!token) throw new Error("Anthropic not connected or token expired. Run: apispoof connect anthropic");
+    return {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "anthropic-version": "2023-06-01",
+      "anthropic-beta": "oauth-2025-04-20",
+      "user-agent": "apispoof/3.0.0"
+    };
+  }
+  async runBlocking(messages, model) {
+    const headers = await this.headers();
+    const body = toAnthropicPayload(messages, model, false);
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text2 = await res.text();
+      throw new Error(`Anthropic API error (${res.status}): ${text2}`);
+    }
+    const data = await res.json();
+    const content = data.content;
+    const text = content?.filter((b) => b.type === "text").map((b) => b.text ?? "").join("") ?? "";
+    const usage = data.usage;
+    return [text, usage ?? null];
+  }
+  async *stream(messages, model) {
+    const headers = await this.headers();
+    const body = toAnthropicPayload(messages, model, true);
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Anthropic API error (${res.status}): ${text}`);
+    }
+    for await (const line of parseSSELines(res)) {
+      if (line === "[DONE]") break;
+      try {
+        const event = JSON.parse(line);
+        if (event.type === "content_block_delta") {
+          const delta = event.delta;
+          if (delta?.text) yield Buffer.from(delta.text);
+        }
+      } catch {
+      }
+    }
+  }
+};
+var OpenAIProvider = class {
+  constructor() {
+    this.name = "openai";
+    this.displayName = "OpenAI (API Key)";
+    this.type = "apikey";
+    this.prefixes = ["gpt", "o1", "o3", "o4", "chatgpt"];
+  }
+  available() {
+    return Boolean(getAccount("openai"));
+  }
+  async models() {
+    const account = getAccount("openai");
+    if (!account) return [];
+    try {
+      const res = await fetch("https://api.openai.com/v1/models", {
+        headers: { Authorization: `Bearer ${account.accessToken}` }
+      });
+      if (!res.ok) return this.fallbackModels();
+      const data = await res.json();
+      return data.data.map((m) => m.id).filter((id) => /^(gpt|o[134]|chatgpt)/.test(id)).sort();
+    } catch {
+      return this.fallbackModels();
+    }
+  }
+  fallbackModels() {
+    return ["gpt-4o", "gpt-4o-mini", "o3", "o4-mini"];
+  }
+  headers() {
+    const account = getAccount("openai");
+    if (!account) throw new Error("OpenAI not connected. Run: apispoof connect openai");
+    return {
+      "Authorization": `Bearer ${account.accessToken}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async runBlocking(messages, model) {
+    const res = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ model, messages, stream: false })
+    });
+    if (!res.ok) {
+      const text2 = await res.text();
+      throw new Error(`OpenAI API error (${res.status}): ${text2}`);
+    }
+    const data = await res.json();
+    const choices = data.choices;
+    const text = choices?.[0]?.message?.content ?? "";
+    const usage = data.usage;
+    return [text, usage ?? null];
+  }
+  async *stream(messages, model) {
+    const res = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ model, messages, stream: true })
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`OpenAI API error (${res.status}): ${text}`);
+    }
+    for await (const line of parseSSELines(res)) {
+      if (line === "[DONE]") break;
+      try {
+        const chunk2 = JSON.parse(line);
+        const choices = chunk2.choices;
+        const content = choices?.[0]?.delta?.content;
+        if (content) yield Buffer.from(content);
+      } catch {
+      }
+    }
+  }
+};
+var GoogleProvider = class {
+  constructor() {
+    this.name = "google";
+    this.displayName = "Google AI (API Key)";
+    this.type = "apikey";
+    this.prefixes = ["gemini"];
+  }
+  available() {
+    return Boolean(getAccount("google"));
+  }
+  async models() {
+    const account = getAccount("google");
+    if (!account) return [];
+    try {
+      const res = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models?key=${account.accessToken}`
+      );
+      if (!res.ok) return this.fallbackModels();
+      const data = await res.json();
+      return data.models.filter((m) => m.supportedGenerationMethods?.includes("generateContent")).map((m) => m.name.replace("models/", "")).filter((id) => id.startsWith("gemini")).sort();
+    } catch {
+      return this.fallbackModels();
+    }
+  }
+  fallbackModels() {
+    return ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash"];
+  }
+  apiKey() {
+    const account = getAccount("google");
+    if (!account) throw new Error("Google AI not connected. Run: apispoof connect google");
+    return account.accessToken;
+  }
+  async runBlocking(messages, model) {
+    const body = toGooglePayload(messages, false);
+    const res = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${this.apiKey()}`,
+      { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) }
+    );
+    if (!res.ok) {
+      const text2 = await res.text();
+      throw new Error(`Google AI error (${res.status}): ${text2}`);
+    }
+    const data = await res.json();
+    const candidates = data.candidates;
+    const text = candidates?.[0]?.content?.parts?.map((p) => p.text).join("") ?? "";
+    const usage = data.usageMetadata;
+    return [text, usage ?? null];
+  }
+  async *stream(messages, model) {
+    const body = toGooglePayload(messages, true);
+    const res = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models/${model}:streamGenerateContent?alt=sse&key=${this.apiKey()}`,
+      { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) }
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Google AI error (${res.status}): ${text}`);
+    }
+    for await (const line of parseSSELines(res)) {
+      if (line === "[DONE]") break;
+      try {
+        const data = JSON.parse(line);
+        const candidates = data.candidates;
+        const text = candidates?.[0]?.content?.parts?.map((p) => p.text).join("") ?? "";
+        if (text) yield Buffer.from(text);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/providers-cli.ts
+var import_child_process3 = require("child_process");
+var import_fs3 = require("fs");
+var import_os4 = require("os");
+var import_path3 = require("path");
+
+// src/messages.ts
+function extractText2(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((p) => p.type === "text").map((p) => p.text ?? "").join(" ");
+  }
+  return String(content ?? "");
+}
+function messagesToPrompt(messages) {
+  const system = [];
+  const turns = [];
+  for (const m of messages) {
+    const text = extractText2(m.content).trim();
+    if (!text) continue;
+    switch (m.role) {
+      case "system":
+        system.push(text);
+        break;
+      case "assistant":
+        turns.push(`Assistant: ${text}`);
+        break;
+      case "tool":
+        turns.push(`Tool result: ${text}`);
+        break;
+      default:
+        turns.push(`User: ${text}`);
+        break;
+    }
+  }
+  const parts = [];
+  if (system.length) parts.push("System instructions:\n" + system.join("\n"));
+  if (turns.length) parts.push(turns.join("\n\n"));
+  return parts.join("\n\n");
+}
+
+// src/providers-cli.ts
+var HOME2 = (0, import_os4.homedir)();
+function which(cmd) {
+  try {
+    return (0, import_child_process3.execFileSync)("which", [cmd], { encoding: "utf8" }).trim();
+  } catch {
+    return "";
+  }
+}
+var SKIP_TOKENS = /* @__PURE__ */ new Set([
+  "output",
+  "format",
+  "text",
+  "json",
+  "model",
+  "usage",
+  "help",
+  "exec",
+  "run",
+  "list",
+  "command",
+  "option",
+  "default",
+  "true",
+  "false",
+  "stdin",
+  "stdout",
+  "stderr",
+  "path",
+  "file",
+  "config",
+  "error",
+  "warn",
+  "approval",
+  "mode",
+  "yolo",
+  "version",
+  "verbose",
+  "debug",
+  "quiet",
+  "output-format",
+  "approval-mode",
+  "list-models",
+  "api-key",
+  "base-url"
+]);
+function extractModelIds(text) {
+  const seen = /* @__PURE__ */ new Set();
+  const re = /\b([a-z][a-z0-9]*(?:[.\-][a-z0-9]+)+)\b/g;
+  for (const [, id] of text.matchAll(re)) {
+    if (id.length >= 5 && /\d/.test(id) && !SKIP_TOKENS.has(id)) seen.add(id);
+  }
+  return [...seen];
+}
+async function tryDiscover(bin, strategies) {
+  for (const args of strategies) {
+    try {
+      const out = (0, import_child_process3.execFileSync)(bin, args, {
+        encoding: "utf8",
+        timeout: 5e3,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const found = extractModelIds(out);
+      if (found.length > 0) return found;
+    } catch {
+    }
+  }
+  return [];
+}
+async function* spawnStream(cmd, args, stdin) {
+  const proc = (0, import_child_process3.spawn)(cmd, args, { env: process.env, stdio: ["pipe", "pipe", "pipe"] });
+  if (stdin !== void 0) proc.stdin.end(stdin);
+  const stderrBufs = [];
+  proc.stderr.on("data", (c) => stderrBufs.push(c));
+  let hasOutput = false;
+  try {
+    for await (const chunk2 of proc.stdout) {
+      hasOutput = true;
+      yield chunk2;
+    }
+  } finally {
+    if (proc.exitCode === null) proc.kill();
+  }
+  const exitCode = await new Promise((resolve) => {
+    proc.exitCode !== null ? resolve(proc.exitCode) : proc.on("close", (c) => resolve(c ?? 0));
+  });
+  if (!hasOutput && exitCode !== 0) {
+    const stderr = Buffer.concat(stderrBufs).toString().trim();
+    throw new Error(stderr || `${(0, import_path3.basename)(cmd)} exited with code ${exitCode}`);
+  }
+}
+var GenericCLIBackend = class {
+  constructor(def) {
+    this.type = "cli";
+    this.name = def.name;
+    this.displayName = `${def.name} (CLI)`;
+    this.prefixes = def.prefixes;
+    this.def = def;
+  }
+  get bin() {
+    return which(this.def.bin) || `${HOME2}/.local/bin/${this.def.bin}`;
+  }
+  available() {
+    return Boolean(which(this.def.bin)) || (0, import_fs3.existsSync)(`${HOME2}/.local/bin/${this.def.bin}`);
+  }
+  async models() {
+    if (this.def.modelsCmd) {
+      try {
+        const out = (0, import_child_process3.execFileSync)(this.bin, this.def.modelsCmd, {
+          encoding: "utf8",
+          timeout: 5e3,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        const found = extractModelIds(out);
+        if (found.length > 0) return found;
+      } catch {
+      }
+    }
+    return this.def.models ?? [];
+  }
+  buildArgs(model) {
+    return this.def.args.map((a) => a === "{model}" ? model : a);
+  }
+  async runBlocking(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    const args = this.buildArgs(model);
+    let out;
+    try {
+      if (this.def.promptMode === "stdin") {
+        out = (0, import_child_process3.execFileSync)(this.bin, args, { input: prompt, encoding: "utf8", timeout: 3e5 });
+      } else {
+        out = (0, import_child_process3.execFileSync)(this.bin, [...args, prompt], { encoding: "utf8", timeout: 3e5 });
+      }
+    } catch (e) {
+      throw new Error(e.stderr?.trim() || `${this.def.bin} exited non-zero`);
+    }
+    return [out.trim(), null];
+  }
+  async *stream(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    const args = this.buildArgs(model);
+    if (this.def.promptMode === "stdin") {
+      yield* spawnStream(this.bin, args, prompt);
+    } else {
+      yield* spawnStream(this.bin, [...args, prompt]);
+    }
+  }
+};
+var ClaudeCLIBackend = class {
+  constructor() {
+    this.name = "claude-cli";
+    this.displayName = "Claude Code (CLI)";
+    this.type = "cli";
+    this.prefixes = ["claude"];
+  }
+  get bin() {
+    return process.env.CLAUDE_BIN ?? which("claude") ?? `${HOME2}/.local/bin/claude`;
+  }
+  available() {
+    return Boolean(which("claude")) || (0, import_fs3.existsSync)(`${HOME2}/.local/bin/claude`);
+  }
+  async models() {
+    const bin = which("claude") || this.bin;
+    const found = await tryDiscover(bin, [["models"], ["models", "list"], ["model", "list"], ["--list-models"]]);
+    if (found.length > 0) return found;
+    return ["claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5-20251001"];
+  }
+  async runBlocking(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    let out;
+    try {
+      out = (0, import_child_process3.execFileSync)(this.bin, ["-p", "--output-format", "json", "--model", model], {
+        input: prompt,
+        encoding: "utf8",
+        timeout: 3e5
+      });
+    } catch (e) {
+      throw new Error(e.stderr?.trim() || "claude exited non-zero");
+    }
+    try {
+      const data = JSON.parse(out.trim() || "{}");
+      return [data.result ?? "", data.usage ?? null];
+    } catch {
+      return [out.trim(), null];
+    }
+  }
+  async *stream(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    yield* spawnStream(this.bin, ["-p", "--output-format", "text", "--model", model], prompt);
+  }
+};
+var GeminiCLIBackend = class {
+  constructor() {
+    this.name = "gemini-cli";
+    this.displayName = "Gemini (CLI)";
+    this.type = "cli";
+    this.prefixes = ["gemini"];
+  }
+  get bin() {
+    return process.env.GEMINI_BIN ?? which("gemini") ?? "/opt/homebrew/bin/gemini";
+  }
+  available() {
+    return Boolean(which("gemini")) || (0, import_fs3.existsSync)(this.bin);
+  }
+  async models() {
+    const bin = which("gemini") || this.bin;
+    const found = await tryDiscover(bin, [["models"], ["models", "list"], ["--list-models"], ["list-models"]]);
+    if (found.length > 0) return found;
+    return ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash"];
+  }
+  async runBlocking(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    let out;
+    try {
+      out = (0, import_child_process3.execFileSync)(this.bin, ["--output-format", "json", "--model", model, "--approval-mode", "yolo"], {
+        input: prompt,
+        encoding: "utf8",
+        timeout: 3e5,
+        env: process.env
+      });
+    } catch (e) {
+      const err = e.stderr?.trim() ?? "";
+      if (/auth|login|sign.?in/i.test(err))
+        throw new Error("Gemini not authenticated. Run: gemini auth  OR  export GEMINI_API_KEY=<key>");
+      throw new Error(err || "gemini exited non-zero");
+    }
+    const raw = out.trim();
+    try {
+      const data = JSON.parse(raw);
+      return [String(data.response ?? data.result ?? data.text ?? raw), data.tokenCount ?? data.usage ?? null];
+    } catch {
+      return [raw, null];
+    }
+  }
+  async *stream(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    yield* spawnStream(this.bin, ["--output-format", "text", "--model", model, "--approval-mode", "yolo"], prompt);
+  }
+};
+var CodexCLIBackend = class {
+  constructor() {
+    this.name = "codex-cli";
+    this.displayName = "Codex (CLI)";
+    this.type = "cli";
+    this.prefixes = ["gpt", "o3", "o4"];
+  }
+  get bin() {
+    return process.env.CODEX_BIN ?? which("codex") ?? "codex";
+  }
+  available() {
+    return Boolean(which("codex"));
+  }
+  async models() {
+    const found = await tryDiscover(this.bin, [["models"], ["models", "list"], ["--list-models"], ["list-models"]]);
+    if (found.length > 0) return found;
+    return ["gpt-4o", "gpt-4o-mini", "o3", "o4-mini"];
+  }
+  async runBlocking(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    let out;
+    try {
+      out = (0, import_child_process3.execFileSync)(this.bin, ["-q", "--model", model, prompt], { encoding: "utf8", timeout: 3e5 });
+    } catch (e) {
+      throw new Error(e.stderr?.trim() || "codex exited non-zero");
+    }
+    return [out.trim(), null];
+  }
+  async *stream(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    yield* spawnStream(this.bin, ["-q", "--model", model, prompt]);
+  }
+};
+var CopilotCLIBackend = class {
+  constructor() {
+    this.name = "copilot-cli";
+    this.displayName = "GitHub Copilot (CLI)";
+    this.type = "cli";
+    this.prefixes = ["copilot"];
+  }
+  get bin() {
+    return process.env.GH_BIN ?? which("gh") ?? "gh";
+  }
+  available() {
+    if (!which("gh")) return false;
+    try {
+      (0, import_child_process3.execFileSync)("gh", ["copilot", "--version"], { encoding: "utf8", stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async models() {
+    const found = await tryDiscover(this.bin, [["copilot", "models"], ["copilot", "models", "list"]]);
+    if (found.length > 0) return found;
+    return ["copilot"];
+  }
+  async runBlocking(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    let out;
+    try {
+      out = (0, import_child_process3.execFileSync)(this.bin, ["copilot", "explain", prompt], { encoding: "utf8", timeout: 12e4 });
+    } catch (e) {
+      throw new Error(e.stderr?.trim() || "gh copilot exited non-zero");
+    }
+    return [out.trim(), null];
+  }
+  async *stream(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    yield* spawnStream(this.bin, ["copilot", "explain", prompt]);
+  }
+};
+var DroidCLIBackend = class _DroidCLIBackend {
+  constructor() {
+    this.name = "droid-cli";
+    this.displayName = "Droid (CLI)";
+    this.type = "cli";
+    this.prefixes = ["droid", "factory", "glm", "kimi", "minimax"];
+  }
+  static {
+    this.KNOWN_MODELS = [
+      "claude-opus-4-6",
+      "claude-sonnet-4-6",
+      "claude-haiku-4-5-20251001",
+      "gpt-4o",
+      "gpt-4o-mini",
+      "glm-4.7",
+      "glm-5",
+      "kimi-k2.5",
+      "minimax-m2.5"
+    ];
+  }
+  get bin() {
+    return process.env.DROID_BIN ?? which("droid") ?? `${HOME2}/.local/bin/droid`;
+  }
+  available() {
+    return Boolean(which("droid")) || (0, import_fs3.existsSync)(`${HOME2}/.local/bin/droid`);
+  }
+  async models() {
+    try {
+      const help = (0, import_child_process3.execFileSync)(which("droid") || this.bin, ["exec", "--help"], {
+        encoding: "utf8",
+        timeout: 5e3,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const found = extractModelIds(help);
+      if (found.length > 0) return found;
+    } catch {
+    }
+    return _DroidCLIBackend.KNOWN_MODELS;
+  }
+  async runBlocking(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    let out;
+    try {
+      out = (0, import_child_process3.execFileSync)(
+        which("droid") || this.bin,
+        ["exec", "--output-format", "text", "--model", model],
+        { input: prompt, encoding: "utf8", timeout: 3e5 }
+      );
+    } catch (e) {
+      throw new Error(e.stderr?.trim() || "droid exited non-zero");
+    }
+    return [out.trim(), null];
+  }
+  async *stream(messages, model) {
+    const prompt = messagesToPrompt(messages);
+    yield* spawnStream(
+      which("droid") || this.bin,
+      ["exec", "--output-format", "text", "--model", model],
+      prompt
+    );
+  }
+};
+function buildCLIBackends() {
+  const builtins = [
+    new ClaudeCLIBackend(),
+    new GeminiCLIBackend(),
+    new CodexCLIBackend(),
+    new CopilotCLIBackend(),
+    new DroidCLIBackend()
+  ];
+  try {
+    const cfg = loadConfig();
+    const custom = (cfg.customBackends ?? []).map((def) => new GenericCLIBackend(def));
+    return [...builtins, ...custom];
+  } catch {
+    return builtins;
+  }
+}
+
+// src/cli.ts
+var import_fs4 = require("fs");
+var import_os5 = require("os");
+var import_path4 = require("path");
+var import_readline = require("readline");
+var DEFAULT_PORT = parseInt(process.env.APISPOOF_PORT ?? "8082");
+var LOG_DIR = configDir();
+function initProviders() {
+  const api = [new AnthropicProvider(), new OpenAIProvider(), new GoogleProvider()];
+  const cli = buildCLIBackends();
+  registerProviders([...api, ...cli]);
+}
+function ask(question) {
+  const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function askHidden(question) {
+  return new Promise((resolve) => {
+    const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
+    process.stdout.write(question);
+    const stdin = process.stdin;
+    if (stdin.setRawMode) stdin.setRawMode(true);
+    let input = "";
+    const onData = (c) => {
+      const ch = c.toString();
+      if (ch === "\n" || ch === "\r") {
+        if (stdin.setRawMode) stdin.setRawMode(false);
+        process.stdin.removeListener("data", onData);
+        process.stdout.write("\n");
+        rl.close();
+        resolve(input);
+      } else if (ch === "") {
+        process.exit(1);
+      } else if (ch === "\x7F") {
+        input = input.slice(0, -1);
+      } else {
+        input += ch;
+        process.stdout.write("*");
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+async function printBanner(port) {
+  const apiKey = getOrCreateApiKey();
+  const providers = availableProviders();
+  const models = await allModels();
+  console.log();
+  console.log("  apispoof is running");
+  console.log();
+  console.log(`  Base URL  : http://127.0.0.1:${port}/v1`);
+  console.log(`  API Key   : ${apiKey}`);
+  console.log(`  Providers : ${providers.map((p) => p.displayName).join(", ") || "none"}`);
+  console.log(`  Models    : ${models.length} available`);
+  console.log(`  Logs      : ${LOG_DIR}/server.log`);
+  console.log();
+  console.log("  Use in your tools:");
+  console.log(`    OPENAI_API_BASE=http://127.0.0.1:${port}/v1`);
+  console.log(`    OPENAI_API_KEY=${apiKey}`);
+  console.log();
+}
+async function cmdConnect(providerArg) {
+  const providers = [
+    { name: "anthropic", label: "Anthropic (Claude)", method: "OAuth \u2014 connect with your Claude account" },
+    { name: "openai", label: "OpenAI", method: "API Key \u2014 from platform.openai.com/api-keys" },
+    { name: "google", label: "Google AI (Gemini)", method: "API Key \u2014 from aistudio.google.com/apikey" }
+  ];
+  let provider;
+  if (providerArg) {
+    const match = providers.find((p) => p.name === providerArg.toLowerCase() || p.label.toLowerCase().includes(providerArg.toLowerCase()));
+    if (!match) {
+      console.error(`  Unknown provider: ${providerArg}`);
+      console.error(`  Available: ${providers.map((p) => p.name).join(", ")}`);
+      process.exit(1);
+    }
+    provider = match;
+  } else {
+    console.log();
+    console.log("  Connect an AI provider");
+    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log();
+    providers.forEach((p, i) => {
+      console.log(`    ${i + 1}. ${p.label}`);
+      console.log(`       ${p.method}`);
+    });
+    console.log();
+    const choice = await ask("  Choose [1/2/3]: ");
+    const idx = parseInt(choice) - 1;
+    if (idx < 0 || idx >= providers.length) {
+      console.log("  Cancelled.");
+      return;
+    }
+    provider = providers[idx];
+  }
+  console.log();
+  console.log(`  Connecting to ${provider.label}...`);
+  try {
+    if (provider.name === "anthropic") {
+      const account = await connectAnthropic();
+      console.log();
+      console.log(`  Connected as ${account.email ?? "unknown user"}`);
+      const ap = new AnthropicProvider();
+      const models = await ap.models();
+      console.log(`  Available models: ${models.join(", ")}`);
+    } else if (provider.name === "openai") {
+      console.log();
+      const key = await askHidden("  Enter your OpenAI API key: ");
+      if (!key) {
+        console.log("  Cancelled.");
+        return;
+      }
+      await connectOpenAI(key);
+      console.log();
+      const op = new OpenAIProvider();
+      const models = await op.models();
+      console.log(`  Connected (${models.length} models available)`);
+      const popular = models.filter((m) => /^(gpt-[45]|o[134])/.test(m)).slice(0, 8);
+      if (popular.length) console.log(`  Popular: ${popular.join(", ")}`);
+    } else if (provider.name === "google") {
+      console.log();
+      const key = await askHidden("  Enter your Gemini API key: ");
+      if (!key) {
+        console.log("  Cancelled.");
+        return;
+      }
+      await connectGoogle(key);
+      console.log();
+      const gp = new GoogleProvider();
+      const models = await gp.models();
+      console.log(`  Connected (${models.length} models available)`);
+      const gemini = models.filter((m) => m.startsWith("gemini")).slice(0, 6);
+      if (gemini.length) console.log(`  Models: ${gemini.join(", ")}`);
+    }
+    console.log();
+  } catch (err) {
+    console.error(`
+  Connection failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function cmdDisconnect(providerArg) {
+  if (!providerArg) {
+    console.error("  Usage: apispoof disconnect <provider>");
+    console.error("  Providers: anthropic, openai, google");
+    process.exit(1);
+  }
+  const name = providerArg.toLowerCase();
+  if (!["anthropic", "openai", "google"].includes(name)) {
+    console.error(`  Unknown provider: ${providerArg}`);
+    process.exit(1);
+  }
+  const removed = removeAccount(name);
+  if (removed) {
+    console.log(`  Disconnected from ${name}`);
+  } else {
+    console.log(`  ${name} was not connected`);
+  }
+}
+function cmdAccounts() {
+  const accounts = listAccounts();
+  console.log();
+  console.log("  Connected accounts");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log();
+  if (accounts.length === 0) {
+    console.log("  No accounts connected.");
+    console.log("  Run: apispoof connect");
+    console.log();
+    return;
+  }
+  for (const a of accounts) {
+    const label = a.provider === "anthropic" ? "Anthropic (Claude)" : a.provider === "openai" ? "OpenAI" : "Google AI (Gemini)";
+    const method = a.provider === "anthropic" ? "OAuth" : "API Key";
+    const since = new Date(a.connectedAt).toLocaleDateString();
+    const status = a.enabled ? "active" : "disabled";
+    console.log(`  ${a.enabled ? "+" : "-"}  ${label}`);
+    console.log(`     Method: ${method}  |  Since: ${since}  |  Status: ${status}`);
+    if (a.email) console.log(`     Email: ${a.email}`);
+    if (a.expiresAt) {
+      const remaining = Math.max(0, Math.round((a.expiresAt - Date.now()) / 6e4));
+      console.log(`     Token: ${remaining > 0 ? `${remaining}min remaining` : "expired (will auto-refresh)"}`);
+    }
+    console.log();
+  }
+}
+async function cmdModels() {
+  console.log();
+  console.log("  Available models");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log();
+  const models = await allModels();
+  if (models.length === 0) {
+    console.log("  No models available.");
+    console.log("  Run: apispoof connect  to add a provider");
+    console.log();
+    return;
+  }
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const m of models) {
+    const list = byProvider.get(m.provider) ?? [];
+    list.push(m.id);
+    byProvider.set(m.provider, list);
+  }
+  for (const [provider, ids] of byProvider) {
+    console.log(`  ${provider}:`);
+    for (const id of ids.slice(0, 12)) {
+      console.log(`    ${id}`);
+    }
+    if (ids.length > 12) console.log(`    ... +${ids.length - 12} more`);
+    console.log();
+  }
+}
+async function cmdSetup() {
+  console.log();
+  console.log("  apispoof \u2014 AI API Bridge");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("  Connect your AI accounts to create an OpenAI-compatible API.");
+  console.log("  Use with Goose, Cursor, Aider, Continue, or any tool.");
+  console.log();
+  const accounts = listAccounts();
+  const cliAvailable = buildCLIBackends().filter((b) => b.available());
+  if (accounts.length > 0) {
+    console.log("  Connected accounts:");
+    for (const a of accounts) {
+      const label = a.provider === "anthropic" ? "Anthropic" : a.provider === "openai" ? "OpenAI" : "Google";
+      console.log(`    + ${label}${a.email ? ` (${a.email})` : ""}`);
+    }
+    console.log();
+  }
+  if (cliAvailable.length > 0) {
+    console.log("  CLI backends detected:");
+    for (const b of cliAvailable) console.log(`    + ${b.displayName}`);
+    console.log();
+  }
+  const wantsConnect = await ask("  Connect a new account? [Y/n]: ");
+  if (wantsConnect.toLowerCase() !== "n") {
+    await cmdConnect();
+  }
+  let more = true;
+  while (more) {
+    const again = await ask("  Connect another provider? [y/N]: ");
+    if (again.toLowerCase() === "y") {
+      await cmdConnect();
+    } else {
+      more = false;
+    }
+  }
+  const cfg = loadConfig();
+  const defaultPort = cfg.port ?? DEFAULT_PORT;
+  const portAnswer = await ask(`  Port [${defaultPort}]: `);
+  const port = portAnswer ? parseInt(portAnswer) || defaultPort : defaultPort;
+  saveConfig({ ...cfg, port });
+  console.log();
+  console.log("  How to run apispoof?");
+  console.log("    1  Foreground  (stops when terminal closes)");
+  console.log("    2  Background service  (auto-starts on login)");
+  console.log();
+  const choice = await ask("  Choose [1/2]: ");
+  console.log();
+  if (choice === "2") {
+    cmdInstall(port);
+  } else {
+    cmdStart(port);
+  }
+}
+function cmdStart(port) {
+  (0, import_fs4.mkdirSync)(LOG_DIR, { recursive: true });
+  const cfg = loadConfig();
+  if (cfg.backend) process.env.APISPOOF_BACKEND = cfg.backend;
+  const available = availableProviders();
+  if (available.length === 0) {
+    console.error("  No providers available.");
+    console.error("  Run: apispoof connect  to add an account");
+    console.error("  Or install a CLI: claude, gemini, codex, etc.");
+    process.exit(1);
+  }
+  const server = createSpoofServer(port);
+  server.listen(port, "127.0.0.1", async () => {
+    allModels().catch(() => {
+    });
+    await printBanner(port);
+    console.log("  Ctrl+C to stop.");
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`  Port ${port} already in use. Try: apispoof start --port 9000`);
+    } else {
+      console.error("  Server error:", err.message);
+    }
+    process.exit(1);
+  });
+}
+function cmdInstall(port) {
+  try {
+    installService(port);
+    console.log("  Waiting for server to start...");
+    let attempts = 0;
+    const poll = setInterval(async () => {
+      attempts++;
+      try {
+        const http = await import("http");
+        http.get(`http://127.0.0.1:${port}/health`, (res) => {
+          if (res.statusCode === 200) {
+            clearInterval(poll);
+            printBanner(port).then(() => {
+              console.log("  Stop: apispoof uninstall");
+              process.exit(0);
+            });
+          }
+        }).on("error", () => {
+        });
+      } catch {
+      }
+      if (attempts >= 15) {
+        clearInterval(poll);
+        console.log(`
+  Server did not respond. Check: tail -f ${LOG_DIR}/server.log`);
+        process.exit(1);
+      }
+    }, 600);
+  } catch (err) {
+    console.error("  Install failed:", err.message);
+    process.exit(1);
+  }
+}
+function cmdUninstall() {
+  try {
+    uninstallService();
+  } catch (err) {
+    console.error("  Uninstall failed:", err.message);
+    process.exit(1);
+  }
+}
+async function cmdStatus(port) {
+  const { running, pid } = serviceStatus();
+  if (running) {
+    await printBanner(port);
+    if (pid) console.log(`  PID: ${pid}`);
+  } else {
+    console.log("  apispoof is not running.");
+    console.log();
+    console.log("  Run: apispoof          -> setup wizard");
+    console.log("  Run: apispoof start    -> start in foreground");
+    console.log("  Run: apispoof install  -> install background service");
+  }
+}
+function cmdKey(args) {
+  if (args[0] === "reset") {
+    const cfg2 = loadConfig();
+    const { apiKey: _, ...rest } = cfg2;
+    saveConfig(rest);
+    const newKey = getOrCreateApiKey();
+    console.log(`  API key regenerated: ${newKey}`);
+    return;
+  }
+  const apiKey = getOrCreateApiKey();
+  const cfg = loadConfig();
+  const port = cfg.port ?? DEFAULT_PORT;
+  console.log();
+  console.log("  apispoof API key (OpenAI-compatible)");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log();
+  console.log(`  ${apiKey}`);
+  console.log();
+  console.log("  Quick setup:");
+  console.log(`    export OPENAI_API_BASE=http://127.0.0.1:${port}/v1`);
+  console.log(`    export OPENAI_API_KEY=${apiKey}`);
+  console.log();
+  console.log("  Reset: apispoof key reset");
+  console.log();
+}
+function cmdConfig(args) {
+  const cfg = loadConfig();
+  if (args[0] === "set") {
+    for (const pair of args.slice(1)) {
+      const eqIdx = pair.indexOf("=");
+      if (eqIdx === -1) {
+        console.error(`  Invalid format: ${pair}  (use key=value)`);
+        process.exit(1);
+      }
+      const key = pair.slice(0, eqIdx);
+      const val = pair.slice(eqIdx + 1);
+      if (key === "port") {
+        const p = parseInt(val);
+        if (isNaN(p) || p < 1 || p > 65535) {
+          console.error("  Invalid port");
+          process.exit(1);
+        }
+        saveConfig({ ...cfg, port: p });
+        console.log(`  port -> ${p}`);
+      } else {
+        console.error(`  Unknown key: ${key}  (valid: port)`);
+        process.exit(1);
+      }
+    }
+    return;
+  }
+  if (args[0] === "reset") {
+    saveConfig({});
+    console.log("  Config reset to defaults.");
+    return;
+  }
+  console.log();
+  console.log("  apispoof config");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log(`  port       : ${cfg.port ?? `${DEFAULT_PORT} (default)`}`);
+  console.log(`  apiKey     : ${cfg.apiKey ?? "(not generated yet)"}`);
+  console.log(`  accounts   : ${(cfg.accounts ?? []).length} connected`);
+  console.log(`  file       : ${(0, import_path4.join)((0, import_os5.homedir)(), ".apispoof/config.json")}`);
+  console.log();
+}
+async function cmdBackendAdd() {
+  console.log();
+  console.log("  Add a custom backend CLI");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log();
+  const name = await ask("  Backend name (e.g. opencode): ");
+  if (!name) {
+    console.log("  Cancelled.");
+    return;
+  }
+  const bin = await ask(`  Binary name in PATH [${name}]: `) || name;
+  const prefixRaw = await ask(`  Model prefixes, comma-separated [${name}]: `);
+  const prefixes = prefixRaw ? prefixRaw.split(",").map((s) => s.trim()).filter(Boolean) : [name];
+  console.log("  How is the prompt delivered?");
+  console.log("    1  stdin  (piped to process.stdin)");
+  console.log("    2  arg    (appended as last argument)");
+  const modeChoice = await ask("  Choose [1/2]: ");
+  const promptMode = modeChoice === "2" ? "arg" : "stdin";
+  console.log("  Command args template. Use {model} for the model name.");
+  const argsRaw = await ask("  Args: ");
+  const args = argsRaw.trim().split(/\s+/).filter(Boolean);
+  const modelsCmdRaw = await ask("  Args to list models (blank to skip): ");
+  const modelsCmd = modelsCmdRaw.trim() ? modelsCmdRaw.trim().split(/\s+/) : void 0;
+  const modelsRaw = await ask("  Fallback model list, comma-separated (blank to skip): ");
+  const models = modelsRaw.trim() ? modelsRaw.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+  const def = { name, bin, prefixes, promptMode, args, modelsCmd, models };
+  const cfg = loadConfig();
+  const existing = cfg.customBackends ?? [];
+  const idx = existing.findIndex((b) => b.name === name);
+  if (idx >= 0) {
+    existing[idx] = def;
+  } else {
+    existing.push(def);
+  }
+  saveConfig({ ...cfg, customBackends: existing });
+  console.log(`
+  ${name} backend saved. Restart apispoof for it to take effect.`);
+}
+async function cmdBackendList() {
+  console.log();
+  console.log("  CLI Backends:");
+  console.log();
+  const backends = buildCLIBackends();
+  for (const b of backends) {
+    if (!b.available()) {
+      console.log(`  -  ${b.displayName}  (not installed)`);
+      continue;
+    }
+    process.stdout.write(`  +  ${b.displayName}  (discovering models...)\r`);
+    const models = await b.models();
+    const preview = models.slice(0, 6).join("  ");
+    const extra = models.length > 6 ? `  +${models.length - 6} more` : "";
+    console.log(`  +  ${b.displayName}                                    `);
+    console.log(`     ${preview}${extra}`);
+    console.log();
+  }
+}
+async function cmdChat(model) {
+  const models = await allModels();
+  const fallbackModel = models[0]?.id ?? "claude-sonnet-4-6";
+  const chatModel = model ?? fallbackModel;
+  let provider;
+  try {
+    provider = pickProvider(chatModel);
+  } catch (err) {
+    console.error(`  ${err.message}`);
+    process.exit(1);
+  }
+  console.log();
+  console.log(`  apispoof chat \u2014 ${provider.displayName}`);
+  console.log(`  Model: ${chatModel}`);
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("  Type a message and press Enter. Ctrl+C to exit.");
+  console.log();
+  const history = [];
+  const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  rl.on("close", () => {
+    console.log("\n  Goodbye.");
+    process.exit(0);
+  });
+  const prompt = () => {
+    rl.question("You: ", async (input) => {
+      const text = input.trim();
+      if (!text) {
+        prompt();
+        return;
+      }
+      history.push({ role: "user", content: text });
+      process.stdout.write("\n");
+      let reply = "";
+      try {
+        process.stdout.write(`${provider.displayName}: `);
+        for await (const chunk2 of provider.stream(history, chatModel)) {
+          const piece = chunk2.toString("utf8");
+          process.stdout.write(piece);
+          reply += piece;
+        }
+      } catch (err) {
+        process.stdout.write(`
+  Error: ${err.message}`);
+      }
+      process.stdout.write("\n\n");
+      if (reply) history.push({ role: "assistant", content: reply });
+      prompt();
+    });
+  };
+  prompt();
+}
+function showHelp() {
+  console.log(`
+  apispoof \u2014 AI API Bridge
+  Turn your AI subscriptions into an OpenAI-compatible API.
+
+  Account management:
+    apispoof                          Interactive setup wizard
+    apispoof connect [provider]       Connect an account (anthropic, openai, google)
+    apispoof disconnect <provider>    Disconnect an account
+    apispoof accounts                 Show connected accounts
+    apispoof models                   List all available models
+
+  Server:
+    apispoof start [--port n]         Start API server in the foreground
+    apispoof install [--port n]       Install as a background service
+    apispoof uninstall                Remove background service
+    apispoof status                   Show service status
+
+  Usage:
+    apispoof key                      Show your OpenAI-compatible API key
+    apispoof key reset                Regenerate the API key
+    apispoof chat [--model m]         Chat in the terminal
+
+  Configuration:
+    apispoof config                   Show saved configuration
+    apispoof config set port=<n>      Set default port
+    apispoof config reset             Clear saved configuration
+    apispoof backend                  List all CLI backends
+    apispoof backend add              Add a custom CLI backend
+
+  Providers: anthropic (OAuth), openai (API key), google (API key)
+  CLI backends: claude, gemini, codex, copilot, droid
+  `.trim());
+}
+function parseArgs() {
+  const cfg = loadConfig();
+  const args = process.argv.slice(2);
+  const cmd = args[0] ?? "";
+  let port = cfg.port ?? DEFAULT_PORT;
+  let model;
+  const rest = [];
+  for (let i = 1; i < args.length; i++) {
+    if ((args[i] === "--port" || args[i] === "-p") && args[i + 1]) {
+      port = parseInt(args[++i]);
+    } else if ((args[i] === "--model" || args[i] === "-m") && args[i + 1]) {
+      model = args[++i];
+    } else {
+      rest.push(args[i]);
+    }
+  }
+  return { cmd, port, model, rest };
+}
+async function main() {
+  initProviders();
+  const { cmd, port, model, rest } = parseArgs();
+  switch (cmd) {
+    case "":
+    case "setup":
+      await cmdSetup();
+      break;
+    case "connect":
+      await cmdConnect(rest[0]);
+      break;
+    case "disconnect":
+      await cmdDisconnect(rest[0]);
+      break;
+    case "accounts":
+      cmdAccounts();
+      break;
+    case "models":
+      await cmdModels();
+      break;
+    case "chat":
+      await cmdChat(model);
+      break;
+    case "start":
+      cmdStart(port);
+      break;
+    case "install":
+      cmdInstall(port);
+      break;
+    case "uninstall":
+      cmdUninstall();
+      break;
+    case "status":
+      await cmdStatus(port);
+      break;
+    case "key":
+      cmdKey(rest);
+      break;
+    case "config":
+      cmdConfig(rest);
+      break;
+    case "backend":
+      if (rest[0] === "add") await cmdBackendAdd();
+      else await cmdBackendList();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      showHelp();
+      break;
+    default:
+      showHelp();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("  Fatal:", err.message);
+  process.exit(1);
+});