@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-WRZJUQ5Z.js

@@ -0,0 +1,664 @@
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/cli/onboarding.ts
+init_esm_shims();
+import chalk from "chalk";
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var PROVIDERS = [
+  {
+    id: "openrouter",
+    name: "OpenRouter (\u63A8\u8350 \u2014 \u652F\u6301\u6240\u6709\u6A21\u578B)",
+    envKey: "OPENROUTER_API_KEY",
+    provider: "openai",
+    baseUrl: "https://openrouter.ai/api/v1",
+    defaultModel: "anthropic/claude-sonnet-4.6",
+    keyUrl: "https://openrouter.ai/keys",
+    keyPrefix: "sk-or-",
+    models: [
+      "anthropic/claude-opus-4.6",
+      "anthropic/claude-sonnet-4.6",
+      "anthropic/claude-haiku-4.5",
+      "openai/gpt-5.4",
+      "openai/gpt-4o",
+      "openai/o4-mini",
+      "google/gemini-3.1-pro-preview",
+      "google/gemini-3-flash-preview",
+      "google/gemini-2.5-pro",
+      "deepseek/deepseek-v3.2",
+      "deepseek/deepseek-r1",
+      "qwen/qwen3-coder",
+      "qwen/qwen3-235b-a22b",
+      "meta-llama/llama-4-maverick",
+      "mistralai/devstral-medium"
+    ]
+  },
+  {
+    id: "anthropic",
+    name: "Anthropic (\u76F4\u8FDE Claude API)",
+    envKey: "ANTHROPIC_API_KEY",
+    provider: "anthropic",
+    baseUrl: "https://api.anthropic.com",
+    defaultModel: "claude-sonnet-4-6",
+    keyUrl: "https://console.anthropic.com/settings/keys",
+    keyPrefix: "sk-ant-",
+    models: [
+      "claude-opus-4-6",
+      "claude-sonnet-4-6",
+      "claude-haiku-4-5"
+    ]
+  },
+  {
+    id: "openai",
+    name: "OpenAI",
+    envKey: "OPENAI_API_KEY",
+    provider: "openai",
+    baseUrl: "https://api.openai.com/v1",
+    defaultModel: "gpt-5.4",
+    keyUrl: "https://platform.openai.com/api-keys",
+    keyPrefix: "sk-",
+    models: ["gpt-5.4", "gpt-5.4-mini", "gpt-4o", "o4-mini", "o3"]
+  },
+  {
+    id: "custom",
+    name: "\u81EA\u5B9A\u4E49 (\u4EFB\u4F55 OpenAI \u517C\u5BB9 API)",
+    envKey: "",
+    provider: "openai",
+    baseUrl: "",
+    defaultModel: "",
+    keyUrl: "",
+    keyPrefix: "",
+    models: []
+  }
+];
+var BACK = /* @__PURE__ */ Symbol("back");
+function arrowSelect(options, title, opts) {
+  return new Promise((resolve, reject) => {
+    let cursor = 0;
+    const stdin = process.stdin;
+    const allowBack = opts?.allowBack ?? true;
+    if (typeof stdin.setRawMode !== "function") {
+      reject(new Error("Interactive onboarding requires a TTY. Set an API key via environment variable instead."));
+      return;
+    }
+    const wasRaw = stdin.isRaw;
+    const wasFlowing = stdin.readableFlowing;
+    const backHint = allowBack ? chalk.dim(" (ESC \u8FD4\u56DE)") : "";
+    function render() {
+      const lines = options.length + 1;
+      process.stdout.write(`\x1B[${lines}A\x1B[J`);
+      console.log(chalk.dim(`  ${title}`) + backHint);
+      for (let i = 0; i < options.length; i++) {
+        const opt = options[i];
+        const selected = i === cursor;
+        const prefix = selected ? chalk.cyan("\u276F ") : "  ";
+        const label = selected ? chalk.bold.cyan(opt.label) : chalk.white(opt.label);
+        const hint = opt.hint ? chalk.dim(` ${opt.hint}`) : "";
+        console.log(`  ${prefix}${label}${hint}`);
+      }
+    }
+    console.log(chalk.dim(`  ${title}`) + backHint);
+    for (const opt of options) {
+      const hint = opt.hint ? chalk.dim(` ${opt.hint}`) : "";
+      console.log(`    ${opt.label}${hint}`);
+    }
+    render();
+    stdin.setRawMode(true);
+    stdin.resume();
+    function onData(data) {
+      const key = data.toString();
+      if (key === "\x1B[A" || key === "k") {
+        cursor = cursor > 0 ? cursor - 1 : options.length - 1;
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        cursor = cursor < options.length - 1 ? cursor + 1 : 0;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve(options[cursor].value);
+      } else if (key === "\x1B" && allowBack) {
+        cleanup();
+        resolve(BACK);
+      } else if (key === "") {
+        cleanup();
+        process.exit(1);
+      } else {
+        const num = parseInt(key, 10);
+        if (num >= 1 && num <= options.length) {
+          cursor = num - 1;
+          render();
+          cleanup();
+          resolve(options[cursor].value);
+        }
+      }
+    }
+    function cleanup() {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(wasRaw ?? false);
+      if (wasFlowing) {
+        stdin.resume();
+      } else {
+        stdin.pause();
+      }
+    }
+    stdin.on("data", onData);
+  });
+}
+function textPrompt(question) {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    let buffer = "";
+    if (typeof stdin.setRawMode !== "function") {
+      reject(new Error("Interactive onboarding requires a TTY. Set an API key via environment variable instead."));
+      return;
+    }
+    const wasRaw = stdin.isRaw;
+    const wasFlowing = stdin.readableFlowing;
+    process.stdout.write(question);
+    stdin.setRawMode(true);
+    stdin.resume();
+    function onData(data) {
+      const ch = data.toString();
+      if (ch === "\x1B") {
+        cleanup();
+        process.stdout.write("\n");
+        resolve(BACK);
+      } else if (ch === "") {
+        cleanup();
+        process.exit(1);
+      } else if (ch === "\r" || ch === "\n") {
+        cleanup();
+        process.stdout.write("\n");
+        resolve(buffer.trim());
+      } else if (ch === "\x7F" || ch === "\b") {
+        if (buffer.length > 0) {
+          buffer = buffer.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+      } else if (ch >= " ") {
+        buffer += ch;
+        process.stdout.write(ch);
+      }
+    }
+    function cleanup() {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(wasRaw ?? false);
+      if (wasFlowing) {
+        stdin.resume();
+      } else {
+        stdin.pause();
+      }
+    }
+    stdin.on("data", onData);
+  });
+}
+async function confirm(question) {
+  const result = await arrowSelect(
+    [
+      { label: "\u662F", value: "yes" },
+      { label: "\u5426", value: "no" }
+    ],
+    question
+  );
+  if (result === BACK) return BACK;
+  return result === "yes";
+}
+async function validateApiKey(baseUrl, apiKey) {
+  try {
+    if (baseUrl.includes("openrouter")) {
+      const res2 = await fetch("https://openrouter.ai/api/v1/auth/key", {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      const data = await res2.json();
+      return !data.error;
+    }
+    const url = baseUrl.replace(/\/$/, "") + "/models";
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    return res.status !== 401 && res.status !== 403;
+  } catch {
+    return true;
+  }
+}
+function hasApiKey() {
+  if (process.env.OPENROUTER_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY) {
+    return true;
+  }
+  const settingsPaths = [
+    join(homedir(), ".code-shell", "settings.json"),
+    join(homedir(), ".claude", "settings.json")
+  ];
+  for (const p of settingsPaths) {
+    if (existsSync(p)) {
+      try {
+        const data = JSON.parse(readFileSync(p, "utf-8"));
+        if (data?.model?.apiKey) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+async function runOnboarding() {
+  console.log();
+  console.log(chalk.bold.cyan("  \u2726 Code Shell \u2014 \u9996\u6B21\u914D\u7F6E"));
+  console.log(chalk.dim("  \u2500".repeat(25)));
+  let step = "provider";
+  let selected = PROVIDERS[0];
+  let apiKey = "";
+  let model = "";
+  let poolModels = [];
+  while (step !== "done") {
+    switch (step) {
+      // ─── Step 1: Provider ────────────────────────────────────
+      case "provider": {
+        console.log();
+        const providerId = await arrowSelect(
+          PROVIDERS.map((p) => ({ label: p.name, value: p.id })),
+          "\u9009\u62E9 API \u63D0\u4F9B\u5546 (\u2191\u2193 \u79FB\u52A8, Enter \u786E\u8BA4):",
+          { allowBack: false }
+          // first step, no back
+        );
+        if (providerId === BACK) break;
+        selected = PROVIDERS.find((p) => p.id === providerId);
+        if (selected.id === "custom") {
+          const customResult = await configureCustomProvider();
+          if (customResult === BACK) break;
+          saveSettings(customResult);
+          printSuccess(selected.name, customResult.model);
+          return customResult;
+        }
+        step = "apikey";
+        break;
+      }
+      // ─── Step 2: API Key ─────────────────────────────────────
+      case "apikey": {
+        console.log();
+        if (selected.keyUrl) {
+          console.log(chalk.dim(`  \u83B7\u53D6 API Key: ${chalk.underline(selected.keyUrl)}`));
+        }
+        console.log();
+        const keyResult = await textPrompt(chalk.cyan(`  ${selected.envKey || "API Key"}: `));
+        if (keyResult === BACK) {
+          step = "provider";
+          break;
+        }
+        if (!keyResult) {
+          console.log(chalk.yellow("  \u26A0 \u8BF7\u8F93\u5165 API Key (ESC \u8FD4\u56DE\u4E0A\u4E00\u6B65)"));
+          break;
+        }
+        process.stdout.write(chalk.dim("  \u9A8C\u8BC1 Key..."));
+        const valid = await validateApiKey(selected.baseUrl, keyResult);
+        if (!valid) {
+          console.log(chalk.red(" \u2717 \u65E0\u6548"));
+          console.log(chalk.yellow("  \u26A0 API Key \u9A8C\u8BC1\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u540E\u91CD\u8BD5 (ESC \u8FD4\u56DE\u4E0A\u4E00\u6B65)"));
+          break;
+        }
+        console.log(chalk.green(" \u2713"));
+        apiKey = keyResult;
+        step = "model_pool";
+        break;
+      }
+      // ─── Step 3: Model Pool — select which models to enable ──
+      case "model_pool": {
+        if (selected.models.length <= 1) {
+          poolModels = [...selected.models];
+          model = selected.defaultModel;
+          step = "arena_ask";
+          break;
+        }
+        console.log();
+        console.log(chalk.dim("  \u9009\u62E9\u8981\u52A0\u5165\u6A21\u578B\u6C60\u7684\u6A21\u578B (\u6A21\u578B\u6C60\u4E2D\u7684\u6A21\u578B\u53EF\u901A\u8FC7 /model \u968F\u65F6\u5207\u6362)"));
+        const poolResult = await selectModelPool(selected.models, selected.defaultModel);
+        if (poolResult === BACK) {
+          step = "apikey";
+          break;
+        }
+        poolModels = poolResult;
+        if (poolModels.length === 0) {
+          poolModels = [selected.defaultModel];
+        }
+        step = "default_model";
+        break;
+      }
+      // ─── Step 4: Default Model — pick from pool ──────────────
+      case "default_model": {
+        if (poolModels.length === 1) {
+          model = poolModels[0];
+          saveSettings({ provider: selected.provider, model, apiKey, baseUrl: selected.baseUrl }, selected, poolModels);
+          step = "arena_ask";
+          break;
+        }
+        console.log();
+        const modelResult = await arrowSelect(
+          poolModels.map((m) => ({
+            label: m,
+            value: m,
+            hint: m === selected.defaultModel ? "(\u63A8\u8350)" : void 0
+          })),
+          "\u9009\u62E9\u9ED8\u8BA4\u6A21\u578B (\u65E5\u5E38\u5BF9\u8BDD\u4F7F\u7528):"
+        );
+        if (modelResult === BACK) {
+          step = "model_pool";
+          break;
+        }
+        model = modelResult;
+        saveSettings({ provider: selected.provider, model, apiKey, baseUrl: selected.baseUrl }, selected, poolModels);
+        step = "arena_ask";
+        break;
+      }
+      // ─── Step 5: Arena? ─────────────────────────────────────
+      case "arena_ask": {
+        saveSettings({ provider: selected.provider, model, apiKey, baseUrl: selected.baseUrl }, selected, poolModels);
+        if (poolModels.length < 2) {
+          step = "done";
+          break;
+        }
+        console.log();
+        const wantArena = await confirm("\u662F\u5426\u914D\u7F6E Arena \u591A\u6A21\u578B\u5BF9\u6BD4? (\u53EF\u5728 /arena \u4E2D\u4F7F\u7528\u591A\u4E2A\u6A21\u578B)");
+        if (wantArena === BACK) {
+          step = "default_model";
+          break;
+        }
+        if (wantArena) {
+          step = "arena_config";
+        } else {
+          step = "done";
+        }
+        break;
+      }
+      // ─── Step 6: Arena config — pick from pool ───────────────
+      case "arena_config": {
+        await configureArenaFromPool(poolModels, model);
+        step = "done";
+        break;
+      }
+    }
+  }
+  const result = { provider: selected.provider, model, apiKey, baseUrl: selected.baseUrl };
+  printSuccess(selected.name, model);
+  const stdin = process.stdin;
+  if (typeof stdin.setRawMode === "function") {
+    stdin.setRawMode(false);
+  }
+  stdin.removeAllListeners("data");
+  return result;
+}
+async function selectModelPool(available, defaultModel) {
+  const preselected = /* @__PURE__ */ new Set();
+  preselected.add(defaultModel);
+  const selected = new Set(preselected);
+  while (true) {
+    console.log();
+    console.log(chalk.dim("  \u5F53\u524D\u6A21\u578B\u6C60:"));
+    if (selected.size === 0) {
+      console.log(chalk.dim("    (\u7A7A)"));
+    } else {
+      for (const m of selected) {
+        console.log(`    ${chalk.cyan("\u2713")} ${m}`);
+      }
+    }
+    console.log();
+    const notInPool = available.filter((m) => !selected.has(m));
+    const options = [
+      ...notInPool.length > 0 ? [{ label: "\u6DFB\u52A0\u6A21\u578B", value: "add" }] : [],
+      ...selected.size > 0 ? [{ label: "\u79FB\u9664\u6A21\u578B", value: "remove" }] : [],
+      { label: selected.size > 0 ? `\u2713 \u786E\u8BA4 (${selected.size} \u4E2A\u6A21\u578B)` : "\u8DF3\u8FC7", value: "done" }
+    ];
+    const action = await arrowSelect(options, "\u6A21\u578B\u6C60\u64CD\u4F5C:", { allowBack: true });
+    if (action === BACK) return BACK;
+    if (action === "done") return [...selected];
+    if (action === "add") {
+      console.log();
+      const choice = await arrowSelect(
+        notInPool.map((m) => ({
+          label: m,
+          value: m,
+          hint: m === defaultModel ? "(\u63A8\u8350)" : void 0
+        })),
+        "\u6DFB\u52A0\u5230\u6A21\u578B\u6C60:"
+      );
+      if (choice !== BACK) {
+        selected.add(choice);
+        console.log(chalk.green(`  \u2713 \u5DF2\u6DFB\u52A0: ${modelDisplayName(choice)}`));
+      }
+    }
+    if (action === "remove") {
+      const inPool = [...selected];
+      console.log();
+      const choice = await arrowSelect(
+        inPool.map((m) => ({ label: m, value: m })),
+        "\u4ECE\u6A21\u578B\u6C60\u79FB\u9664:"
+      );
+      if (choice !== BACK) {
+        selected.delete(choice);
+        console.log(chalk.yellow(`  \u2717 \u5DF2\u79FB\u9664: ${modelDisplayName(choice)}`));
+      }
+    }
+  }
+}
+async function configureArenaFromPool(poolModels, defaultModel) {
+  const participants = /* @__PURE__ */ new Set();
+  console.log();
+  console.log(chalk.dim(`  \u4ECE\u6A21\u578B\u6C60\u4E2D\u9009\u62E9\u53C2\u4E0E Arena \u5BF9\u6BD4\u7684\u6A21\u578B (\u9ED8\u8BA4\u5BF9\u8BDD\u6A21\u578B: ${chalk.white(defaultModel)})`));
+  while (true) {
+    console.log();
+    if (participants.size > 0) {
+      console.log(chalk.dim("  \u5F53\u524D Arena \u9635\u5BB9:"));
+      let idx = 0;
+      for (const m of participants) {
+        idx++;
+        console.log(`    ${chalk.dim(`${idx}.`)} ${chalk.cyan(modelDisplayName(m))} ${chalk.dim(`(${m})`)}`);
+      }
+    } else {
+      console.log(chalk.dim("  \u5F53\u524D Arena \u9635\u5BB9: (\u7A7A)"));
+    }
+    console.log();
+    const notInArena = poolModels.filter((m) => !participants.has(m));
+    const options = [
+      ...notInArena.length > 0 ? [{ label: "\u4ECE\u6A21\u578B\u6C60\u6DFB\u52A0", value: "add" }] : [],
+      ...participants.size > 0 ? [{ label: "\u79FB\u9664\u6700\u540E\u6DFB\u52A0\u7684", value: "remove" }] : [],
+      {
+        label: participants.size >= 2 ? `\u2713 \u5B8C\u6210\u914D\u7F6E (${participants.size} \u4E2A\u6A21\u578B)` : "\u8DF3\u8FC7 (\u81F3\u5C11\u9700\u8981 2 \u4E2A\u6A21\u578B)",
+        value: "done"
+      }
+    ];
+    const action = await arrowSelect(options, "\u64CD\u4F5C:", { allowBack: true });
+    if (action === BACK || action === "done") break;
+    if (action === "add") {
+      console.log();
+      const choice = await arrowSelect(
+        notInArena.map((m) => ({ label: `${modelDisplayName(m)}  ${chalk.dim(m)}`, value: m })),
+        "\u9009\u62E9\u6A21\u578B:"
+      );
+      if (choice !== BACK) {
+        participants.add(choice);
+        console.log(chalk.green(`  \u2713 \u5DF2\u6DFB\u52A0: ${modelDisplayName(choice)}`));
+      }
+    }
+    if (action === "remove" && participants.size > 0) {
+      const arr = [...participants];
+      const removed = arr.pop();
+      participants.delete(removed);
+      console.log(chalk.yellow(`  \u2717 \u5DF2\u79FB\u9664: ${modelDisplayName(removed)}`));
+    }
+  }
+  if (participants.size >= 2) {
+    const arenaKeys = [...participants].map((m) => modelKey(m));
+    saveArenaSettingsByKeys(arenaKeys);
+    console.log();
+    console.log(chalk.green(`  \u2713 Arena \u5DF2\u914D\u7F6E ${participants.size} \u4E2A\u6A21\u578B`));
+  } else {
+    console.log(chalk.dim("  \u8DF3\u8FC7 Arena \u914D\u7F6E (\u9700\u8981\u81F3\u5C11 2 \u4E2A\u6A21\u578B)"));
+  }
+}
+async function configureCustomProvider() {
+  console.log();
+  const baseUrl = await textPrompt(chalk.cyan("  API Base URL: "));
+  if (baseUrl === BACK) return BACK;
+  const apiKey = await textPrompt(chalk.cyan("  API Key: "));
+  if (apiKey === BACK) return BACK;
+  const model = await textPrompt(chalk.cyan("  \u6A21\u578B\u540D\u79F0: "));
+  if (model === BACK) return BACK;
+  return {
+    provider: "openai",
+    model: model || "gpt-4o",
+    apiKey: apiKey || "",
+    baseUrl: baseUrl || "http://localhost:11434/v1"
+  };
+}
+var KNOWN_MAX_OUTPUT = {
+  "anthropic/claude-opus-4.6": 32e3,
+  "anthropic/claude-opus-4-6": 32e3,
+  "claude-opus-4-6": 32e3,
+  "anthropic/claude-sonnet-4.6": 16e3,
+  "anthropic/claude-sonnet-4-6": 16e3,
+  "claude-sonnet-4-6": 16e3,
+  "anthropic/claude-haiku-4.5": 8192,
+  "anthropic/claude-haiku-4-5": 8192,
+  "claude-haiku-4-5": 8192,
+  "openai/gpt-5.4": 32e3,
+  "gpt-5.4": 32e3,
+  "openai/gpt-4o": 16384,
+  "gpt-4o": 16384,
+  "openai/o4-mini": 1e5,
+  "o4-mini": 1e5,
+  "openai/o3": 1e5,
+  "o3": 1e5,
+  "google/gemini-3.1-pro-preview": 65536,
+  "google/gemini-3-flash-preview": 65536,
+  "google/gemini-2.5-pro": 65536,
+  "deepseek/deepseek-v3.2": 8192,
+  "deepseek/deepseek-r1": 8192,
+  "qwen/qwen3-coder": 16384,
+  "qwen/qwen3-235b-a22b": 8192,
+  "meta-llama/llama-4-maverick": 32e3,
+  "mistralai/devstral-medium": 24e3
+};
+function modelKey(model) {
+  const slash = model.lastIndexOf("/");
+  const base = slash >= 0 ? model.slice(slash + 1) : model;
+  if (base.startsWith("claude-")) {
+    const parts = base.split("-");
+    return parts.length >= 2 ? `${parts[0]}-${parts[1]}` : parts[0];
+  }
+  if (base.startsWith("gpt-")) {
+    const rest = base.slice(4);
+    if (/^\d/.test(rest)) return "gpt";
+    return `gpt${rest.split("-")[0]}`;
+  }
+  if (base.startsWith("gemini-")) {
+    if (base.includes("flash")) return "gemini-flash";
+    if (base.includes("pro")) return "gemini-pro";
+    return "gemini";
+  }
+  if (base.startsWith("deepseek-")) {
+    if (base.includes("r1")) return "deepseek-r1";
+    return "deepseek";
+  }
+  if (base.startsWith("qwen")) {
+    if (base.includes("coder")) return "qwen-coder";
+    return "qwen";
+  }
+  if (/^o\d/.test(base)) return base.split("-")[0];
+  if (base.startsWith("llama")) return "llama";
+  if (base.startsWith("devstral")) return "devstral";
+  return base.split("-")[0] ?? base;
+}
+function buildModelPool(provider, apiKey) {
+  return provider.models.map((m) => ({
+    key: modelKey(m),
+    label: modelDisplayName(m),
+    provider: provider.provider,
+    model: m,
+    baseUrl: provider.baseUrl,
+    apiKey,
+    maxOutputTokens: KNOWN_MAX_OUTPUT[m]
+  }));
+}
+function modelDisplayName(model) {
+  const slash = model.lastIndexOf("/");
+  const base = slash >= 0 ? model.slice(slash + 1) : model;
+  const parts = base.split("-");
+  if (parts[0] === "claude") {
+    const variant = parts[1] ?? "";
+    return `Claude ${variant.charAt(0).toUpperCase() + variant.slice(1)}`;
+  }
+  if (base.startsWith("gpt-")) return `GPT-${parts.slice(1).join("-")}`;
+  if (base.startsWith("gemini-")) return `Gemini ${parts.slice(1).join("-")}`;
+  return base.charAt(0).toUpperCase() + base.slice(1);
+}
+function printSuccess(providerName, model) {
+  console.log();
+  console.log(chalk.green("  \u2713 \u914D\u7F6E\u5DF2\u4FDD\u5B58"));
+  console.log(chalk.dim(`    Provider: ${providerName}`));
+  console.log(chalk.dim(`    Model:    ${model}`));
+  console.log(chalk.dim(`    Config:   ~/.code-shell/settings.json`));
+  console.log();
+}
+function saveSettings(result, providerDef, poolModels) {
+  const dir = join(homedir(), ".code-shell");
+  const file = join(dir, "settings.json");
+  mkdirSync(dir, { recursive: true });
+  let existing = {};
+  if (existsSync(file)) {
+    try {
+      existing = JSON.parse(readFileSync(file, "utf-8"));
+    } catch {
+    }
+  }
+  const updated = {
+    ...existing,
+    model: {
+      ...typeof existing.model === "object" ? existing.model : {},
+      provider: result.provider,
+      name: result.model,
+      apiKey: result.apiKey,
+      baseUrl: result.baseUrl
+    }
+  };
+  if (providerDef && poolModels && poolModels.length > 0) {
+    const allEntries = buildModelPool(providerDef, result.apiKey);
+    const selectedSet = new Set(poolModels);
+    updated.models = allEntries.filter((e) => selectedSet.has(e.model));
+  }
+  writeFileSync(file, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+}
+function saveArenaSettingsByKeys(keys) {
+  const dir = join(homedir(), ".code-shell");
+  const file = join(dir, "settings.json");
+  let existing = {};
+  if (existsSync(file)) {
+    try {
+      existing = JSON.parse(readFileSync(file, "utf-8"));
+    } catch {
+    }
+  }
+  const updated = {
+    ...existing,
+    arena: { participants: keys }
+  };
+  writeFileSync(file, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+}
+async function reconfigure() {
+  const file = join(homedir(), ".code-shell", "settings.json");
+  if (existsSync(file)) {
+    try {
+      const settings = JSON.parse(readFileSync(file, "utf-8"));
+      delete settings.model?.apiKey;
+      writeFileSync(file, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    } catch {
+    }
+  }
+  return runOnboarding();
+}
+
+export {
+  hasApiKey,
+  runOnboarding,
+  reconfigure
+};