smooth-operator-mcp 2.1.1 → 2.2.1

package/dist/smooth-operator.mjs

@@ -366,8 +366,8 @@ __export(installer_exports, {
   planHarnessInstall: () => planHarnessInstall,
   supportedHarnessTargets: () => supportedHarnessTargets
 });
-import { constants as constants2 } from "node:fs";
-import { chmod as chmod2, lstat as lstat3, mkdir as mkdir3, open as open2, rename as rename2, unlink as unlink3, writeFile } from "node:fs/promises";
+import { constants as constants2, accessSync, existsSync } from "node:fs";
+import { chmod as chmod2, lstat as lstat3, mkdir as mkdir3, open as open2, rename as rename3, unlink as unlink3, writeFile } from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { homedir as homedir3, platform as platform2 } from "node:os";
@@ -394,7 +394,7 @@ function planHarnessInstall(target, options = {}) {
     return { kind: "cli", target: normalized, command: "codex", args: ["mcp", "add", SERVER_NAME, "--", cliEntry.command, ...cliEntry.args] };
   }
   if (normalized === "gemini") {
-    return { kind: "cli", target: normalized, command: "gemini", args: ["mcp", "add", SERVER_NAME, cliEntry.command, ...cliEntry.args, "--scope", "user"] };
+    return { kind: "cli", target: normalized, command: "gemini", args: ["mcp", "add", "--scope", "user", SERVER_NAME, cliEntry.command, ...cliEntry.args] };
   }
   if (normalized === "vscode") {
     return {
@@ -444,10 +444,21 @@ function normalizeTarget(target) {
 function resolveServerEntry() {
   const modulePath = fileURLToPath(import.meta.url);
   if (basename4(modulePath) === "smooth-operator.mjs") {
-    return { command: process.execPath, args: [modulePath] };
+    return { command: resolveStableNodeExecutable(), args: [modulePath] };
   }
   return { command: "smooth-operator", args: [] };
 }
+function resolveStableNodeExecutable() {
+  const candidates = platform2() === "darwin" ? ["/opt/homebrew/bin/node", "/usr/local/bin/node"] : ["/usr/local/bin/node", "/usr/bin/node"];
+  for (const candidate of candidates) {
+    try {
+      accessSync(candidate, constants2.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return process.execPath;
+}
 async function runCliInstall(plan, executeCommand) {
   const runner = executeCommand ?? (async (command, args) => {
     await execFileAsync(command, [...args], {
@@ -556,7 +567,7 @@ async function installJsonConfig(target, plannedPath, options, allowOpenCodeJson
 `, { mode: 384, flag: "wx" });
     await chmod2(tempPath, 384);
     await rejectSymlink2(path, "configuration file");
-    await rename2(tempPath, path);
+    await rename3(tempPath, path);
     return `Installed SmoothOperator in ${path}${backupPath ? ` (backup: ${backupPath})` : ""}. Restart the harness.`;
   } catch (error) {
     await unlink3(tempPath).catch(() => void 0);
@@ -614,6 +625,26 @@ async function chooseExistingOpenCodePath(plannedPath) {
   }
   return plannedPath;
 }
+function isStaleEmbeddedCommand(command) {
+  if (typeof command !== "string" || !command.includes("/")) {
+    return false;
+  }
+  return !existsSync(command);
+}
+function isStaleEmbeddedCommandArray(command) {
+  if (!Array.isArray(command) || command.length === 0) {
+    return false;
+  }
+  const interpreter = command[0];
+  return typeof interpreter === "string" && interpreter.includes("/") && !existsSync(interpreter);
+}
+function isRepairableStdioEntry(existing, entry) {
+  return isStaleEmbeddedCommand(existing.command) && Array.isArray(existing.args) && existing.args.length === entry.args.length && existing.args.every((arg, index) => arg === entry.args[index]);
+}
+function isRepairableOpenCodeEntry(existing, desired) {
+  const repaired = { ...existing, command: desired.command };
+  return isStaleEmbeddedCommandArray(existing.command) && sameOpenCodeEntry(repaired, desired);
+}
 function mergeMcpServersConfig(config, entry, path) {
   if (config.mcpServers !== void 0 && !isRecord3(config.mcpServers)) {
     throw new AppError("INSTALL_CONFIG_INVALID", `The mcpServers value in ${path} must be an object; refusing to replace it.`);
@@ -621,9 +652,16 @@ function mergeMcpServersConfig(config, entry, path) {
   const servers = isRecord3(config.mcpServers) ? { ...config.mcpServers } : {};
   const existing = servers[SERVER_NAME];
   if (existing !== void 0) {
-    if (!isRecord3(existing) || !sameStdioEntry(existing, entry)) {
+    if (!isRecord3(existing)) {
       throw new AppError("INSTALL_CONFIG_CONFLICT", `The '${SERVER_NAME}' server in ${path} has a conflicting configuration; refusing to overwrite it.`);
     }
+    if (!sameStdioEntry(existing, entry)) {
+      if (!isRepairableStdioEntry(existing, entry)) {
+        throw new AppError("INSTALL_CONFIG_CONFLICT", `The '${SERVER_NAME}' server in ${path} has a conflicting configuration; refusing to overwrite it.`);
+      }
+      servers[SERVER_NAME] = { command: entry.command, args: [...entry.args] };
+      return { config: { ...config, mcpServers: servers }, alreadyConfigured: false };
+    }
     return { config, alreadyConfigured: true };
   }
   servers[SERVER_NAME] = { command: entry.command, args: [...entry.args] };
@@ -645,10 +683,24 @@ function mergeOpenCodeConfig(config, entry, path) {
   const existing = servers[SERVER_NAME];
   const desired = modernSchema ? { type: "local", command: [entry.command, ...entry.args] } : { type: "local", command: [entry.command, ...entry.args], enabled: true };
   if (existing !== void 0) {
-    if (!isRecord3(existing) || !sameOpenCodeEntry(existing, desired)) {
+    if (!isRecord3(existing)) {
       throw new AppError("INSTALL_CONFIG_CONFLICT", `The '${SERVER_NAME}' server in ${path} has a conflicting configuration; refusing to overwrite it.`);
     }
-    return { config, alreadyConfigured: true };
+    if (!sameOpenCodeEntry(existing, desired)) {
+      if (!isRepairableOpenCodeEntry(existing, desired)) {
+        throw new AppError("INSTALL_CONFIG_CONFLICT", `The '${SERVER_NAME}' server in ${path} has a conflicting configuration; refusing to overwrite it.`);
+      }
+      existing.command = desired.command;
+    } else {
+      return { config, alreadyConfigured: true };
+    }
+    servers[SERVER_NAME] = existing;
+    if (modernSchema) {
+      mcp.servers = servers;
+    } else {
+      Object.assign(mcp, servers);
+    }
+    return { config: { ...config, mcp }, alreadyConfigured: false };
   }
   servers[SERVER_NAME] = desired;
   if (modernSchema) {
@@ -882,6 +934,99 @@ var init_installer = __esm({
   }
 });
 
+// src/server/ui.ts
+var ui_exports = {};
+__export(ui_exports, {
+  createUi: () => createUi
+});
+function colorEnabled(stdout) {
+  if (!stdout?.isTTY) return false;
+  if (process.env.NO_COLOR) return false;
+  const term = process.env.TERM ?? "";
+  return term !== "dumb";
+}
+function createUi(stdout) {
+  const enabled = colorEnabled(stdout);
+  const write = typeof stdout?.write === "function" ? stdout.write.bind(stdout) : (() => true);
+  const paint = (code, text) => enabled ? `${code}${text}${RESET}` : text;
+  return {
+    colors: enabled,
+    bold: (text) => paint(BOLD, text),
+    dim: (text) => paint(DIM, text),
+    cyan: (text) => paint(CYAN, text),
+    green: (text) => paint(GREEN, text),
+    yellow: (text) => paint(YELLOW, text),
+    red: (text) => paint(RED, text),
+    /** Application banner shown once at the top of the wizard. */
+    banner(name, tagline, version = "") {
+      const line = "\u2500".repeat(Math.max(name.length + tagline.length + 8, 44));
+      write(`
+${paint(CYAN, line)}
+`);
+      write(`  ${paint(BOLD, name)}${version ? ` ${paint(DIM, `v${version}`)}` : ""}
+`);
+      write(`  ${paint(CYAN, tagline)}
+`);
+      write(`${paint(CYAN, line)}
+
+`);
+    },
+    /** Numbered step header, e.g. "── [2/6] Headless mode ──". */
+    step(current, total, title) {
+      write(`
+${paint(BOLD, `[${current}/${total}] ${title}`)}
+`);
+    },
+    /** Indented explanatory paragraph under a question. */
+    explain(lines) {
+      for (const line of lines) {
+        write(`  ${paint(DIM, line)}
+`);
+      }
+    },
+    /** One option row in a numbered choice list. */
+    option(index, label, description, recommended = false) {
+      const badge = recommended ? paint(GREEN, " (recommended)") : "";
+      write(`  ${paint(CYAN, `${index})`)} ${paint(BOLD, label)}${badge}
+`);
+      write(`     ${paint(DIM, description)}
+`);
+    },
+    keyValues(rows) {
+      const width = Math.max(...rows.map(([key]) => key.length));
+      for (const [key, value] of rows) {
+        write(`  ${paint(DIM, key.padEnd(width))}  ${value}
+`);
+      }
+    },
+    success(text) {
+      write(`${paint(GREEN, "\u2714")} ${text}
+`);
+    },
+    failure(text) {
+      write(`${paint(RED, "\u2716")} ${text}
+`);
+    },
+    note(text) {
+      write(`  ${paint(YELLOW, "\u203A")} ${paint(DIM, text)}
+`);
+    }
+  };
+}
+var RESET, BOLD, DIM, CYAN, GREEN, YELLOW, RED;
+var init_ui = __esm({
+  "src/server/ui.ts"() {
+    "use strict";
+    RESET = "\x1B[0m";
+    BOLD = "\x1B[1m";
+    DIM = "\x1B[2m";
+    CYAN = "\x1B[36m";
+    GREEN = "\x1B[32m";
+    YELLOW = "\x1B[33m";
+    RED = "\x1B[31m";
+  }
+});
+
 // src/server/installer-wizard.ts
 var installer_wizard_exports = {};
 __export(installer_wizard_exports, {
@@ -904,26 +1049,43 @@ function isInteractive() {
 }
 async function promptForHarness(opts) {
   const { createInterface } = await import("node:readline/promises");
-  const rl = createInterface({
-    input: opts.stdin,
-    output: opts.stdout
-  });
+  const ui = createUi(opts.stdout);
+  const input = opts.stdin;
+  const output = opts.stdout;
+  const rl = createInterface({ input, output });
   try {
-    const answer = await rl.question(`Harness [opencode/claude-code/copilot/codex/gemini/vscode/cursor/windsurf/claude-desktop] [opencode]: `);
-    const trimmed = answer.trim().toLowerCase();
-    if (!trimmed) return "opencode";
-    const map = {
-      "claude": "claude-code",
-      "github-copilot": "copilot",
-      "codex-cli": "codex",
-      "gemini-cli": "gemini",
-      "vs-code": "vscode"
-    };
-    return map[trimmed] ?? trimmed;
+    if (opts.stdout.isTTY) {
+      ui.step(0, HARNESS_MENU.length, "Which harness should get a browser?");
+      ui.explain(["The AI harness you use every day. Pick yours; you can re-run this later for others."]);
+      HARNESS_MENU.forEach((entry, index) => ui.option(index + 1, entry.label, entry.description));
+    }
+    while (true) {
+      const answer = await rl.question(`Choose 1-${HARNESS_MENU.length} or type a name [opencode]: `);
+      const trimmed = answer.trim().toLowerCase();
+      if (!trimmed) return "opencode";
+      const numeric = Number.parseInt(trimmed, 10);
+      if (`${numeric}` === trimmed && numeric >= 1 && numeric <= HARNESS_MENU.length) {
+        return HARNESS_MENU[numeric - 1].id;
+      }
+      if (/^\d+$/.test(trimmed)) {
+        continue;
+      }
+      return normalizeHarnessName(trimmed);
+    }
   } finally {
     rl.close();
   }
 }
+function normalizeHarnessName(name) {
+  const aliases = {
+    "claude": "claude-code",
+    "github-copilot": "copilot",
+    "codex-cli": "codex",
+    "gemini-cli": "gemini",
+    "vs-code": "vscode"
+  };
+  return aliases[name] ?? name;
+}
 function recommendedDefaults(homeDir) {
   return {
     mode: "managed",
@@ -934,52 +1096,188 @@ function recommendedDefaults(homeDir) {
     dataDir: join7(homeDir ?? homedir4(), ".smooth-operator")
   };
 }
-async function runWizard(_harness, opts) {
+function tolerantQuestion(rl) {
+  return {
+    async question(prompt) {
+      try {
+        return await rl.question(prompt);
+      } catch (error) {
+        const code = error.code;
+        const aborted = error instanceof Error && error.name === "AbortError";
+        if (aborted || code === "ABORT_ERR" || code === "ERR_USE_AFTER_CLOSE") {
+          return "";
+        }
+        throw error;
+      }
+    }
+  };
+}
+async function askYesNo(session, prompt, fallback) {
+  while (true) {
+    const hint = fallback ? "[Y/n]" : "[y/N]";
+    const answer = (await session.question(`${prompt} ${hint}: `)).trim().toLowerCase();
+    if (!answer) return fallback;
+    if (["y", "yes"].includes(answer)) return true;
+    if (["n", "no"].includes(answer)) return false;
+  }
+}
+function parseDomainList(raw) {
+  const domains = raw.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean);
+  const invalid = domains.find((domain) => !/^(?:\*\.)?[a-z0-9-]+(?:\.[a-z0-9-]+)+$/.test(domain));
+  return invalid === void 0 ? domains : void 0;
+}
+async function runWizard(harness, opts) {
+  const defaults = recommendedDefaults(opts.homeDir);
   if (opts.yes) {
-    return recommendedDefaults(opts.homeDir);
+    return defaults;
   }
   const stdin = opts.stdin ?? process.stdin;
   const stdout = opts.stdout ?? process.stdout;
   const interactive = Boolean(stdin.isTTY && stdout.isTTY && !process.env.CI);
   if (!interactive) {
-    return recommendedDefaults(opts.homeDir);
+    return defaults;
   }
+  const ui = createUi(stdout);
   const { createInterface } = await import("node:readline/promises");
   const rl = createInterface({
     input: stdin,
     output: stdout
   });
+  const session = tolerantQuestion(rl);
   try {
-    const modeAns = await rl.question("Browser mode: 1) managed private (recommended) 2) personal Chrome (connect) 3) disabled [1]: ");
-    const modeMap = { "1": "managed", "2": "connect", "3": "disabled", "": "managed" };
-    let mode = modeMap[modeAns.trim()] ?? "managed";
-    if (!["managed", "connect", "disabled"].includes(mode)) mode = "managed";
+    ui.banner("SmoothOperator Setup", `Give ${harness} a real Chrome it can drive`, opts.version ?? "2.2.0");
+    ui.note(`Configuring: ${harness}`);
+    ui.note("Answer each question, or press Enter to accept the recommended default.");
+    ui.note(`You can re-run \`smooth-operator install ${harness}\` at any time to change these.`);
+    ui.step(1, 6, "Browser mode");
+    ui.explain([
+      "Who owns the Chrome window your AI drives?",
+      "",
+      "Managed gives the AI its own private Chrome profile at ~/.smooth-operator/browser.",
+      "Your daily browser stays untouched; logins for the AI live separately.",
+      "",
+      "Connect attaches to your real Chrome instead, so the AI uses everything",
+      "you are already signed into. Only pick this if you need your existing logins.",
+      "",
+      "Disabled keeps the server but turns all browsing tools off."
+    ]);
+    ui.option(1, "Managed private Chrome", "Isolated profile owned by SmoothOperator. Safest default.", true);
+    ui.option(2, "Personal Chrome (connect)", "Reuse your real browser and its existing sign-ins.");
+    ui.option(3, "Disabled", "No browser. Tools that need a page will report an error.");
+    let mode = "managed";
     let browserUrl;
-    if (mode === "connect") {
-      browserUrl = "http://127.0.0.1:9222";
-    }
-    const headlessAns = await rl.question("Headless Chrome? (y/N) [N]: ");
-    const headless = headlessAns.trim().toLowerCase() === "y";
-    const allowedAns = await rl.question("Allowed domains (comma-separated, empty=all) []: ");
-    const allowedDomains = allowedAns.trim() ? allowedAns.split(",").map((s) => s.trim()).filter(Boolean) : [];
-    const blockedAns = await rl.question("Blocked domains (comma-separated) []: ");
-    const blockedDomains = blockedAns.trim() ? blockedAns.split(",").map((s) => s.trim()).filter(Boolean) : [];
-    const evalAns = await rl.question("Allow page JavaScript (browser_evaluate)? (y/N) [N]: ");
-    const allowEval = evalAns.trim().toLowerCase() === "y";
-    const dataDirAns = await rl.question(`Data directory [${join7(opts.homeDir ?? homedir4(), ".smooth-operator")}]: `);
-    const dataDir = dataDirAns.trim() ? dataDirAns.trim() : join7(opts.homeDir ?? homedir4(), ".smooth-operator");
-    if (mode === "connect") {
-      try {
-        const launched = await launchPersonalChrome({ dataDir, spawn: opts.spawn, probe: opts.probe ?? defaultProbe, port: 9222 });
-        browserUrl = launched.url;
-      } catch {
+    let headless = false;
+    let allowedDomains = [];
+    let blockedDomains = [];
+    let allowEval = false;
+    let dataDir = defaults.dataDir;
+    while (true) {
+      const answer = (await session.question("Mode [1]: ")).trim();
+      if (!answer || answer === "1") {
+        mode = "managed";
+        break;
+      }
+      if (answer === "2") {
+        mode = "connect";
+        browserUrl = "http://127.0.0.1:9222";
+        break;
+      }
+      if (answer === "3") {
+        mode = "disabled";
+        break;
+      }
+      ui.failure("Enter 1, 2, or 3.");
+    }
+    let headlessChoice = false;
+    if (mode !== "disabled") {
+      ui.step(2, 6, "Headless mode");
+      ui.explain([
+        "Headless runs Chrome with no visible window - lighter and invisible.",
+        "Visible Chrome lets you watch clicks happen and handle CAPTCHAs or",
+        "logins yourself when a site pauses for human verification."
+      ]);
+      headlessChoice = await askYesNo(session, "Run Chrome headless (no window)?", false);
+      ui.step(3, 6, "Allowed domains");
+      ui.explain([
+        "Restrict which sites the AI may open, e.g. docs.example.com, *.wikipedia.org",
+        "Leave empty to allow every site. Blocked domains always win over allowed ones."
+      ]);
+      while (true) {
+        const parsed = parseDomainList(await session.question("Allowed domains (comma-separated, Enter for all): "));
+        if (parsed !== void 0) {
+          allowedDomains = parsed;
+          break;
+        }
+        ui.failure("That did not look like a domain list. Example: example.com, *.shop.test");
+      }
+      ui.step(4, 6, "Blocked domains");
+      ui.explain(["Never open these sites, even when everything else is allowed."]);
+      while (true) {
+        const parsed = parseDomainList(await session.question("Blocked domains (comma-separated, Enter for none): "));
+        if (parsed !== void 0) {
+          blockedDomains = parsed;
+          break;
+        }
+        ui.failure("That did not look like a domain list. Example: ads.example.com");
+      }
+      ui.step(5, 6, "JavaScript execution");
+      ui.explain([
+        "browser_evaluate runs arbitrary JavaScript on a page - powerful for scraping",
+        "but it can also trigger bot defenses. Most users never need it on."
+      ]);
+      allowEval = await askYesNo(session, "Allow the AI to run JavaScript on pages?", false);
+      ui.step(6, 6, "Data directory");
+      ui.explain([
+        "Where the private Chrome profile, logs, and downloads live.",
+        "Permissions are locked to 0600 so only your user can read them."
+      ]);
+      while (dataDir === defaults.dataDir) {
+        const answer = (await session.question(`Data directory [${defaults.dataDir}]: `)).trim();
+        if (!answer) break;
+        if (!answer.startsWith("/") || answer.replace(/\/+$/, "") === "") {
+          ui.failure("Enter an absolute path other than the filesystem root.");
+          continue;
+        }
+        dataDir = answer;
+        break;
+      }
+      headless = headlessChoice;
+      if (mode === "connect") {
+        ui.note("Starting your personal Chrome with remote debugging on port 9222...");
+        try {
+          const launched = await launchPersonalChrome({ dataDir, spawn: opts.spawn, probe: opts.probe ?? defaultProbe, port: 9222 });
+          browserUrl = launched.url;
+          ui.success(`Connected to your Chrome at ${launched.url}`);
+        } catch {
+          browserUrl = "http://127.0.0.1:9222";
+          ui.note("Could not reach Chrome on port 9222 yet - keeping the default URL.");
+        }
       }
     }
+    writeSummary(ui, harness, { mode, headless, allowedDomains, blockedDomains, allowEval, dataDir });
     return { mode, headless, allowedDomains, blockedDomains, allowEval, dataDir, browserUrl };
   } finally {
     rl.close();
   }
 }
+function writeSummary(ui, harness, choices) {
+  const modeLabel = {
+    managed: "Managed private Chrome (isolated profile)",
+    connect: "Your personal Chrome via debugging port",
+    disabled: "Disabled - no browser tools"
+  };
+  ui.banner("Configuration Summary", `Ready to configure ${harness}`, "");
+  ui.keyValues([
+    ["Browser mode", choices.mode === "connect" ? modeLabel.connect : modeLabel[choices.mode] ?? choices.mode],
+    ["Headless", choices.headless ? "yes - no visible window" : "no - you can watch and intervene"],
+    ...choices.mode === "disabled" ? [] : [
+      ["Allowed sites", choices.allowedDomains.length ? choices.allowedDomains.join(", ") : "all sites"],
+      ["Blocked sites", choices.blockedDomains.length ? choices.blockedDomains.join(", ") : "none"],
+      ["Page JavaScript", choices.allowEval ? "enabled" : "off (recommended)"],
+      ["Data directory", choices.dataDir]
+    ]
+  ]);
+}
 async function defaultProbe(url, timeoutMs) {
   try {
     const controller = new AbortController();
@@ -995,7 +1293,7 @@ async function defaultProbe(url, timeoutMs) {
 }
 async function persistWizardConfig(choices, homeDir) {
   const { join: join8, dirname: dirname5, resolve: resolve6 } = await import("node:path");
-  const { mkdir: mkdir4, chmod: chmod3, lstat: lstat4, readFile: readFile3, writeFile: writeFile2, rename: rename3 } = await import("node:fs/promises");
+  const { mkdir: mkdir4, chmod: chmod3, lstat: lstat4, readFile: readFile3, writeFile: writeFile2, rename: rename4 } = await import("node:fs/promises");
   const configPath = resolve6(join8(homeDir, ".smooth-operator/config.json"));
   await mkdir4(dirname5(configPath), { recursive: true, mode: 448 });
   await chmod3(dirname5(configPath), 448).catch(() => {
@@ -1041,7 +1339,8 @@ async function persistWizardConfig(choices, homeDir) {
   if (choices.dataDir !== defaultDataDir) {
     config.dataDir = choices.dataDir;
   }
-  const tmpPath = `${configPath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+  const { randomUUID: randomUUID4 } = await import("node:crypto");
+  const tmpPath = `${configPath}.tmp-${process.pid}-${randomUUID4()}`;
   await writeFile2(tmpPath, JSON.stringify(config, null, 2) + "\n", { mode: 384, flag: "wx" });
   await chmod3(tmpPath, 384);
   try {
@@ -1066,7 +1365,7 @@ async function persistWizardConfig(choices, homeDir) {
   } catch (error) {
     if (!isMissingPathError2(error)) throw error;
   }
-  await rename3(tmpPath, configPath);
+  await rename4(tmpPath, configPath);
   await chmod3(configPath, 384);
 }
 async function launchPersonalChrome(opts) {
@@ -1094,12 +1393,24 @@ async function launchPersonalChrome(opts) {
   }
   throw new AppError2("BROWSER_CONNECT_TIMEOUT", `Chrome DevTools endpoint on port ${port} did not become ready after ${attempts} probes. Close Chrome or choose another port.`);
 }
-var PROBE_INTERVAL_MS, DEFAULT_PROBE_ATTEMPTS;
+var PROBE_INTERVAL_MS, DEFAULT_PROBE_ATTEMPTS, HARNESS_MENU;
 var init_installer_wizard = __esm({
   "src/server/installer-wizard.ts"() {
     "use strict";
+    init_ui();
     PROBE_INTERVAL_MS = 300;
     DEFAULT_PROBE_ATTEMPTS = 33;
+    HARNESS_MENU = [
+      { id: "opencode", label: "OpenCode", description: "Configures ~/.config/opencode/opencode.json" },
+      { id: "claude-code", label: "Claude Code", description: "Runs `claude mcp add` for your user scope" },
+      { id: "copilot", label: "GitHub Copilot CLI", description: "Runs `copilot mcp add`" },
+      { id: "codex", label: "OpenAI Codex CLI", description: "Runs `codex mcp add`" },
+      { id: "gemini", label: "Gemini CLI", description: "Runs `gemini mcp add` for your user scope" },
+      { id: "vscode", label: "VS Code", description: "Runs `code --add-mcp`" },
+      { id: "cursor", label: "Cursor", description: "Adds SmoothOperator to ~/.cursor/mcp.json" },
+      { id: "windsurf", label: "Windsurf", description: "Adds SmoothOperator to Windsurf's mcp_config.json" },
+      { id: "claude-desktop", label: "Claude Desktop", description: "Updates claude_desktop_config.json" }
+    ];
   }
 });
 
@@ -1972,7 +2283,7 @@ init_errors();
 init_logger();
 
 // src/server/version.ts
-var SERVER_VERSION = "2.1.1";
+var SERVER_VERSION = "2.2.1";
 
 // src/server/mcp.ts
 var EmptyInputSchema = z3.object({}).strict();
@@ -2797,7 +3108,7 @@ function boundToolError(result) {
 init_logger();
 
 // src/server/runtime.ts
-import { chmod, lstat as lstat2, mkdir as mkdir2, open, readFile as readFile2, realpath as realpath2, unlink as unlink2 } from "node:fs/promises";
+import { chmod, lstat as lstat2, mkdir as mkdir2, open, readFile as readFile2, realpath as realpath2, rename as rename2, unlink as unlink2 } from "node:fs/promises";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { basename as basename3, dirname as dirname3, join as join5, resolve as resolve4 } from "node:path";
 import process3 from "node:process";
@@ -7548,12 +7859,41 @@ async function acquireBrowserProfileLease(profileDirectory) {
         throw new AppError("BROWSER_PROFILE_LOCK_FAILED", "The native browser profile has an unreadable lock. Verify that no SmoothOperator process is using it, then remove the lock file.", { retryable: true });
       }
       if (existing === "stale") {
-        throw new AppError("BROWSER_PROFILE_LOCK_FAILED", "The native browser profile has a stale lock. Verify that no SmoothOperator process is using it, then remove the lock file and retry.", { retryable: true });
+        if (await reclaimStaleLock(lockPath)) {
+          continue;
+        }
+        throw new AppError("BROWSER_PROFILE_LOCK_FAILED", "The native browser profile has a stale lock that could not be reclaimed. Verify that no SmoothOperator process is using it, then remove the lock file and retry.", { retryable: true });
       }
     }
   }
   throw new AppError("BROWSER_PROFILE_IN_USE", "The native browser profile became busy while it was being acquired.", { retryable: true });
 }
+async function reclaimStaleLock(lockPath) {
+  try {
+    const before = await lstat2(lockPath);
+    const raw = await readFile2(lockPath, "utf8");
+    const pid = JSON.parse(raw).pid;
+    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) {
+      return false;
+    }
+    try {
+      process3.kill(pid, 0);
+      return false;
+    } catch (error) {
+      if (fileSystemErrorCode(error) !== "ESRCH") {
+        return false;
+      }
+    }
+    const after = await lstat2(lockPath);
+    if (after.ino !== before.ino || after.dev !== before.dev) {
+      return false;
+    }
+    await rename2(lockPath, `${lockPath}.stale-${randomUUID2()}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function readProfileLock(lockPath) {
   let raw;
   try {
@@ -7771,10 +8111,27 @@ async function main(args = process4.argv.slice(2)) {
     if (!harness) {
       throw new AppError("CONFIG_INVALID", "The install command requires a harness target.");
     }
-    const wizardChoices = await runWizard2(harness, { yes, stdin: process4.stdin, stdout: process4.stdout, homeDir: homedir5(), env: process4.env });
+    planHarnessInstall(harness, { homeDirectory: homedir5(), environment: process4.env });
+    const wizardChoices = await runWizard2(harness, { yes, stdin: process4.stdin, stdout: process4.stdout, homeDir: homedir5(), env: process4.env, version: SERVER_VERSION });
     await persistWizardConfig2(wizardChoices, homedir5());
-    process4.stdout.write(`${await installHarness(harness)}
+    const installMessage = await installHarness(harness);
+    const { createUi: createUi2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+    const ui = createUi2(process4.stdout);
+    if (process4.stdout.isTTY) {
+      ui.banner("Installation Complete", `${harness} can now drive a browser`, SERVER_VERSION);
+      ui.keyValues([
+        ["Config file", `${homedir5()}/.smooth-operator/config.json`],
+        ["Browser mode", wizardChoices.mode]
+      ]);
+      process4.stdout.write("\n");
+      ui.step(0, 2, "Next steps");
+      ui.option(1, "Restart the harness", "Quit and reopen it so it picks up the new MCP server.");
+      ui.option(2, "Verify", "Ask your AI to run server_health and browser_doctor.");
+      ui.success(installMessage);
+    } else {
+      process4.stdout.write(`${installMessage}
 `);
+    }
     return;
   }
   if (args.length === 1 && (args[0] === "--version" || args[0] === "-V")) {