smooth-operator-mcp 2.1.1 → 2.2.0

package/dist/smooth-operator.mjs

@@ -882,6 +882,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 +997,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 +1044,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("/")) {
+          ui.failure("Enter an absolute path (starting with /).");
+          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();
@@ -1094,12 +1340,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 +2230,7 @@ init_errors();
 init_logger();
 
 // src/server/version.ts
-var SERVER_VERSION = "2.1.1";
+var SERVER_VERSION = "2.2.0";
 
 // src/server/mcp.ts
 var EmptyInputSchema = z3.object({}).strict();
@@ -7771,10 +8029,26 @@ 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 });
+    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")) {