@wrongstack/cli 0.295.0 → 0.296.2

package/dist/chunk-JBSQ7ONN.js

@@ -0,0 +1,1023 @@
+import {
+  hasApiKey,
+  isKeylessLocalProvider,
+  visibleModelIds
+} from "./chunk-66T43Q4Y.js";
+import {
+  appendHistory,
+  backupCurrent
+} from "./chunk-YWUPHRGB.js";
+
+// src/arg-parser.ts
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "yolo",
+  "no-yolo",
+  "yolo-destructive",
+  "confirm-destructive",
+  "force-all-yolo",
+  "verbose",
+  "trace",
+  "help",
+  "version",
+  "yes",
+  "no-banner",
+  "no-features",
+  "tui",
+  "no-tui",
+  // Legacy no-ops: every surface now starts fresh unless an explicit
+  // `--resume <id>` is supplied. Keep parsing these as booleans so old
+  // launch scripts do not accidentally consume the next positional token.
+  "no-recovery",
+  "recover",
+  "output-json",
+  "prompt",
+  "metrics",
+  "webui",
+  "simpleui",
+  "full-auto",
+  "desktop",
+  "open",
+  "webui-require-token",
+  "require-token",
+  "no-check",
+  "no-models-refresh",
+  // (removed: 'director' and 'no-director' — Director Mode is always on)
+  "no-autonomy",
+  "no-hints",
+  "hints",
+  "no-menu",
+  "no-hooks",
+  "skip",
+  "skip-index",
+  "mouse",
+  "no-interactive",
+  "token-saving-mode",
+  "system-lite",
+  "system-pro",
+  "hq",
+  "hq-allow-exec",
+  "tunnel",
+  // Opt-in to a non-loopback HQ bind with no token/password configured.
+  "insecure-open",
+  "strict-port",
+  "client",
+  // `wstack update` booleans. Keeping these here prevents parseArgs from
+  // consuming a following positional token as an accidental flag value.
+  "check-only",
+  "allow-scripts",
+  "lifecycle-scripts",
+  "npm",
+  "pnpm",
+  "yarn",
+  "bun",
+  // `wstack acp` booleans. Without these, parseArgs treats the value after
+  // `--fs`/`--echo` as the flag's value and eats a following positional
+  // (e.g. the agent list in `acp bench --fs gemini-cli,codex-cli`).
+  "echo",
+  "fs",
+  // `wstack modeldiag test` booleans. Keep a following positional token from
+  // being consumed as the value of one of these switches.
+  "all-models",
+  "plan",
+  "json"
+]);
+function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a) continue;
+    if (a === "--") {
+      positional.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) {
+        flags[a.slice(2, eq)] = a.slice(eq + 1);
+        continue;
+      }
+      const name = a.slice(2);
+      if (BOOLEAN_FLAGS.has(name)) {
+        flags[name] = true;
+        continue;
+      }
+      if (i + 1 < argv.length && !(argv[i + 1] ?? "").startsWith("-")) {
+        flags[name] = argv[++i] ?? "";
+      } else {
+        flags[name] = true;
+      }
+    } else if (a.startsWith("-") && a.length === 2) {
+      const short = a.slice(1);
+      const expand = { v: "verbose", y: "yes" };
+      flags[expand[short] ?? short] = true;
+    } else {
+      positional.push(a);
+    }
+  }
+  normalizeSurfaceAliases(flags, positional);
+  return { flags, positional };
+}
+function normalizeSurfaceAliases(flags, positional) {
+  if (flags["simpleui"]) flags["webui"] = true;
+  const first = positional[0];
+  if (first === "simpleui") {
+    flags["simpleui"] = true;
+    flags["webui"] = true;
+    positional.splice(0, 1);
+    return;
+  }
+  if (first === "webui" || first === "desktop") {
+    flags[first] = true;
+    positional.splice(0, 1);
+    return;
+  }
+  if (first === "hq" && (positional.length === 1 || positional[1] === "serve")) {
+    flags["hq"] = true;
+    positional.splice(0, positional[1] === "serve" ? 2 : 1);
+  }
+}
+function parseAuthFlags(args) {
+  const out = { positional: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--label") {
+      const v = args[++i];
+      if (v) out.label = v;
+    } else if (a === "--family") {
+      const v = args[++i];
+      if (v) out.family = v;
+    } else if (a === "--base-url") {
+      const v = args[++i];
+      if (v) out.baseUrl = v;
+    } else if (a === "--env") {
+      const v = args[++i];
+      if (v)
+        out.envVars = v.split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (a && !a.startsWith("--")) {
+      out.positional.push(a);
+    }
+  }
+  return out;
+}
+function parseSpawnFlags(input) {
+  const opts = {};
+  let rest = input;
+  const consume = (re) => {
+    const m = rest.match(re);
+    if (m) {
+      rest = rest.slice(m[0].length).replace(/^\s+/, "");
+      return m;
+    }
+    return null;
+  };
+  while (rest.length > 0) {
+    let m;
+    m = consume(/^--provider=(\S+)\s*/);
+    if (m) opts.provider = m[1];
+    else {
+      m = consume(/^--model=(\S+)\s*/);
+      if (m) opts.model = m[1];
+      else {
+        m = consume(/^--name=("([^"]+)"|(\S+))\s*/);
+        if (m) opts.name = m[2] ?? m[3];
+        else {
+          m = consume(/^--tools=(\S+)\s*/);
+          if (m)
+            opts.tools = m[1]?.split(",").map((t) => t.trim()).filter(Boolean);
+          else {
+            m = consume(/^-p\s+(\S+)\s*/);
+            if (m) opts.provider = m[1];
+            else {
+              m = consume(/^-m\s+(\S+)\s*/);
+              if (m) opts.model = m[1];
+              else {
+                m = consume(/^-n\s+("([^"]+)"|(\S+))\s*/);
+                if (m) opts.name = m[2] ?? m[3];
+                else break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return { description: rest.trim(), opts };
+}
+
+// src/auth-menu/local-presets.ts
+import { projectLocalProviderPresets } from "@wrongstack/providers/definitions";
+var LOCAL_LLM_PRESETS = projectLocalProviderPresets();
+
+// src/picker.ts
+import os from "node:os";
+import { color as color3, expectDefined as expectDefined2, setOutputLineGuard as setOutputLineGuard2, setRawMode as setRawMode2, stripAnsi as stripAnsi2, writeOut as writeOut2 } from "@wrongstack/core/utils";
+import { toErrorMessage } from "@wrongstack/core/utils";
+
+// src/picker-key-state.ts
+function applyPickerKey(state, chunk, matchCount) {
+  if (chunk === "\x1B[A") return { ...state, selected: Math.max(0, state.selected - 1) };
+  if (chunk === "\x1B[B")
+    return { ...state, selected: Math.min(Math.max(0, matchCount - 1), state.selected + 1) };
+  if (chunk === "\x1B") return { ...state, query: "", selected: 0, status: "typing" };
+  if (chunk.charCodeAt(0) === 27) return state;
+  let query = state.query;
+  let selected = state.selected;
+  const status = "typing";
+  for (const ch of chunk) {
+    if (ch === "\r" || ch === "\n") {
+      return { ...state, status: matchCount > 0 ? "submitted" : "typing" };
+    }
+    if (ch === "") return { ...state, status: "cancelled" };
+    if (ch === "") {
+      query = "";
+      selected = 0;
+      continue;
+    }
+    if (ch === "\x7F" || ch === "\b") {
+      query = query.slice(0, -1);
+      selected = 0;
+      continue;
+    }
+    if (ch >= " " && ch !== "\x7F") {
+      query += ch;
+      selected = 0;
+    }
+  }
+  return { query, selected, status };
+}
+
+// src/picker-model-picker.ts
+import { color as color2, expectDefined, setOutputLineGuard, setRawMode, writeOut } from "@wrongstack/core/utils";
+
+// src/picker-ui.ts
+import { color, stripAnsi } from "@wrongstack/core/utils";
+var theme = {
+  accent: color.amber,
+  chrome: color.gray,
+  cursor: (s) => color.amber(color.bold(s)),
+  ctx: color.cyan,
+  cost: color.green,
+  caps: color.magenta
+};
+var BOX = {
+  tl: "\u256D",
+  tr: "\u256E",
+  bl: "\u2570",
+  br: "\u256F",
+  h: "\u2500",
+  v: "\u2502"
+};
+var PICKER_MIN_WIDTH = 74;
+var PICKER_MAX_WIDTH = 100;
+function pickerWidth() {
+  const cols = process.stdout.columns;
+  if (typeof cols !== "number" || !Number.isFinite(cols) || cols <= 0) {
+    return PICKER_MIN_WIDTH;
+  }
+  return Math.max(PICKER_MIN_WIDTH, Math.min(PICKER_MAX_WIDTH, cols - 2));
+}
+function visibleWidth(s) {
+  return stripAnsi(s).length;
+}
+function padVisible(s, width) {
+  const w = visibleWidth(s);
+  if (w === width) return s;
+  if (w < width) return s + " ".repeat(width - w);
+  const plain = stripAnsi(s);
+  return `${plain.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+function boxTop(title) {
+  const width = pickerWidth();
+  const label = ` ${title} `;
+  const pad = Math.max(0, width - visibleWidth(label) - 1);
+  return theme.chrome(
+    `${BOX.tl}${BOX.h}${theme.accent(color.bold(label))}${theme.chrome(BOX.h.repeat(pad))}${BOX.tr}`
+  );
+}
+function boxBottom() {
+  return theme.chrome(`${BOX.bl}${BOX.h.repeat(pickerWidth())}${BOX.br}`);
+}
+function boxRow(content) {
+  return `${theme.chrome(BOX.v)} ${padVisible(content, pickerWidth() - 2)} ${theme.chrome(BOX.v)}`;
+}
+function boxDivider() {
+  return theme.chrome(`${BOX.v}${BOX.h.repeat(pickerWidth())}${BOX.v}`);
+}
+function keyHints(pairs) {
+  return pairs.map(([k, label]) => `${theme.accent(k)} ${color.dim(label)}`).join(color.dim(" \xB7 "));
+}
+var CODEX_PROVIDER_ID = "openai-codex";
+var CODEX_PICKER_HEADER = "Select Model and Effort";
+var CODEX_LEGACY_NOTE = "Access legacy models by running `wstack -m <model_name>` or in your `config.json`.";
+function codexPickerPreamble(provider) {
+  if (provider.id !== CODEX_PROVIDER_ID) return "";
+  return `  ${color.bold(CODEX_PICKER_HEADER)}
+${color.dim(`  ${CODEX_LEGACY_NOTE}`)}
+
+`;
+}
+
+// src/picker-model-picker.ts
+var LIVE_PICKER_MAX_VISIBLE = 15;
+function filterModels(query, models) {
+  const q = query.trim().toLowerCase();
+  if (!q) return [...models];
+  return models.filter((m) => m.id.toLowerCase().includes(q) || m.name.toLowerCase().includes(q));
+}
+function renderLiveModelList(query, filtered, selectedIdx, header) {
+  const ordered = [...filtered].sort(
+    (a, b) => (b.release_date ?? "").localeCompare(a.release_date ?? "")
+  );
+  const visible = ordered.slice(0, LIVE_PICKER_MAX_VISIBLE);
+  const lines = [];
+  lines.push(boxTop("Select a model"));
+  lines.push(boxRow(color2.dim(header)));
+  const caret = query.length > 0 ? color2.dim("\u258F") : theme.cursor("\u258F");
+  lines.push(boxRow(`${theme.accent("\u276F")} ${color2.dim("Select model:")} ${query}${caret}`));
+  lines.push(boxDivider());
+  let flat = 0;
+  for (const m of visible) {
+    const selected = flat === selectedIdx;
+    const marker = selected ? theme.cursor("\u25B6") : " ";
+    const ctxRaw = m.limit?.context ? `${(m.limit.context / 1e3).toFixed(0)}k` : "?";
+    const ctx = theme.ctx(ctxRaw.padStart(6));
+    const costRaw = m.cost?.input !== void 0 ? `$${m.cost.input}/$${m.cost.output ?? "?"}` : "";
+    const cost = costRaw ? theme.cost(costRaw) : "";
+    const capTags = [];
+    if (m.tool_call) capTags.push("tools");
+    if (m.reasoning) capTags.push("reason");
+    if (m.modalities?.input?.includes("image")) capTags.push("vision");
+    const caps = capTags.map((c) => theme.caps(c)).join(color2.dim(" "));
+    const id = selected ? theme.accent(color2.bold(m.id)) : m.id;
+    lines.push(boxRow(`${marker} ${padVisible(id, 34)} ${ctx}  ${padVisible(cost, 12)} ${caps}`));
+    flat++;
+  }
+  if (ordered.length > LIVE_PICKER_MAX_VISIBLE) {
+    lines.push(
+      boxRow(color2.dim(`  \u2026 ${ordered.length - LIVE_PICKER_MAX_VISIBLE} more \u2014 type to filter`))
+    );
+  }
+  lines.push(boxDivider());
+  lines.push(
+    boxRow(
+      keyHints([
+        ["\u2191\u2193", "move"],
+        ["Enter", "select"],
+        ["Esc", "clear"],
+        ["Ctrl+C", "quit"]
+      ])
+    )
+  );
+  lines.push(boxBottom());
+  return lines.join("\n");
+}
+async function runLiveModelPicker(provider, defaultModel) {
+  const stdin = process.stdin;
+  const out = process.stdout;
+  if (!stdin.isTTY || !out.isTTY) return void 0;
+  const header = `${provider.name} (${provider.id}) models:`;
+  const byNewest = (a, b) => (b.release_date ?? "").localeCompare(a.release_date ?? "");
+  const ranked = [...provider.models].sort(byNewest);
+  const defaultIdx = defaultModel !== void 0 ? ranked.findIndex((m) => m.id === defaultModel) : -1;
+  setOutputLineGuard(null);
+  let state = {
+    query: "",
+    selected: defaultIdx >= 0 ? defaultIdx : 0,
+    status: "typing"
+  };
+  const order = (filtered) => [...filtered].sort(byNewest);
+  let ordered = order(filterModels(state.query, provider.models));
+  const visibleCount = () => Math.min(ordered.length, LIVE_PICKER_MAX_VISIBLE);
+  const clamp = () => {
+    if (state.selected >= visibleCount()) state.selected = Math.max(0, visibleCount() - 1);
+  };
+  clamp();
+  const preamble = codexPickerPreamble(provider);
+  if (preamble) writeOut(preamble);
+  let frame = renderLiveModelList(state.query, ordered, state.selected, header);
+  writeOut(frame);
+  return new Promise((resolve) => {
+    const wasRaw = stdin.isRaw;
+    const wasPaused = stdin.isPaused();
+    setRawMode(stdin, true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.off("data", onData);
+      setRawMode(stdin, wasRaw);
+      if (wasPaused) stdin.pause();
+    };
+    const repaint = () => {
+      const ups = (frame.match(/\n/g) ?? []).length;
+      writeOut(`\x1B[${ups}A\r\x1B[J`);
+      ordered = order(filterModels(state.query, provider.models));
+      clamp();
+      frame = renderLiveModelList(state.query, ordered, state.selected, header);
+      writeOut(frame);
+    };
+    const onData = (chunk) => {
+      ordered = order(filterModels(state.query, provider.models));
+      state = applyPickerKey(state, chunk, visibleCount());
+      ordered = order(filterModels(state.query, provider.models));
+      clamp();
+      if (state.status === "cancelled") {
+        cleanup();
+        writeOut("\n");
+        resolve(void 0);
+        return;
+      }
+      if (state.status === "submitted") {
+        if (ordered.length === 0) {
+          state = { ...state, status: "typing" };
+          repaint();
+          return;
+        }
+        const pick = ordered[state.selected] ?? expectDefined(ordered[0]);
+        cleanup();
+        writeOut("\n");
+        resolve(pick);
+        return;
+      }
+      repaint();
+    };
+    stdin.on("data", onData);
+  });
+}
+
+// src/picker.ts
+function appendLocalPresetProviders(merged) {
+  const existing = new Set(merged.map((p) => p.id));
+  for (const preset of LOCAL_LLM_PRESETS) {
+    if (existing.has(preset.id)) continue;
+    merged.push({
+      id: preset.id,
+      name: preset.label,
+      family: "openai-compatible",
+      apiBase: preset.defaultBaseUrl,
+      // No env vars → with a loopback apiBase this reads as a keyless
+      // local gateway, so the picker offers it without a key.
+      envVars: [],
+      // No catalog models yet; OmniRoute/LM Studio/etc. auto-discover at
+      // boot or the user picks `m` to set a list. An empty list still
+      // lets the provider be chosen — pickModel surfaces the "no models
+      // listed" hint and the user can type an id directly.
+      models: []
+    });
+  }
+  return merged;
+}
+function filterProviders(query, providers) {
+  const q = query.trim().toLowerCase();
+  if (!q) return [...providers];
+  return providers.filter(
+    (p) => p.id.toLowerCase().includes(q) || p.name.toLowerCase().includes(q)
+  );
+}
+var PROVIDER_FAMILY_PREFERRED_ORDER = [
+  "anthropic",
+  "anthropic-oauth",
+  "openai",
+  "openai-codex",
+  "github-copilot",
+  "google",
+  "openai-compatible"
+];
+function orderProvidersForDisplay(filtered) {
+  const families = /* @__PURE__ */ new Map();
+  for (const p of filtered) {
+    const arr = families.get(p.family) ?? [];
+    arr.push(p);
+    families.set(p.family, arr);
+  }
+  const order = [
+    ...PROVIDER_FAMILY_PREFERRED_ORDER.filter((f) => families.has(f)),
+    ...[...families.keys()].filter((f) => !PROVIDER_FAMILY_PREFERRED_ORDER.includes(f))
+  ];
+  const flat = [];
+  for (const fam of order) {
+    const arr = (families.get(fam) ?? []).slice().sort((a, b) => a.id.toLowerCase().localeCompare(b.id.toLowerCase()));
+    flat.push(...arr);
+  }
+  return flat;
+}
+function renderLiveProviderList(query, filtered, selectedIdx, savedSet) {
+  const ordered = orderProvidersForDisplay(filtered);
+  const scrollOffset = Math.max(0, selectedIdx - LIVE_PICKER_MAX_VISIBLE + 1);
+  const visible = ordered.slice(scrollOffset, scrollOffset + LIVE_PICKER_MAX_VISIBLE);
+  const lines = [];
+  lines.push(boxTop("Select a provider"));
+  const caret = query.length > 0 ? color3.dim("\u258F") : theme.cursor("\u258F");
+  lines.push(boxRow(`${theme.accent("\u276F")} ${color3.dim("Select provider:")} ${query}${caret}`));
+  lines.push(boxDivider());
+  if (scrollOffset > 0) {
+    lines.push(boxRow(color3.dim(`  ${scrollOffset} more above \u2191`)));
+  }
+  let flat = 0;
+  let lastFamily = "";
+  for (const p of visible) {
+    if (p.family !== lastFamily) {
+      lines.push(boxRow(`${theme.accent("\xB7")} ${color3.dim(p.family.toUpperCase())}`));
+      lastFamily = p.family;
+    }
+    const selected = flat === selectedIdx - scrollOffset;
+    const sel = selected ? theme.cursor("\u25B6") : " ";
+    let marker;
+    if (savedSet) {
+      const mark = savedSet.has(p.id) ? color3.cyan("\u25C9") : color3.dim("\u25CB");
+      marker = `${sel} ${mark}`;
+    } else {
+      marker = `${sel}`;
+    }
+    const id = selected ? theme.accent(color3.bold(p.id)) : p.id;
+    const name = selected ? p.name : color3.dim(p.name);
+    lines.push(boxRow(`${marker} ${padVisible(id, 24)} ${name}`));
+    flat++;
+  }
+  if (scrollOffset + LIVE_PICKER_MAX_VISIBLE < ordered.length) {
+    lines.push(
+      boxRow(
+        color3.dim(`  ${ordered.length - scrollOffset - LIVE_PICKER_MAX_VISIBLE} more below \u2193`)
+      )
+    );
+  }
+  lines.push(boxDivider());
+  lines.push(
+    boxRow(
+      keyHints([
+        ["\u2191\u2193", "scroll"],
+        ["Enter", "select"],
+        ["Esc", "clear"],
+        ["Ctrl+C", "quit"]
+      ])
+    )
+  );
+  lines.push(boxBottom());
+  return lines.join("\n");
+}
+async function saveToGlobalConfig(configPath, provider, model, homeFn = () => process.env.HOME ?? os.homedir()) {
+  try {
+    const { atomicWrite } = await import("@wrongstack/core/utils");
+    const fs = await import("node:fs/promises");
+    let existing = {};
+    try {
+      const raw = await fs.readFile(configPath, "utf8");
+      existing = JSON.parse(raw);
+    } catch {
+    }
+    const oldCfg = { ...existing };
+    existing.provider = provider;
+    existing.model = model;
+    try {
+      await backupCurrent(homeFn, configPath);
+    } catch (err) {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "picker.backup_failed",
+          message: toErrorMessage(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }
+    await atomicWrite(configPath, JSON.stringify(existing, null, 2), { mode: 384 });
+    try {
+      await appendHistory(
+        oldCfg,
+        existing,
+        `Provider/model changed: ${oldCfg.provider ?? "(none)"} \u2192 ${provider}, ${oldCfg.model ?? "(none)"} \u2192 ${model}`,
+        homeFn,
+        configPath
+      );
+    } catch {
+    }
+    return true;
+  } catch (err) {
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "picker.save_failed",
+        message: toErrorMessage(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    return false;
+  }
+}
+var QUERY_MARKER = "Select provider:";
+function cursorToQuery(frame, query) {
+  const rows = frame.split("\n");
+  const lastIdx = rows.length - 1;
+  const queryIdx = rows.findIndex((r) => r.includes(QUERY_MARKER));
+  if (queryIdx < 0) return;
+  const up = lastIdx - queryIdx;
+  const queryLine = rows[queryIdx] ?? "";
+  const plain = stripAnsi2(queryLine);
+  const markerAt = plain.indexOf(QUERY_MARKER);
+  const col = markerAt + QUERY_MARKER.length + 1 + query.length + 1;
+  if (up > 0) writeOut2(`\x1B[${up}A`);
+  writeOut2(`\x1B[${col}G`);
+}
+async function runLiveProviderPicker(displayList, savedSet) {
+  const stdin = process.stdin;
+  const out = process.stdout;
+  if (!stdin.isTTY || !out.isTTY) return void 0;
+  setOutputLineGuard2(null);
+  let state = { query: "", selected: 0, status: "typing" };
+  let ordered = orderProvidersForDisplay(filterProviders(state.query, displayList));
+  const visibleCount = () => ordered.length;
+  const clamp = () => {
+    if (state.selected >= visibleCount()) state.selected = Math.max(0, visibleCount() - 1);
+  };
+  clamp();
+  let frame = renderLiveProviderList(state.query, ordered, state.selected, savedSet);
+  writeOut2(frame);
+  writeOut2("\x1B7");
+  cursorToQuery(frame, state.query);
+  return new Promise((resolve) => {
+    const wasRaw = stdin.isRaw;
+    const wasPaused = stdin.isPaused();
+    setRawMode2(stdin, true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.off("data", onData);
+      setRawMode2(stdin, wasRaw);
+      if (wasPaused) stdin.pause();
+    };
+    const repaint = () => {
+      writeOut2("\x1B8");
+      const ups = (frame.match(/\n/g) ?? []).length;
+      writeOut2(`\x1B[${ups}A\r\x1B[J`);
+      ordered = orderProvidersForDisplay(filterProviders(state.query, displayList));
+      clamp();
+      frame = renderLiveProviderList(state.query, ordered, state.selected, savedSet);
+      writeOut2(frame);
+      writeOut2("\x1B7");
+      cursorToQuery(frame, state.query);
+    };
+    const onData = (chunk) => {
+      ordered = orderProvidersForDisplay(filterProviders(state.query, displayList));
+      state = applyPickerKey(state, chunk, visibleCount());
+      ordered = orderProvidersForDisplay(filterProviders(state.query, displayList));
+      clamp();
+      if (state.status === "cancelled") {
+        cleanup();
+        writeOut2("\n");
+        resolve(void 0);
+        return;
+      }
+      if (state.status === "submitted") {
+        if (ordered.length === 0) {
+          state = { ...state, status: "typing" };
+          repaint();
+          return;
+        }
+        const pick = ordered[state.selected] ?? ordered[0];
+        cleanup();
+        writeOut2("\n");
+        resolve(pick);
+        return;
+      }
+      repaint();
+    };
+    stdin.on("data", onData);
+  });
+}
+async function runPicker(deps) {
+  const { modelsRegistry, renderer, reader, config, defaultProvider, defaultModel } = deps;
+  renderer.write(
+    `
+${theme.accent(color3.bold("\u258C WrongStack"))}  ${color3.dim("Provider & Model Selection")}
+`
+  );
+  renderer.write(color3.dim(`${theme.chrome("\xB7")} Loading provider catalog\u2026
+`));
+  let providers;
+  try {
+    providers = await modelsRegistry.listProviders();
+  } catch {
+    renderer.writeError(
+      "Failed to load provider catalog. Pass --provider and --model to skip the picker."
+    );
+    return void 0;
+  }
+  const supported = providers.filter((p) => p.family !== "unsupported");
+  const catalogById = new Map(supported.map((p) => [p.id, p]));
+  const overlay = config?.providers ?? {};
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const p of supported) {
+    const cfg = overlay[p.id];
+    seen.add(p.id);
+    if (cfg) {
+      merged.push({
+        ...p,
+        family: cfg.family ?? p.family,
+        apiBase: cfg.baseUrl ?? p.apiBase,
+        envVars: cfg.envVars && cfg.envVars.length > 0 ? cfg.envVars : p.envVars,
+        // When the user has saved an explicit model list, it wins — they
+        // know which models their endpoint actually serves (e.g. LM
+        // Studio, vLLM, or a proxy with custom model ids). Otherwise the
+        // catalog list keeps providing suggestions.
+        models: visibleModelIds(
+          p.id,
+          config ?? { providers: {} },
+          p.models.map((m) => m.id),
+          cfg
+        ).map((m) => p.models.find((pm) => pm.id === m) ?? { id: m, name: m })
+      });
+    } else {
+      merged.push(p);
+    }
+  }
+  for (const [id, cfg] of Object.entries(overlay)) {
+    if (seen.has(id)) continue;
+    if (!cfg?.family || cfg.family === "unsupported") continue;
+    const catalogType = cfg.type && cfg.type !== id ? cfg.type : void 0;
+    const inherited = catalogType ? catalogById.get(catalogType) : void 0;
+    merged.push({
+      id,
+      name: inherited ? `${inherited.name} ${color3.dim("(alias)")}` : id,
+      family: cfg.family,
+      apiBase: cfg.baseUrl ?? inherited?.apiBase,
+      envVars: cfg.envVars ?? inherited?.envVars ?? [],
+      models: visibleModelIds(
+        id,
+        config ?? { providers: {} },
+        (inherited?.models ?? []).map((m) => m.id),
+        cfg
+      ).map((m) => inherited?.models.find((pm) => pm.id === m) ?? { id: m, name: m }),
+      npm: inherited?.npm
+    });
+  }
+  const keyed = merged.filter((p) => hasApiKey(p, config) || isKeylessLocalProvider(p));
+  let displayList = keyed;
+  let showingFallback = false;
+  if (keyed.length === 0) {
+    displayList = merged;
+    showingFallback = merged.length > 0;
+  }
+  appendLocalPresetProviders(displayList);
+  if (displayList.length === 0) {
+    renderer.writeError("No supported providers found in catalog.");
+    return void 0;
+  }
+  if (process.stdin.isTTY) {
+    const chosen2 = await runLiveProviderPicker(displayList);
+    if (!chosen2) {
+      renderer.write(color3.dim("Cancelled.\n"));
+      return void 0;
+    }
+    return pickModel(chosen2, modelsRegistry, renderer, reader, defaultModel);
+  }
+  const families = /* @__PURE__ */ new Map();
+  for (const p of displayList) {
+    const list = families.get(p.family) ?? [];
+    list.push(p);
+    families.set(p.family, list);
+  }
+  const ordered = [];
+  const preferredOrder = [
+    "anthropic",
+    "anthropic-oauth",
+    "openai",
+    "openai-codex",
+    "github-copilot",
+    "google",
+    "openai-compatible"
+  ];
+  const familyOrder = [
+    ...preferredOrder.filter((f) => families.has(f)),
+    ...[...families.keys()].filter((f) => !preferredOrder.includes(f))
+  ];
+  let idx = 1;
+  let defaultIdx;
+  renderer.write("\n");
+  renderer.write(`${boxTop("Select a provider")}
+`);
+  for (const fam of familyOrder) {
+    const list = [...families.get(fam) ?? []].sort(
+      (a, b) => a.id.toLowerCase().localeCompare(b.id.toLowerCase())
+    );
+    if (!list || list.length === 0) continue;
+    renderer.write(`${boxRow(`${theme.accent("\xB7")} ${color3.dim(fam.toUpperCase())}`)}
+`);
+    for (const p of list) {
+      const envFound = p.envVars.some((v) => !!process.env[v]);
+      const entry = config?.providers?.[p.id];
+      const configKey = typeof entry?.apiKey === "string" && entry.apiKey.length > 0 || Array.isArray(entry?.apiKeys) && entry?.apiKeys?.some((k) => k?.apiKey);
+      const marker = envFound ? color3.green("\u25CF") : configKey ? color3.cyan("\u25C9") : color3.dim("\u25CB");
+      const isDefault = p.id === defaultProvider;
+      if (isDefault) defaultIdx = idx;
+      const idLabel = isDefault ? theme.accent(color3.bold(p.id)) : p.id;
+      const suffix = isDefault ? color3.dim(" (default)") : "";
+      renderer.write(
+        `${boxRow(`${color3.dim(`${idx}.`.padStart(4))} ${marker} ${padVisible(idLabel, 22)} ${color3.dim(p.name)}${suffix}`)}
+`
+      );
+      ordered.push({ provider: p, index: idx });
+      idx++;
+    }
+  }
+  renderer.write(`${boxDivider()}
+`);
+  if (showingFallback) {
+    renderer.write(
+      `${boxRow(`${color3.yellow("\u26A0 No API keys detected.")} ${color3.dim("Run `wstack auth <provider>` after picking.")}`)}
+`
+    );
+  } else {
+    renderer.write(`${boxRow(color3.dim("\u25CF env key   \u25C9 stored in config   \u25CB no key"))}
+`);
+  }
+  renderer.write(`${boxBottom()}
+`);
+  const defaultHint = defaultIdx !== void 0 && defaultProvider ? ` ${color3.dim(`[Enter = ${defaultProvider}]`)}` : "";
+  const providerAnswer = (await reader.readLine(
+    `
+${color3.amber("?")} Select provider (1-${ordered.length})${defaultHint} ${color3.dim("[q to quit]")}: `
+  )).trim();
+  if (providerAnswer.toLowerCase() === "q") {
+    renderer.write(color3.dim("Cancelled.\n"));
+    return void 0;
+  }
+  if (!providerAnswer) {
+    if (defaultIdx !== void 0) {
+      const def = ordered[defaultIdx - 1];
+      if (def) return pickModel(def.provider, modelsRegistry, renderer, reader, defaultModel);
+    }
+    renderer.write(color3.dim("Cancelled.\n"));
+    return void 0;
+  }
+  const providerIdx = Number.parseInt(providerAnswer, 10);
+  if (Number.isNaN(providerIdx) || providerIdx < 1 || providerIdx > ordered.length) {
+    const byId = ordered.find((o) => o.provider.id.toLowerCase() === providerAnswer.toLowerCase());
+    if (!byId) {
+      renderer.writeError(`Invalid selection: "${providerAnswer}"`);
+      return void 0;
+    }
+    return pickModel(byId.provider, modelsRegistry, renderer, reader, defaultModel);
+  }
+  const chosen = ordered[providerIdx - 1];
+  if (!chosen) return void 0;
+  const modelHint = chosen.provider.id === defaultProvider ? defaultModel : void 0;
+  return pickModel(chosen.provider, modelsRegistry, renderer, reader, modelHint);
+}
+async function pickModel(provider, registry, renderer, reader, defaultModel) {
+  renderer.write(`
+${boxTop("Select a model")}
+`);
+  renderer.write(
+    `${boxRow(`${color3.bold(provider.name)} ${color3.dim(`(${provider.id})`)} models:`)}
+`
+  );
+  renderer.write(`${boxBottom()}
+`);
+  const codexBlock = codexPickerPreamble(provider);
+  if (codexBlock) renderer.write(codexBlock);
+  const models = [...provider.models].sort(
+    (a, b) => (b.release_date ?? "").localeCompare(a.release_date ?? "")
+  );
+  if (models.length === 0) {
+    renderer.write(
+      color3.dim(
+        "  No models listed yet for this provider \u2014 type a model id to use it (local servers auto-discover models at launch).\n"
+      )
+    );
+    const typed = (await reader.readLine(`
+${color3.amber("?")} Model id ${color3.dim("(or Enter to cancel)")}: `)).trim();
+    if (!typed) {
+      renderer.write(color3.dim("Cancelled.\n"));
+      return void 0;
+    }
+    renderer.write(`
+  ${color3.green("\u2713")} ${color3.bold(provider.id)} / ${color3.bold(typed)}
+
+`);
+    return { provider: provider.id, model: typed };
+  }
+  if (process.stdin.isTTY) {
+    const chosen = await runLiveModelPicker(provider, defaultModel);
+    if (!chosen) {
+      renderer.write(color3.dim("Cancelled.\n"));
+      return void 0;
+    }
+    renderer.write(
+      `
+  ${color3.green("\u2713")} ${color3.bold(provider.id)} / ${color3.bold(chosen.id)}
+
+`
+    );
+    return { provider: provider.id, model: chosen.id };
+  }
+  const defaultIdxInModels = defaultModel !== void 0 ? models.findIndex((m) => m.id === defaultModel) : -1;
+  const pageSize = 30;
+  let offset = 0;
+  while (offset < models.length) {
+    const page = models.slice(offset, offset + pageSize);
+    const pageFrom = offset + 1;
+    const pageTo = Math.min(offset + page.length, models.length);
+    renderer.write(`${boxTop(`Models ${pageFrom}\u2013${pageTo} of ${models.length}`)}
+`);
+    for (let i = 0; i < page.length; i++) {
+      const m = expectDefined2(page[i]);
+      const num = offset + i + 1;
+      const ctxRaw = m.limit?.context ? `${(m.limit.context / 1e3).toFixed(0)}k` : "?";
+      const ctx = theme.ctx(ctxRaw.padStart(6));
+      const cost = m.cost?.input !== void 0 ? `$${m.cost.input}/$${m.cost.output ?? "?"}` : "";
+      const costCol = cost ? theme.cost(cost) : "";
+      const capTags = [];
+      if (m.tool_call) capTags.push("tools");
+      if (m.reasoning) capTags.push("reason");
+      if (m.modalities?.input?.includes("image")) capTags.push("vision");
+      const capStr = capTags.map((c) => theme.caps(c)).join(color3.dim(" "));
+      const isDefault = m.id === defaultModel;
+      const idLabel = isDefault ? theme.accent(color3.bold(m.id)) : m.id;
+      const suffix = isDefault ? color3.dim(" (default)") : "";
+      const num5 = color3.dim(`${num}.`.padStart(5));
+      renderer.write(
+        `${boxRow(`${num5} ${padVisible(idLabel, 34)} ${ctx}  ${padVisible(costCol, 11)} ${capStr}${suffix}`)}
+`
+      );
+    }
+    renderer.write(`${boxBottom()}
+`);
+    offset += pageSize;
+    if (offset < models.length) {
+      const more = (await reader.readLine(
+        `
+${color3.amber("?")} Showing ${Math.min(offset, models.length)}/${models.length} \u2014 Enter number, ${color3.dim("Enter")} for more, or ${color3.dim("q")} to quit: `
+      )).trim();
+      if (more.toLowerCase() === "q") {
+        renderer.write(color3.dim("Cancelled.\n"));
+        return void 0;
+      }
+      if (!more) continue;
+      return resolveModelSelection(more, models, provider, registry, renderer, reader);
+    }
+  }
+  const defaultHint = defaultIdxInModels >= 0 && defaultModel ? ` ${color3.dim(`[Enter = ${defaultModel}]`)}` : "";
+  const answer = (await reader.readLine(
+    `
+${color3.amber("?")} Select model (1-${models.length})${defaultHint} ${color3.dim("[q to quit]")}: `
+  )).trim();
+  if (answer.toLowerCase() === "q") {
+    renderer.write(color3.dim("Cancelled.\n"));
+    return void 0;
+  }
+  if (!answer) {
+    if (defaultIdxInModels >= 0 && defaultModel) {
+      renderer.write(
+        `
+  ${color3.green("\u2713")} ${color3.bold(provider.id)} / ${color3.bold(defaultModel)}
+
+`
+      );
+      return { provider: provider.id, model: defaultModel };
+    }
+    renderer.write(color3.dim("Cancelled.\n"));
+    return void 0;
+  }
+  return resolveModelSelection(answer, models, provider, registry, renderer, reader);
+}
+async function resolveModelSelection(answer, models, provider, _registry, renderer, _reader) {
+  const idx = Number.parseInt(answer, 10);
+  let modelId;
+  if (!Number.isNaN(idx) && idx >= 1 && idx <= models.length) {
+    modelId = models[idx - 1]?.id;
+  } else {
+    const lower = answer.toLowerCase();
+    const match = models.find((m) => m.id.toLowerCase() === lower);
+    if (match) {
+      modelId = match.id;
+    } else {
+      const partial = models.filter((m) => m.id.toLowerCase().includes(lower));
+      if (partial.length === 1) {
+        modelId = partial[0]?.id;
+      } else if (partial.length > 1) {
+        renderer.writeError(`"${answer}" matches multiple models. Be more specific.`);
+        return void 0;
+      }
+    }
+  }
+  if (!modelId) {
+    modelId = answer;
+  }
+  renderer.write(`
+  ${color3.green("\u2713")} ${color3.bold(provider.id)} / ${color3.bold(modelId)}
+
+`);
+  return { provider: provider.id, model: modelId };
+}
+
+export {
+  parseArgs,
+  parseAuthFlags,
+  parseSpawnFlags,
+  LOCAL_LLM_PRESETS,
+  saveToGlobalConfig,
+  runLiveProviderPicker,
+  runPicker
+};
+//# sourceMappingURL=chunk-JBSQ7ONN.js.map