@tsconfigdotjson/vibe-os 0.2.0 → 0.4.0

package/server/harnesses/claude.ts

@@ -0,0 +1,248 @@
+// Claude Code.
+//
+// The editor offers models and permission modes as dropdowns, so something has
+// to know what the valid values are. Hardcoding them would be wrong within a
+// release or two, so they are read off the binary that is actually installed.
+// Update Claude Code and the dropdowns follow.
+
+import type { ChoiceOption } from "../../shared/harness.ts";
+import { log } from "../log.ts";
+import { type HarnessAdapter, looksLikeLadder, run } from "./util.ts";
+
+export const CLAUDE_INSTALL = "curl -fsSL https://claude.ai/install.sh | bash";
+
+/**
+ * Aliases the CLI documents but which do not appear as model ids.
+ *
+ * A floor rather than the source of truth: whatever is found in the binary is
+ * merged over the top, so a new tier appears on its own. These are the right
+ * default for a profile because they do not pin: a role called "Backend
+ * Manager" wants the best Opus, not the one that was current the day it was
+ * written.
+ */
+const KNOWN_ALIASES = ["opus", "sonnet", "haiku", "fable", "opusplan"];
+
+/**
+ * The effort ladder as of writing, used only when the binary cannot be read.
+ *
+ * Not merged with what was discovered. Effort is ordinal, so a union of two
+ * sources would put a newly added level in the wrong place. Either the binary's
+ * order or this one, never a blend.
+ */
+const KNOWN_EFFORT = ["low", "medium", "high", "xhigh", "max"];
+
+/** Readable names for the effort ladder. Unknown levels show raw. */
+const EFFORT_LABELS: Record<string, string> = {
+  low: "Low — quick and cheap",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra high",
+  max: "Maximum — slowest, most thorough",
+};
+
+/** Plain-English names for the modes the CLI reports. Unknown ones show raw. */
+const MODE_LABELS: Record<string, string> = {
+  acceptEdits: "Accept edits automatically",
+  plan: "Plan first, then ask",
+  auto: "Decide automatically",
+  manual: "Ask every time",
+  dontAsk: "Never ask",
+  bypassPermissions: "Bypass permission checks",
+};
+
+const LATEST = "Latest of its tier";
+const PINNED = "Pinned to one version";
+
+const aliasOptions = (aliases: string[]): ChoiceOption[] =>
+  aliases
+    .filter((a) => a !== "default")
+    .map((a) => ({
+      value: a,
+      label: a[0].toUpperCase() + a.slice(1),
+      group: LATEST,
+    }));
+
+const effortOptions = (levels: string[]): ChoiceOption[] =>
+  levels.map((l) => ({ value: l, label: EFFORT_LABELS[l] ?? l }));
+
+/**
+ * Model ids embedded in the executable.
+ *
+ * grep rather than reading the file in-process: the binary is ~270MB and the
+ * answer is a few hundred bytes, so streaming it through a matcher costs
+ * nothing while `readFile` would cost the whole thing in memory.
+ */
+async function embeddedModels(binary: string): Promise<string[]> {
+  try {
+    const { stdout } = await run(
+      "grep",
+      ["-aoE", "claude-(opus|sonnet|haiku|fable)-[0-9]+(-[0-9]+)?", binary],
+      { timeout: 30_000, maxBuffer: 4 * 1024 * 1024 },
+    );
+    const seen = new Set(
+      stdout
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean),
+    );
+    // Newest first: people reach for the latest far more often than a pin to
+    // something old.
+    return [...seen].sort((a, b) =>
+      b.localeCompare(a, "en", { numeric: true }),
+    );
+  } catch {
+    return [];
+  }
+}
+
+/** The choices `--permission-mode` lists in its own help output. */
+export function permissionModes(help: string): string[] {
+  // Help text wraps, so the list is matched across newlines and whitespace.
+  const section =
+    /--permission-mode[\s\S]{0,400}?\(choices:([\s\S]{0,300}?)\)/.exec(help);
+  if (!section) return [];
+  return [...section[1].matchAll(/"([^"]+)"/g)].map((m) => m[1]);
+}
+
+/**
+ * The levels `--effort` lists in its own help output.
+ *
+ * `--effort` prints a bare `(low, medium, high, xhigh, max)`, so the only
+ * anchor is the first parenthesis after the flag. That is loose enough to catch
+ * a sentence in some future release, which is what the shape check is for.
+ */
+export function effortLevels(help: string): string[] {
+  const section = /--effort[\s\S]{0,400}?\(([^)]{0,200})\)/.exec(help);
+  if (!section) return [];
+  const levels = section[1].split(",").map((s) => s.trim());
+  return looksLikeLadder(levels) ? levels : [];
+}
+
+export const claude: HarnessAdapter = {
+  spec: {
+    id: "claude",
+    label: "Claude",
+    command: "claude",
+    paths: [
+      "~/.local/bin/claude",
+      "/usr/local/bin/claude",
+      "/opt/claude/.local/bin/claude",
+    ],
+    resume: {
+      args: ["--continue"],
+      unless: ["--continue", "-c", "--resume", "-r"],
+    },
+    install: CLAUDE_INSTALL,
+    defaults: ["--dangerously-skip-permissions"],
+    fields: [
+      {
+        kind: "select",
+        key: "model",
+        label: "Model",
+        flag: "--model",
+        options: aliasOptions(KNOWN_ALIASES),
+        none: "Default — whatever Claude picks",
+        suffix: {
+          token: "[1m]",
+          label: "1M context",
+          hint: "Ask for the million-token context window",
+        },
+      },
+      {
+        kind: "select",
+        key: "effort",
+        label: "Thinking",
+        flag: "--effort",
+        options: effortOptions(KNOWN_EFFORT),
+        none: "Default — whatever the harness picks",
+        hint: "How long the session reasons before it acts. Higher is slower and costs more tokens; it is worth it for work where being wrong is expensive.",
+      },
+      {
+        kind: "select",
+        key: "permission",
+        label: "Permissions",
+        flag: "--permission-mode",
+        none: "Ask before each action",
+        specials: [
+          {
+            value: "skip",
+            label: "Skip every check — no prompts at all",
+            flag: "--dangerously-skip-permissions",
+            warn: "This session will not ask before editing, running or deleting anything. Reasonable on a box that is already a sandbox; think twice anywhere else.",
+          },
+        ],
+      },
+      {
+        kind: "mcp",
+        key: "mcp",
+        label: "MCP servers",
+        strict: "--strict-mcp-config",
+        config: "--mcp-config",
+        emptyHint:
+          "Nothing configured yet. Add one on the box with `claude mcp add --scope user …` and it appears here. The scope matters: without it Claude files the server under whichever directory you ran the command in, and in a workspace that goes when the worktree does.",
+      },
+      {
+        kind: "toggle",
+        flag: "--remote-control",
+        label: "Remote control",
+        hint: "Drive this session from claude.ai. Needs nothing on the box beyond outbound network.",
+      },
+      {
+        kind: "toggle",
+        flag: "--chrome",
+        label: "Browser tools",
+        hint: "Claude in Chrome. Pairs with the extension on the machine you are browsing from.",
+      },
+      {
+        kind: "toggle",
+        flag: "--continue",
+        label: "Resume last conversation",
+        hint: "Pick up the most recent session in this directory.",
+      },
+      {
+        kind: "toggle",
+        flag: "--verbose",
+        label: "Verbose output",
+        hint: "Show full tool output rather than the collapsed form.",
+      },
+    ],
+    valued: ["--agent", "--fallback-model", "--name"],
+    extraPlaceholder: '--append-system-prompt "…"',
+  },
+
+  async discover(binary) {
+    // Concurrently, because each `claude` invocation costs a couple of seconds
+    // of its own startup. `--help` is read once and answers two questions.
+    const [models, help] = await Promise.all([
+      embeddedModels(binary),
+      run(binary, ["--help"], { timeout: 15_000, maxBuffer: 4 * 1024 * 1024 })
+        .then(({ stdout }) => stdout)
+        .catch(() => ""),
+    ]);
+    const modes = permissionModes(help);
+    const effort = effortLevels(help);
+
+    // A tier that shows up in the binary but not in the list above still gets
+    // an alias, because that is how Claude names them.
+    const tiers = models.map((m) => m.split("-")[1]).filter(Boolean);
+    const aliases = [...new Set([...KNOWN_ALIASES, ...tiers])];
+
+    log.debug(
+      `claude: ${models.length} models, ${modes.length} permission modes, ` +
+        `${effort.length > 0 ? effort.join("/") : "no"} effort levels`,
+    );
+    return {
+      options: {
+        model: [
+          ...aliasOptions(aliases),
+          ...models.map((m) => ({ value: m, group: PINNED })),
+        ],
+        permission: modes.map((m) => ({
+          value: m,
+          label: MODE_LABELS[m] ?? m,
+        })),
+        ...(effort.length > 0 ? { effort: effortOptions(effort) } : {}),
+      },
+    };
+  },
+};

package/server/harnesses/codex.ts

@@ -0,0 +1,241 @@
+// OpenAI's Codex CLI.
+//
+// The flag list is verbatim from `codex --help` on codex-cli 0.160.1. Models
+// come from `codex debug models`, which renders the CLI's own catalog as JSON
+// and works logged out and offline, so the dropdown is real on any box that
+// has the binary.
+//
+// Codex sets its thinking level through a config override rather than a flag
+// of its own, `-c model_reasoning_effort=high`, and resumes with a subcommand,
+// `codex resume --last`, rather than a flag. The spec says both as data.
+
+import { readFile } from "node:fs/promises";
+import type { ChoiceOption } from "../../shared/harness.ts";
+import { log } from "../log.ts";
+import { type HarnessAdapter, home, looksLikeLadder, run } from "./util.ts";
+
+export const CODEX_INSTALL = "npm install -g @openai/codex";
+
+const EFFORT = "model_reasoning_effort=";
+
+/** What every model in the catalog supported as of writing. */
+const KNOWN_EFFORT = ["low", "medium", "high", "xhigh"];
+
+/**
+ * Models out of `codex debug models`, in the CLI's own order.
+ *
+ * Only `visibility: "list"` entries: the hidden ones are internal (the
+ * auto-review model) or previews the picker in Codex itself does not show.
+ * Sorted by `priority`, which is the order Codex's own `/model` picker uses.
+ *
+ * The thinking ladder is the longest one any listed model supports. Every
+ * model's list is a prefix of the same scale, so the longest is the scale, in
+ * order; a union would have to guess where a new level goes.
+ */
+export function parseCodexModels(stdout: string): {
+  models: ChoiceOption[];
+  effort: string[];
+} {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return { models: [], effort: [] };
+  }
+  const list = (parsed as { models?: unknown })?.models;
+  if (!Array.isArray(list)) return { models: [], effort: [] };
+
+  const listed = list
+    .filter(
+      (m): m is Record<string, unknown> =>
+        Boolean(m) &&
+        typeof m === "object" &&
+        typeof (m as { slug?: unknown }).slug === "string" &&
+        (m as { visibility?: unknown }).visibility === "list",
+    )
+    .sort(
+      (a, b) =>
+        (typeof a.priority === "number" ? a.priority : 999) -
+        (typeof b.priority === "number" ? b.priority : 999),
+    );
+
+  let effort: string[] = [];
+  for (const m of listed) {
+    const levels = Array.isArray(m.supported_reasoning_levels)
+      ? m.supported_reasoning_levels
+          .map((l: unknown) => (l as { effort?: unknown })?.effort)
+          .filter((e: unknown): e is string => typeof e === "string")
+      : [];
+    if (levels.length > effort.length && looksLikeLadder(levels))
+      effort = levels;
+  }
+
+  return {
+    models: listed.map((m) => ({
+      value: m.slug as string,
+      label:
+        typeof m.display_name === "string" && m.display_name !== m.slug
+          ? `${m.display_name} (${m.slug})`
+          : (m.slug as string),
+    })),
+    effort,
+  };
+}
+
+/**
+ * Top-level string settings from `config.toml`, the ones a profile's empty
+ * fields fall back to.
+ *
+ * Only keys above the first `[table]`: the same key inside `[profiles.x]` is
+ * not what a bare `codex` uses. Not a TOML parser, and does not need to be:
+ * a value this cannot read just means no "Default — …" label.
+ */
+export function codexDefaults(toml: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const line of toml.split("\n")) {
+    if (/^\s*\[/.test(line)) break;
+    const match = /^\s*(model|model_reasoning_effort)\s*=\s*"([^"]*)"/.exec(
+      line,
+    );
+    if (match?.[2]) out[match[1] === "model" ? "model" : "effort"] = match[2];
+  }
+  return out;
+}
+
+export const codex: HarnessAdapter = {
+  spec: {
+    id: "codex",
+    label: "Codex",
+    command: "codex",
+    // Where `npm install -g` lands for a user-level npm prefix, which is what a
+    // box without root has.
+    paths: [
+      "~/.local/bin/codex",
+      "~/.npm-global/bin/codex",
+      "/usr/local/bin/codex",
+    ],
+    // `resume` takes the same options as the root command, so the profile's
+    // flags follow it unchanged.
+    resume: { args: ["resume", "--last"], subcommand: true },
+    install: CODEX_INSTALL,
+    // Device auth, because the box usually has no browser for the redirect.
+    login: { args: ["login", "status"], fix: "codex login --device-auth" },
+    defaults: ["--dangerously-bypass-approvals-and-sandbox"],
+    fields: [
+      {
+        kind: "select",
+        key: "model",
+        label: "Model",
+        flag: "--model",
+        aliases: ["-m"],
+        none: "Default — whatever Codex picks",
+        placeholder: "Default — whatever Codex picks",
+        hint: "Read off `codex debug models`, so the list follows the installed CLI.",
+        emptyHint:
+          "Nothing to offer — `codex debug models` could not be read. Typed ids still work.",
+      },
+      {
+        kind: "select",
+        key: "effort",
+        label: "Thinking",
+        flag: "-c",
+        aliases: ["--config"],
+        prefix: EFFORT,
+        options: KNOWN_EFFORT.map((value) => ({ value })),
+        none: "Default — whatever Codex picks",
+        hint: "Passed as `-c model_reasoning_effort=…`. Not every model takes every level.",
+      },
+      {
+        kind: "select",
+        key: "sandbox",
+        label: "Sandbox",
+        flag: "--sandbox",
+        aliases: ["-s"],
+        options: [
+          { value: "read-only", label: "Read only" },
+          { value: "workspace-write", label: "Write inside the worktree" },
+          { value: "danger-full-access", label: "Full access — no sandbox" },
+        ],
+        none: "Default — whatever Codex is set to",
+      },
+      {
+        kind: "select",
+        key: "approval",
+        label: "Approvals",
+        flag: "--ask-for-approval",
+        aliases: ["-a"],
+        options: [
+          { value: "on-request", label: "When the model asks" },
+          { value: "never", label: "Never ask" },
+        ],
+        none: "Default — whatever Codex is set to",
+      },
+      {
+        kind: "toggle",
+        flag: "--dangerously-bypass-approvals-and-sandbox",
+        label: "Skip approvals and sandbox",
+        hint: "No prompts and no sandbox. Same trade as Claude's skip-every-check.",
+        warn: "This session will not ask before running anything, and runs it unsandboxed. Reasonable on a box that is already a sandbox; think twice anywhere else.",
+      },
+      {
+        kind: "toggle",
+        flag: "--approve-for-me",
+        label: "Auto-review approvals",
+        hint: "Route approval requests through Codex's automatic reviewer, inside the workspace-write sandbox.",
+      },
+      {
+        kind: "toggle",
+        flag: "--search",
+        label: "Web search",
+        hint: "Give the model live web search, with no per-call approval.",
+      },
+      {
+        kind: "toggle",
+        flag: "--no-alt-screen",
+        label: "Inline mode",
+        hint: "Run without the alternate screen, so the terminal keeps its scrollback.",
+      },
+    ],
+    valued: [
+      "--enable",
+      "--disable",
+      "--remote",
+      "--remote-auth-token-env",
+      "-i",
+      "--image",
+      "--local-provider",
+      "-p",
+      "--profile",
+      "-C",
+      "--cd",
+      "--add-dir",
+    ],
+    extraPlaceholder: "--profile work",
+  },
+
+  async discover(binary) {
+    const codexHome = process.env.CODEX_HOME || `${home}/.codex`;
+    const [catalog, toml] = await Promise.all([
+      run(binary, ["debug", "models"], {
+        timeout: 30_000,
+        maxBuffer: 16 * 1024 * 1024,
+      })
+        .then(({ stdout }) => parseCodexModels(stdout))
+        .catch(() => ({ models: [], effort: [] })),
+      readFile(`${codexHome}/config.toml`, "utf8").catch(() => ""),
+    ]);
+    log.debug(
+      `codex: ${catalog.models.length} models, ` +
+        `${catalog.effort.length > 0 ? catalog.effort.join("/") : "no"} effort levels`,
+    );
+    return {
+      options: {
+        model: catalog.models,
+        ...(catalog.effort.length > 0
+          ? { effort: catalog.effort.map((value) => ({ value })) }
+          : {}),
+      },
+      defaults: codexDefaults(toml),
+    };
+  },
+};

package/server/harnesses/cursor.ts

@@ -0,0 +1,202 @@
+// Cursor's CLI.
+//
+// `cursor-agent models` is a real listing mode, but it lists the account's
+// models rather than the binary's: logged out, or offline, it cannot be read,
+// so an empty list is "could not tell" and the field stays free text. No floor
+// of well-known model names, because offering a model this account does not
+// have would suggest a choice that can only fail after launch.
+//
+// The flag list is verbatim from `cursor-agent --help` on a real install.
+
+import { log } from "../log.ts";
+import { type Discovery, type HarnessAdapter, run } from "./util.ts";
+
+export const CURSOR_INSTALL = "curl https://cursor.com/install -fsS | bash";
+
+/** Single-quote for the shell the window's command runs in. */
+const shellQuote = (value: string): string =>
+  `'${value.replaceAll("'", `'\\''`)}'`;
+
+/**
+ * Model ids out of `cursor-agent models`.
+ *
+ * The format is verbatim from a real box: an `Available models` header, then
+ * one `id - Display Name` per line, then a `Tip:` sentence about `--model`. The
+ * default is marked inside the display half: `auto - Auto (default)`.
+ *
+ * A line has to open with an id-shaped token followed by the ` - ` separator
+ * (or nothing at all), which keeps the header and the tip out. Order is kept as
+ * printed: Cursor leads with `auto` and its recommendations, which is a better
+ * sort than alphabetical for a 200-entry list.
+ */
+export function parseCursorModels(stdout: string): {
+  models: string[];
+  defaultModel: string | null;
+} {
+  const models: string[] = [];
+  let defaultModel: string | null = null;
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    const match = /^([A-Za-z0-9][\w./-]*)(?:\s+-\s+(.*))?$/.exec(line);
+    if (!match) continue;
+    const [, id, label] = match;
+    if (!models.includes(id)) models.push(id);
+    // The marker word can share its parens: one account prints `(default)`,
+    // another `(current, default)`.
+    if (
+      label &&
+      /\([^)]*\b(default|current|selected)\b[^)]*\)/i.test(label) &&
+      !defaultModel
+    )
+      defaultModel = id;
+  }
+  return { models, defaultModel };
+}
+
+/**
+ * Cursor's name for a directory, as it spells it under `~/.cursor/projects`.
+ *
+ * Every run of anything that is not a letter or a digit becomes one dash, and
+ * the leading one that a path always starts with is dropped. Case survives.
+ * Read off a real install: `/home/ubuntu` is `home-ubuntu`, and
+ * `/tmp/Cursor.Test_1 space/sub` is `tmp-Cursor-Test-1-space-sub`.
+ */
+export function cursorProjectSlug(dir: string): string {
+  return dir.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+/**
+ * Shell that points this worktree's Cursor project at the box's MCP credentials.
+ *
+ * Cursor keeps MCP OAuth tokens per working directory, in
+ * `~/.cursor/projects/<slug>/mcp-auth.json`, while the server list is global.
+ * Every workspace here is a fresh worktree at a path Cursor has never seen, so
+ * "log in once on this box" would mean "log in once per window".
+ *
+ * A symlink rather than a copy because Cursor writes through it: an access
+ * token lasts a day, and the refresh that happens in whichever window is open
+ * has to be the refresh every other window sees.
+ *
+ * The link is only created where there is nothing at all. An existing file is
+ * somebody's real per-directory login; an existing link is this, already done.
+ * The shared store may not exist yet: writing through a dangling symlink
+ * creates the target, so `cursor-agent mcp login linear` in any window is the
+ * one login the box needs.
+ *
+ * Failure is silent and inert. If Cursor changes how it names these
+ * directories, the link lands somewhere Cursor does not read and windows behave
+ * as they did before: a login prompt, not a broken window.
+ */
+export function cursorMcpLink(cwd: string, stateDir: string): string {
+  const store = `${stateDir}/cursor/mcp-auth.json`;
+  const storeDir = shellQuote(`${stateDir}/cursor`);
+  // The slug is letters, digits and dashes by construction, so it needs no
+  // quoting of its own; `$HOME` is left to the shell because the session runs
+  // as the user whose credentials these are.
+  const dir = `"$HOME/.cursor/projects/${cursorProjectSlug(cwd)}"`;
+  const link = `"$HOME/.cursor/projects/${cursorProjectSlug(cwd)}/mcp-auth.json"`;
+  return [
+    `mkdir -p ${dir} ${storeDir} 2>/dev/null`,
+    // Refresh tokens, so no wider than the state dir this sits in.
+    `chmod 700 ${storeDir} 2>/dev/null`,
+    `{ [ -e ${link} ] || [ -L ${link} ] || ln -s ${shellQuote(store)} ${link} 2>/dev/null; }`,
+  ].join("; ");
+}
+
+export const cursor: HarnessAdapter = {
+  spec: {
+    id: "cursor",
+    label: "Cursor",
+    // The unambiguous one of the two names its installer symlinks. `agent` is
+    // the other, and too generic to be the one a PATH lookup bets on.
+    command: "cursor-agent",
+    paths: ["~/.local/bin/cursor-agent", "/usr/local/bin/cursor-agent"],
+    resume: { args: ["--continue"], unless: ["--continue", "--resume"] },
+    install: CURSOR_INSTALL,
+    login: { args: ["status"], fix: "cursor-agent login" },
+    // --trust as well: every workspace is a fresh worktree, which to Cursor is
+    // an untrusted directory, and a role window should open on the
+    // conversation rather than on the trust prompt.
+    defaults: ["--force", "--trust"],
+    fields: [
+      {
+        kind: "select",
+        key: "model",
+        label: "Model",
+        flag: "--model",
+        aliases: ["-m"],
+        none: "Default — whatever Cursor picks",
+        placeholder: "Default — whatever Cursor picks",
+        hint: "Read off `cursor-agent models`, so the list follows your account.",
+        emptyHint:
+          "Nothing to offer — `cursor-agent models` could not be read, which usually means the box is not logged in. Typed ids still work.",
+      },
+      {
+        kind: "toggle",
+        flag: "--force",
+        // The CLI documents both as the same switch.
+        aliases: ["--yolo", "-f"],
+        label: "Skip approvals",
+        hint: "Edit files and run commands without asking. Same trade as Claude's skip-every-check.",
+        warn: "This session will not ask before editing or running anything. Reasonable on a box that is already a sandbox; think twice anywhere else.",
+      },
+      {
+        kind: "toggle",
+        flag: "--trust",
+        label: "Trust the worktree",
+        hint: "Skip the new-workspace trust prompt. Every vibe-os worktree is new to Cursor.",
+      },
+      {
+        kind: "toggle",
+        flag: "--approve-mcps",
+        label: "Approve MCP servers",
+        hint: "Skip the per-workspace approval prompt for the servers in ~/.cursor/mcp.json.",
+      },
+      {
+        kind: "toggle",
+        flag: "--continue",
+        label: "Resume last conversation",
+        hint: "Pick up the most recent session rather than starting a new one.",
+      },
+    ],
+    valued: [
+      "--output-format",
+      "--workspace",
+      "--api-key",
+      "--mode",
+      "--sandbox",
+      "--header",
+      "-H",
+      "--endpoint",
+      "-e",
+      "--add-dir",
+      "--plugin-dir",
+      "--worktree-base",
+    ],
+    // `--resume` takes an optional chat id and `-w`/`--worktree` an optional
+    // name. With a value they name one, which no control here can say.
+    optional: ["--resume", "--worktree", "-w"],
+    extraPlaceholder: '--resume "…"',
+  },
+
+  async discover(binary): Promise<Discovery> {
+    const listed = await run(binary, ["models"], {
+      timeout: 30_000,
+      maxBuffer: 4 * 1024 * 1024,
+    })
+      .then(({ stdout }) => parseCursorModels(stdout))
+      // Logged out or offline it exits complaining; that is "could not read",
+      // which the empty list already says.
+      .catch(() => ({ models: [], defaultModel: null }));
+    log.debug(`cursor-agent: ${listed.models.length} models`);
+    return {
+      options: { model: listed.models.map((value) => ({ value })) },
+      defaults: listed.defaultModel
+        ? { model: listed.defaultModel }
+        : ({} as Record<string, string>),
+    };
+  },
+
+  setup: ({ cwd, stateDir }) => cursorMcpLink(cwd, stateDir),
+};