unbrowse 12.2.1-preview.0 → 12.3.0

package/SKILL.md

@@ -63,7 +63,7 @@ Hosts that need a stdio server or reject dotted tool names can run `npx unbrowse
 - CLI: `unbrowse discover`, `run`, `inspect`, `resume`, `scrape <url>` (one page as markdown), `index <url>` (teach a site; `index status`), `registry`, `site`, `whoami`. `scrape` and `index` need CLI 12.2.0 or later. `unbrowse run` never drives a website in a browser (the only browser it opens is the first-use sign-in). There is no `unbrowse browse` and no `unbrowse install`. `unbrowse help` describes the installed version.
 - SDK: REST integration and scripting. Consult the public SDK docs for its supported methods; MCP tools and REST methods are not interchangeable names.
 
-Core MCP tools: `unbrowse_discover`, `unbrowse_run`, `unbrowse_inspect`, `unbrowse_resume`, `unbrowse_cancel`, `unbrowse_scrape`, `unbrowse_map`, `unbrowse_sites`, `unbrowse_usage`, `unbrowse_credits`, `unbrowse_forget`, `unbrowse_learn`, `unbrowse_index`, `unbrowse_index_status`, `unbrowse_credentials_list`, `unbrowse_credentials_request`, `unbrowse_credentials_status`, `unbrowse_connect` (connect an app's own MCP server, such as Linear, Notion or GitHub, so its tools run as the person: an app with sign-in returns a link the person opens), and the cloud browser `unbrowse_browse_open`, `unbrowse_browse_snapshot`, `unbrowse_browse_act`, `unbrowse_browse_finish`, `unbrowse_browse_close`.
+Core MCP tools: `unbrowse_discover`, `unbrowse_run`, `unbrowse_inspect`, `unbrowse_resume`, `unbrowse_cancel`, `unbrowse_scrape`, `unbrowse_map`, `unbrowse_sites`, `unbrowse_usage`, `unbrowse_credits`, `unbrowse_forget`, `unbrowse_learn`, `unbrowse_index`, `unbrowse_index_status`, `unbrowse_credentials_list`, `unbrowse_credentials_request`, `unbrowse_credentials_status`, `unbrowse_connect` (connect an app's own MCP server, such as Linear, Notion or GitHub, so its tools run as the person: an app with sign-in returns a link the person opens), `unbrowse_import_mcps` (bring the MCP servers this agent already has into Unbrowse, below), and the cloud browser `unbrowse_browse_open`, `unbrowse_browse_snapshot`, `unbrowse_browse_act`, `unbrowse_browse_finish`, `unbrowse_browse_close`.
 
 [references/tools.json](references/tools.json) contains the exported core MCP input schemas. The connected server's `tools/list` is authoritative: it also includes dynamic tools available to this user's workspace. Never invent a capability ID or input schema.
 
@@ -112,6 +112,14 @@ To cover a whole site ahead of need, `unbrowse_index {url, focus?, maxCapabiliti
 
 An existing HAR pair can be sent through `unbrowse_learn`. Only submit recordings the user authorized; HARs can contain private data. Private and loopback destinations are refused by the hosted service.
 
+## Bring the agent's MCP servers
+
+When the person wants their existing MCP servers in Unbrowse (one sign-in, every agent gets them), import them instead of re-adding each by hand.
+
+- From a terminal: `npx unbrowse mcps` lists the servers in this machine's agent configs (Claude Code, Claude Desktop, Cursor, Codex, VS Code, Windsurf, Gemini, Zed); `npx unbrowse mcps import` imports them (`--dry-run` shows the plan). Keys in those configs stay on the machine unless the person adds `--with-keys`.
+- As an MCP tool: read your host's MCP config yourself and call `unbrowse_import_mcps {servers:[{name, url} | {name, command, args}]}`. Never pass keys, headers or env values; `dryRun: true` shows the plan.
+- Remote servers connect by address. A local (stdio) server cannot run in Unbrowse's cloud: when the catalog has the same app hosted, that is connected instead; otherwise it is `local_only` and stays in the agent. `sign_in` and `key` rows carry the link the person opens. Show them the plan before importing.
+
 ## Website sign-in
 
 Unbrowse account sign-in and a website's saved login are separate. Never ask for passwords in chat or type credentials via ordinary tool arguments.

package/dist/cli.js

@@ -25,6 +25,9 @@ var __esm = (fn, res, err) => () => {
   return res;
 };
 
+// ../sdk/src/version.ts
+var SDK_VERSION = "12.3.0";
+
 // ../sdk/src/client.ts
 function apiBase(url) {
   const u = url.replace(/\/+$/, "");
@@ -35,10 +38,12 @@ class Unbrowse {
   baseUrl;
   apiKey;
   fetchImpl;
+  client;
   constructor(opts = {}) {
     this.baseUrl = apiBase(opts.baseUrl ?? env("UNBROWSE_BASE_URL") ?? DEFAULT_BASE_URL);
     this.apiKey = opts.apiKey ?? env("UNBROWSE_API_KEY");
     this.fetchImpl = opts.fetch ?? ((...a) => globalThis.fetch(...a));
+    this.client = (opts.client ?? `sdk/${SDK_VERSION}`).replace(/[^A-Za-z0-9._/-]/g, "").slice(0, 64);
   }
   async send(path, init) {
     const res = await this.fetchImpl(`${this.baseUrl}${path}`, {
@@ -46,6 +51,7 @@ class Unbrowse {
       headers: {
         ...this.apiKey ? { authorization: `Bearer ${this.apiKey}` } : {},
         "content-type": "application/json",
+        ...this.client ? { "x-unbrowse-client": this.client } : {},
         ...init?.headers ?? {}
       }
     });
@@ -158,7 +164,15 @@ class Unbrowse {
           if (finished)
             return;
           try {
-            const next = await this.answerEgress(egressId, req.id, answer);
+            let next;
+            try {
+              next = await this.answerEgress(egressId, req.id, answer);
+            } catch (err) {
+              if (!(err instanceof UnbrowseError && err.status === 413) || !("response" in answer))
+                throw err;
+              const bytes = Math.round((answer.response.body?.length ?? 0) * 0.75);
+              next = await this.answerEgress(egressId, req.id, { error: `the site's response (${bytes} bytes) is too large to relay from this machine; run it from Unbrowse instead (CLI: --from-unbrowse)` });
+            }
             if (isEgressStep(next) || isEgressWaiting(next))
               latest = next;
             else
@@ -232,6 +246,13 @@ class Unbrowse {
     connect: (a) => this.post("/accounts/connections", a),
     register: (a) => this.post("/accounts/register", a)
   };
+  connectors = {
+    list: () => this.req("/connectors"),
+    apps: (q = "", limit = 20) => this.req(`/connectors/apps?q=${encodeURIComponent(q)}&limit=${limit}`),
+    connect: (c) => this.post("/connectors/connect", c),
+    import: (servers, opts = {}) => this.post("/connectors/import", { servers, ...opts.dryRun ? { dryRun: true } : {} }),
+    disconnect: (app) => this.post("/connectors/disconnect", { app })
+  };
   vault() {
     return this.req("/vault");
   }
@@ -296,7 +317,10 @@ function isEgressStep(v) {
   return !!v && typeof v === "object" && v.status === "egress_required";
 }
 function isEgressWaiting(v) {
-  return !!v && typeof v === "object" && v.status === "waiting_for_client" && typeof v.egressId === "string";
+  if (!v || typeof v !== "object")
+    return false;
+  const o = v;
+  return typeof o.egressId === "string" && o.runId === undefined && o.status !== "egress_required";
 }
 async function sendEgress(send, req) {
   const body = req.body === undefined ? undefined : req.bodyEncoding === "base64" ? base64ToBytes(req.body) : req.body;
@@ -418,17 +442,208 @@ var init_src = __esm(() => {
   init_mcp();
 });
 
+// src/agent-mcps.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+function parseJsonc(text) {
+  let out = "";
+  for (let i = 0;i < text.length; i++) {
+    const c = text[i];
+    if (c === '"') {
+      let j = i + 1;
+      while (j < text.length && text[j] !== '"')
+        j += text[j] === "\\" ? 2 : 1;
+      out += text.slice(i, j + 1);
+      i = j;
+    } else if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== `
+`)
+        i++;
+      out += `
+`;
+    } else if (c === "/" && text[i + 1] === "*") {
+      i = text.indexOf("*/", i + 2);
+      if (i < 0)
+        break;
+      i++;
+    } else
+      out += c;
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+function parseCodexToml(text) {
+  const servers = {};
+  let current;
+  let sub;
+  const value = (v) => {
+    v = v.trim();
+    if (/^".*"$/.test(v) || /^'.*'$/.test(v))
+      return v.slice(1, -1).replace(/\\"/g, '"');
+    if (v.startsWith("["))
+      return [...v.matchAll(/"((?:[^"\\]|\\.)*)"|'([^']*)'/g)].map((m) => m[1] ?? m[2]);
+    if (v.startsWith("{"))
+      return Object.fromEntries([...v.matchAll(/([\w.-]+|"[^"]+")\s*=\s*("(?:[^"\\]|\\.)*"|'[^']*')/g)].map((m) => [m[1].replace(/"/g, ""), m[2].slice(1, -1)]));
+    if (v === "true" || v === "false")
+      return v === "true";
+    return v;
+  };
+  for (const line of text.split(/\r?\n/)) {
+    const t = line.replace(/\s+#.*$/, "").trim();
+    if (!t || t.startsWith("#"))
+      continue;
+    const table = /^\[mcp_servers\.("?)([^\]".]+)\1(?:\.([\w-]+))?\]$/.exec(t);
+    if (table) {
+      current = servers[table[2]] ??= {};
+      sub = table[3];
+      if (sub)
+        current[sub] ??= {};
+      continue;
+    }
+    if (t.startsWith("[")) {
+      current = undefined;
+      continue;
+    }
+    const kv = /^([\w.-]+|"[^"]+")\s*=\s*(.+)$/.exec(t);
+    if (!kv || !current)
+      continue;
+    const key = kv[1].replace(/"/g, "");
+    if (sub)
+      current[sub][key] = value(kv[2]);
+    else
+      current[key] = value(kv[2]);
+  }
+  return servers;
+}
+function places(home = process.env.HOME || process.env.USERPROFILE || homedir2(), cwd = process.cwd(), platform = process.platform, env = process.env) {
+  const appData = env.APPDATA ?? join2(home, "AppData", "Roaming");
+  const desktop = platform === "darwin" ? join2(home, "Library", "Application Support", "Claude") : platform === "win32" ? join2(appData, "Claude") : join2(env.XDG_CONFIG_HOME ?? join2(home, ".config"), "Claude");
+  const code = platform === "darwin" ? join2(home, "Library", "Application Support", "Code", "User") : platform === "win32" ? join2(appData, "Code", "User") : join2(env.XDG_CONFIG_HOME ?? join2(home, ".config"), "Code", "User");
+  const zed = platform === "darwin" || platform === "linux" ? join2(env.XDG_CONFIG_HOME ?? join2(home, ".config"), "zed", "settings.json") : join2(appData, "Zed", "settings.json");
+  const mcpServers = (t) => asObj(parseJsonc(t).mcpServers);
+  return [
+    { host: "claude-code", file: join2(home, ".claude.json"), read: (t) => {
+      const j = parseJsonc(t);
+      const projects = asObj(j.projects);
+      return { ...asObj(projects[cwd]?.mcpServers), ...asObj(j.mcpServers) };
+    } },
+    { host: "claude-code", file: join2(cwd, ".mcp.json"), read: mcpServers },
+    { host: "claude-desktop", file: join2(desktop, "claude_desktop_config.json"), read: mcpServers },
+    { host: "cursor", file: join2(home, ".cursor", "mcp.json"), read: mcpServers },
+    { host: "cursor", file: join2(cwd, ".cursor", "mcp.json"), read: mcpServers },
+    { host: "codex", file: join2(env.CODEX_HOME ?? join2(home, ".codex"), "config.toml"), read: parseCodexToml },
+    { host: "vscode", file: join2(code, "mcp.json"), read: (t) => asObj(parseJsonc(t).servers) },
+    { host: "vscode", file: join2(cwd, ".vscode", "mcp.json"), read: (t) => asObj(parseJsonc(t).servers) },
+    { host: "windsurf", file: join2(home, ".codeium", "windsurf", "mcp_config.json"), read: mcpServers },
+    { host: "gemini", file: join2(home, ".gemini", "settings.json"), read: mcpServers },
+    { host: "zed", file: zed, read: (t) => asObj(parseJsonc(t).context_servers) }
+  ];
+}
+function normalize(host, file, name, raw) {
+  const zedCommand = asObj(raw.command);
+  const command = str(raw.command) ?? str(zedCommand.path);
+  const args = (Array.isArray(raw.args) ? raw.args : Array.isArray(zedCommand.args) ? zedCommand.args : []).filter((a) => typeof a === "string").map((a) => secretish(a) && !/^https:\/\/[^\s?#=]+$/.test(a) ? HIDDEN : a);
+  const url = str(raw.url) ?? str(raw.serverUrl) ?? str(raw.httpUrl);
+  const type = String(raw.type ?? raw.transport ?? "").toLowerCase();
+  const transport = url ? type === "sse" || !type && /\/sse\/?$/.test(url) ? "sse" : "streamable-http" : undefined;
+  const headers = { ...asObj(raw.headers), ...asObj(raw.http_headers) };
+  const env = { ...asObj(raw.env), ...asObj(zedCommand.env) };
+  const self = !!url && isUnbrowse(url) || /unbrowse/.test(`${command ?? ""} ${args.join(" ")}`) && args.includes("mcp");
+  return { host, file, name, ...url ? { url, transport } : {}, ...command ? { command, args } : {}, headerNames: Object.keys(headers), envNames: Object.keys(env), self };
+}
+function scan(opts = {}) {
+  const servers = [];
+  const skipped = [];
+  const seenFiles = new Set;
+  for (const p of places(opts.home, opts.cwd, opts.platform, opts.env)) {
+    if (seenFiles.has(p.file) || !existsSync2(p.file))
+      continue;
+    seenFiles.add(p.file);
+    try {
+      for (const [name, raw] of Object.entries(p.read(readFileSync2(p.file, "utf8")))) {
+        if (raw && typeof raw === "object" && raw.disabled !== true && raw.enabled !== false)
+          servers.push(normalize(p.host, p.file, name, raw));
+      }
+    } catch (e) {
+      skipped.push({ file: p.file, why: e.message.slice(0, 120) });
+    }
+  }
+  return { servers, skipped };
+}
+function toImport(f) {
+  if (f.url)
+    return { name: f.name, url: f.url, ...f.transport ? { transport: f.transport } : {} };
+  const args = (f.args ?? []).filter((a) => a !== HIDDEN && (/^https:\/\/[^\s?#]+$/.test(a) || !a.startsWith("-") && !secretish(a) && /^[@\w][\w@./:-]*$/.test(a) && /mcp|server|remote|gateway/i.test(a)));
+  return { name: f.name, ...f.command ? { command: f.command.split(/[\\/]/).pop() } : {}, ...args.length ? { args } : {} };
+}
+function keyOf(f, raw) {
+  if (!f.url)
+    return;
+  const headers = { ...asObj(raw.headers), ...asObj(raw.http_headers) };
+  for (const [h, v] of Object.entries(headers)) {
+    if (typeof v !== "string" || !v.trim() || /\$\{|\$[A-Z_]/.test(v))
+      continue;
+    if (/^(authorization|x-api-key|api-key|x-auth-token)$/i.test(h))
+      return { header: h.toLowerCase(), key: v.trim() };
+  }
+  return;
+}
+function rawEntry(f, opts = {}) {
+  const p = places(opts.home, opts.cwd, opts.platform, opts.env).find((x) => x.file === f.file && x.host === f.host);
+  try {
+    return p ? p.read(readFileSync2(f.file, "utf8"))[f.name] : undefined;
+  } catch {
+    return;
+  }
+}
+function unique(servers) {
+  const seen = new Set;
+  return servers.filter((s) => {
+    const k = s.url ? `u:${s.url.replace(/\/+$/, "")}` : `c:${s.command} ${(s.args ?? []).join(" ")}`;
+    if (seen.has(k))
+      return false;
+    seen.add(k);
+    return true;
+  });
+}
+var asObj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {}, str = (v) => typeof v === "string" && v.trim() ? v.trim() : undefined, secretish = (a) => /[=]/.test(a) || /(token|secret|key|password|bearer)/i.test(a) || /[A-Za-z0-9_\-]{32,}/.test(a) || /^(sk|ghp|gho|xox[abp]|ub_live|AKIA)[-_A-Za-z0-9]/.test(a), HIDDEN = "‹hidden›", isUnbrowse = (url) => /^https?:\/\/((www|v3|stage|api)\.)?unbrowse\.ai(\/|$)/i.test(url) || /^https?:\/\/[a-z0-9-]+-mcp\.unbrowse\.ai(\/|$)/i.test(url);
+var init_agent_mcps = () => {};
+
 // src/mcp-proxy.ts
 import { createInterface } from "node:readline";
 function safeToolName(name) {
   return name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 64);
 }
-function createProxy(upstream, version) {
+async function localMcps(args, upstream) {
+  const A = await Promise.resolve().then(() => (init_agent_mcps(), {}));
+  const { servers, skipped } = scan();
+  const names = Array.isArray(args.names) ? new Set(args.names.map(String)) : undefined;
+  const pick = servers.filter((s) => !names || names.has(s.name));
+  const listing = pick.map(({ file: _f, ...s }) => s);
+  if (args.import !== true) {
+    return { content: [{ type: "text", text: JSON.stringify({ servers: listing, skipped: skipped.map((x) => x.why) }, null, 2) }], structuredContent: { servers: listing }, isError: false };
+  }
+  const send = unique(pick.filter((s) => !s.self)).map(toImport);
+  if (!send.length)
+    return { content: [{ type: "text", text: "No MCP servers to import." }], isError: false };
+  return (await upstream()).rpc("tools/call", { name: "unbrowse_import_mcps", arguments: { servers: send, ...args.dryRun === true ? { dryRun: true } : {} } });
+}
+function localRun(rest, log = (l) => void process.stderr.write(`${l}
+`)) {
+  return async (args) => {
+    const request = Object.fromEntries(RUN_KEYS.filter((k) => args[k] !== undefined).map((k) => [k, args[k]]));
+    const deadline = Number(args.deadlineMs);
+    const view = await (await rest()).runOnClient(request, { onRequest: (r) => log(`→ ${r.method} ${r.url}`), timeoutMs: Math.max(120000, Number.isFinite(deadline) ? deadline : 0) });
+    const text = JSON.stringify(view);
+    return { content: [{ type: "text", text: text.length > RESULT_MAX ? `${text.slice(0, RESULT_MAX)}…` : text }], structuredContent: view, isError: false };
+  };
+}
+function createProxy(upstream, version, opts = {}) {
   const names = new Map;
   async function list() {
     const tools = await (await upstream()).listTools();
     names.clear();
-    const out = [];
+    const out = [LOCAL_MCPS];
     for (const t of tools) {
       const safe = safeToolName(t.name);
       if (names.has(safe))
@@ -464,6 +679,10 @@ function createProxy(upstream, version) {
           return reply({ tools: await list() });
         case "tools/call": {
           const name = String(msg.params?.name ?? "");
+          if (name === LOCAL_MCPS.name)
+            return reply(await localMcps(msg.params?.arguments ?? {}, upstream));
+          if (opts.runLocal && await original(name) === "unbrowse_run")
+            return reply(await opts.runLocal(msg.params?.arguments ?? {}));
           return reply(await (await upstream()).rpc("tools/call", { ...msg.params, name: await original(name) }));
         }
         default:
@@ -478,7 +697,7 @@ function createProxy(upstream, version) {
   };
 }
 async function serveStdio(opts) {
-  const handle = createProxy(async () => new UnbrowseMcp({ url: opts.url, apiKey: await opts.token() ?? "", endUser: opts.endUser, client: `cli-mcp/${opts.version}` }), opts.version);
+  const handle = createProxy(async () => new UnbrowseMcp({ url: opts.url, apiKey: await opts.token() ?? "", endUser: opts.endUser, client: `cli-mcp/${opts.version}` }), opts.version, opts.fromHere ? { runLocal: localRun(opts.fromHere) } : {});
   const write = (m) => new Promise((resolve) => process.stdout.write(`${JSON.stringify(m)}
 `, () => resolve()));
   const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
@@ -499,10 +718,24 @@ async function serveStdio(opts) {
   }
   await Promise.all(pending);
 }
-var PROTOCOLS;
+var PROTOCOLS, LOCAL_MCPS, RUN_KEYS, RESULT_MAX = 40000;
 var init_mcp_proxy = __esm(() => {
   init_src();
   PROTOCOLS = ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"];
+  LOCAL_MCPS = {
+    name: "unbrowse_local_mcps",
+    description: "The MCP servers configured in this machine's agents (Claude Code, Claude Desktop, Cursor, Codex, VS Code, Windsurf, Gemini, Zed), read by this local Unbrowse server: name, agent, remote address or local command, and the NAMES of any headers and env vars (never their values). import: true brings them into Unbrowse through unbrowse_import_mcps (remote ones by address, local ones as their hosted app; Unbrowse itself and duplicates skipped); dryRun: true shows that plan. Keys stay on this machine; for a server that needs one, the person opens the returned link, or runs `unbrowse mcps import --with-keys` in a terminal.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        import: { type: "boolean", description: "Import them into Unbrowse" },
+        dryRun: { type: "boolean", description: "With import: show the plan without connecting anything" },
+        names: { type: "array", items: { type: "string" }, description: "Only these servers (by their config name)" }
+      },
+      additionalProperties: false
+    }
+  };
+  RUN_KEYS = ["capability", "task", "targetUrl", "input", "accountRefs", "interactionMode", "idempotencyKey", "allowedDestinations"];
 });
 
 // src/cookie-daemon.ts
@@ -532,9 +765,9 @@ __export(exports_cookie_daemon, {
   writeJson: () => writeJson
 });
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir2, platform } from "node:os";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3, platform } from "node:os";
+import { dirname as dirname2, join as join3 } from "node:path";
 function siteOf(domain) {
   const labels = domain.replace(/^\./, "").toLowerCase().split(".");
   if (labels.length <= 2)
@@ -547,7 +780,7 @@ function configDir(cliConfigPath) {
 }
 function readJson(path, fallback) {
   try {
-    return existsSync2(path) ? JSON.parse(readFileSync2(path, "utf8")) : fallback;
+    return existsSync3(path) ? JSON.parse(readFileSync3(path, "utf8")) : fallback;
   } catch {
     return fallback;
   }
@@ -691,10 +924,10 @@ async function watch(opts) {
 }
 function servicePlan(opts) {
   const os = opts.os ?? platform();
-  const home = opts.home ?? homedir2();
+  const home = opts.home ?? homedir3();
   const env = Object.entries(opts.env ?? {});
   if (os === "linux") {
-    const path = join2(home, ".config", "systemd", "user", `${SERVICE}.service`);
+    const path = join3(home, ".config", "systemd", "user", `${SERVICE}.service`);
     const content = [
       "[Unit]",
       "Description=Unbrowse cookie sync: keeps your browser sign-ins for chosen sites in sync with Unbrowse",
@@ -722,8 +955,8 @@ function servicePlan(opts) {
     };
   }
   if (os === "darwin") {
-    const path = join2(home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-    const logPath = join2(home, "Library", "Logs", `${SERVICE}.log`);
+    const path = join3(home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+    const logPath = join3(home, "Library", "Logs", `${SERVICE}.log`);
     const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
     const content = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -761,7 +994,7 @@ function quoteSystemd(s) {
 function ephemeralCli(cli) {
   return /[\\/](_npx|\.npm[\\/]_npx|npx-[^\\/]+|tmp|Temp)[\\/]/i.test(cli);
 }
-var ALL_SITES = "*", allSites = (cfg) => cfg.sites.includes(ALL_SITES), UPLOAD_BATCH = 500, TWO_LEVEL, DEFAULT_INTERVAL_MIN = 15, REFRESH_MS, SERVICE = "unbrowse-cookies", LAUNCHD_LABEL = "ai.unbrowse.cookies", configFile = (dir) => join2(dir, "cookie-sync.json"), stateFile = (dir) => join2(dir, "cookie-sync.state.json");
+var ALL_SITES = "*", allSites = (cfg) => cfg.sites.includes(ALL_SITES), UPLOAD_BATCH = 500, TWO_LEVEL, DEFAULT_INTERVAL_MIN = 15, REFRESH_MS, SERVICE = "unbrowse-cookies", LAUNCHD_LABEL = "ai.unbrowse.cookies", configFile = (dir) => join3(dir, "cookie-sync.json"), stateFile = (dir) => join3(dir, "cookie-sync.state.json");
 var init_cookie_daemon = __esm(() => {
   TWO_LEVEL = /^(co|com|net|org|gov|edu|ac|or|ne|go)\.[a-z]{2}$/;
   REFRESH_MS = 24 * 60 * 60000;
@@ -985,18 +1218,18 @@ var HEADER = 100;
 // src/cookies.ts
 import { createDecipheriv, createHash as createHash3, pbkdf2Sync } from "node:crypto";
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "node:fs";
-import { homedir as homedir3, platform as platform2 } from "node:os";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4 } from "node:fs";
+import { homedir as homedir4, platform as platform2 } from "node:os";
+import { join as join4 } from "node:path";
 function chromium(name, [mac, linux], keychain) {
   return {
     name,
     engine: "chromium",
     keychain: `${keychain} Safe Storage`,
     dirs: (h) => ({
-      darwin: [join3(h, "Library/Application Support", mac)],
-      linux: [join3(h, ".config", linux), join3(h, ".var/app", flatpakId(name), "config", linux)],
-      win32: [join3(process.env.LOCALAPPDATA ?? join3(h, "AppData/Local"), mac.replace(/\//g, "\\"), "User Data")]
+      darwin: [join4(h, "Library/Application Support", mac)],
+      linux: [join4(h, ".config", linux), join4(h, ".var/app", flatpakId(name), "config", linux)],
+      win32: [join4(process.env.LOCALAPPDATA ?? join4(h, "AppData/Local"), mac.replace(/\//g, "\\"), "User Data")]
     })
   };
 }
@@ -1005,9 +1238,9 @@ function firefox(name, [mac, linux, linuxHome]) {
     name,
     engine: "firefox",
     dirs: (h) => ({
-      darwin: [join3(h, "Library/Application Support", mac)],
-      linux: [join3(h, ".config", linux), join3(h, linuxHome ?? `.${name.toLowerCase()}`)],
-      win32: [join3(process.env.APPDATA ?? join3(h, "AppData/Roaming"), mac)]
+      darwin: [join4(h, "Library/Application Support", mac)],
+      linux: [join4(h, ".config", linux), join4(h, linuxHome ?? `.${name.toLowerCase()}`)],
+      win32: [join4(process.env.APPDATA ?? join4(h, "AppData/Roaming"), mac)]
     })
   };
 }
@@ -1019,7 +1252,7 @@ function findProfiles() {
   const raw = [];
   for (const def of BROWSERS) {
     for (const base of def.dirs(home())[OS] ?? []) {
-      if (!existsSync3(base))
+      if (!existsSync4(base))
         continue;
       raw.push(...def.engine === "chromium" ? chromiumProfiles(def, base) : firefoxProfiles(def, base));
     }
@@ -1040,7 +1273,7 @@ function chromiumProfiles(def, base) {
   const out = [];
   let names = [];
   try {
-    const local = JSON.parse(readFileSync3(join3(base, "Local State"), "utf8"));
+    const local = JSON.parse(readFileSync4(join4(base, "Local State"), "utf8"));
     names = Object.keys(local.profile?.info_cache ?? {});
   } catch {
     names = ["Default"];
@@ -1048,8 +1281,8 @@ function chromiumProfiles(def, base) {
   if (!names.length)
     names = ["Default"];
   for (const dir of names) {
-    const path = join3(base, dir);
-    if (existsSync3(join3(path, "Cookies")) || existsSync3(join3(path, "Network", "Cookies"))) {
+    const path = join4(base, dir);
+    if (existsSync4(join4(path, "Cookies")) || existsSync4(join4(path, "Network", "Cookies"))) {
       out.push({ browser: def.name, profile: dir, label: `${def.name} · ${dir}`, path, engine: "chromium" });
     }
   }
@@ -1059,14 +1292,14 @@ function firefoxProfiles(def, base) {
   const out = [];
   let dirs = [];
   try {
-    const ini = readFileSync3(join3(base, "profiles.ini"), "utf8");
+    const ini = readFileSync4(join4(base, "profiles.ini"), "utf8");
     dirs = [...ini.matchAll(/^Path=(.+)$/gm)].map((m) => m[1].trim());
   } catch {
     dirs = safeReaddir(base).filter((d) => /\.default|\.dev-edition/.test(d));
   }
   for (const rel of dirs) {
-    const path = join3(base, rel);
-    if (existsSync3(join3(path, "cookies.sqlite")))
+    const path = join4(base, rel);
+    if (existsSync4(join4(path, "cookies.sqlite")))
       out.push({ browser: def.name, profile: rel, label: `${def.name} · ${rel}`, path, engine: "firefox" });
   }
   return out;
@@ -1082,7 +1315,7 @@ function readCookies(profile, opts = {}) {
   return profile.engine === "chromium" ? chromiumCookies(profile, opts) : firefoxCookies(profile, opts);
 }
 function loadDb(path) {
-  return new Uint8Array(readFileSync3(path));
+  return new Uint8Array(readFileSync4(path));
 }
 function domainMatch(host, want) {
   if (!want)
@@ -1092,7 +1325,7 @@ function domainMatch(host, want) {
   return h === w || h.endsWith(`.${w}`);
 }
 function chromiumCookies(profile, opts) {
-  const dbPath = existsSync3(join3(profile.path, "Network", "Cookies")) ? join3(profile.path, "Network", "Cookies") : join3(profile.path, "Cookies");
+  const dbPath = existsSync4(join4(profile.path, "Network", "Cookies")) ? join4(profile.path, "Network", "Cookies") : join4(profile.path, "Cookies");
   const rows = readTable(loadDb(dbPath), "cookies");
   const decryptor = chromiumDecryptor(profile.browser, rows);
   const out = [];
@@ -1118,7 +1351,7 @@ function chromiumCookies(profile, opts) {
   return out;
 }
 function firefoxCookies(profile, opts) {
-  const rows = readTable(loadDb(join3(profile.path, "cookies.sqlite")), "moz_cookies");
+  const rows = readTable(loadDb(join4(profile.path, "cookies.sqlite")), "moz_cookies");
   const out = [];
   for (const r of rows) {
     const host = String(r.host ?? "");
@@ -1259,7 +1492,7 @@ function keychainName(browser) {
 function windowsKey(_browser) {
   return null;
 }
-var home = () => process.env.UNBROWSE_COOKIES_HOME ?? homedir3(), OS, BROWSERS, TEXT;
+var home = () => process.env.UNBROWSE_COOKIES_HOME ?? homedir4(), OS, BROWSERS, TEXT;
 var init_cookies = __esm(() => {
   OS = platform2();
   BROWSERS = [
@@ -1280,7 +1513,7 @@ var init_cookies = __esm(() => {
 // src/cli.ts
 import { spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, realpathSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, realpathSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
 
@@ -1323,6 +1556,34 @@ function v1Key(baseUrl) {
     return;
   }
 }
+function sharedSignIn(baseUrl, now = Date.now()) {
+  if (process.env.UNBROWSE_SHARED_SIGNIN === "0")
+    return;
+  const dir = process.env.CLAUDE_CONFIG_DIR ?? join(process.env.HOME || homedir(), ".claude");
+  let entries;
+  try {
+    entries = Object.values(JSON.parse(readFileSync(join(dir, ".credentials.json"), "utf8")).mcpOAuth ?? {});
+  } catch {
+    return;
+  }
+  const api = new URL(apiResource(baseUrl));
+  for (const e of entries) {
+    if (typeof e?.serverUrl !== "string" || typeof e.accessToken !== "string" || !e.accessToken)
+      continue;
+    if (typeof e.expiresAt === "number" && now > e.expiresAt - 60000)
+      continue;
+    let url;
+    try {
+      url = new URL(e.serverUrl);
+    } catch {
+      continue;
+    }
+    if (url.origin !== api.origin || !(url.pathname === api.pathname || url.pathname.startsWith(`${api.pathname}/`)))
+      continue;
+    return { token: e.accessToken, from: `Claude Code's MCP sign-in (${String(e.serverName ?? url.origin + url.pathname)})` };
+  }
+  return;
+}
 async function currentToken(baseUrl, fetchImpl = fetch) {
   if (process.env.UNBROWSE_API_KEY)
     return process.env.UNBROWSE_API_KEY;
@@ -1333,7 +1594,7 @@ async function currentToken(baseUrl, fetchImpl = fetch) {
     return stored.apiKey;
   const o = stored.oauth;
   if (!o)
-    return v1Key(baseUrl);
+    return v1Key(baseUrl) ?? sharedSignIn(baseUrl)?.token;
   if (o.expiresAt && o.refreshToken && Date.now() > o.expiresAt - 60000) {
     try {
       const fresh = await tokenRequest(baseUrl, { grant_type: "refresh_token", refresh_token: o.refreshToken, client_id: o.clientId, resource: apiResource(baseUrl) }, fetchImpl);
@@ -1345,6 +1606,18 @@ async function currentToken(baseUrl, fetchImpl = fetch) {
   }
   return o.accessToken;
 }
+function signInSource(baseUrl) {
+  if (process.env.UNBROWSE_API_KEY)
+    return "env";
+  const stored = load();
+  if (stored.baseUrl && stored.baseUrl !== baseUrl)
+    return;
+  if (stored.apiKey || stored.oauth)
+    return "stored";
+  if (v1Key(baseUrl))
+    return "v1";
+  return sharedSignIn(baseUrl) ? "shared" : undefined;
+}
 function describe(baseUrl) {
   if (process.env.UNBROWSE_API_KEY)
     return "API key from UNBROWSE_API_KEY";
@@ -1358,6 +1631,9 @@ function describe(baseUrl) {
   const v1 = !stored.baseUrl ? v1Key(baseUrl) : undefined;
   if (v1)
     return `v1 API key ${mask(v1)} from ~/.unbrowse/config.json (still works; \`unbrowse login\` replaces it)`;
+  const shared = !stored.baseUrl ? sharedSignIn(baseUrl) : undefined;
+  if (shared)
+    return `${shared.from}, shared (\`unbrowse login\` gives the CLI its own)`;
   return "not signed in";
 }
 function mask(key) {
@@ -1442,7 +1718,7 @@ ${url.toString()}`);
 
 // src/cli.ts
 init_src();
-var VERSION = "12.2.1-preview.0";
+var VERSION = "12.3.0";
 var DEFAULT_ORIGIN = "https://unbrowse.ai";
 var HELP = `unbrowse ${VERSION} — call websites as APIs through the Unbrowse API
 
@@ -1474,6 +1750,10 @@ var HELP = `unbrowse ${VERSION} — call websites as APIs through the Unbrowse A
   cookies daemon start|status|stop
                                   The same as a background service (systemd / launchd) [--domain a,b | --all-sites] [--yes]
 
+  mcps                            MCP servers in this machine's agents (Claude Code, Cursor, Codex, VS Code, …)
+  mcps import [name…]             Bring them into Unbrowse: remote ones by address, local ones as their hosted app
+      [--dry-run] [--with-keys]     keys in those configs stay here unless --with-keys (asks first; --yes in scripts)
+
   learn <a.har> <b.har>…          Compile two HAR recordings into a capability [--title T] [--goal G]
   learned [id]                    Your learned capabilities, or one with its harness and skill
   logins                          Saved logins as masked hints
@@ -1487,11 +1767,15 @@ var HELP = `unbrowse ${VERSION} — call websites as APIs through the Unbrowse A
 
   mcp                             Local stdio MCP server proxying the hosted one (tool names use _ not .)
       [--url URL] [--end-user ID]   for agent hosts that need stdio or strict tool names (Grok Build)
+      [--from-here]                 unbrowse_run sends its site requests from this machine, like run (a Grok Bot's computer)
+  mcp add [claude] [codex]        Register that proxy with Claude Code / Codex: they use this CLI's sign-in (no second sign-in)
+      [--name NAME] [--replace] [--dry-run]
+                                  And back: no CLI sign-in, but Claude Code signed in to Unbrowse (plugin) → the CLI uses that
 
 Options: --json (errors as JSON) · --base-url URL · --no-open
 Env: UNBROWSE_API_KEY, UNBROWSE_BASE_URL (default ${DEFAULT_ORIGIN}), UNBROWSE_EGRESS=server, UNBROWSE_MCP_URL, UNBROWSE_END_USER
 Exit: 0 ok · 1 error · 2 input required · 3 sign-in or login needed · 4 not verified`;
-var BOOLEAN = new Set(["json", "help", "version", "no-open", "no-wait", "unattended", "from-here", "from-unbrowse", "all", "all-sites", "yes", "full", "events"]);
+var BOOLEAN = new Set(["json", "help", "version", "no-open", "no-wait", "unattended", "from-here", "from-unbrowse", "all", "all-sites", "yes", "full", "events", "dry-run", "with-keys", "replace"]);
 var NEEDS_ACCOUNT = new Set(["whoami", "usage", "discover", "run", "scrape", "index", "inspect", "resume", "cancel", "learn", "learned", "logins", "call", "cookies"]);
 var SCRAPE_FORMATS = ["markdown", "html", "text", "links", "raw"];
 function parseArgs(argv) {
@@ -1553,14 +1837,15 @@ async function main(argv, io = stdio) {
   const origin = String(args.flags["base-url"] ?? process.env.UNBROWSE_BASE_URL ?? load().baseUrl ?? DEFAULT_ORIGIN).replace(/\/+$/, "");
   const flag = (k) => typeof args.flags[k] === "string" ? args.flags[k] : undefined;
   const print = (v) => io.out(JSON.stringify(v, null, 2));
-  const client = async () => new Unbrowse({ apiKey: await currentToken(origin) ?? "", baseUrl: origin });
-  if (cmd === "mcp") {
+  const client = async () => new Unbrowse({ apiKey: await currentToken(origin) ?? "", baseUrl: origin, client: `cli/${VERSION}` });
+  if (cmd === "mcp" && rest[0] !== "add") {
     await Promise.resolve().then(() => init_mcp_proxy());
     await serveStdio({
       url: flag("url") ?? process.env.UNBROWSE_MCP_URL ?? `${origin}/api/mcp`,
       token: async () => await currentToken(origin) ?? undefined,
       version: VERSION,
-      endUser: flag("end-user") ?? process.env.UNBROWSE_END_USER
+      endUser: flag("end-user") ?? process.env.UNBROWSE_END_USER,
+      ...args.flags["from-here"] || process.env.UNBROWSE_EGRESS === "client" ? { fromHere: client } : {}
     });
     return 0;
   }
@@ -1636,7 +1921,7 @@ async function main(argv, io = stdio) {
     if (!io.interactive || !io.ask || args.flags.json)
       return;
     const { D, dir } = await cookieSync();
-    if (existsSync4(D.configFile(dir)))
+    if (existsSync5(D.configFile(dir)))
       return;
     io.err("Optional: let runs act as you on sites you are signed into in your browser. Unbrowse keeps those sites' cookies in sync in the background (sealed in your vault; only the sites you name leave this machine).");
     const answer = (await io.ask("Sites to keep in sync (e.g. github.com, linkedin.com), or Enter to skip: ")).trim();
@@ -1678,6 +1963,8 @@ Your browser opens ${origin}; approve it and \`unbrowse ${cmd}\` carries on. (Sc
         await offerCookieSync().catch((e) => io.err(`Cookie sync not set up: ${e.message}`));
         return 0;
       }
+      case "mcp":
+        return await mcpAdd(rest.slice(1), args, io, origin);
       case "logout":
         clear();
         io.err("Signed out.");
@@ -1829,7 +2116,7 @@ Your browser opens ${origin}; approve it and \`unbrowse ${cmd}\` carries on. (Sc
             if (plan)
               for (const cmd of plan.disable)
                 exec(cmd);
-            if (plan && existsSync4(plan.path))
+            if (plan && existsSync5(plan.path))
               rmSync2(plan.path, { force: true });
             rmSync2(D.configFile(dir), { force: true });
             rmSync2(D.stateFile(dir), { force: true });
@@ -1838,7 +2125,7 @@ Your browser opens ${origin}; approve it and \`unbrowse ${cmd}\` carries on. (Sc
           }
           if (action === "status") {
             const state = D.readJson(D.stateFile(dir), { sites: {} });
-            const installed = !!plan && existsSync4(plan.path);
+            const installed = !!plan && existsSync5(plan.path);
             const active = installed && plan ? exec(plan.status).status === 0 : false;
             const out = {
               installed,
@@ -1918,13 +2205,15 @@ Your browser opens ${origin}; approve it and \`unbrowse ${cmd}\` carries on. (Sc
       }
       case "learn": {
         need(rest[0], "learn <a.har> <b.har>…");
-        const har = rest.map((f) => JSON.parse(readFileSync4(f, "utf8")));
+        const har = rest.map((f) => JSON.parse(readFileSync5(f, "utf8")));
         print(await ub.learn({ har: har.length === 1 ? har[0] : har, ...flag("title") ? { title: flag("title") } : {}, ...flag("goal") ? { goal: flag("goal") } : {} }));
         return 0;
       }
       case "learned":
         print(await ub.learned(rest[0]));
         return 0;
+      case "mcps":
+        return await mcps(rest, args, io, origin, print, client, onboard);
       case "logins":
         if (rest[0] === "remove")
           print(await ub.logins.remove({ origin: need(rest[1], "logins remove <origin>") }));
@@ -2018,6 +2307,148 @@ async function settle(ub, view, args, io, print) {
     io.err(`${view.status}: ${view.error.code}${view.error.message ? ` — ${view.error.message}` : ""}`);
   return 1;
 }
+async function mcpAdd(rest, args, io, origin) {
+  const HOSTS = ["claude", "codex"];
+  const unknown = rest.filter((h) => !HOSTS.includes(h));
+  if (unknown.length)
+    throw new UsageError(`usage: unbrowse mcp add [claude] [codex] [--name NAME] [--replace] [--dry-run] (unknown: ${unknown.join(", ")})`);
+  const name = (typeof args.flags.name === "string" ? args.flags.name : "") || "unbrowse";
+  const exec = io.exec ?? (() => ({ status: 1, stdout: "", stderr: "no exec" }));
+  const dry = !!args.flags["dry-run"];
+  const replace = !!args.flags.replace;
+  const win = (io.service?.os ?? process.platform) === "win32";
+  const shell = (cmd) => win ? ["cmd", "/c", ...cmd] : cmd;
+  await Promise.resolve().then(() => init_cookie_daemon());
+  let cli = io.service?.cli ?? process.argv[1] ?? "";
+  try {
+    cli = realpathSync(cli);
+  } catch {}
+  const launch = [...io.service?.cli || !ephemeralCli(cli) ? [io.service?.node ?? process.execPath, cli] : shell(["npx", "-y", "unbrowse"]), "mcp", ...origin !== DEFAULT_ORIGIN ? ["--base-url", origin] : []];
+  const env = ["UNBROWSE_CONFIG_DIR", "XDG_CONFIG_HOME", "CLAUDE_CONFIG_DIR", "UNBROWSE_SHARED_SIGNIN"].flatMap((k) => process.env[k] ? [`${k}=${process.env[k]}`] : []);
+  const plans = {
+    claude: { get: ["claude", "mcp", "get", name], remove: ["claude", "mcp", "remove", name, "--scope", "user"], add: ["claude", "mcp", "add", "--scope", "user", name, ...env.flatMap((e) => ["-e", e]), "--", ...launch] },
+    codex: { get: ["codex", "mcp", "get", name], remove: ["codex", "mcp", "remove", name], add: ["codex", "mcp", "add", name, ...env.flatMap((e) => ["--env", e]), "--", ...launch] }
+  };
+  const wanted = rest.length ? rest : HOSTS.filter((h) => dry || exec(shell([h, "--version"])).status === 0);
+  if (!wanted.length)
+    return io.err("No Claude Code or Codex found on PATH. Any MCP host can run the proxy itself: " + launch.join(" ")), 1;
+  let failed = 0;
+  for (const h of wanted) {
+    const plan = plans[h];
+    if (dry) {
+      io.out([...replace ? [plan.remove] : [], plan.add].map((c) => shell(c).join(" ")).join(`
+`));
+      continue;
+    }
+    if (exec(shell(plan.get)).status === 0) {
+      if (!replace) {
+        failed++;
+        io.err(`✗ ${h}: a server named "${name}" already exists; left as it is. Re-run with --replace, or pick --name.`);
+        continue;
+      }
+      const r = exec(shell(plan.remove));
+      if (r.status !== 0) {
+        failed++;
+        io.err(`✗ ${h}: could not remove the existing "${name}": ${(r.stderr || r.stdout).trim() || `exit ${r.status}`}`);
+        continue;
+      }
+    }
+    const r = exec(shell(plan.add));
+    if (r.status === 0)
+      io.err(`✓ ${h}: added "${name}" (stdio, on this CLI's sign-in)`);
+    else
+      failed++, io.err(`✗ ${h}: ${(r.stderr || r.stdout).trim() || `exit ${r.status}`}`);
+  }
+  if (!dry) {
+    const source = signInSource(origin);
+    if (source === "env")
+      io.err("This CLI is signed in only through UNBROWSE_API_KEY, which the hosts do not get: run `unbrowse login` (or `unbrowse login --key`) so they have a sign-in.");
+    else if (source === "shared")
+      io.err("This CLI is using Claude Code's sign-in, which only Claude Code renews: run `unbrowse login` so the hosts keep working.");
+    else if (!source)
+      io.err("Not signed in yet: run `unbrowse login` once and the hosts use that sign-in.");
+  }
+  return failed ? 1 : 0;
+}
+async function mcps(rest, args, io, origin, print, client, onboard) {
+  const A = await Promise.resolve().then(() => (init_agent_mcps(), {}));
+  const { servers, skipped } = scan();
+  const tilde = (f) => f.replace(process.env.HOME ?? "\x00", "~");
+  if (rest[0] !== "import") {
+    if (rest[0])
+      throw new UsageError("usage: unbrowse mcps [import [name…] [--dry-run] [--with-keys]]");
+    if (args.flags.json)
+      return print({ servers: servers.map(({ file, ...s }) => ({ ...s, file: tilde(file) })), skipped }), 0;
+    if (!servers.length)
+      return io.err(`No MCP servers found in this machine's agent configs.${skipped.length ? ` Unreadable: ${skipped.map((x) => tilde(x.file)).join(", ")}` : ""}`), 0;
+    let last = "";
+    for (const s of servers) {
+      const where = `${s.host}  ${tilde(s.file)}`;
+      if (where !== last)
+        io.out(where), last = where;
+      const what = s.url ? `remote  ${s.url}` : `local   ${[s.command, ...s.args ?? []].join(" ").slice(0, 90)}`;
+      const env = s.envNames.length > 3 ? [...s.envNames.slice(0, 3).map((e) => `env ${e}`), `+${s.envNames.length - 3} env`] : s.envNames.map((e) => `env ${e}`);
+      const secrets = [...s.headerNames.map((h) => `header ${h}`), ...env];
+      io.out(`  ${s.name.padEnd(22)} ${what}${secrets.length ? `   (${secrets.join(", ")})` : ""}${s.self ? "   (Unbrowse itself)" : ""}`);
+    }
+    io.err(`
+${unique(servers.filter((s) => !s.self)).length} to import: unbrowse mcps import --dry-run`);
+    return 0;
+  }
+  if (!await currentToken(origin) && !await onboard())
+    return 3;
+  const names = new Set(rest.slice(1));
+  const pick = unique(servers.filter((s) => !s.self && (!names.size || names.has(s.name))));
+  const missing = [...names].filter((n) => !servers.some((s) => s.name === n));
+  if (missing.length)
+    throw new UsageError(`no MCP server named ${missing.join(", ")} in this machine's agent configs (unbrowse mcps lists them)`);
+  if (!pick.length)
+    return io.err("Nothing to import."), 0;
+  const dry = !!args.flags["dry-run"];
+  const keyed = args.flags["with-keys"] ? pick.flatMap((f) => {
+    const k = keyOf(f, rawEntry(f) ?? {});
+    return k ? [{ f, k }] : [];
+  }) : [];
+  if (keyed.length && !dry && !args.flags.yes) {
+    const list = keyed.map((x) => `${x.f.name} (${x.k.header})`).join(", ");
+    if (!io.interactive || !io.ask)
+      throw new UsageError(`Re-run with --yes to confirm: the keys for ${list} will be sent to ${origin} and sealed in your vault.`);
+    const ok = (await io.ask(`Send the keys for ${list} from your agent configs to Unbrowse (sealed in your vault)? [y/N] `)).trim().toLowerCase();
+    if (ok !== "y" && ok !== "yes")
+      return io.err("Nothing sent."), 1;
+  }
+  const ub = await client();
+  const rows = [];
+  for (const { f, k } of keyed) {
+    if (dry) {
+      rows.push({ name: f.name, status: "planned", via: "url", note: `Would connect ${f.url} with the ${k.header} from its config.` });
+      continue;
+    }
+    try {
+      const r = await ub.connectors.connect({ url: f.url, name: f.name, ...f.transport ? { transport: f.transport } : {}, header: k.header, key: k.key });
+      rows.push({ name: f.name, status: r.status, app: r.app, tools: r.tools, url: r.url, via: "url", note: r.status === "connected" ? `Connected with its key: ${r.tools} tools.` : `Needs the person: ${r.url}` });
+    } catch (e) {
+      rows.push({ name: f.name, status: "failed", note: e.message.slice(0, 200) });
+    }
+  }
+  const rest2 = pick.filter((f) => !keyed.some((x) => x.f === f));
+  if (rest2.length)
+    rows.push(...(await ub.connectors.import(rest2.map(toImport), { dryRun: dry })).results);
+  if (args.flags.json)
+    print({ results: rows });
+  else {
+    const mark = { connected: "✓", planned: "·", sign_in: "→", key: "→", already: "=", skipped: "-", local_only: "-", failed: "✗" };
+    for (const r of rows)
+      io.out(`${mark[r.status] ?? "?"} ${r.name.padEnd(22)} ${r.status.padEnd(10)} ${r.note}${r.url ? `
+    ${r.url}` : ""}`);
+    const hasKeyRows = rows.some((r) => r.status === "key") && !args.flags["with-keys"] && pick.some((f) => f.headerNames.length);
+    if (hasKeyRows)
+      io.err("A key server can take the key from your agent config instead: unbrowse mcps import --with-keys");
+    if (dry)
+      io.err("Nothing was connected. Run without --dry-run to import.");
+  }
+  return rows.some((r) => r.status === "failed") ? 1 : 0;
+}
 function noCapabilityHint(view, args) {
   const result = view.result ?? {};
   const task = args._.slice(1).join(" ");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unbrowse",
-  "version": "12.2.1-preview.0",
+  "version": "12.3.0",
   "mcpName": "io.github.unbrowse-ai/unbrowse",
   "description": "Call websites as APIs: a thin CLI over the Unbrowse API.",
   "license": "MIT",

package/references/tools.json

@@ -549,6 +549,65 @@
         "additionalProperties": false
       }
     },
+    {
+      "name": "unbrowse_import_mcps",
+      "description": "Import the MCP servers this agent already has into Unbrowse, so their tools run here with the person's own account and every agent signed in to Unbrowse gets them. Read your host's MCP config yourself (Claude Code: ~/.claude.json and .mcp.json; Claude Desktop: claude_desktop_config.json; Cursor: ~/.cursor/mcp.json; Codex: ~/.codex/config.toml; VS Code: .vscode/mcp.json; Windsurf: ~/.codeium/windsurf/mcp_config.json; Gemini: ~/.gemini/settings.json) and pass each server: a remote one as {name, url}, a local one as {name, command, args}. Never pass keys, headers or env values. A remote server is connected by its address (open ones at once; one with OAuth or a key returns the link the person opens). A local server cannot run in Unbrowse's cloud: when the catalog has the same app hosted, that is connected instead, otherwise it is reported local_only and stays in the agent. Servers already connected, duplicates and Unbrowse itself are skipped. dryRun: true shows the plan without connecting. CLI: `unbrowse mcps import` reads the configs itself.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "servers": {
+            "type": "array",
+            "maxItems": 50,
+            "description": "The MCP servers in your agent's config",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "The server's name in the config"
+                },
+                "url": {
+                  "type": "string",
+                  "description": "A remote server's https address"
+                },
+                "transport": {
+                  "type": "string",
+                  "enum": [
+                    "streamable-http",
+                    "http",
+                    "sse"
+                  ],
+                  "description": "A remote server's transport, when the config says"
+                },
+                "command": {
+                  "type": "string",
+                  "description": "A local server's command, e.g. npx"
+                },
+                "args": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  },
+                  "description": "A local server's arguments (package names; leave out tokens and paths to secrets)"
+                }
+              },
+              "required": [
+                "name"
+              ],
+              "additionalProperties": false
+            }
+          },
+          "dryRun": {
+            "type": "boolean",
+            "description": "Show what would happen without connecting anything"
+          }
+        },
+        "required": [
+          "servers"
+        ],
+        "additionalProperties": false
+      }
+    },
     {
       "name": "unbrowse_credits",
       "description": "This workspace's credits: the free monthly allowance left (pays for Unbrowse's own verified calls only; resets monthly) and paid credits (bought by the user; never expire), plus recent credit history and the top-up link. 1 credit = one verified call = $0.001. Pass a pack (p10 = $10 → 10,000, p50 = $50 → 50,000, p200 = $200 → 200,000) to get a Stripe Checkout link for the user to open — you never pay or see card details.",