@btraut/browser-bridge 0.2.0 → 0.4.0

package/dist/index.js

@@ -142,6 +142,11 @@ var DiagnosticReportSchema = import_zod2.z.object({
   ok: import_zod2.z.boolean(),
   session_id: import_zod2.z.string().optional(),
   checks: import_zod2.z.array(DiagnosticCheckSchema).optional(),
+  sessions: import_zod2.z.object({
+    count: import_zod2.z.number().finite().optional(),
+    max_age_ms: import_zod2.z.number().finite().optional(),
+    max_idle_ms: import_zod2.z.number().finite().optional()
+  }).optional(),
   extension: import_zod2.z.object({
     connected: import_zod2.z.boolean().optional(),
     version: import_zod2.z.string().optional(),
@@ -673,7 +678,7 @@ var resolveTimeoutMs = (timeoutMs) => {
   }
   return Math.floor(parsed);
 };
-var normalizePath = (path2) => path2.startsWith("/") ? path2 : `/${path2}`;
+var normalizePath = (path9) => path9.startsWith("/") ? path9 : `/${path9}`;
 var createCoreClient = (options = {}) => {
   const host = resolveHost(options.host);
   const port = resolvePort(options.port);
@@ -682,11 +687,11 @@ var createCoreClient = (options = {}) => {
   const fetchImpl = options.fetchImpl ?? fetch;
   const spawnImpl = options.spawnImpl ?? import_node_child_process.spawn;
   const ensureDaemon = options.ensureDaemon ?? true;
-  const requestJson = async (method, path2, body) => {
+  const requestJson = async (method, path9, body) => {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
     try {
-      const response = await fetchImpl(`${baseUrl}${normalizePath(path2)}`, {
+      const response = await fetchImpl(`${baseUrl}${normalizePath(path9)}`, {
         method,
         headers: {
           "content-type": "application/json"
@@ -774,9 +779,9 @@ startCoreServer({ host: ${JSON.stringify(
     }
     await ensurePromise;
   };
-  const post = async (path2, body) => {
+  const post = async (path9, body) => {
     await ensureReady();
-    return requestJson("POST", path2, body);
+    return requestJson("POST", path9, body);
   };
   return { baseUrl, ensureReady, post };
 };
@@ -1365,18 +1370,18 @@ var resolvePort2 = (port) => {
   }
   return parsed;
 };
-var normalizePath2 = (path2) => path2.startsWith("/") ? path2 : `/${path2}`;
+var normalizePath2 = (path9) => path9.startsWith("/") ? path9 : `/${path9}`;
 var createCoreClient2 = (options = {}) => {
   const host = resolveHost2(options.host);
   const port = resolvePort2(options.port);
   const baseUrl = `http://${host}:${port}`;
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
   const fetchImpl = options.fetchImpl ?? fetch;
-  const requestJson = async (path2, body) => {
+  const requestJson = async (path9, body) => {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
     try {
-      const response = await fetchImpl(`${baseUrl}${normalizePath2(path2)}`, {
+      const response = await fetchImpl(`${baseUrl}${normalizePath2(path9)}`, {
         method: "POST",
         headers: {
           "content-type": "application/json"
@@ -1398,8 +1403,8 @@ var createCoreClient2 = (options = {}) => {
       clearTimeout(timeout);
     }
   };
-  const post = async (path2, body) => {
-    return requestJson(path2, body);
+  const post = async (path9, body) => {
+    return requestJson(path9, body);
   };
   return { baseUrl, post };
 };
@@ -1837,9 +1842,186 @@ var startMcpServer = async (options = {}) => {
   return { ...handle, transport };
 };
 
+// packages/cli/src/tui.ts
+var requireTty = () => {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("Interactive install requires a TTY.");
+  }
+};
+var checkboxPrompt = async (options) => {
+  const mod = await import("@inquirer/prompts");
+  const { checkbox } = mod;
+  const values = await checkbox({
+    message: options.message,
+    // Avoid wrapping from bottom -> top (and top -> bottom) when navigating long lists.
+    loop: false,
+    choices: options.choices.map((c) => ({
+      value: c.value,
+      name: c.label,
+      checked: c.checked,
+      disabled: c.disabled
+    }))
+  });
+  return values;
+};
+
+// packages/cli/src/installer/mcp-install.ts
+var import_node_child_process2 = require("node:child_process");
+
+// packages/cli/src/installer/cursor-mcp.ts
+var import_promises2 = __toESM(require("node:fs/promises"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path2 = __toESM(require("node:path"));
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var resolveCursorUserSettingsPath = (options) => {
+  const platform = options?.platform ?? process.platform;
+  const homeDir = options?.homeDir ?? import_node_os.default.homedir();
+  const env = options?.env ?? process.env;
+  if (platform === "darwin") {
+    return import_node_path2.default.join(
+      homeDir,
+      "Library",
+      "Application Support",
+      "Cursor",
+      "User",
+      "settings.json"
+    );
+  }
+  if (platform === "win32") {
+    const appData = env.APPDATA;
+    if (!appData) {
+      throw new Error(
+        "APPDATA is not set; cannot resolve Cursor settings path."
+      );
+    }
+    return import_node_path2.default.join(appData, "Cursor", "User", "settings.json");
+  }
+  return import_node_path2.default.join(homeDir, ".config", "Cursor", "User", "settings.json");
+};
+var installCursorMcp = async (settingsPath) => {
+  const filePath = settingsPath ?? resolveCursorUserSettingsPath();
+  const dir = import_node_path2.default.dirname(filePath);
+  await import_promises2.default.mkdir(dir, { recursive: true });
+  let settings = {};
+  try {
+    const raw = await import_promises2.default.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (isObject(parsed)) {
+      settings = parsed;
+    } else {
+      throw new Error("Cursor settings.json is not a JSON object.");
+    }
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      settings = {};
+    } else {
+      throw error;
+    }
+  }
+  const mcp = isObject(settings.mcp) ? settings.mcp : {};
+  const servers = isObject(mcp.servers) ? mcp.servers : {};
+  servers["browser-bridge"] = {
+    command: "browser-bridge",
+    args: ["mcp"]
+  };
+  mcp.servers = servers;
+  settings.mcp = mcp;
+  await import_promises2.default.writeFile(
+    filePath,
+    JSON.stringify(settings, null, 2) + "\n",
+    "utf8"
+  );
+  return { settingsPath: filePath };
+};
+
+// packages/cli/src/installer/mcp-install.ts
+var runQuiet = async (cmd, args) => {
+  await new Promise((resolve2, reject) => {
+    const child = (0, import_node_child_process2.spawn)(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve2();
+      else {
+        const suffix = stderr.trim() ? `: ${stderr.trim()}` : "";
+        reject(new Error(`${cmd} exited with ${code ?? "unknown"}${suffix}`));
+      }
+    });
+  });
+};
+var tryRun = async (cmd, args) => {
+  try {
+    await runQuiet(cmd, args);
+  } catch {
+  }
+};
+var installMcp = async (harness) => {
+  try {
+    if (harness === "codex") {
+      await tryRun("codex", ["mcp", "remove", "browser-bridge"]);
+      await runQuiet("codex", [
+        "mcp",
+        "add",
+        "browser-bridge",
+        "--",
+        "browser-bridge",
+        "mcp"
+      ]);
+      return { ok: true };
+    }
+    if (harness === "claude") {
+      await tryRun("claude", [
+        "mcp",
+        "remove",
+        "--scope",
+        "local",
+        "browser-bridge"
+      ]);
+      await tryRun("claude", [
+        "mcp",
+        "remove",
+        "--scope",
+        "project",
+        "browser-bridge"
+      ]);
+      await tryRun("claude", [
+        "mcp",
+        "remove",
+        "--scope",
+        "user",
+        "browser-bridge"
+      ]);
+      await runQuiet("claude", [
+        "mcp",
+        "add",
+        "--scope",
+        "user",
+        "--transport",
+        "stdio",
+        "browser-bridge",
+        "--",
+        "browser-bridge",
+        "mcp"
+      ]);
+      return { ok: true };
+    }
+    const cursor = await installCursorMcp();
+    return { ok: true, details: { cursorSettingsPath: cursor.settingsPath } };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error.";
+    return {
+      ok: false,
+      error: { code: "MCP_INSTALL_FAILED", message }
+    };
+  }
+};
+
 // packages/cli/src/commands/mcp.ts
 var registerMcpCommand = (program2) => {
-  program2.command("mcp").description("Run the MCP server over stdio").option("--name <name>", "MCP server name").option("--version <version>", "MCP server version").action(async (options, command) => {
+  const startServer = async (options, command) => {
     const globals = getGlobalOptions(command);
     const coreClient = createCoreClient({
       host: globals.host,
@@ -1856,7 +2038,39 @@ var registerMcpCommand = (program2) => {
       console.error(error);
       process.exitCode = 1;
     }
+  };
+  const mcp = program2.command("mcp").description("MCP server and helpers");
+  mcp.command("install").description("Install Browser Bridge as an MCP server in supported clients").action(async (_options, command) => {
+    await runLocal(command, async ({ json }) => {
+      if (json) {
+        throw new Error("mcp install is interactive; omit --json.");
+      }
+      requireTty();
+      const selected = await checkboxPrompt({
+        message: "Install MCP into clients:",
+        choices: [
+          { value: "codex", label: "Codex", checked: true },
+          { value: "claude", label: "Claude", checked: true },
+          { value: "cursor", label: "Cursor", checked: true }
+        ]
+      });
+      const results = {};
+      let hadError = false;
+      for (const harness of selected) {
+        const result = await installMcp(harness);
+        results[harness] = result;
+        if (result.ok === false) {
+          hadError = true;
+        }
+      }
+      if (hadError) {
+        process.exitCode = 1;
+      }
+      return { ok: true, result: { installed: results } };
+    });
   });
+  mcp.option("--name <name>", "MCP server name").option("--version <version>", "MCP server version").action(startServer);
+  mcp.command("serve").description("Run the MCP server over stdio").option("--name <name>", "MCP server name").option("--version <version>", "MCP server version").action(startServer);
 };
 
 // packages/core/src/server.ts
@@ -1865,21 +2079,21 @@ var import_express2 = __toESM(require("express"));
 // packages/core/src/routes/session.ts
 var import_express = require("express");
 
-// packages/core/src/inspect.ts
+// packages/core/src/inspect/service.ts
 var import_readability = require("@mozilla/readability");
 var import_jsdom = require("jsdom");
 var import_turndown = __toESM(require("turndown"));
 
 // packages/core/src/artifacts.ts
-var import_promises2 = require("node:fs/promises");
-var import_node_os = __toESM(require("node:os"));
-var import_node_path2 = __toESM(require("node:path"));
+var import_promises3 = require("node:fs/promises");
+var import_node_os2 = __toESM(require("node:os"));
+var import_node_path3 = __toESM(require("node:path"));
 var ARTIFACTS_DIR_NAME = "browser-agent";
-var resolveTempRoot = () => process.env.TMPDIR || process.env.TEMP || process.env.TMP || import_node_os.default.tmpdir();
-var getArtifactRootDir = (sessionId) => import_node_path2.default.join(resolveTempRoot(), ARTIFACTS_DIR_NAME, sessionId);
+var resolveTempRoot = () => process.env.TMPDIR || process.env.TEMP || process.env.TMP || import_node_os2.default.tmpdir();
+var getArtifactRootDir = (sessionId) => import_node_path3.default.join(resolveTempRoot(), ARTIFACTS_DIR_NAME, sessionId);
 var ensureArtifactRootDir = async (sessionId) => {
   const rootDir = getArtifactRootDir(sessionId);
-  await (0, import_promises2.mkdir)(rootDir, { recursive: true });
+  await (0, import_promises3.mkdir)(rootDir, { recursive: true });
   return rootDir;
 };
 
@@ -2004,23 +2218,23 @@ var PAGE_STATE_SCRIPT = [
 ].join("\n");
 
 // packages/cli/src/open-path.ts
-var import_node_child_process2 = require("node:child_process");
+var import_node_child_process3 = require("node:child_process");
 var openPath = async (target) => {
   const platform = process.platform;
   if (platform === "darwin") {
-    const child2 = (0, import_node_child_process2.spawn)("open", [target], { detached: true, stdio: "ignore" });
+    const child2 = (0, import_node_child_process3.spawn)("open", [target], { detached: true, stdio: "ignore" });
     child2.unref();
     return;
   }
   if (platform === "win32") {
-    const child2 = (0, import_node_child_process2.spawn)("cmd", ["/c", "start", "", target], {
+    const child2 = (0, import_node_child_process3.spawn)("cmd", ["/c", "start", "", target], {
       detached: true,
       stdio: "ignore"
     });
     child2.unref();
     return;
   }
-  const child = (0, import_node_child_process2.spawn)("xdg-open", [target], {
+  const child = (0, import_node_child_process3.spawn)("xdg-open", [target], {
     detached: true,
     stdio: "ignore"
   });
@@ -2076,6 +2290,404 @@ var registerSessionCommands = (program2) => {
   });
 };
 
+// packages/cli/src/commands/skill.ts
+var import_promises7 = __toESM(require("node:fs/promises"));
+var import_node_os4 = __toESM(require("node:os"));
+var import_node_path8 = __toESM(require("node:path"));
+
+// packages/cli/src/installer/harness-targets.ts
+var import_node_os3 = __toESM(require("node:os"));
+var import_node_path4 = __toESM(require("node:path"));
+var getDefaultHarnessTargets = (homeDir) => {
+  const home = homeDir ?? import_node_os3.default.homedir();
+  return [
+    {
+      id: "codex",
+      label: "Codex",
+      skillsDir: import_node_path4.default.join(home, ".agents", "skills"),
+      supportsMcpInstall: true
+    },
+    {
+      id: "claude",
+      label: "Claude",
+      skillsDir: import_node_path4.default.join(home, ".claude", "skills"),
+      supportsMcpInstall: true
+    },
+    {
+      id: "cursor",
+      label: "Cursor",
+      skillsDir: import_node_path4.default.join(home, ".cursor", "skills"),
+      supportsMcpInstall: true
+    },
+    {
+      id: "factory",
+      label: "Factory",
+      skillsDir: import_node_path4.default.join(home, ".factory", "skills"),
+      supportsMcpInstall: false
+    },
+    {
+      id: "opencode",
+      label: "OpenCode",
+      skillsDir: import_node_path4.default.join(home, ".opencode", "skills"),
+      supportsMcpInstall: false
+    },
+    {
+      id: "gemini",
+      label: "Gemini",
+      skillsDir: import_node_path4.default.join(home, ".gemini", "skills"),
+      supportsMcpInstall: false
+    },
+    {
+      id: "github",
+      label: "GitHub",
+      skillsDir: import_node_path4.default.join(home, ".github", "skills"),
+      supportsMcpInstall: false
+    },
+    {
+      id: "ampcode",
+      label: "Ampcode",
+      skillsDir: import_node_path4.default.join(home, ".ampcode", "skills"),
+      supportsMcpInstall: false
+    }
+  ];
+};
+
+// packages/cli/src/installer/package-info.ts
+var import_promises4 = __toESM(require("node:fs/promises"));
+var import_node_path5 = __toESM(require("node:path"));
+var PACKAGE_NAME = "@btraut/browser-bridge";
+var tryReadJson = async (filePath) => {
+  try {
+    const raw = await import_promises4.default.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var resolveCliPackageRootDir = async () => {
+  let dir = __dirname;
+  for (let i = 0; i < 12; i++) {
+    const candidate = import_node_path5.default.join(dir, "package.json");
+    const parsed = await tryReadJson(candidate);
+    if (parsed && parsed.name === PACKAGE_NAME) {
+      return dir;
+    }
+    const parent = import_node_path5.default.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  throw new Error(
+    "Unable to locate Browser Bridge package root (package.json)."
+  );
+};
+var readCliPackageVersion = async () => {
+  const rootDir = await resolveCliPackageRootDir();
+  const pkgPath = import_node_path5.default.join(rootDir, "package.json");
+  const parsed = await tryReadJson(pkgPath);
+  if (!parsed || typeof parsed.version !== "string" || !parsed.version) {
+    throw new Error(`Unable to read version from ${pkgPath}`);
+  }
+  return parsed.version;
+};
+var resolveSkillSourceDir = async () => {
+  const rootDir = await resolveCliPackageRootDir();
+  const packaged = import_node_path5.default.join(rootDir, "skills", "browser-bridge");
+  try {
+    await import_promises4.default.stat(packaged);
+    return packaged;
+  } catch {
+  }
+  const repoRoot = import_node_path5.default.resolve(rootDir, "..", "..");
+  const docsSkill = import_node_path5.default.join(repoRoot, "docs", "skills", "browser-bridge");
+  try {
+    await import_promises4.default.stat(docsSkill);
+    return docsSkill;
+  } catch {
+  }
+  throw new Error(
+    `Unable to locate packaged skill. Expected ${packaged} (npm install) or ${docsSkill} (repo dev).`
+  );
+};
+
+// packages/cli/src/installer/skill-install.ts
+var import_promises6 = __toESM(require("node:fs/promises"));
+var import_node_path7 = __toESM(require("node:path"));
+
+// packages/cli/src/installer/skill-manifest.ts
+var import_promises5 = __toESM(require("node:fs/promises"));
+var import_node_path6 = __toESM(require("node:path"));
+var SKILL_MANIFEST_FILENAME = "skill.json";
+var readSkillManifest = async (skillDir) => {
+  try {
+    const raw = await import_promises5.default.readFile(
+      import_node_path6.default.join(skillDir, SKILL_MANIFEST_FILENAME),
+      "utf8"
+    );
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && parsed.name === "browser-bridge" && typeof parsed.version === "string") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var writeSkillManifest = async (skillDir, version) => {
+  const payload = { name: "browser-bridge", version };
+  await import_promises5.default.writeFile(
+    import_node_path6.default.join(skillDir, SKILL_MANIFEST_FILENAME),
+    JSON.stringify(payload, null, 2) + "\n",
+    "utf8"
+  );
+};
+
+// packages/cli/src/installer/skill-install.ts
+var installBrowserBridgeSkill = async (options) => {
+  const destDir = import_node_path7.default.join(options.destSkillsDir, "browser-bridge");
+  await import_promises6.default.mkdir(options.destSkillsDir, { recursive: true });
+  await import_promises6.default.rm(destDir, { recursive: true, force: true });
+  await import_promises6.default.cp(options.srcSkillDir, destDir, { recursive: true });
+  await writeSkillManifest(destDir, options.version);
+  return { ok: true, destDir };
+};
+
+// packages/cli/src/commands/skill.ts
+var getHarnessMarkerDir = (homeDir, harness) => {
+  switch (harness) {
+    case "codex":
+      return import_node_path8.default.join(homeDir, ".agents");
+    default:
+      return import_node_path8.default.join(homeDir, `.${harness}`);
+  }
+};
+var registerSkillCommands = (program2) => {
+  const skill = program2.command("skill").description("Skill commands");
+  skill.command("install").description("Install the Browser Bridge skill into one or more clients").option(
+    "--client <id...>",
+    "Client ids to install into (codex, claude, cursor, factory, opencode, gemini, github, ampcode)"
+  ).option("--harness <id...>", "Alias for --client").action(
+    async (options, command) => {
+      await runLocal(command, async ({ json }) => {
+        if (json) {
+          throw new Error("skill install is interactive; omit --json.");
+        }
+        const version = await readCliPackageVersion();
+        const srcSkillDir = await resolveSkillSourceDir();
+        const targets = getDefaultHarnessTargets();
+        const byId = new Map(targets.map((t) => [t.id, t]));
+        let selected;
+        const requested = options.client?.length ? options.client : options.harness;
+        if (requested && requested.length > 0) {
+          selected = requested.map((id) => {
+            if (!byId.has(id)) {
+              throw new Error(`Unknown client: ${id}`);
+            }
+            return id;
+          });
+        } else {
+          requireTty();
+          const homeDir = import_node_os4.default.homedir();
+          const checked = /* @__PURE__ */ new Set();
+          for (const t of targets) {
+            try {
+              const marker = getHarnessMarkerDir(homeDir, t.id);
+              await import_promises7.default.stat(marker);
+              checked.add(t.id);
+            } catch {
+            }
+          }
+          if (checked.size === 0) {
+            checked.add("codex");
+          }
+          selected = await checkboxPrompt({
+            message: "Install Browser Bridge skill into clients:",
+            choices: targets.map((t) => ({
+              value: t.id,
+              label: `${t.label} (${t.skillsDir})`,
+              checked: checked.has(t.id)
+            }))
+          });
+        }
+        const results = {};
+        for (const client of selected) {
+          const target = byId.get(client);
+          if (!target) continue;
+          const installed = await installBrowserBridgeSkill({
+            srcSkillDir,
+            destSkillsDir: target.skillsDir,
+            version
+          });
+          results[client] = { destDir: installed.destDir };
+        }
+        return {
+          ok: true,
+          result: {
+            version,
+            installed: results
+          }
+        };
+      });
+    }
+  );
+  skill.command("status").description("Show Browser Bridge skill install status across clients").action(async (_options, command) => {
+    await runLocal(command, async () => {
+      const version = await readCliPackageVersion();
+      const targets = getDefaultHarnessTargets();
+      const rows = [];
+      for (const t of targets) {
+        const skillDir = import_node_path8.default.join(t.skillsDir, "browser-bridge");
+        let installed = false;
+        try {
+          await import_promises7.default.stat(skillDir);
+          installed = true;
+        } catch {
+          installed = false;
+        }
+        const manifest = installed ? await readSkillManifest(skillDir) : null;
+        const installedVersion = manifest?.version ?? null;
+        const upToDate = installedVersion === version;
+        rows.push({
+          harness: t.id,
+          skillsDir: t.skillsDir,
+          installed,
+          installedVersion,
+          expectedVersion: version,
+          upToDate
+        });
+      }
+      return { ok: true, result: { rows } };
+    });
+  });
+};
+
+// packages/cli/src/commands/install.ts
+var import_promises8 = __toESM(require("node:fs/promises"));
+var import_node_os5 = __toESM(require("node:os"));
+var import_node_path9 = __toESM(require("node:path"));
+var formatInstallSummary = (options) => {
+  const wantsSkill = options.setup.includes("skill");
+  const wantsMcp = options.setup.includes("mcp");
+  const lines = [];
+  if (wantsSkill) {
+    const skillInstalled = options.results.filter((r) => r.skill?.ok).map((r) => `- ${r.harness}: ${r.skill?.destDir ?? ""}`);
+    if (skillInstalled.length > 0) {
+      lines.push("Skill installed:");
+      lines.push(...skillInstalled);
+      lines.push("");
+    }
+  }
+  if (wantsMcp) {
+    const mcpOk = options.results.filter((r) => r.mcp?.ok).map((r) => `- ${r.harness}`);
+    const mcpFailed = options.results.filter((r) => r.mcp && r.mcp.ok === false).map(
+      (r) => r.mcp && r.mcp.ok === false ? `- ${r.harness}: ${r.mcp.error.message}` : `- ${r.harness}: unknown error`
+    );
+    if (mcpOk.length > 0) {
+      lines.push("MCP installed:");
+      lines.push(...mcpOk);
+      lines.push("");
+    }
+    if (mcpFailed.length > 0) {
+      lines.push("MCP failed:");
+      lines.push(...mcpFailed);
+      lines.push("");
+    }
+  }
+  return lines.join("\n").trimEnd();
+};
+var getHarnessMarkerDir2 = (harness) => {
+  const homeDir = import_node_os5.default.homedir();
+  switch (harness) {
+    case "codex":
+      return import_node_path9.default.join(homeDir, ".agents");
+    default:
+      return import_node_path9.default.join(homeDir, `.${harness}`);
+  }
+};
+var registerInstallCommand = (program2) => {
+  program2.command("install").description("Install Browser Bridge integrations (Skill and/or MCP)").action(async (_options, command) => {
+    await runLocal(command, async ({ json }) => {
+      if (json) {
+        throw new Error("install is interactive; omit --json.");
+      }
+      requireTty();
+      console.log("Browser Bridge Installer");
+      const setup = await checkboxPrompt({
+        message: "Choose what you'd like to install:",
+        choices: [
+          { value: "skill", label: "Skill (Recommended)", checked: true },
+          { value: "mcp", label: "MCP (Optional)", checked: true }
+        ]
+      });
+      if (setup.length === 0) {
+        return { ok: true, result: "No changes (nothing selected)." };
+      }
+      const wantsSkill = setup.includes("skill");
+      const wantsMcp = setup.includes("mcp");
+      const targets = getDefaultHarnessTargets();
+      const checked = /* @__PURE__ */ new Set();
+      for (const t of targets) {
+        try {
+          await import_promises8.default.stat(getHarnessMarkerDir2(t.id));
+          checked.add(t.id);
+        } catch {
+        }
+      }
+      if (checked.size === 0) {
+        checked.add("codex");
+      }
+      const selected = await checkboxPrompt({
+        message: "Install into clients:",
+        choices: targets.map((t) => {
+          const mcpCapable = t.supportsMcpInstall;
+          const enabled = wantsSkill || mcpCapable;
+          const disabled = enabled ? false : wantsMcp ? "MCP install not supported yet" : false;
+          const suffix = wantsMcp && wantsSkill && !mcpCapable ? " (skill only)" : "";
+          return {
+            value: t.id,
+            label: `${t.label}${suffix}`,
+            checked: checked.has(t.id),
+            disabled
+          };
+        })
+      });
+      const version = await readCliPackageVersion();
+      const srcSkillDir = await resolveSkillSourceDir();
+      const byId = new Map(targets.map((t) => [t.id, t]));
+      const results = [];
+      let hadError = false;
+      for (const harness of selected) {
+        const t = byId.get(harness);
+        if (!t) continue;
+        const row = { harness };
+        if (wantsSkill) {
+          const installed = await installBrowserBridgeSkill({
+            srcSkillDir,
+            destSkillsDir: t.skillsDir,
+            version
+          });
+          row.skill = { ok: true, destDir: installed.destDir };
+        }
+        if (wantsMcp && t.supportsMcpInstall) {
+          if (harness === "codex" || harness === "claude" || harness === "cursor") {
+            row.mcp = await installMcp(harness);
+            if (row.mcp.ok === false) {
+              hadError = true;
+            }
+          }
+        }
+        results.push(row);
+      }
+      if (hadError) {
+        process.exitCode = 1;
+      }
+      const summary = formatInstallSummary({ setup, results });
+      return { ok: true, result: summary || "Done." };
+    });
+  });
+};
+
 // packages/cli/src/index.ts
 var program = new import_commander.Command();
 program.name("browser-bridge").description("Browser Bridge CLI").option("--host <host>", "Core host (default: 127.0.0.1)").option("--port <port>", "Core port (default: 3210)").option("--json", "Output JSON").option("--no-daemon", "Disable auto-starting Core");
@@ -2087,5 +2699,7 @@ registerDiagnosticsCommands(program);
 registerDialogCommands(program);
 registerOpenArtifactsCommand(program);
 registerMcpCommand(program);
+registerSkillCommands(program);
+registerInstallCommand(program);
 void program.parseAsync(process.argv);
 //# sourceMappingURL=index.js.map