smooth-operator-mcp 2.2.0 → 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) {
@@ -1182,8 +1234,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;
@@ -1241,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(() => {
@@ -1287,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 {
@@ -1312,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) {
@@ -2230,7 +2283,7 @@ init_errors();
 init_logger();
 
 // src/server/version.ts
-var SERVER_VERSION = "2.2.0";
+var SERVER_VERSION = "2.2.1";
 
 // src/server/mcp.ts
 var EmptyInputSchema = z3.object({}).strict();
@@ -3055,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";
@@ -7806,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 {
@@ -8029,6 +8111,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);