@leadbay/mcp 0.17.0 → 0.17.2

package/dist/installer-gui.js

@@ -0,0 +1,1470 @@
+#!/usr/bin/env node
+
+// installer/installer-gui.ts
+import { createServer as createServer2 } from "http";
+import { randomUUID } from "crypto";
+import { realpathSync } from "fs";
+import { resolve as resolvePath } from "path";
+import { fileURLToPath } from "url";
+
+// installer/install-claude-code.ts
+import { spawn } from "child_process";
+function buildClaudeCodeAddArgs(token, region, includeWrite, telemetryEnabled, localBinPath) {
+  const args = [
+    "mcp",
+    "add",
+    "leadbay",
+    "--scope",
+    "user",
+    "--env",
+    `LEADBAY_TOKEN=${token}`,
+    "--env",
+    `LEADBAY_REGION=${region}`,
+    "--env",
+    `LEADBAY_TELEMETRY_ENABLED=${telemetryEnabled ? "true" : "false"}`
+  ];
+  if (!includeWrite) args.push("--env", `LEADBAY_MCP_WRITE=0`);
+  if (localBinPath) {
+    args.push("--", "node", localBinPath);
+  } else {
+    args.push("--", "npx", "-y", "-p", "@leadbay/mcp@latest", "leadbay-mcp");
+  }
+  return args;
+}
+function buildClaudeCodeRemoveArgs() {
+  return ["mcp", "remove", "leadbay", "--scope", "user"];
+}
+async function runClaudeMcp(args) {
+  return await new Promise((resolve) => {
+    const child = spawn("claude", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => stdout += chunk.toString());
+    child.stderr.on("data", (chunk) => stderr += chunk.toString());
+    child.on("close", (code) => resolve({ code, stdout, stderr }));
+    child.on("error", (err) => resolve({ code: null, stdout, stderr, spawnError: err.message }));
+  });
+}
+async function isLeadbayConfiguredInClaudeCode() {
+  const result = await runClaudeMcp(["mcp", "list"]);
+  if (result.spawnError || result.code !== 0) return false;
+  return /^leadbay:/m.test(result.stdout);
+}
+async function installInClaudeCode(token, region, includeWrite, telemetryEnabled, localBinPath) {
+  const args = buildClaudeCodeAddArgs(token, region, includeWrite, telemetryEnabled, localBinPath);
+  const first = await runClaudeMcp(args);
+  if (first.spawnError) return { ok: false, message: `failed to spawn claude: ${first.spawnError}` };
+  if (first.code === 0) return { ok: true, message: "registered" };
+  const stderr = first.stderr.trim();
+  if (!/already exists/i.test(stderr)) {
+    return { ok: false, message: `claude mcp add exited ${first.code}: ${stderr.slice(0, 200)}` };
+  }
+  const removed = await runClaudeMcp(buildClaudeCodeRemoveArgs());
+  if (removed.spawnError) return { ok: false, message: `failed to spawn claude: ${removed.spawnError}` };
+  if (removed.code !== 0) {
+    return { ok: false, message: `claude mcp remove exited ${removed.code}: ${removed.stderr.trim().slice(0, 200)}` };
+  }
+  const second = await runClaudeMcp(args);
+  if (second.spawnError) return { ok: false, message: `failed to spawn claude: ${second.spawnError}` };
+  return {
+    ok: second.code === 0,
+    message: second.code === 0 ? "updated" : `claude mcp add exited ${second.code}: ${second.stderr.trim().slice(0, 200)}`
+  };
+}
+async function uninstallFromClaudeCode() {
+  const result = await runClaudeMcp(buildClaudeCodeRemoveArgs());
+  if (result.spawnError) return { ok: false, message: `failed to spawn claude: ${result.spawnError}` };
+  if (result.code === 0) return { ok: true, message: "removed" };
+  const stderr = result.stderr.trim();
+  if (/not found|does not exist|no server/i.test(stderr)) return { ok: true, message: "already absent" };
+  return { ok: false, message: `claude mcp remove exited ${result.code}: ${stderr.slice(0, 200)}` };
+}
+
+// installer/install-json-config.ts
+async function installInJsonConfig(configPath, token, region, includeWrite, telemetryEnabled, localBinPath) {
+  try {
+    const { readFileSync: readFileSync3, writeFileSync, existsSync: existsSync3, mkdirSync, statSync } = await import("fs");
+    const { dirname } = await import("path");
+    let parsed = {};
+    let preserved = {};
+    const existed = existsSync3(configPath);
+    if (existed) {
+      const raw = readFileSync3(configPath, "utf8");
+      try {
+        preserved = JSON.parse(raw);
+        parsed = preserved;
+      } catch {
+        return { ok: false, message: `existing ${configPath} is not valid JSON; refusing to overwrite` };
+      }
+    } else {
+      mkdirSync(dirname(configPath), { recursive: true });
+    }
+    parsed.mcpServers = parsed.mcpServers ?? {};
+    const env = {
+      LEADBAY_TOKEN: token,
+      LEADBAY_REGION: region,
+      // Always written so MCP-client config UIs can render it as a toggle.
+      LEADBAY_TELEMETRY_ENABLED: telemetryEnabled ? "true" : "false"
+    };
+    if (!includeWrite) env.LEADBAY_MCP_WRITE = "0";
+    parsed.mcpServers.leadbay = localBinPath ? { command: "node", args: [localBinPath], env } : { command: "npx", args: ["-y", "-p", "@leadbay/mcp@latest", "leadbay-mcp"], env };
+    const tmp = configPath + ".tmp";
+    writeFileSync(tmp, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+    const { renameSync, chmodSync } = await import("fs");
+    renameSync(tmp, configPath);
+    try {
+      const st = statSync(configPath);
+      if ((st.mode & 511) > 384 && Object.keys(preserved).length === 0) {
+        chmodSync(configPath, 384);
+      }
+    } catch {
+    }
+    return { ok: true, message: existed ? "updated" : "registered" };
+  } catch (err) {
+    return { ok: false, message: err?.message ?? String(err) };
+  }
+}
+function stripJsonMcpEntry(existing) {
+  let parsed;
+  try {
+    parsed = JSON.parse(existing);
+  } catch {
+    return { content: existing, changed: false };
+  }
+  if (!parsed?.mcpServers?.leadbay) return { content: existing, changed: false };
+  delete parsed.mcpServers.leadbay;
+  return { content: JSON.stringify(parsed, null, 2) + "\n", changed: true };
+}
+async function uninstallFromJsonConfig(configPath) {
+  try {
+    const { existsSync: existsSync3, readFileSync: readFileSync3, writeFileSync } = await import("fs");
+    if (!existsSync3(configPath)) return { ok: true, message: "config not found \u2014 nothing to do" };
+    const existing = readFileSync3(configPath, "utf8");
+    const { content, changed } = stripJsonMcpEntry(existing);
+    if (!changed) return { ok: true, message: "leadbay entry not present" };
+    writeFileSync(configPath, content, "utf8");
+    return { ok: true, message: "removed" };
+  } catch (err) {
+    return { ok: false, message: err?.message ?? String(err) };
+  }
+}
+
+// installer/install-codex.ts
+function shellQuote(value) {
+  return '"' + value.replace(/([\"\\$`])/g, "\\$1") + '"';
+}
+function buildCodexConfigBlock(includeWrite, telemetryEnabled, version = "latest", localBinPath) {
+  const envVars = ["LEADBAY_TOKEN", "LEADBAY_REGION", "LEADBAY_TELEMETRY_ENABLED"];
+  if (!includeWrite) envVars.push("LEADBAY_MCP_WRITE");
+  const envVarsToml = envVars.map((v) => `"${v}"`).join(", ");
+  const commandLine = localBinPath ? `command = "node"
+args = [${JSON.stringify(localBinPath)}]
+` : `command = "npx"
+args = ["-y", "@leadbay/mcp@${version}"]
+`;
+  return `[mcp_servers.leadbay]
+` + commandLine + `env_vars = [${envVarsToml}]
+`;
+}
+function buildShellExportBlock(token, region, includeWrite, telemetryEnabled) {
+  const lines = [
+    "",
+    "# Added by leadbay-mcp install",
+    `export LEADBAY_TOKEN=${shellQuote(token)}`,
+    `export LEADBAY_REGION=${shellQuote(region)}`,
+    `export LEADBAY_TELEMETRY_ENABLED=${shellQuote(telemetryEnabled ? "true" : "false")}`
+  ];
+  if (!includeWrite) {
+    lines.push(`export LEADBAY_MCP_WRITE=${shellQuote("0")}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function mergeCodexConfig(existing, block) {
+  const withoutLeadbay = existing.replace(
+    /(^|\r?\n)\[mcp_servers\.leadbay\]\r?\n[\s\S]*?(?=\r?\n\[|$)/g,
+    (match, prefix) => prefix && match.startsWith(prefix) ? prefix : ""
+  );
+  const trimmed = withoutLeadbay.trimEnd();
+  return `${trimmed ? `${trimmed}
+
+` : ""}${block.trimEnd()}
+`;
+}
+function mergeShellExportBlock(existing, block) {
+  const managedBlock = /(^|\r?\n)# Added by leadbay-mcp install\r?\nexport LEADBAY_TOKEN=.*\r?\nexport LEADBAY_REGION=.*\r?\nexport LEADBAY_TELEMETRY_ENABLED=.*\r?\n(?:export LEADBAY_MCP_WRITE=.*\r?\n)?/g;
+  const stripped = existing.replace(managedBlock, (match, prefix) => prefix || "");
+  if (stripped === existing && existing.includes("LEADBAY_TOKEN=")) {
+    return { content: existing, changed: false };
+  }
+  const trimmed = stripped.trimEnd();
+  return {
+    content: `${trimmed ? `${trimmed}
+` : ""}${block}`,
+    changed: true
+  };
+}
+function stripCodexBlock(existing) {
+  const stripped = existing.replace(
+    /(^|\r?\n)\[mcp_servers\.leadbay\]\r?\n[\s\S]*?(?=\r?\n\[|$)/g,
+    (match, prefix) => prefix && match.startsWith(prefix) ? prefix : ""
+  );
+  if (stripped === existing) return { content: existing, changed: false };
+  const trimmed = stripped.trimEnd();
+  return { content: trimmed ? trimmed + "\n" : "", changed: true };
+}
+function stripShellExportBlock(existing) {
+  const managedBlock = /(^|\r?\n)# Added by leadbay-mcp install\r?\nexport LEADBAY_TOKEN=.*\r?\nexport LEADBAY_REGION=.*\r?\nexport LEADBAY_TELEMETRY_ENABLED=.*\r?\n(?:export LEADBAY_MCP_WRITE=.*\r?\n)?/g;
+  const stripped = existing.replace(managedBlock, (match, prefix) => prefix || "");
+  if (stripped === existing) return { content: existing, changed: false };
+  return { content: stripped.trimEnd() + (stripped.trimEnd() ? "\n" : ""), changed: true };
+}
+async function installInCodexConfig(configPath, includeWrite, telemetryEnabled, localBinPath) {
+  try {
+    const { readFileSync: readFileSync3, writeFileSync, existsSync: existsSync3, mkdirSync, statSync, renameSync, chmodSync } = await import("fs");
+    const { dirname } = await import("path");
+    let existing = "";
+    const existed = existsSync3(configPath);
+    if (existed) {
+      existing = readFileSync3(configPath, "utf8");
+    } else {
+      mkdirSync(dirname(configPath), { recursive: true });
+    }
+    const hadLeadbayConfig = /(^|\r?\n)\[mcp_servers\.leadbay\]\r?\n/.test(existing);
+    const next = mergeCodexConfig(
+      existing,
+      buildCodexConfigBlock(includeWrite, telemetryEnabled, "latest", localBinPath)
+    );
+    const tmp = `${configPath}.tmp`;
+    writeFileSync(tmp, next, "utf8");
+    renameSync(tmp, configPath);
+    try {
+      const st = statSync(configPath);
+      if (!existed || (st.mode & 511) > 384) {
+        chmodSync(configPath, 384);
+      }
+    } catch {
+    }
+    return { ok: true, message: hadLeadbayConfig ? "updated" : "registered" };
+  } catch (err) {
+    return { ok: false, message: err?.message ?? String(err) };
+  }
+}
+async function appendShellExports(token, region, includeWrite, telemetryEnabled) {
+  try {
+    const cp = await import("child_process");
+    if (process.platform === "win32") {
+      const values = {
+        LEADBAY_TOKEN: token,
+        LEADBAY_REGION: region,
+        LEADBAY_TELEMETRY_ENABLED: telemetryEnabled ? "true" : "false"
+      };
+      if (!includeWrite) values.LEADBAY_MCP_WRITE = "0";
+      for (const [key, value] of Object.entries(values)) {
+        const ok = await new Promise((resolve) => {
+          const child = cp.spawn("setx", [key, value], { stdio: "ignore" });
+          child.on("close", (code) => resolve(code === 0));
+          child.on("error", () => resolve(false));
+        });
+        if (!ok) return { ok: false, message: `failed to set ${key} with setx` };
+      }
+      return { ok: true, message: "env exported with setx; restart Codex/terminal" };
+    }
+    const { existsSync: existsSync3, readFileSync: readFileSync3, writeFileSync, renameSync } = await import("fs");
+    const os = await import("os");
+    const home = os.homedir();
+    const preferred = [`${home}/.zshrc`, `${home}/.bashrc`].filter((path) => existsSync3(path));
+    const paths = preferred.length ? preferred : [`${home}/.profile`];
+    const block = buildShellExportBlock(token, region, includeWrite, telemetryEnabled);
+    const updated = [];
+    for (const path of paths) {
+      const existing = existsSync3(path) ? readFileSync3(path, "utf8") : "";
+      const merged = mergeShellExportBlock(existing, block);
+      if (!merged.changed) continue;
+      const tmp = `${path}.leadbay.tmp`;
+      writeFileSync(tmp, merged.content, "utf8");
+      renameSync(tmp, path);
+      updated.push(path);
+    }
+    return {
+      ok: true,
+      message: updated.length ? `env exported to ${updated.join(", ")}; restart Codex/terminal or source the file` : "env exports already present"
+    };
+  } catch (err) {
+    return { ok: false, message: err?.message ?? String(err) };
+  }
+}
+async function uninstallFromCodexConfig(configPath) {
+  try {
+    const { existsSync: existsSync3, readFileSync: readFileSync3, writeFileSync } = await import("fs");
+    if (!existsSync3(configPath)) return { ok: true, message: "config not found \u2014 nothing to do" };
+    const existing = readFileSync3(configPath, "utf8");
+    const { content, changed } = stripCodexBlock(existing);
+    if (!changed) return { ok: true, message: "leadbay block not present" };
+    writeFileSync(configPath, content, "utf8");
+    return { ok: true, message: "removed from TOML" };
+  } catch (err) {
+    return { ok: false, message: err?.message ?? String(err) };
+  }
+}
+async function uninstallShellExports() {
+  try {
+    const { existsSync: existsSync3, readFileSync: readFileSync3, writeFileSync, renameSync } = await import("fs");
+    const os = await import("os");
+    const home = os.homedir();
+    const candidates = [`${home}/.zshrc`, `${home}/.bashrc`, `${home}/.profile`].filter(
+      (p) => existsSync3(p)
+    );
+    const updated = [];
+    for (const p of candidates) {
+      const existing = readFileSync3(p, "utf8");
+      const { content, changed } = stripShellExportBlock(existing);
+      if (!changed) continue;
+      const tmp = `${p}.leadbay.tmp`;
+      writeFileSync(tmp, content, "utf8");
+      renameSync(tmp, p);
+      updated.push(p);
+    }
+    return {
+      ok: true,
+      message: updated.length ? `removed from ${updated.join(", ")}; restart terminal or source the file` : "managed export block not found in shell files"
+    };
+  } catch (err) {
+    return { ok: false, message: err?.message ?? String(err) };
+  }
+}
+
+// installer/install-dxt.ts
+var DXT_EXTENSION_ID = "local.dxt.leadbay.leadbay";
+async function removeDxtExtension(claudeSupportDir) {
+  try {
+    const { existsSync: existsSync3, readFileSync: readFileSync3, writeFileSync, rmSync } = await import("fs");
+    const { join: join2 } = await import("path");
+    const extensionDir = join2(claudeSupportDir, "Claude Extensions", DXT_EXTENSION_ID);
+    const registryPath = join2(claudeSupportDir, "extensions-installations.json");
+    let removedDir = false;
+    let removedEntry = false;
+    if (existsSync3(extensionDir)) {
+      rmSync(extensionDir, { recursive: true, force: true });
+      removedDir = true;
+    }
+    if (existsSync3(registryPath)) {
+      try {
+        const raw = readFileSync3(registryPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed?.extensions?.[DXT_EXTENSION_ID]) {
+          delete parsed.extensions[DXT_EXTENSION_ID];
+          const tmp = registryPath + ".tmp";
+          writeFileSync(tmp, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+          const { renameSync } = await import("fs");
+          renameSync(tmp, registryPath);
+          removedEntry = true;
+        }
+      } catch {
+      }
+    }
+    const removed = removedDir || removedEntry;
+    return {
+      ok: true,
+      removed,
+      message: removed ? "DXT extension removed" : "DXT extension not installed"
+    };
+  } catch (err) {
+    return { ok: false, removed: false, message: err?.message ?? String(err) };
+  }
+}
+
+// installer/installer-gui.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+
+// installer/install-shared.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var HOSTED_MCP_URL = "https://leadbay-mcp-prod.fly.dev/mcp";
+function formatInstallOsLabel(platform = process.platform, arch = process.arch) {
+  const name = platform === "darwin" ? "macOS" : platform === "win32" ? "Windows" : platform === "linux" ? "Linux" : platform;
+  return `${name} (${arch})`;
+}
+function detectClaudeDesktopMode(claudeSupportDir) {
+  const markers = [];
+  const legacy = existsSync(join(claudeSupportDir, "claude_desktop_config.json"));
+  if (existsSync(join(claudeSupportDir, "Claude Extensions"))) {
+    markers.push("Claude Extensions/");
+  }
+  if (existsSync(join(claudeSupportDir, "extensions-installations.json"))) {
+    markers.push("extensions-installations.json");
+  }
+  const cfgPath = join(claudeSupportDir, "config.json");
+  if (existsSync(cfgPath)) {
+    try {
+      const raw = readFileSync(cfgPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") {
+        const hasDxtKey = Object.keys(parsed).some((key) => key.startsWith("dxt:"));
+        if (hasDxtKey) markers.push("config.json (dxt:* keys)");
+      }
+    } catch {
+    }
+  }
+  return { legacy, dxt: markers.length > 0, markers };
+}
+async function findOnPath(bin) {
+  return await new Promise((resolve) => {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    const child = spawn2(cmd, [bin], { stdio: ["ignore", "pipe", "ignore"] });
+    let buf = "";
+    child.stdout.on("data", (chunk) => buf += chunk.toString());
+    child.on("close", (code) => resolve(code === 0 ? buf.split(/\r?\n/)[0] : null));
+    child.on("error", () => resolve(null));
+  });
+}
+async function windowsStoreAppInstalled(packageName, appName) {
+  if (process.platform !== "win32") return false;
+  return await new Promise((resolve) => {
+    const script = [
+      `$pkg = Get-AppxPackage -Name '${packageName}' -ErrorAction SilentlyContinue`,
+      `$app = Get-StartApps | Where-Object { $_.AppID -like '${packageName}_*!${appName}' } | Select-Object -First 1`,
+      "if ($pkg -or $app) { exit 0 } else { exit 1 }"
+    ].join("; ");
+    const child = spawn2("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.on("close", (code) => resolve(code === 0));
+    child.on("error", () => resolve(false));
+  });
+}
+async function isClaudeDesktopInstalled(home) {
+  if (process.platform === "darwin") {
+    return existsSync("/Applications/Claude.app") || existsSync(home + "/Applications/Claude.app");
+  }
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA ?? home + "/AppData/Local";
+    const programFiles = process.env.ProgramFiles;
+    const programFilesX86 = process.env["ProgramFiles(x86)"];
+    return [
+      local + "/Programs/Claude/Claude.exe",
+      local + "/Claude/Claude.exe",
+      programFiles ? programFiles + "/Claude/Claude.exe" : null,
+      programFilesX86 ? programFilesX86 + "/Claude/Claude.exe" : null
+    ].some((candidate) => candidate !== null && existsSync(candidate));
+  }
+  const desktopBin = await findOnPath("claude-desktop");
+  if (desktopBin) return true;
+  return existsSync(home + "/.local/share/applications/claude-desktop.desktop") || existsSync("/usr/share/applications/claude-desktop.desktop") || existsSync("/opt/Claude/Claude") || existsSync("/opt/Claude/claude") || existsSync("/opt/claude/claude");
+}
+async function isChatGptDesktopInstalled(home) {
+  if (process.platform === "darwin") {
+    return existsSync("/Applications/ChatGPT.app") || existsSync(home + "/Applications/ChatGPT.app");
+  }
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA ?? home + "/AppData/Local";
+    const programFiles = process.env.ProgramFiles;
+    const programFilesX86 = process.env["ProgramFiles(x86)"];
+    const exeInstalled = [
+      local + "/Programs/ChatGPT/ChatGPT.exe",
+      local + "/ChatGPT/ChatGPT.exe",
+      programFiles ? programFiles + "/OpenAI/ChatGPT/ChatGPT.exe" : null,
+      programFiles ? programFiles + "/ChatGPT/ChatGPT.exe" : null,
+      programFilesX86 ? programFilesX86 + "/OpenAI/ChatGPT/ChatGPT.exe" : null,
+      programFilesX86 ? programFilesX86 + "/ChatGPT/ChatGPT.exe" : null
+    ].some((candidate) => candidate !== null && existsSync(candidate));
+    return exeInstalled || await windowsStoreAppInstalled("OpenAI.ChatGPT-Desktop", "ChatGPT");
+  }
+  return false;
+}
+async function isCursorInstalled(home) {
+  const cursorBin = await findOnPath("cursor");
+  if (cursorBin) return true;
+  if (process.platform === "darwin") return existsSync("/Applications/Cursor.app");
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA ?? `${home}\\AppData\\Local`;
+    return existsSync(`${local}\\Programs\\Cursor\\Cursor.exe`);
+  }
+  return existsSync("/usr/share/applications/cursor.desktop") || existsSync("/opt/Cursor/cursor");
+}
+async function detectClients() {
+  const out = [];
+  const home = homedir();
+  const claudeBin = await findOnPath("claude");
+  if (claudeBin) {
+    out.push({ id: "claude-code", label: "Claude Code", detail: `${claudeBin} mcp add ...` });
+  }
+  const claudeSupportDir = process.platform === "win32" ? `${process.env.APPDATA ?? `${home}\\AppData\\Roaming`}\\Claude` : process.platform === "darwin" ? `${home}/Library/Application Support/Claude` : `${home}/.config/Claude`;
+  const claudeDesktopPath = process.platform === "win32" ? `${claudeSupportDir}\\claude_desktop_config.json` : `${claudeSupportDir}/claude_desktop_config.json`;
+  const mode = detectClaudeDesktopMode(claudeSupportDir);
+  if (await isClaudeDesktopInstalled(home)) {
+    out.push({ id: "claude-desktop", label: "Claude Desktop", detail: claudeDesktopPath, configPath: claudeDesktopPath, mode, supportDir: claudeSupportDir });
+  }
+  if (await isChatGptDesktopInstalled(home)) {
+    out.push({ id: "chatgpt-desktop", label: "ChatGPT Desktop", detail: HOSTED_MCP_URL });
+  }
+  const cursorPath = process.platform === "win32" ? `${home}\\.cursor\\mcp.json` : `${home}/.cursor/mcp.json`;
+  if (await isCursorInstalled(home)) {
+    out.push({
+      id: "cursor",
+      label: "Cursor",
+      detail: existsSync(cursorPath) ? cursorPath : `${cursorPath} (will be created)`,
+      configPath: cursorPath
+    });
+  }
+  const codexBin = await findOnPath("codex");
+  const codexDir = process.platform === "win32" ? `${process.env.USERPROFILE ?? home}\\.codex` : `${home}/.codex`;
+  if (codexBin) {
+    const codexConfigPath = process.platform === "win32" ? `${codexDir}\\config.toml` : `${codexDir}/config.toml`;
+    out.push({ id: "codex", label: "Codex", detail: codexConfigPath, configPath: codexConfigPath });
+  }
+  return out;
+}
+
+// src/oauth.ts
+import { createHash, randomBytes } from "crypto";
+import { createServer } from "http";
+import { request as httpsRequestRaw } from "https";
+import { spawn as spawn3 } from "child_process";
+var STARGATE_URLS = {
+  prod: "https://stargate.leadbay.app/1.0/user_info",
+  staging: "https://staging.stargate.leadbay.app/1.0/user_info"
+};
+var FR_COUNTRY_CODES = /* @__PURE__ */ new Set([
+  "FR",
+  // France
+  // French overseas territories — same regional partition as France in the
+  // backend's stargate /login route (see backend/specs/stargate/1.0).
+  "GP",
+  "MQ",
+  "GF",
+  "RE",
+  "YT",
+  "MF",
+  "BL",
+  "PM",
+  "WF",
+  "PF",
+  "NC",
+  "TF"
+]);
+async function inferRegionViaStargate(opts) {
+  const url = STARGATE_URLS[opts.staging ? "staging" : "prod"];
+  const res = await httpsCall("GET", url, { Accept: "application/json" });
+  if (res.status !== 200) {
+    throw new Error(
+      `Stargate region probe failed: GET ${url} returned ${res.status}. Pass --region us|fr to skip auto-detection.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(res.body);
+  } catch {
+    throw new Error(`Stargate region probe returned non-JSON body`);
+  }
+  const country = parsed.userCountry;
+  if (!country || typeof country !== "string") {
+    throw new Error(`Stargate response missing userCountry: ${res.body.slice(0, 200)}`);
+  }
+  if (country === "US") return "us";
+  if (FR_COUNTRY_CODES.has(country)) return "fr";
+  throw new Error(
+    `Stargate detected your country as ${country}, which isn't mapped to a Leadbay region. Pass --region us|fr explicitly.`
+  );
+}
+function generatePkce() {
+  const verifier = base64UrlEncode(randomBytes(32));
+  const challenge = base64UrlEncode(
+    createHash("sha256").update(verifier, "ascii").digest()
+  );
+  return { verifier, challenge, method: "S256" };
+}
+function base64UrlEncode(buf) {
+  return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function httpsCall(method, url, headers, body) {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const reqHeaders = { ...headers };
+    if (body !== void 0) reqHeaders["Content-Length"] = Buffer.byteLength(body);
+    const req = httpsRequestRaw(
+      {
+        hostname: u.hostname,
+        port: u.port ? Number(u.port) : 443,
+        path: u.pathname + u.search,
+        method,
+        headers: reqHeaders
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on(
+          "end",
+          () => resolve({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf8") })
+        );
+      }
+    );
+    req.on("error", reject);
+    if (body !== void 0) req.write(body);
+    req.end();
+  });
+}
+async function fetchDiscoveryDoc(authServerBaseUrl) {
+  const url = trimSlash(authServerBaseUrl) + "/.well-known/oauth-authorization-server";
+  const res = await httpsCall("GET", url, { Accept: "application/json" });
+  if (res.status !== 200) {
+    throw new Error(
+      `OAuth discovery failed: GET ${url} returned ${res.status}. Either OAuth isn't deployed to this backend yet, or the URL is wrong.`
+    );
+  }
+  let doc;
+  try {
+    doc = JSON.parse(res.body);
+  } catch {
+    throw new Error(`OAuth discovery returned non-JSON body from ${url}`);
+  }
+  for (const field of ["authorization_endpoint", "token_endpoint", "registration_endpoint"]) {
+    if (typeof doc[field] !== "string" || !doc[field]) {
+      throw new Error(`OAuth discovery doc missing required field: ${field}`);
+    }
+  }
+  if (doc.code_challenge_methods_supported && !doc.code_challenge_methods_supported.includes("S256")) {
+    throw new Error(
+      `OAuth server doesn't support S256 PKCE (only ${doc.code_challenge_methods_supported.join(", ")}). Aborting \u2014 plain PKCE is too weak for a public client.`
+    );
+  }
+  return doc;
+}
+function trimSlash(s) {
+  return s.endsWith("/") ? s.slice(0, -1) : s;
+}
+async function registerClient(registrationEndpoint, params) {
+  const body = JSON.stringify({
+    client_name: params.clientName,
+    redirect_uris: [params.redirectUri],
+    logo_uri: params.logoUri,
+    token_endpoint_auth_method: "none"
+    // public client
+  });
+  const res = await httpsCall(
+    "POST",
+    registrationEndpoint,
+    { "Content-Type": "application/json", Accept: "application/json" },
+    body
+  );
+  if (res.status === 429) {
+    throw new Error(
+      `OAuth client registration rate-limited (429). The backend allows ~10 registrations per IP per hour. Wait and retry, or use the password flow (drop the --oauth flag).`
+    );
+  }
+  if (res.status !== 201 && res.status !== 200) {
+    throw new Error(
+      `OAuth client registration failed: POST ${registrationEndpoint} \u2192 ${res.status} ${res.body.slice(0, 300)}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(res.body);
+  } catch {
+    throw new Error(`OAuth client registration returned non-JSON body`);
+  }
+  if (!parsed.client_id) {
+    throw new Error(`OAuth client registration response missing client_id`);
+  }
+  return parsed;
+}
+async function startLoopbackListener(opts) {
+  let resolveCallback;
+  let rejectCallback;
+  const callbackPromise = new Promise((res, rej) => {
+    resolveCallback = res;
+    rejectCallback = rej;
+  });
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (req.method !== "GET" || url.pathname !== "/callback") {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+    const params = url.searchParams;
+    const errParam = params.get("error");
+    if (errParam) {
+      const desc = params.get("error_description") ?? "";
+      res.statusCode = 400;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(renderHtml("Authorization failed", `${errParam}${desc ? `: ${desc}` : ""}`));
+      rejectCallback(new Error(`OAuth authorization denied: ${errParam}${desc ? ` (${desc})` : ""}`));
+      return;
+    }
+    const code = params.get("code");
+    const state = params.get("state");
+    if (!code || !state) {
+      res.statusCode = 400;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(renderHtml("Authorization failed", "Missing code or state parameter."));
+      rejectCallback(new Error("OAuth callback missing code or state"));
+      return;
+    }
+    if (state !== opts.expectedState) {
+      res.statusCode = 400;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(renderHtml("Authorization failed", "Invalid state parameter (possible CSRF)."));
+      rejectCallback(new Error("OAuth callback state mismatch (possible CSRF)"));
+      return;
+    }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.end(renderHtml("You're signed in", "You can close this tab and return to the terminal."));
+    resolveCallback({ code, state });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const addr = server.address();
+  const redirectUri = `http://127.0.0.1:${addr.port}/callback`;
+  const timer = setTimeout(() => {
+    rejectCallback(new Error(`OAuth login timed out after ${Math.round(opts.timeoutMs / 1e3)}s`));
+  }, opts.timeoutMs);
+  return {
+    redirectUri,
+    waitForCallback: () => callbackPromise.finally(() => {
+      clearTimeout(timer);
+    }),
+    close: () => {
+      clearTimeout(timer);
+      server.close();
+    }
+  };
+}
+function renderHtml(title, message) {
+  const safeTitle = escapeHtml(title);
+  const safeMsg = escapeHtml(message);
+  return `<!doctype html>
+<html lang="en"><head>
+<meta charset="utf-8"><title>${safeTitle} \u2014 Leadbay MCP</title>
+<style>
+body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;
+     display:flex;align-items:center;justify-content:center;height:100vh;
+     margin:0;background:#fafafa;color:#111}
+.card{padding:32px 40px;border:1px solid #eee;border-radius:12px;
+      background:#fff;max-width:420px;text-align:center}
+h1{font-size:18px;margin:0 0 12px;font-weight:600}
+p{margin:0;color:#555;font-size:14px;line-height:1.5}
+</style></head>
+<body><div class="card"><h1>${safeTitle}</h1><p>${safeMsg}</p></div></body></html>`;
+}
+function escapeHtml(s) {
+  return s.replace(
+    /[&<>"']/g,
+    (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]
+  );
+}
+async function exchangeCodeForToken(opts) {
+  const form = new URLSearchParams({
+    grant_type: "authorization_code",
+    code: opts.code,
+    redirect_uri: opts.redirectUri,
+    client_id: opts.clientId,
+    code_verifier: opts.codeVerifier
+  }).toString();
+  const res = await httpsCall(
+    "POST",
+    opts.tokenEndpoint,
+    {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    },
+    form
+  );
+  if (res.status !== 200) {
+    throw new Error(
+      `OAuth token exchange failed: POST ${opts.tokenEndpoint} \u2192 ${res.status} ${res.body.slice(0, 300)}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(res.body);
+  } catch {
+    throw new Error("OAuth token endpoint returned non-JSON body");
+  }
+  if (!parsed.access_token) {
+    throw new Error(`OAuth token response missing access_token: ${res.body.slice(0, 200)}`);
+  }
+  return { accessToken: parsed.access_token };
+}
+async function openInBrowser(url) {
+  const platform = process.platform;
+  let cmd;
+  let args;
+  if (platform === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    cmd = "cmd";
+    args = ["/c", "start", '""', url];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+  await new Promise((resolve, reject) => {
+    const child = spawn3(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", reject);
+    child.on("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+async function oauthLogin(opts) {
+  const log = opts.log ?? (() => {
+  });
+  const open = opts.openBrowser ?? openInBrowser;
+  const timeoutMs = opts.timeoutMs ?? 5 * 60 * 1e3;
+  log(`Discovering OAuth endpoints at ${opts.authServerBaseUrl}\u2026
+`);
+  const doc = await fetchDiscoveryDoc(opts.authServerBaseUrl);
+  const state = base64UrlEncode(randomBytes(16));
+  const pkce = generatePkce();
+  log("Starting loopback listener on 127.0.0.1\u2026\n");
+  const listener = await startLoopbackListener({ expectedState: state, timeoutMs });
+  try {
+    log(`Registering client at ${doc.registration_endpoint}\u2026
+`);
+    const client = await registerClient(doc.registration_endpoint, {
+      clientName: opts.clientName,
+      redirectUri: listener.redirectUri,
+      logoUri: opts.logoUri
+    });
+    const authorizeUrl = new URL(doc.authorization_endpoint);
+    authorizeUrl.searchParams.set("response_type", "code");
+    authorizeUrl.searchParams.set("client_id", client.client_id);
+    authorizeUrl.searchParams.set("redirect_uri", listener.redirectUri);
+    authorizeUrl.searchParams.set("state", state);
+    authorizeUrl.searchParams.set("code_challenge", pkce.challenge);
+    authorizeUrl.searchParams.set("code_challenge_method", pkce.method);
+    log(`Opening browser to authorize\u2026
+  ${authorizeUrl.toString()}
+`);
+    try {
+      await open(authorizeUrl.toString());
+    } catch (err) {
+      log(
+        `Could not open browser automatically (${err?.message ?? err}). Open this URL manually:
+  ${authorizeUrl.toString()}
+`
+      );
+    }
+    log("Waiting for authorization (5 min timeout)\u2026\n");
+    const { code } = await listener.waitForCallback();
+    log("Exchanging authorization code for access token\u2026\n");
+    const { accessToken } = await exchangeCodeForToken({
+      tokenEndpoint: doc.token_endpoint,
+      code,
+      codeVerifier: pkce.verifier,
+      clientId: client.client_id,
+      redirectUri: listener.redirectUri
+    });
+    return { accessToken };
+  } finally {
+    listener.close();
+  }
+}
+
+// installer/installer-gui.ts
+var VERSION = "0.17.2";
+var PORT = Number(process.env.LEADBAY_INSTALLER_PORT ?? 0);
+var sessions = /* @__PURE__ */ new Map();
+var OAUTH_BASE_URLS = {
+  prod: {
+    us: "https://api-us.leadbay.app",
+    fr: "https://api-fr.leadbay.app"
+  }
+};
+async function isLeadbayConfigured(client) {
+  if (client.id === "claude-code") {
+    return await isLeadbayConfiguredInClaudeCode();
+  }
+  if (client.id === "codex") {
+    const configPath2 = client.detail;
+    if (!existsSync2(configPath2)) return false;
+    try {
+      return readFileSync2(configPath2, "utf8").includes("[mcp_servers.leadbay]");
+    } catch {
+      return false;
+    }
+  }
+  if (client.id === "chatgpt-desktop") return false;
+  const configPath = client.configPath;
+  if (!configPath || !existsSync2(configPath)) return false;
+  try {
+    const parsed = JSON.parse(readFileSync2(configPath, "utf8"));
+    return Boolean(parsed?.mcpServers?.leadbay);
+  } catch {
+    return false;
+  }
+}
+async function clientsWithConfiguredStatus() {
+  const clients = await detectClients();
+  return await Promise.all(
+    clients.map(async (client) => ({
+      ...client,
+      configured: await isLeadbayConfigured(client)
+    }))
+  );
+}
+function sendJson(res, status, body) {
+  const raw = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": Buffer.byteLength(raw)
+  });
+  res.end(raw);
+}
+function sendSse(res, event) {
+  res.write(`data: ${JSON.stringify(event)}
+
+`);
+}
+function readJson(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}"));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function cleanupSessions() {
+  const cutoff = Date.now() - 30 * 60 * 1e3;
+  for (const [id, session] of sessions) {
+    if (session.createdAt < cutoff) sessions.delete(id);
+  }
+}
+async function loginWithOAuth() {
+  cleanupSessions();
+  try {
+    const region = await inferRegionViaStargate({ staging: false });
+    const { hostname } = await import("os");
+    const { accessToken } = await oauthLogin({
+      authServerBaseUrl: OAUTH_BASE_URLS.prod[region],
+      clientName: `Leadbay MCP installer @ ${hostname()}`,
+      log: () => void 0
+    });
+    const sessionId = randomUUID();
+    const accountLabel = `Leadbay OAuth (${region.toUpperCase()})`;
+    sessions.set(sessionId, { token: accessToken, region, accountLabel, createdAt: Date.now() });
+    return { ok: true, sessionId, region, accountLabel };
+  } catch (err) {
+    return { ok: false, error: err?.message ?? String(err) };
+  }
+}
+function sanitizeOutput(raw) {
+  return raw.replace(/LEADBAY_TOKEN=("[^"]+"|'[^']+'|[^\s]+)/g, "LEADBAY_TOKEN=<redacted>");
+}
+function isManualSetupClient(client) {
+  return client.id === "chatgpt-desktop";
+}
+function isAllowedOrigin(req, expectedHost) {
+  const host = req.headers["host"] ?? "";
+  if (host !== expectedHost) return false;
+  const origin = req.headers["origin"];
+  if (!origin) return true;
+  return origin === `http://${expectedHost}` || origin === `http://127.0.0.1`;
+}
+var LOCAL_BIN_PATH = (() => {
+  const flag = process.argv.find((a) => a === "--local" || a.startsWith("--local="));
+  if (!flag) return void 0;
+  const explicit = flag.startsWith("--local=") ? flag.slice("--local=".length) : "";
+  if (explicit) {
+    return resolvePath(process.cwd(), explicit);
+  }
+  const here = typeof __dirname !== "undefined" ? __dirname : resolvePath(fileURLToPath(import.meta.url), "..");
+  return resolvePath(here, "..", "dist", "bin.js");
+})();
+async function installInto(client, session, includeWrite, telemetryEnabled) {
+  let res;
+  if (client.id === "claude-code") {
+    res = await installInClaudeCode(session.token, session.region, includeWrite, telemetryEnabled, LOCAL_BIN_PATH);
+  } else if (client.id === "codex") {
+    const configRes = await installInCodexConfig(client.configPath ?? client.detail, includeWrite, telemetryEnabled, LOCAL_BIN_PATH);
+    if (!configRes.ok) {
+      res = configRes;
+    } else {
+      const exportRes = await appendShellExports(session.token, session.region, includeWrite, telemetryEnabled);
+      res = exportRes.ok ? { ok: true, message: `${configRes.message}; ${exportRes.message}` } : { ok: false, message: `config ${configRes.message}; ${exportRes.message}` };
+    }
+  } else if (client.id === "chatgpt-desktop") {
+    res = { ok: true, message: "manual setup required; add this MCP URL in ChatGPT Settings > Apps: " + HOSTED_MCP_URL };
+  } else if (client.id === "claude-desktop" && client.mode?.dxt && client.supportDir) {
+    const dxtResult = await removeDxtExtension(client.supportDir);
+    const jsonResult = await installInJsonConfig(client.configPath, session.token, session.region, includeWrite, telemetryEnabled, LOCAL_BIN_PATH);
+    if (!jsonResult.ok) {
+      res = jsonResult;
+    } else {
+      res = {
+        ok: true,
+        message: dxtResult.removed ? `DXT extension removed; ${jsonResult.message}` : jsonResult.message
+      };
+    }
+  } else {
+    res = await installInJsonConfig(client.configPath, session.token, session.region, includeWrite, telemetryEnabled, LOCAL_BIN_PATH);
+  }
+  return { id: client.id, label: client.label, ...res };
+}
+async function install(body) {
+  cleanupSessions();
+  const session = body.sessionId ? sessions.get(body.sessionId) : void 0;
+  const clientIds = body.clientIds ?? [];
+  if (!session) return { ok: false, output: "Login expired. Go back and sign in again." };
+  if (!clientIds.length) return { ok: false, output: "Select at least one agent." };
+  const detected = await detectClients();
+  const selected = detected.filter((client) => clientIds.includes(client.id));
+  if (!selected.length) return { ok: false, output: "No selected agents were detected on this machine." };
+  const includeWrite = body.includeWrite !== false;
+  const telemetryEnabled = body.telemetryEnabled !== false;
+  const results = [];
+  for (const client of selected) results.push(await installInto(client, session, includeWrite, telemetryEnabled));
+  const output = [
+    `Logged in to ${session.region.toUpperCase()} backend.`,
+    `Settings: write tools ${includeWrite ? "on" : "off"}, telemetry ${telemetryEnabled ? "on" : "off"}.`,
+    "",
+    "Install summary:",
+    ...results.map((result) => `${result.ok ? "OK" : "ERROR"} ${result.label}: ${result.message}`),
+    "",
+    "Restart your MCP client(s) to pick up the new server."
+  ].join("\n");
+  return { ok: results.some((result) => result.ok), output: sanitizeOutput(output), results };
+}
+async function streamInstall(url, res) {
+  cleanupSessions();
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache, no-transform",
+    connection: "keep-alive"
+  });
+  const session = sessions.get(url.searchParams.get("sessionId") ?? "");
+  const clientIds = (url.searchParams.get("clients") ?? "").split(",").filter(Boolean);
+  const includeWrite = url.searchParams.get("write") !== "0";
+  const telemetryEnabled = url.searchParams.get("telemetry") !== "0";
+  const emit = (level, message) => sendSse(res, { level, message: sanitizeOutput(message) });
+  if (!session) {
+    emit("error", "Login expired. Go back and sign in again.");
+    emit("done", "Install stopped.");
+    res.end();
+    return;
+  }
+  if (!clientIds.length) {
+    emit("error", "Select at least one agent.");
+    emit("done", "Install stopped.");
+    res.end();
+    return;
+  }
+  emit("info", `Connected to ${session.accountLabel}.`);
+  emit("info", `Write tools ${includeWrite ? "enabled" : "disabled"}; telemetry ${telemetryEnabled ? "enabled" : "disabled"}.`);
+  emit("info", "Refreshing installed-agent detection...");
+  const detected = await detectClients();
+  const selected = detected.filter((client) => clientIds.includes(client.id));
+  const selectedHasOnlyManualSetup = selected.length > 0 && selected.every(isManualSetupClient);
+  if (!selected.length) {
+    emit("error", "No selected agents were detected on this machine.");
+    emit("done", "Install stopped.");
+    res.end();
+    return;
+  }
+  let okCount = 0;
+  for (const client of selected) {
+    emit("active", isManualSetupClient(client) ? `Preparing ${client.label} manual setup...` : `Installing ${client.label}...`);
+    const result = await installInto(client, session, includeWrite, telemetryEnabled);
+    if (result.ok) {
+      okCount += 1;
+      emit("success", `${result.label}: ${result.message}`);
+    } else {
+      emit("error", `${result.label}: ${result.message}`);
+    }
+  }
+  emit(okCount > 0 ? "success" : "error", selectedHasOnlyManualSetup ? "Manual ChatGPT setup instructions ready." : `${okCount}/${selected.length} agent(s) installed, updated, or prepared.`);
+  emit("done", selectedHasOnlyManualSetup ? "Follow the manual setup instructions shown above." : "Restart your MCP client(s) to pick up the new server.");
+  res.end();
+}
+async function streamUninstall(url, res) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache, no-transform",
+    connection: "keep-alive"
+  });
+  const clientIds = (url.searchParams.get("clients") ?? "").split(",").filter(Boolean);
+  const emit = (level, message) => sendSse(res, { level, message });
+  if (!clientIds.length) {
+    emit("error", "Select at least one agent.");
+    emit("done", "Uninstall stopped.");
+    res.end();
+    return;
+  }
+  const detected = await detectClients();
+  const selected = detected.filter((c) => clientIds.includes(c.id));
+  if (!selected.length) {
+    emit("error", "No selected agents were detected on this machine.");
+    emit("done", "Uninstall stopped.");
+    res.end();
+    return;
+  }
+  let okCount = 0;
+  for (const client of selected) {
+    emit("active", `Removing from ${client.label}...`);
+    let res2;
+    if (client.id === "claude-code") {
+      res2 = await uninstallFromClaudeCode();
+    } else if (client.id === "codex") {
+      const tomlRes = await uninstallFromCodexConfig(client.configPath ?? client.detail);
+      const shellRes = await uninstallShellExports();
+      res2 = tomlRes.ok && shellRes.ok ? { ok: true, message: `${tomlRes.message}; ${shellRes.message}` } : { ok: false, message: `toml: ${tomlRes.message}; shell: ${shellRes.message}` };
+    } else {
+      res2 = await uninstallFromJsonConfig(client.configPath);
+    }
+    if (res2.ok) {
+      okCount += 1;
+      emit("success", `${client.label}: ${res2.message}`);
+    } else {
+      emit("error", `${client.label}: ${res2.message}`);
+    }
+  }
+  emit(okCount > 0 ? "success" : "error", `${okCount}/${selected.length} agent(s) removed.`);
+  emit("done", "Restart your MCP client(s) to complete the removal.");
+  res.end();
+}
+function pageUninstallHtml() {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Leadbay MCP uninstaller</title>
+  <style>
+    :root { color-scheme: light dark; --bg:#f6f7f4; --panel:#fff; --text:#1d241f; --muted:#65706a; --line:#dbe2dc; --accent:#008f7a; --accent2:#06705f; --danger:#b42318; --shadow:0 18px 45px rgba(32,45,38,.12); }
+    @media (prefers-color-scheme: dark) { :root { --bg:#121612; --panel:#1b211c; --text:#eef4ed; --muted:#a4afa7; --line:#303930; --shadow:0 18px 45px rgba(0,0,0,.28); } }
+    * { box-sizing:border-box; }
+    body { margin:0; min-height:100vh; background:var(--bg); color:var(--text); font:14px/1.45 ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif; display:grid; place-items:center; padding:28px; }
+    main { width:min(880px,100%); background:var(--panel); border:1px solid var(--line); border-radius:8px; box-shadow:var(--shadow); overflow:hidden; }
+    header { padding:22px 24px 16px; border-bottom:1px solid var(--line); display:flex; align-items:flex-start; justify-content:space-between; gap:16px; }
+    h1 { font-size:22px; line-height:1.15; margin:0 0 6px; letter-spacing:0; }
+    .meta { color:var(--muted); }
+    .badge { border:1px solid var(--line); border-radius:999px; padding:5px 10px; color:var(--muted); white-space:nowrap; }
+    .steps { display:grid; grid-template-columns:repeat(2,1fr); border-bottom:1px solid var(--line); }
+    .step-pill { padding:12px 24px; border-right:1px solid var(--line); color:var(--muted); font-weight:700; }
+    .step-pill:last-child { border-right:0; }
+    .step-pill.active { color:var(--text); background:color-mix(in srgb,var(--danger),transparent 88%); }
+    section { padding:22px 24px; }
+    .hidden { display:none; }
+    .hint,.detail { color:var(--muted); }
+    .agents { display:grid; gap:8px; margin-top:12px; }
+    .agent { display:grid; grid-template-columns:auto 1fr; gap:12px; align-items:center; padding:12px; border:1px solid var(--line); border-radius:6px; }
+    .agent strong { display:block; }
+    .agent input { width:18px; min-height:18px; }
+    .actions { display:flex; justify-content:space-between; gap:10px; border-top:1px solid var(--line); padding:16px 24px 20px; }
+    .right-actions { display:flex; gap:10px; }
+    button { min-height:40px; border-radius:6px; border:1px solid var(--line); background:transparent; color:var(--text); padding:8px 14px; font:inherit; font-weight:700; cursor:pointer; }
+    button.danger { background:var(--danger); border-color:var(--danger); color:#fff; }
+    button:disabled { opacity:.6; cursor:wait; }
+    .log-panel { margin:0; background:color-mix(in srgb,var(--panel),#000 7%); border-top:1px solid var(--line); padding:16px 24px; min-height:76px; max-height:280px; overflow:auto; font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace; font-size:13px; }
+    .log-row { display:flex; gap:10px; align-items:flex-start; padding:3px 0; white-space:pre-wrap; word-break:break-word; }
+    .log-row::before { width:56px; flex:0 0 56px; font-weight:800; text-transform:uppercase; font-size:11px; letter-spacing:.02em; }
+    .log-info { color:var(--muted); } .log-info::before { content:"info"; }
+    .log-active { color:#c99700; } .log-active::before { content:"run"; }
+    .log-success { color:#19a974; } .log-success::before { content:"ok"; }
+    .log-error { color:var(--danger); } .log-error::before { content:"error"; }
+    .badge-configured { font-size:10px; font-weight:800; padding:2px 6px; border-radius:999px; vertical-align:middle; background:color-mix(in srgb,var(--danger),transparent 80%); color:var(--danger); }
+    .badge-absent { font-size:10px; font-weight:800; padding:2px 6px; border-radius:999px; vertical-align:middle; background:color-mix(in srgb,var(--muted),transparent 80%); color:var(--muted); }
+    @media (max-width:680px) { body{padding:12px;place-items:start center;} header{display:block;} .badge{display:inline-block;margin-top:12px;} .steps{grid-template-columns:1fr;} .step-pill{border-right:0;border-bottom:1px solid var(--line);} .actions{display:grid;} .right-actions{display:grid;} }
+  </style>
+</head>
+<body>
+  <main>
+    <header><div><h1>Leadbay MCP uninstaller</h1><div class="meta" id="meta">${formatInstallOsLabel()}</div></div><div class="badge">v${VERSION}</div></header>
+    <div class="steps"><div class="step-pill active" id="pill-1">1. Select agents</div><div class="step-pill" id="pill-2">2. Remove</div></div>
+
+    <section id="step-1"><strong>Detected agents</strong><div class="hint">Select which agents to remove Leadbay MCP from.</div><div class="agents" id="agents"></div></section>
+    <section id="step-2" class="hidden"><strong>Removing</strong><div class="hint">Keep this window open until the final message appears.</div></section>
+
+    <div class="actions"><button id="back" disabled>Back</button><div class="right-actions"><button id="refresh">Refresh</button><button class="danger" id="next">Remove selected</button></div></div>
+    <div id="log" class="log-panel"><div class="log-row log-info">Ready.</div></div>
+  </main>
+  <script>
+    const $ = (id) => document.getElementById(id);
+    let step = 1;
+    let clients = [];
+    function clearLog() { $("log").innerHTML = ""; }
+    function appendLog(level, text) { const row = document.createElement("div"); row.className = "log-row log-" + level; row.textContent = text; $("log").appendChild(row); $("log").scrollTop = $("log").scrollHeight; }
+    function esc(s) { return String(s).replace(/[&<>"']/g, (c) => ({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[c])); }
+    function setStep(n) { step = n; [1,2].forEach((i) => { $("step-" + i).classList.toggle("hidden", i !== step); $("pill-" + i).classList.toggle("active", i === step); }); $("back").disabled = step === 1 || step === 2; $("next").classList.toggle("hidden", step === 2); $("refresh").classList.toggle("hidden", step === 2); }
+    function renderAgents() { const root = $("agents"); if (!clients.length) { root.innerHTML = '<div class="hint">No Leadbay MCP installation detected on this machine.</div>'; return; } root.innerHTML = clients.map((c) => '<label class="agent"><input type="checkbox" data-client="' + esc(c.id) + '" checked /><span><strong>' + esc(c.label) + '</strong><span class="detail">' + esc(c.detail) + '</span></span></label>').join(""); }
+    async function refresh() { clearLog(); appendLog("info", "Detecting agents..."); const res = await fetch("/api/status"); const data = await res.json(); clients = (data.clients || []).filter((c) => c.configured); renderAgents(); appendLog("info", clients.length ? "Agents detected." : "No Leadbay MCP installation detected on this machine."); }
+    async function doUninstall() { const selected = [...document.querySelectorAll("[data-client]:checked")].map((el) => el.dataset.client); if (!selected.length) { clearLog(); appendLog("error", "Select at least one agent."); return; } setStep(2); clearLog(); appendLog("info", "Starting removal..."); const params = new URLSearchParams({ clients: selected.join(",") }); const events = new EventSource("/api/uninstall-stream?" + params.toString()); events.onmessage = (event) => { const data = JSON.parse(event.data); appendLog(data.level === "done" ? "success" : data.level, data.message); if (data.level === "done") events.close(); }; events.onerror = () => { appendLog("error", "Uninstall stream disconnected."); events.close(); }; }
+    $("back").addEventListener("click", () => setStep(1));
+    $("refresh").addEventListener("click", refresh);
+    $("next").addEventListener("click", doUninstall);
+    refresh();
+  </script>
+</body>
+</html>`;
+}
+function pageHtml() {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Leadbay MCP installer</title>
+  <style>
+    :root { color-scheme: light dark; --bg:#f6f7f4; --panel:#fff; --text:#1d241f; --muted:#65706a; --line:#dbe2dc; --accent:#008f7a; --accent2:#06705f; --danger:#b42318; --shadow:0 18px 45px rgba(32,45,38,.12); }
+    @media (prefers-color-scheme: dark) { :root { --bg:#121612; --panel:#1b211c; --text:#eef4ed; --muted:#a4afa7; --line:#303930; --shadow:0 18px 45px rgba(0,0,0,.28); } }
+    * { box-sizing:border-box; }
+    body { margin:0; min-height:100vh; background:var(--bg); color:var(--text); font:14px/1.45 ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif; display:grid; place-items:center; padding:28px; }
+    main { width:min(880px,100%); background:var(--panel); border:1px solid var(--line); border-radius:8px; box-shadow:var(--shadow); overflow:hidden; }
+    header { padding:22px 24px 16px; border-bottom:1px solid var(--line); display:flex; align-items:flex-start; justify-content:space-between; gap:16px; }
+    h1 { font-size:22px; line-height:1.15; margin:0 0 6px; letter-spacing:0; }
+    .meta,.hint,.detail,label span { color:var(--muted); }
+    .badge { border:1px solid var(--line); border-radius:999px; padding:5px 10px; color:var(--muted); white-space:nowrap; }
+    .steps { display:grid; grid-template-columns:repeat(4,1fr); border-bottom:1px solid var(--line); }
+    .step-pill { padding:12px 24px; border-right:1px solid var(--line); color:var(--muted); font-weight:700; }
+    .step-pill:last-child { border-right:0; }
+    .step-pill.active { color:var(--text); background:color-mix(in srgb,var(--accent),transparent 88%); }
+    section { padding:22px 24px; }
+    .hidden { display:none; }
+    .grid { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:14px; }
+    label { display:grid; gap:6px; font-weight:650; }
+    input,select { width:100%; min-height:40px; border:1px solid var(--line); border-radius:6px; background:transparent; color:var(--text); padding:8px 10px; font:inherit; }
+    .options { display:flex; gap:14px; flex-wrap:wrap; margin-top:14px; }
+    .toggle { display:inline-flex; align-items:center; gap:8px; font-weight:600; }
+    .toggle input { width:16px; min-height:16px; }
+    .setting-card { display:grid; gap:4px; max-width:360px; }
+    .setting-card .hint { padding-left:24px; }
+    .agents { display:grid; gap:8px; margin-top:12px; }
+    .agent { display:grid; grid-template-columns:auto 1fr; gap:12px; align-items:center; padding:12px; border:1px solid var(--line); border-radius:6px; }
+    .agent strong { display:block; }
+    .agent input { width:18px; min-height:18px; }
+    .actions { display:flex; justify-content:space-between; gap:10px; border-top:1px solid var(--line); padding:16px 24px 20px; }
+    .right-actions { display:flex; gap:10px; }
+    button { min-height:40px; border-radius:6px; border:1px solid var(--line); background:transparent; color:var(--text); padding:8px 14px; font:inherit; font-weight:700; cursor:pointer; }
+    button.primary { background:var(--accent); border-color:var(--accent); color:#fff; }
+    button.primary:hover { background:var(--accent2); }
+    button:disabled { opacity:.6; cursor:wait; }
+    .log-panel { margin:0; background:color-mix(in srgb,var(--panel),#000 7%); border-top:1px solid var(--line); padding:16px 24px; min-height:76px; max-height:280px; overflow:auto; font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace; font-size:13px; }
+    .log-row { display:flex; gap:10px; align-items:flex-start; padding:3px 0; white-space:pre-wrap; word-break:break-word; }
+    .log-row::before { width:56px; flex:0 0 56px; font-weight:800; text-transform:uppercase; font-size:11px; letter-spacing:.02em; }
+    .log-info { color:var(--muted); }
+    .log-info::before { content:"info"; }
+    .log-active { color:#c99700; }
+    .log-active::before { content:"run"; }
+    .log-success { color:#19a974; }
+    .log-success::before { content:"ok"; }
+    .log-error { color:var(--danger); }
+    .log-error::before { content:"error"; }
+    .error { color:var(--danger); }
+    .badge-install,.badge-update { font-size:10px; font-weight:800; padding:2px 6px; border-radius:999px; vertical-align:middle; }
+    .badge-install { background:color-mix(in srgb,var(--accent),transparent 80%); color:var(--accent2); }
+    .badge-update { background:color-mix(in srgb,#c99700,transparent 80%); color:#a07800; }
+    @media (prefers-color-scheme: dark) { .badge-update { color:#f0c040; } .badge-install { color:#00c9a0; } }
+    @media (max-width:680px) { body{padding:12px;place-items:start center;} header{display:block;} .badge{display:inline-block;margin-top:12px;} .grid,.steps{grid-template-columns:1fr;} .step-pill{border-right:0;border-bottom:1px solid var(--line);} .actions{display:grid;} .right-actions{display:grid;} }
+  </style>
+</head>
+<body>
+  <main>
+    <header><div><h1>Leadbay MCP installer</h1><div class="meta" id="meta">${formatInstallOsLabel()}</div></div><div class="badge">v${VERSION}</div></header>
+    <div class="steps"><div class="step-pill active" id="pill-1">1. Sign in</div><div class="step-pill" id="pill-2">2. Agents</div><div class="step-pill" id="pill-3">3. Install</div></div>
+
+    <section id="step-1"><strong>Connect your Leadbay account</strong><div class="hint">This opens Leadbay in your browser. After approval, come back here to choose where to install the MCP.</div></section>
+    <section id="step-2" class="hidden"><strong>Detected agents</strong><div class="hint">Local agents are installed automatically when supported. ChatGPT Desktop requires manual setup with the hosted MCP URL.</div><div class="agents" id="agents"></div><div class="options"><div class="setting-card"><label class="toggle"><input id="write" type="checkbox" checked /> Write tools</label><div class="hint">Allows Leadbay actions that change data or spend credits, like import, enrich, qualify, refine audience, and log outreach.</div></div><div class="setting-card"><label class="toggle"><input id="telemetry" type="checkbox" checked /> Telemetry</label><div class="hint">Sends product usage and crash events so we can debug installs. It does not send tool arguments, lead data, or the token.</div></div></div></section>
+    <section id="step-3" class="hidden"><strong>Installing</strong><div class="hint">Keep this window open until the final message appears. ChatGPT Desktop setup is manual in ChatGPT Settings > Apps.</div></section>
+
+    <div class="actions"><button id="back" disabled>Back</button><div class="right-actions"><button id="refresh" class="hidden">Refresh</button><button class="primary" id="next">Sign in with Leadbay</button></div></div>
+    <div id="log" class="log-panel"><div class="log-row log-info">Ready.</div></div>
+  </main>
+  <script>
+    const $ = (id) => document.getElementById(id);
+    let step = 1;
+    let sessionId = null;
+    let clients = [];
+    function clearLog() { $("log").innerHTML = ""; }
+    function appendLog(level, text) { const row = document.createElement("div"); row.className = "log-row log-" + level; row.textContent = text; $("log").appendChild(row); $("log").scrollTop = $("log").scrollHeight; }
+    function line(text, error = false) { clearLog(); appendLog(error ? "error" : "info", text); }
+    function esc(s) { return String(s).replace(/[&<>"']/g, (c) => ({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[c])); }
+    function setStep(next) { step = next; [1,2,3].forEach((n) => { $("step-" + n).classList.toggle("hidden", n !== step); $("pill-" + n).classList.toggle("active", n === step); }); $("back").disabled = step === 1 || step === 3; $("refresh").classList.toggle("hidden", step !== 2); $("next").classList.toggle("hidden", step === 3); $("next").textContent = step === 2 ? "Continue" : "Sign in with Leadbay"; }
+    function renderAgents() { const root = $("agents"); if (!clients.length) { root.innerHTML = '<div class="hint">No supported MCP client detected on this machine.</div>'; return; } root.innerHTML = clients.map((client) => { const manual = client.id === "chatgpt-desktop"; const badgeText = manual ? "manual setup" : client.configured ? "update" : "install"; const badgeClass = manual ? "badge-update" : client.configured ? "badge-update" : "badge-install"; return '<label class="agent"><input type="checkbox" data-client="' + esc(client.id) + '" checked /><span><strong>' + esc(client.label) + ' <span class="' + badgeClass + '">' + badgeText + '</span></strong><span class="detail">' + esc(client.detail) + '</span></span></label>'; }).join(""); }
+    async function refresh() { line("Detecting agents..."); const res = await fetch("/api/status"); const data = await res.json(); clients = data.clients || []; renderAgents(); line(clients.length ? "Agents detected." : "No supported agents detected."); }
+    async function doLogin() { $("next").disabled = true; line("Opening Leadbay sign-in in your browser..."); try { const res = await fetch("/api/oauth-login", { method:"POST" }); const data = await res.json(); if (!data.ok) return line(data.error || "OAuth login failed.", true); sessionId = data.sessionId; line("Signed in. Detecting installed agents..."); setStep(2); await refresh(); } finally { $("next").disabled = false; } }
+    async function install() { const selected = [...document.querySelectorAll("[data-client]:checked")].map((el) => el.dataset.client); if (!selected.length) return line("Select at least one agent.", true); setStep(3); clearLog(); appendLog("info", "Starting install..."); const params = new URLSearchParams({ sessionId, clients: selected.join(","), write: $("write").checked ? "1" : "0", telemetry: $("telemetry").checked ? "1" : "0" }); const events = new EventSource("/api/install-stream?" + params.toString()); events.onmessage = (event) => { const data = JSON.parse(event.data); appendLog(data.level === "done" ? "success" : data.level, data.message); if (data.level === "done") events.close(); }; events.onerror = () => { appendLog("error", "Install log stream disconnected."); events.close(); }; }
+    $("back").addEventListener("click", () => setStep(Math.max(1, step - 1)));
+    $("refresh").addEventListener("click", refresh);
+    $("next").addEventListener("click", async () => { if (step === 1) await doLogin(); else await install(); });
+  </script>
+</body>
+</html>`;
+}
+async function openBrowser(url) {
+  const { spawn: spawn4 } = await import("child_process");
+  const trySpawn = (command, args) => new Promise((resolve) => {
+    try {
+      const child = spawn4(command, args, { stdio: "ignore", detached: true });
+      child.unref();
+      child.on("error", () => resolve(false));
+      child.on("close", (code) => resolve(code === 0));
+    } catch {
+      resolve(false);
+    }
+  });
+  if (process.platform === "darwin") {
+    await trySpawn("open", [url]);
+    return;
+  }
+  if (process.platform === "win32") {
+    await trySpawn("cmd", ["/c", "start", "", url]);
+    return;
+  }
+  const candidates = ["xdg-open", "sensible-browser", "google-chrome", "chromium-browser", "firefox"];
+  for (const cmd of candidates) {
+    if (await trySpawn(cmd, [url])) return;
+  }
+  process.stderr.write(`
+  Open this URL in your browser to continue:
+  ${url}
+
+`);
+}
+async function startInstallerGui(options = {}) {
+  let expectedHost = `127.0.0.1:${(options.port ?? PORT) || 0}`;
+  const server = createServer2(async (req, res) => {
+    if (!isAllowedOrigin(req, expectedHost)) {
+      sendJson(res, 403, { ok: false, error: "forbidden" });
+      return;
+    }
+    try {
+      if (req.method === "GET" && req.url === "/") {
+        const raw = pageHtml();
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8", "content-length": Buffer.byteLength(raw) });
+        res.end(raw);
+        return;
+      }
+      if (req.method === "GET" && req.url === "/api/status") {
+        sendJson(res, 200, {
+          os: formatInstallOsLabel(),
+          hostedMcpUrl: HOSTED_MCP_URL,
+          clients: await clientsWithConfiguredStatus()
+        });
+        return;
+      }
+      if (req.method === "POST" && req.url === "/api/oauth-login") {
+        sendJson(res, 200, await loginWithOAuth());
+        return;
+      }
+      if (req.method === "POST" && req.url === "/api/install") {
+        sendJson(res, 200, await install(await readJson(req)));
+        return;
+      }
+      if (req.method === "GET" && req.url?.startsWith("/api/install-stream")) {
+        await streamInstall(new URL(req.url, "http://127.0.0.1"), res);
+        return;
+      }
+      sendJson(res, 404, { ok: false, error: "not found" });
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: err?.message ?? String(err) });
+    }
+  });
+  return await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port ?? PORT, "127.0.0.1", async () => {
+      server.off("error", reject);
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : options.port ?? PORT;
+      expectedHost = `127.0.0.1:${port}`;
+      const url = `http://127.0.0.1:${port}/`;
+      process.stderr.write(`Leadbay MCP installer GUI: ${url}
+`);
+      if (options.openBrowser !== false) await openBrowser(url).catch(() => void 0);
+      resolve({ url, close: () => new Promise((closeResolve, closeReject) => server.close((err) => err ? closeReject(err) : closeResolve())) });
+    });
+  });
+}
+async function startUninstallerGui(options = {}) {
+  let expectedHost = `127.0.0.1:${(options.port ?? PORT) || 0}`;
+  const server = createServer2(async (req, res) => {
+    if (!isAllowedOrigin(req, expectedHost)) {
+      sendJson(res, 403, { ok: false, error: "forbidden" });
+      return;
+    }
+    try {
+      if (req.method === "GET" && req.url === "/") {
+        const raw = pageUninstallHtml();
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8", "content-length": Buffer.byteLength(raw) });
+        res.end(raw);
+        return;
+      }
+      if (req.method === "GET" && req.url === "/api/status") {
+        sendJson(res, 200, {
+          os: formatInstallOsLabel(),
+          clients: await clientsWithConfiguredStatus()
+        });
+        return;
+      }
+      if (req.method === "GET" && req.url?.startsWith("/api/uninstall-stream")) {
+        await streamUninstall(new URL(req.url, "http://127.0.0.1"), res);
+        return;
+      }
+      sendJson(res, 404, { ok: false, error: "not found" });
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: err?.message ?? String(err) });
+    }
+  });
+  return await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port ?? PORT, "127.0.0.1", async () => {
+      server.off("error", reject);
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : options.port ?? PORT;
+      expectedHost = `127.0.0.1:${port}`;
+      const url = `http://127.0.0.1:${port}/`;
+      process.stderr.write(`Leadbay MCP uninstaller GUI: ${url}
+`);
+      if (options.openBrowser !== false) await openBrowser(url).catch(() => void 0);
+      resolve({ url, close: () => new Promise((closeResolve, closeReject) => server.close((err) => err ? closeReject(err) : closeResolve())) });
+    });
+  });
+}
+async function main() {
+  const uninstall = process.argv.includes("--uninstall");
+  const handle = uninstall ? await startUninstallerGui({ openBrowser: !process.argv.includes("--no-open") }) : await startInstallerGui({ openBrowser: !process.argv.includes("--no-open") });
+  await new Promise((resolve) => {
+    process.once("SIGINT", () => resolve());
+    process.once("SIGTERM", () => resolve());
+  });
+  await handle.close().catch(() => void 0);
+}
+var isEntrypoint = (() => {
+  try {
+    const entry = process.argv[1];
+    if (!entry) return false;
+    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(entry);
+  } catch {
+    return false;
+  }
+})();
+if (isEntrypoint) {
+  main().catch((err) => {
+    process.stderr.write(`leadbay-mcp-installer: ${err?.message ?? err}
+`);
+    process.exit(1);
+  });
+}
+export {
+  install,
+  sanitizeOutput,
+  startInstallerGui,
+  startUninstallerGui
+};