smooth-operator-mcp 2.2.0 → 2.3.0

package/README.md

@@ -27,7 +27,7 @@ Or straight from GitHub:
 npm install -g github:Gitshop77/Smooth-Operator && smooth-operator install opencode
 ~~~
 
-Wizard asks 6 questions (managed vs personal Chrome, headless, domains, JS). Run `smooth-operator install` with no harness to pick one interactively (TTY only; piped/CI runs print usage and exit). `--yes` skips every prompt, so give it a target: `smooth-operator install opencode --yes`. Personal Chrome → wizard launches Chrome on `9222` for you.
+Wizard asks 7 questions (browser — any Chromium-based browser is detected, managed vs personal Chrome, headless, domains, JS). Run `smooth-operator install` with no harness to pick one interactively (TTY only; piped/CI runs print usage and exit). `--yes` skips every prompt, so give it a target: `smooth-operator install opencode --yes`. Personal Chrome → wizard launches Chrome on `9222` for you.
 
 Requires Node 22.23.2+ and Chrome. Profile at `~/.smooth-operator/browser` — sign in once.
 

package/dist/smooth-operator.mjs

@@ -287,7 +287,8 @@ var init_errors = __esm({
 var discovery_exports = {};
 __export(discovery_exports, {
   chromeExecutableSearchPaths: () => chromeExecutableSearchPaths,
-  findChromeExecutable: () => findChromeExecutable
+  findChromeExecutable: () => findChromeExecutable,
+  findChromiumExecutables: () => findChromiumExecutables
 });
 import * as nodeFs from "node:fs";
 import { homedir as homedir2 } from "node:os";
@@ -296,6 +297,9 @@ import { env as env2 } from "node:process";
 function findChromeExecutable(fs = nodeFs) {
   return chromeExecutableCandidates().find((candidate) => fs.existsSync(candidate.path)) ?? null;
 }
+function findChromiumExecutables(fs = nodeFs) {
+  return chromeExecutableCandidates().filter((candidate) => fs.existsSync(candidate.path));
+}
 function chromeExecutableSearchPaths() {
   return chromeExecutableCandidates().map((candidate) => candidate.path);
 }
@@ -309,16 +313,23 @@ function chromeExecutableCandidates() {
 function macOsCandidates() {
   const applicationDirectories = ["/Applications", join2(homedir2(), "Applications")];
   return [
-    ...applicationBundleCandidates(applicationDirectories, "Google Chrome", "Google Chrome", "stable"),
-    ...applicationBundleCandidates(applicationDirectories, "Google Chrome Beta", "Google Chrome Beta", "beta"),
-    ...applicationBundleCandidates(applicationDirectories, "Google Chrome Dev", "Google Chrome Dev", "dev"),
-    ...applicationBundleCandidates(applicationDirectories, "Google Chrome Canary", "Google Chrome Canary", "canary")
+    ...applicationBundleCandidates(applicationDirectories, "Google Chrome", "Google Chrome", "Google Chrome", "stable"),
+    ...applicationBundleCandidates(applicationDirectories, "Google Chrome Beta", "Google Chrome Beta", "Google Chrome Beta", "beta"),
+    ...applicationBundleCandidates(applicationDirectories, "Google Chrome Dev", "Google Chrome Dev", "Google Chrome Dev", "dev"),
+    ...applicationBundleCandidates(applicationDirectories, "Google Chrome Canary", "Google Chrome Canary", "Google Chrome Canary", "canary"),
+    ...applicationBundleCandidates(applicationDirectories, "Brave Browser", "Brave Browser", "Brave", "stable"),
+    ...applicationBundleCandidates(applicationDirectories, "Microsoft Edge", "Microsoft Edge", "Microsoft Edge", "stable"),
+    ...applicationBundleCandidates(applicationDirectories, "Chromium", "Chromium", "Chromium", "stable"),
+    ...applicationBundleCandidates(applicationDirectories, "Vivaldi", "Vivaldi", "Vivaldi", "stable"),
+    ...applicationBundleCandidates(applicationDirectories, "Arc", "Arc", "Arc", "stable"),
+    ...applicationBundleCandidates(applicationDirectories, "Opera", "Opera", "Opera", "stable")
   ];
 }
-function applicationBundleCandidates(applicationDirectories, bundleName, executableName, channel) {
+function applicationBundleCandidates(applicationDirectories, bundleName, executableName, label, channel) {
   return applicationDirectories.map((applicationDirectory) => ({
     path: join2(applicationDirectory, `${bundleName}.app`, "Contents", "MacOS", executableName),
-    channel
+    channel,
+    label
   }));
 }
 function windowsCandidates() {
@@ -328,29 +339,39 @@ function windowsCandidates() {
     env2.LOCALAPPDATA
   ].filter((directory) => Boolean(directory));
   return [
-    ...windowsChannelCandidates(directories, "Chrome", "stable"),
-    ...windowsChannelCandidates(directories, "Chrome Beta", "beta"),
-    ...windowsChannelCandidates(directories, "Chrome Dev", "dev"),
-    ...windowsChannelCandidates(directories, "Chrome SxS", "canary")
+    ...windowsChannelCandidates(directories, ["Google", "Chrome"], "chrome.exe", "Google Chrome", "stable"),
+    ...windowsChannelCandidates(directories, ["Google", "Chrome Beta"], "chrome.exe", "Google Chrome Beta", "beta"),
+    ...windowsChannelCandidates(directories, ["Google", "Chrome Dev"], "chrome.exe", "Google Chrome Dev", "dev"),
+    ...windowsChannelCandidates(directories, ["Google", "Chrome SxS"], "chrome.exe", "Google Chrome Canary", "canary"),
+    ...windowsChannelCandidates(directories, ["BraveSoftware", "Brave-Browser"], "brave.exe", "Brave", "stable"),
+    ...windowsChannelCandidates(directories, ["Microsoft", "Edge"], "msedge.exe", "Microsoft Edge", "stable"),
+    ...windowsChannelCandidates(directories, ["Chromium"], "chrome.exe", "Chromium", "stable"),
+    ...windowsChannelCandidates(directories, ["Vivaldi"], "vivaldi.exe", "Vivaldi", "stable")
   ];
 }
-function windowsChannelCandidates(directories, directory, channel) {
+function windowsChannelCandidates(directories, directoryParts, executable, label, channel) {
   return directories.map((baseDirectory) => ({
-    path: win32.join(baseDirectory, "Google", directory, "Application", "chrome.exe"),
-    channel
+    path: win32.join(baseDirectory, ...directoryParts, "Application", executable),
+    channel,
+    label
   }));
 }
 function linuxCandidates() {
   const searchDirectories = (env2.PATH ?? "").split(delimiter).filter(Boolean);
   const commands = [
-    ["google-chrome", "stable"],
-    ["google-chrome-stable", "stable"],
-    ["google-chrome-beta", "beta"],
-    ["google-chrome-unstable", "dev"],
-    ["chromium", "stable"],
-    ["chromium-browser", "stable"]
+    ["google-chrome", "Google Chrome", "stable"],
+    ["google-chrome-stable", "Google Chrome", "stable"],
+    ["google-chrome-beta", "Google Chrome Beta", "beta"],
+    ["google-chrome-unstable", "Google Chrome Dev", "dev"],
+    ["brave-browser", "Brave", "stable"],
+    ["microsoft-edge", "Microsoft Edge", "stable"],
+    ["microsoft-edge-stable", "Microsoft Edge", "stable"],
+    ["chromium", "Chromium", "stable"],
+    ["chromium-browser", "Chromium", "stable"],
+    ["vivaldi", "Vivaldi", "stable"],
+    ["vivaldi-stable", "Vivaldi", "stable"]
   ];
-  return commands.flatMap(([command, channel]) => searchDirectories.map((directory) => ({ path: join2(directory, command), channel })));
+  return commands.flatMap(([command, label, channel]) => searchDirectories.map((directory) => ({ path: join2(directory, command), channel, label })));
 }
 var init_discovery = __esm({
   "src/server/browser/discovery.ts"() {
@@ -366,8 +387,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 +415,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 +465,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 +588,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 +646,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 +673,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 +704,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) {
@@ -985,6 +1058,7 @@ __export(installer_wizard_exports, {
   runWizard: () => runWizard
 });
 import { join as join7 } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -1041,9 +1115,43 @@ function recommendedDefaults(homeDir) {
     allowedDomains: [],
     blockedDomains: [],
     allowEval: false,
-    dataDir: join7(homeDir ?? homedir4(), ".smooth-operator")
+    dataDir: join7(homeDir ?? homedir4(), ".smooth-operator"),
+    browserExecutablePath: void 0
   };
 }
+async function askBrowser(session, ui) {
+  const { findChromiumExecutables: findChromiumExecutables2 } = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
+  const detected = findChromiumExecutables2();
+  if (detected.length > 0) {
+    detected.forEach((candidate, index) => {
+      ui.option(index + 1, candidate.label, candidate.path, index === 0);
+    });
+    while (true) {
+      const answer = (await session.question(`Browser [1]: `)).trim();
+      if (!answer || answer === "1") return detected[0].path;
+      const numeric = Number.parseInt(answer, 10);
+      if (`${numeric}` === answer && numeric >= 1 && numeric <= detected.length) {
+        return detected[numeric - 1].path;
+      }
+      if (/^\d+$/.test(answer)) continue;
+      if (answer.startsWith("/") && existsSync2(answer)) return answer;
+      ui.failure("Enter a listed number or an existing absolute path.");
+    }
+  }
+  while (true) {
+    const answer = (await session.question("Browser executable path (Enter = auto-detect): ")).trim();
+    if (!answer) return void 0;
+    if (!answer.startsWith("/")) {
+      ui.failure("Enter an absolute path.");
+      continue;
+    }
+    if (!existsSync2(answer)) {
+      ui.failure("That path does not exist.");
+      continue;
+    }
+    return answer;
+  }
+}
 function tolerantQuestion(rl) {
   return {
     async question(prompt) {
@@ -1097,7 +1205,7 @@ async function runWizard(harness, opts) {
     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.step(1, WIZARD_STEP_TOTAL, "Browser mode");
     ui.explain([
       "Who owns the Chrome window your AI drives?",
       "",
@@ -1136,16 +1244,24 @@ async function runWizard(harness, opts) {
       }
       ui.failure("Enter 1, 2, or 3.");
     }
+    let browserExecutablePath;
     let headlessChoice = false;
     if (mode !== "disabled") {
-      ui.step(2, 6, "Headless mode");
+      ui.step(2, WIZARD_STEP_TOTAL, "Browser");
+      ui.explain([
+        "Any Chromium-based browser works: Chrome, Brave, Edge, Chromium,",
+        "Vivaldi, Arc, Opera. The AI gets its own isolated profile inside the",
+        "browser you pick - your everyday profiles are never touched."
+      ]);
+      browserExecutablePath = await askBrowser(session, ui);
+      ui.step(3, WIZARD_STEP_TOTAL, "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.step(4, WIZARD_STEP_TOTAL, "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."
@@ -1158,7 +1274,7 @@ async function runWizard(harness, opts) {
         }
         ui.failure("That did not look like a domain list. Example: example.com, *.shop.test");
       }
-      ui.step(4, 6, "Blocked domains");
+      ui.step(5, WIZARD_STEP_TOTAL, "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): "));
@@ -1168,13 +1284,13 @@ async function runWizard(harness, opts) {
         }
         ui.failure("That did not look like a domain list. Example: ads.example.com");
       }
-      ui.step(5, 6, "JavaScript execution");
+      ui.step(6, WIZARD_STEP_TOTAL, "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.step(7, WIZARD_STEP_TOTAL, "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."
@@ -1182,8 +1298,8 @@ async function runWizard(harness, opts) {
       while (dataDir === defaults.dataDir) {
         const answer = (await session.question(`Data directory [${defaults.dataDir}]: `)).trim();
         if (!answer) break;
-        if (!answer.startsWith("/")) {
-          ui.failure("Enter an absolute path (starting with /).");
+        if (!answer.startsWith("/") || answer.replace(/\/+$/, "") === "") {
+          ui.failure("Enter an absolute path other than the filesystem root.");
           continue;
         }
         dataDir = answer;
@@ -1202,8 +1318,8 @@ async function runWizard(harness, opts) {
         }
       }
     }
-    writeSummary(ui, harness, { mode, headless, allowedDomains, blockedDomains, allowEval, dataDir });
-    return { mode, headless, allowedDomains, blockedDomains, allowEval, dataDir, browserUrl };
+    writeSummary(ui, harness, { mode, headless, allowedDomains, blockedDomains, allowEval, dataDir, browserExecutablePath });
+    return { mode, headless, allowedDomains, blockedDomains, allowEval, dataDir, browserUrl, browserExecutablePath };
   } finally {
     rl.close();
   }
@@ -1217,6 +1333,7 @@ function writeSummary(ui, harness, choices) {
   ui.banner("Configuration Summary", `Ready to configure ${harness}`, "");
   ui.keyValues([
     ["Browser mode", choices.mode === "connect" ? modeLabel.connect : modeLabel[choices.mode] ?? choices.mode],
+    ...choices.browserExecutablePath ? [["Browser", choices.browserExecutablePath]] : [],
     ["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"],
@@ -1241,7 +1358,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(() => {
@@ -1273,6 +1390,9 @@ async function persistWizardConfig(choices, homeDir) {
   if (choices.browserUrl) {
     chosenBrowser.url = choices.browserUrl;
   }
+  if (choices.browserExecutablePath) {
+    chosenBrowser.executablePath = choices.browserExecutablePath;
+  }
   const chosenSecurity = {
     allowEval: choices.allowEval,
     allowedDomains: choices.allowedDomains,
@@ -1287,7 +1407,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 {
@@ -1312,7 +1433,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) {
@@ -1340,7 +1461,7 @@ 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, HARNESS_MENU;
+var PROBE_INTERVAL_MS, DEFAULT_PROBE_ATTEMPTS, HARNESS_MENU, WIZARD_STEP_TOTAL;
 var init_installer_wizard = __esm({
   "src/server/installer-wizard.ts"() {
     "use strict";
@@ -1358,6 +1479,7 @@ var init_installer_wizard = __esm({
       { 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" }
     ];
+    WIZARD_STEP_TOTAL = 7;
   }
 });
 
@@ -2230,7 +2352,7 @@ init_errors();
 init_logger();
 
 // src/server/version.ts
-var SERVER_VERSION = "2.2.0";
+var SERVER_VERSION = "2.3.0";
 
 // src/server/mcp.ts
 var EmptyInputSchema = z3.object({}).strict();
@@ -3055,7 +3177,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";
@@ -7806,12 +7928,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 {
@@ -8029,6 +8180,7 @@ async function main(args = process4.argv.slice(2)) {
     if (!harness) {
       throw new AppError("CONFIG_INVALID", "The install command requires a harness target.");
     }
+    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());
     const installMessage = await installHarness(harness);