smooth-operator-mcp 3.0.2 → 3.0.5

package/dist/smooth-operator.mjs

@@ -354,7 +354,7 @@ function truncateUtf8(value, maxBytes) {
   while (low < high) {
     const midpoint = Math.ceil((low + high) / 2);
     const candidate = decoder.decode(bytes.slice(0, midpoint));
-    if (UTF8_ENCODER.encode(candidate).byteLength <= maxBytes) {
+    if (UTF8_ENCODER.encode(candidate).byteLength <= boundedMaxBytes) {
       low = midpoint;
     } else {
       high = midpoint - 1;
@@ -397,7 +397,7 @@ var SERVER_VERSION;
 var init_version = __esm({
   "src/server/version.ts"() {
     "use strict";
-    SERVER_VERSION = "3.0.2";
+    SERVER_VERSION = "3.0.5";
   }
 });
 
@@ -639,9 +639,9 @@ function resolveConfigPath(target, homeDirectory = homedir3(), environment = pro
     return join6(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   if (platform2() === "win32") {
-    return join6(environment.APPDATA ?? join6(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+    return join6(resolveConfigDirectory(environment.APPDATA, join6(home, "AppData", "Roaming")), "Claude", "claude_desktop_config.json");
   }
-  return join6(environment.XDG_CONFIG_HOME ?? join6(home, ".config"), "Claude", "claude_desktop_config.json");
+  return join6(resolveConfigDirectory(environment.XDG_CONFIG_HOME, join6(home, ".config")), "Claude", "claude_desktop_config.json");
 }
 function resolveOpenCodeConfigPath(homeDirectory = homedir3(), environment = process.env, override) {
   if (override) {
@@ -650,9 +650,17 @@ function resolveOpenCodeConfigPath(homeDirectory = homedir3(), environment = pro
   if (environment.OPENCODE_CONFIG) {
     return resolve5(environment.OPENCODE_CONFIG);
   }
-  const configDirectory = environment.OPENCODE_CONFIG_DIR ?? join6(homeDirectory || homedir3(), ".config", "opencode");
+  const configDirectory = resolveConfigDirectory(environment.OPENCODE_CONFIG_DIR, join6(homeDirectory || homedir3(), ".config", "opencode"));
   return join6(configDirectory, "opencode.json");
 }
+function resolveConfigDirectory(value, fallback) {
+  const candidate = value?.trim() || fallback;
+  try {
+    return resolve5(candidate);
+  } catch (error) {
+    throw new AppError("INSTALL_CONFIG_INVALID", "Configuration directory paths must be valid filesystem paths.", { cause: error });
+  }
+}
 async function installJsonConfig(target, plannedPath, options, allowOpenCodeJsoncFallback = false) {
   const path = target === "opencode" && allowOpenCodeJsoncFallback ? await chooseExistingOpenCodePath(plannedPath) : plannedPath;
   await ensureSecureDirectory(dirname4(path));
@@ -898,6 +906,9 @@ function sameOpenCodeEntry(value, desired) {
 }
 async function ensureSecureDirectory(path) {
   const absolute = resolve5(path);
+  if (parse3(absolute).root === absolute) {
+    throw new AppError("INSTALL_CONFIG_FAILED", "Configuration directories must not be filesystem roots.");
+  }
   await assertNoSymlinkComponents2(absolute, "configuration directory");
   await mkdir3(absolute, { recursive: true, mode: 448 });
   await assertNoSymlinkComponents2(absolute, "configuration directory");
@@ -1227,7 +1238,7 @@ __export(installer_wizard_exports, {
   runWizard: () => runWizard
 });
 import { dirname as dirname5, isAbsolute as isAbsolute4, join as join7, parse as parse4, resolve as resolve6, win32 as win323 } from "node:path";
-import { existsSync as existsSync2 } from "node:fs";
+import { accessSync as accessSync2, constants as constants3, statSync } from "node:fs";
 import { chmod as chmod3, lstat as lstat4, rename as rename4, unlink as unlink4, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import { isIP as isIP3 } from "node:net";
@@ -1244,6 +1255,19 @@ function isAbsolutePath(value) {
 function isFilesystemRoot(value) {
   return isAbsolute4(value) && parse4(value).root === value || win323.isAbsolute(value) && win323.parse(value).root === value;
 }
+function isExecutableFile(path) {
+  try {
+    if (!statSync(path).isFile()) {
+      return false;
+    }
+    if (process.platform !== "win32") {
+      accessSync2(path, constants3.X_OK);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
 function isInteractive() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
 }
@@ -1313,8 +1337,8 @@ async function askBrowser(session, ui) {
         return detected[numeric - 1].path;
       }
       if (/^\d+$/.test(answer)) continue;
-      if (isAbsolutePath(answer) && existsSync2(answer)) return answer;
-      ui.failure("Enter a listed number or an existing absolute path.");
+      if (isAbsolutePath(answer) && isExecutableFile(answer)) return answer;
+      ui.failure("Enter a listed number or an existing executable file path.");
     }
   }
   while (true) {
@@ -1324,8 +1348,8 @@ async function askBrowser(session, ui) {
       ui.failure("Enter an absolute path.");
       continue;
     }
-    if (!existsSync2(answer)) {
-      ui.failure("That path does not exist.");
+    if (!isExecutableFile(answer)) {
+      ui.failure("That path is not an executable file.");
       continue;
     }
     return answer;
@@ -1560,16 +1584,65 @@ function writeSummary(ui, harness, choices) {
   ]);
 }
 async function defaultProbe(url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
     const response = await fetch(url, { signal: controller.signal });
-    clearTimeout(timer);
     if (!response.ok) return { state: "no-file" };
-    const version = await response.json().catch(() => ({}));
-    return { state: "live", version };
+    const version = await readProbeJson(response, controller.signal);
+    return isDevToolsVersion(version) ? { state: "live", version } : { state: "no-file" };
   } catch {
     return { state: "no-file" };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function isDevToolsVersion(value) {
+  return isRecord4(value) && typeof value.Browser === "string" && typeof value.webSocketDebuggerUrl === "string" && /^wss?:\/\//i.test(value.webSocketDebuggerUrl);
+}
+async function readProbeJson(response, signal) {
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_PROBE_RESPONSE_BYTES) {
+    return void 0;
+  }
+  if (!response.body) {
+    return void 0;
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      if (signal.aborted) {
+        return void 0;
+      }
+      const next = await reader.read();
+      if (next.done) {
+        break;
+      }
+      if (!(next.value instanceof Uint8Array)) {
+        return void 0;
+      }
+      total += next.value.byteLength;
+      if (total > MAX_PROBE_RESPONSE_BYTES) {
+        return void 0;
+      }
+      chunks.push(next.value);
+    }
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    return void 0;
   }
 }
 async function assertPrivateWizardConfig(handle) {
@@ -1671,16 +1744,21 @@ async function launchPersonalChrome(opts) {
   if (!safeDataDir || !isAbsolutePath(rawDataDir) || isFilesystemRoot(safeDataDir) || /[\u0000-\u001f\u007f]/.test(rawDataDir)) {
     throw new AppError("INSTALL_CONFIG_INVALID", "The personal Chrome data directory must be an absolute non-root path without control characters.");
   }
+  if (opts.probeAttempts !== void 0 && (!Number.isSafeInteger(opts.probeAttempts) || opts.probeAttempts < 1 || opts.probeAttempts > MAX_PROBE_ATTEMPTS)) {
+    throw new AppError("INSTALL_CONFIG_INVALID", `The personal Chrome probe attempt count must be an integer between 1 and ${MAX_PROBE_ATTEMPTS}.`);
+  }
+  await ensureSecureDirectory(safeDataDir);
+  const personalProfileDir = join7(safeDataDir, "personal-chrome");
+  await ensureSecureDirectory(personalProfileDir);
   const { findChromeExecutable: findChromeExecutable2 } = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
   const executable = opts.executablePath ?? findChromeExecutable2()?.path;
-  if (!executable) {
+  if (!executable || !isExecutableFile(executable)) {
     throw new AppError("BROWSER_NOT_CONFIGURED", "Install Chrome or set SMOOTH_OPERATOR_BROWSER_EXECUTABLE");
   }
-  await ensureSecureDirectory(safeDataDir);
   const spawnFn = opts.spawn ?? (await import("node:child_process")).spawn;
   const args = [
     `--remote-debugging-port=${port}`,
-    `--user-data-dir=${join7(safeDataDir, "personal-chrome")}`,
+    `--user-data-dir=${personalProfileDir}`,
     "--no-first-run",
     "--no-default-browser-check",
     ...opts.headless ? ["--headless=new"] : []
@@ -1689,19 +1767,44 @@ async function launchPersonalChrome(opts) {
   child.unref();
   const probe = opts.probe;
   const attempts = opts.probeAttempts ?? DEFAULT_PROBE_ATTEMPTS;
+  const deadline = opts.probeAttempts === void 0 ? Date.now() + DEFAULT_PROBE_DEADLINE_MS : void 0;
+  let attemptsMade = 0;
   for (let attempt = 0; attempt < attempts; attempt += 1) {
+    if (deadline !== void 0 && Date.now() >= deadline) {
+      break;
+    }
     if (attempt > 0) {
-      await new Promise((resolveTimeout) => setTimeout(resolveTimeout, PROBE_INTERVAL_MS));
+      const remaining2 = deadline === void 0 ? PROBE_INTERVAL_MS : deadline - Date.now();
+      if (remaining2 <= 0) break;
+      await new Promise((resolveTimeout) => setTimeout(resolveTimeout, Math.min(PROBE_INTERVAL_MS, remaining2)));
     }
+    const remaining = deadline === void 0 ? PROBE_TIMEOUT_MS : Math.min(PROBE_TIMEOUT_MS, deadline - Date.now());
+    if (remaining <= 0) break;
+    attemptsMade += 1;
     try {
-      const res = await probe(`http://127.0.0.1:${port}/json/version`, 1e3);
+      const res = await boundedProbe(probe, `http://127.0.0.1:${port}/json/version`, remaining);
       if (res.state === "live") return { url: `http://127.0.0.1:${port}` };
     } catch {
     }
   }
-  throw new AppError("BROWSER_CONNECT_TIMEOUT", `Chrome DevTools endpoint on port ${port} did not become ready after ${attempts} probes. Close Chrome or choose another port.`);
+  throw new AppError("BROWSER_CONNECT_TIMEOUT", `Chrome DevTools endpoint on port ${port} did not become ready after ${attemptsMade} probes. Close Chrome or choose another port.`);
+}
+async function boundedProbe(probe, url, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve().then(() => probe(url, timeoutMs)),
+      new Promise((resolveProbe) => {
+        timer = setTimeout(() => resolveProbe({ state: "timeout" }), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
 }
-var PROBE_INTERVAL_MS, DEFAULT_PROBE_ATTEMPTS, MAX_WIZARD_CONFIG_BYTES, HARNESS_MENU, WIZARD_STEP_TOTAL;
+var PROBE_INTERVAL_MS, PROBE_TIMEOUT_MS, DEFAULT_PROBE_ATTEMPTS, DEFAULT_PROBE_DEADLINE_MS, MAX_PROBE_ATTEMPTS, MAX_PROBE_RESPONSE_BYTES, MAX_WIZARD_CONFIG_BYTES, HARNESS_MENU, WIZARD_STEP_TOTAL;
 var init_installer_wizard = __esm({
   "src/server/installer-wizard.ts"() {
     "use strict";
@@ -1710,7 +1813,11 @@ var init_installer_wizard = __esm({
     init_ui();
     init_version();
     PROBE_INTERVAL_MS = 300;
+    PROBE_TIMEOUT_MS = 1e3;
     DEFAULT_PROBE_ATTEMPTS = 33;
+    DEFAULT_PROBE_DEADLINE_MS = 1e4;
+    MAX_PROBE_ATTEMPTS = 100;
+    MAX_PROBE_RESPONSE_BYTES = 64 * 1024;
     MAX_WIZARD_CONFIG_BYTES = 2e6;
     HARNESS_MENU = [
       { id: "opencode", label: "OpenCode", description: "Configures ~/.config/opencode/opencode.json" },
@@ -1907,7 +2014,7 @@ function isValidDomainPattern(pattern) {
     }
     const bracketless = base.replace(/^\[|\]$/g, "");
     if (isIP(bracketless) !== 0) {
-      return true;
+      return !wildcard;
     }
     const ascii = domainToASCII(base);
     return Boolean(ascii) && ascii.split(".").every((label) => label.length > 0 && label.length <= 63 && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(label));
@@ -1999,6 +2106,18 @@ function canonicalizeAllowedFileRoots(rawRoots) {
     if (parse(canonicalRoot).root === canonicalRoot) {
       throw new AppError("CONFIG_INVALID", "Configured file roots must not be filesystem roots.");
     }
+    try {
+      if (!lstatSync(canonicalRoot).isDirectory()) {
+        throw new AppError("CONFIG_INVALID", "Configured file roots must be directories.");
+      }
+    } catch (error) {
+      if (error instanceof AppError) {
+        throw error;
+      }
+      if (!isMissingPathError(error)) {
+        throw new AppError("CONFIG_INSECURE", "Configured file roots could not be inspected safely.", { cause: error });
+      }
+    }
     if (!roots.includes(canonicalRoot)) {
       roots.push(canonicalRoot);
     }
@@ -2312,11 +2431,21 @@ function normalizeHostPattern(value) {
     throw new AppError("CONFIG_INVALID", "Configuration failed validation: configured HTTP host allowlists must contain hostnames or bracketed IPv6 addresses without ports.");
   }
   try {
-    return new URL(`http://${trimmed}`).hostname.toLowerCase();
+    const hostname = new URL(`http://${trimmed}`).hostname.toLowerCase();
+    return hostname.endsWith(".") ? hostname.slice(0, -1) : hostname;
   } catch (error) {
     throw new AppError("CONFIG_INVALID", "Configuration failed validation: configured HTTP host allowlists contain an invalid hostname.", { cause: error });
   }
 }
+function normalizeListenHost(value) {
+  const trimmed = value.trim();
+  try {
+    const hostname = new URL(`http://${trimmed}`).hostname.toLowerCase();
+    return hostname.endsWith(".") ? hostname.slice(0, -1) : hostname;
+  } catch {
+    return trimmed;
+  }
+}
 function normalizeHostList(values) {
   return normalizeList(values).map(normalizeHostPattern);
 }
@@ -2329,7 +2458,7 @@ function isValidDomainPattern2(value) {
   }
   const bracketless = base.replace(/^\[|\]$/g, "");
   if (isIP2(bracketless) !== 0) {
-    return true;
+    return !wildcard;
   }
   let ascii;
   try {
@@ -2575,7 +2704,7 @@ function loadServerConfig(args = [], environment = env, homeDirectory = homedir(
   const config = {
     transport: argValue("--transport") ?? environment.SMOOTH_OPERATOR_TRANSPORT ?? fileConfig.transport ?? "stdio",
     http: {
-      host: (argValue("--host") ?? environment.SMOOTH_OPERATOR_HTTP_HOST ?? nestedHttp.host ?? "127.0.0.1").trim(),
+      host: normalizeListenHost(argValue("--host") ?? environment.SMOOTH_OPERATOR_HTTP_HOST ?? nestedHttp.host ?? "127.0.0.1"),
       port: parseInteger(argValue("--port") ?? environment.SMOOTH_OPERATOR_HTTP_PORT, nestedHttp.port ?? 3344),
       path: (environment.SMOOTH_OPERATOR_HTTP_PATH ?? nestedHttp.path ?? "/mcp").trim(),
       token: environment.SMOOTH_OPERATOR_HTTP_TOKEN ?? nestedHttp.token,
@@ -4554,11 +4683,31 @@ var DEFAULT_TYPE = {
   rng: Math.random
 };
 function randomRange(min, max, rand = Math.random) {
-  return min + rand() * (max - min);
+  const sample = rand();
+  const boundedSample = Number.isFinite(sample) ? Math.min(1, Math.max(0, sample)) : 0;
+  return min + boundedSample * (max - min);
 }
-function sleep(ms) {
-  return new Promise((resolve7) => {
-    setTimeout(resolve7, Math.max(0, ms));
+function sleep(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.reject(new Error("Operation aborted"));
+  }
+  return new Promise((resolve7, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => finish(resolve7), Math.max(0, ms));
+    const onAbort = () => finish(() => reject(new Error("Operation aborted")));
+    const finish = (callback) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      callback();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) {
+      onAbort();
+    }
   });
 }
 async function humanMouseMove(page, x1, y1, x2, y2, durationMs = 80, options = {}) {
@@ -4577,15 +4726,18 @@ async function humanType(page, text, options = {}) {
   const cfg = { ...DEFAULT_TYPE, ...options, rng };
   const keyboard = page.keyboard;
   for (const char of text) {
+    if (cfg.signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
     if (char === " ") {
       await keyboard.down("Space");
       await keyboard.up("Space");
     } else {
       await keyboard.type(char);
     }
-    await sleep(randomRange(cfg.minDelayMs, cfg.maxDelayMs, cfg.rng));
+    await sleep(randomRange(cfg.minDelayMs, cfg.maxDelayMs, cfg.rng), cfg.signal);
     if (cfg.rng() < cfg.thinkPauseChance) {
-      await sleep(randomRange(cfg.thinkPauseMinMs, cfg.thinkPauseMaxMs, cfg.rng));
+      await sleep(randomRange(cfg.thinkPauseMinMs, cfg.thinkPauseMaxMs, cfg.rng), cfg.signal);
     }
   }
 }
@@ -9307,6 +9459,7 @@ var BrowserService = class {
     try {
       await humanMouseMove(state.page, 0, 0, centerX, centerY, 80);
     } catch {
+      throwIfAborted(signal);
     }
   }
   async clickTarget(state, target, button, clickCount, signal, frame = state.page.mainFrame(), pointerType = "mouse") {
@@ -9820,7 +9973,7 @@ var BrowserService = class {
       if (!nativeControlValueSet) {
         throwIfAborted(signal);
         if (this.stealthSettings().behaviorEnabled) {
-          await humanType(state.page, text);
+          await humanType(state.page, text, { signal });
         } else {
           await state.page.keyboard.type(text);
         }