@free-lzj/dsh-browser-use 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,743 @@
+import * as McpClient from "@deepseek-ai/dsh-mcp-client";
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+//#region lib/types/mcp-tabs.js
+/**
+* BrowserSkill's own MCP server, driven from the Host.
+*
+* Why not call the `bsk` CLI: a short-lived `bsk` cannot own a daemon inside a
+* desktop application. It tries to start one, the process inherits Electron's
+* outer Job Object, and `bsk` gives up ("still belongs to a Job Object after
+* breakaway"). A long-lived `bsk mcp` does work — it keeps the daemon as its own
+* child — which is also why the tools this plugin exposes to the model function
+* while a one-shot `bsk tab list` does not.
+*
+* So the mention menu speaks the same protocol the tools do: one `bsk mcp`
+* child, newline-delimited JSON-RPC, tools called by name.
+*
+* @module @free-lzj/dsh-browser-use/mcp-tabs
+*/
+/** How long one JSON-RPC round trip may take. */
+const CALL_TIMEOUT_MS = 3e4;
+/** How long the server may take to answer `initialize`. */
+const START_TIMEOUT_MS = 15e3;
+/** The MCP revision this client speaks; the server answers with its own. */
+const PROTOCOL_VERSION = "2024-11-05";
+/** One candidate executable, tried in order. */
+function candidates() {
+	const override = process.env["DSH_BSK_PATH"];
+	if (override !== void 0 && override !== "") return [override];
+	return [
+		"bsk",
+		join(homedir(), ".local", "bin", "bsk.exe"),
+		join(homedir(), ".local", "bin", "bsk")
+	];
+}
+/**
+* Read one raw tab row into the shape the menu uses, or nothing.
+* @param value - one element of the server's `tabs` array.
+* @returns the tab, or undefined when the row cannot be described.
+*/
+function readTab(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const row = value;
+	const tabId = row.tab_id;
+	if (typeof tabId !== "number" || !Number.isFinite(tabId)) return void 0;
+	const title = typeof row.title === "string" ? row.title.trim() : "";
+	const url = typeof row.url === "string" ? row.url.trim() : "";
+	if (title === "" && url === "") return void 0;
+	return {
+		tabId,
+		title: title === "" ? url : title,
+		url,
+		active: row.active === true
+	};
+}
+/**
+* A minimal MCP stdio client, scoped to the two calls the menu needs.
+*
+* Deliberately not `@deepseek-ai/dsh-mcp-client`: that one exists to publish a
+* server's tools to an Agent, and the menu needs a private request/response
+* channel instead. Two children is the price of the two jobs being independent.
+*/
+var BskMcpChannel = class {
+	#child;
+	#buffer = "";
+	#seq = 1;
+	#pending = /* @__PURE__ */ new Map();
+	#session;
+	#starting;
+	#disposed = false;
+	/**
+	* Tabs in the user's own windows, most useful first.
+	* @param signal - caller cancellation; a cancelled call stops waiting, not the server.
+	* @returns the tabs, or none when the browser is unreachable.
+	*/
+	async listUserTabs(signal) {
+		const session = await this.#ensureSession(signal);
+		const answer = await this.#tool("bsk_tabs", {
+			action: "list",
+			scope: "user",
+			session
+		}, signal);
+		const tabs = Array.isArray(answer.tabs) ? answer.tabs : [];
+		const parsed = [];
+		for (const row of tabs) {
+			const tab = readTab(row);
+			if (tab !== void 0) parsed.push(tab);
+		}
+		return [...parsed.filter((tab) => tab.active), ...parsed.filter((tab) => !tab.active)];
+	}
+	/** Stop the child this channel owns. */
+	dispose() {
+		this.#disposed = true;
+		for (const [id, pending] of this.#pending) {
+			clearTimeout(pending.timer);
+			pending.reject(/* @__PURE__ */ new Error("browser-use: channel disposed"));
+			this.#pending.delete(id);
+		}
+		this.#child?.kill();
+		this.#child = void 0;
+	}
+	/**
+	* The session this channel drives, started on first use.
+	* @param signal - caller cancellation while waiting for the start.
+	* @returns the session id.
+	*/
+	async #ensureSession(signal) {
+		if (this.#session !== void 0) return this.#session;
+		if (this.#starting === void 0) {
+			const starting = this.#tool("bsk_session", {
+				action: "start",
+				name: "dsh-mention"
+			}, signal).then((answer) => {
+				if (typeof answer.session_id !== "string" || answer.session_id === "") throw new Error("browser-use: bsk_session start answered without a session_id");
+				this.#session = answer.session_id;
+				return answer.session_id;
+			});
+			this.#starting = starting;
+			starting.catch(() => {
+				if (this.#starting === starting) this.#starting = void 0;
+			});
+		}
+		return this.#starting;
+	}
+	/**
+	* Call one MCP tool and parse its JSON answer.
+	* @param name - tool name on the server.
+	* @param args - tool arguments.
+	* @param signal - caller cancellation.
+	* @returns the parsed answer body.
+	*/
+	async #tool(name, args, signal) {
+		const message = await this.#request("tools/call", {
+			name,
+			arguments: args
+		}, signal);
+		if (message.error !== void 0) throw new Error(`browser-use: ${name} failed: ${JSON.stringify(message.error)}`);
+		const text = message.result?.content?.map((part) => typeof part.text === "string" ? part.text : "").join("") ?? "";
+		if (text === "") throw new Error(`browser-use: ${name} answered nothing`);
+		let body;
+		try {
+			body = JSON.parse(text);
+		} catch {
+			throw new Error(`browser-use: ${name} answered non-JSON: ${text.slice(0, 200)}`);
+		}
+		if (typeof body !== "object" || body === null) throw new Error(`browser-use: ${name} answered ${typeof body}`);
+		const record = body;
+		if (record["code"] !== null && record["code"] !== void 0) throw new Error(`browser-use: ${name}: ${String(record["message"] ?? record["hint"] ?? record["code"])}`);
+		return record;
+	}
+	/**
+	* One JSON-RPC round trip, starting the child when needed.
+	* @param method - JSON-RPC method.
+	* @param params - method parameters.
+	* @param signal - caller cancellation.
+	* @returns the whole response message.
+	*/
+	async #request(method, params, signal) {
+		if (this.#disposed) throw new Error("browser-use: channel disposed");
+		await this.#ensureChild(signal);
+		const child = this.#child;
+		if (child === void 0 || child.stdin === null) throw new Error("browser-use: bsk mcp is not running");
+		const id = this.#seq;
+		this.#seq += 1;
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.#pending.delete(id);
+				reject(/* @__PURE__ */ new Error(`browser-use: ${method} timed out after ${CALL_TIMEOUT_MS}ms`));
+			}, CALL_TIMEOUT_MS);
+			const onAbort = () => {
+				clearTimeout(timer);
+				this.#pending.delete(id);
+				reject(/* @__PURE__ */ new Error("browser-use: request cancelled"));
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+			this.#pending.set(id, {
+				resolve: (message) => {
+					signal.removeEventListener("abort", onAbort);
+					resolve(message);
+				},
+				reject: (error) => {
+					signal.removeEventListener("abort", onAbort);
+					reject(error);
+				},
+				timer
+			});
+			child.stdin?.write(`${JSON.stringify({
+				jsonrpc: "2.0",
+				id,
+				method,
+				params
+			})}\n`);
+		});
+	}
+	/**
+	* Start the server and complete the handshake, once.
+	* @param signal - caller cancellation while starting.
+	*/
+	async #ensureChild(signal) {
+		if (this.#child !== void 0) return;
+		const child = await this.#spawn(signal);
+		this.#child = child;
+		child.stdout?.on("data", (chunk) => {
+			this.#feed(chunk.toString("utf8"));
+		});
+		child.on("exit", () => {
+			if (this.#child === child) this.#child = void 0;
+			this.#rejectAll("browser-use: bsk mcp exited");
+		});
+		await this.#request("initialize", {
+			protocolVersion: PROTOCOL_VERSION,
+			capabilities: {},
+			clientInfo: {
+				name: "dsh-browser-use",
+				version: "0"
+			}
+		}, signal);
+	}
+	/**
+	* Spawn the first candidate executable that exists.
+	* @param signal - caller cancellation while spawning.
+	* @returns the live child.
+	*/
+	async #spawn(signal) {
+		let missing;
+		for (const command of candidates()) {
+			const child = spawn(command, ["mcp"], {
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				],
+				windowsHide: true
+			});
+			if (await new Promise((resolve) => {
+				const onError = (error) => {
+					child.removeListener("spawn", onSpawn);
+					missing = error;
+					resolve(false);
+				};
+				const onSpawn = () => {
+					child.removeListener("error", onError);
+					resolve(true);
+				};
+				child.once("error", onError);
+				child.once("spawn", onSpawn);
+				signal.addEventListener("abort", () => resolve(false), { once: true });
+				setTimeout(() => resolve(child.pid !== void 0), START_TIMEOUT_MS);
+			}) && child.pid !== void 0) return child;
+			child.kill();
+		}
+		throw missing ?? /* @__PURE__ */ new Error("browser-use: could not start `bsk mcp`; is BrowserSkill installed?");
+	}
+	/**
+	* Parse one stdout chunk into responses.
+	* @param chunk - the text that arrived.
+	*/
+	#feed(chunk) {
+		this.#buffer += chunk;
+		for (;;) {
+			const at = this.#buffer.indexOf("\n");
+			if (at < 0) return;
+			const line = this.#buffer.slice(0, at).trim();
+			this.#buffer = this.#buffer.slice(at + 1);
+			if (line === "") continue;
+			let message;
+			try {
+				message = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			const id = message.id;
+			if (typeof id !== "number") continue;
+			const pending = this.#pending.get(id);
+			if (pending === void 0) continue;
+			clearTimeout(pending.timer);
+			this.#pending.delete(id);
+			pending.resolve(message);
+		}
+	}
+	/**
+	* Fail every in-flight request.
+	* @param message - the failure sentence.
+	*/
+	#rejectAll(message) {
+		for (const [id, pending] of this.#pending) {
+			clearTimeout(pending.timer);
+			pending.reject(new Error(message));
+			this.#pending.delete(id);
+		}
+	}
+};
+//#endregion
+//#region lib/types/browser-mention.js
+/**
+* The browser tab provider: the first, and for now the only, mentionable thing.
+*
+* Everything specific to browsers lives here — the query match, the row text,
+* the ref shape. The registry above and the routes beside it stay ignorant of
+* what a tab is, which is what lets the next provider be a new file alone.
+*
+* @module @free-lzj/dsh-browser-use/browser-mention
+*/
+/** The provider id; also the `<provider>:` prefix of every ref it returns. */
+const PROVIDER_ID = "browser";
+/** Section heading the client renders when it has no translation of its own. */
+const PROVIDER_LABEL = "浏览器";
+/**
+* Describe one tab in a menu row.
+*
+* The host alone would make several rows look identical (three `页面设计器`
+* tabs differ only by the page they show), so the path is part of the row when
+* the URL is not merely a site root.
+* @param tab - the tab.
+* @returns the row's second line.
+*/
+function describe(tab) {
+	let site = tab.url;
+	let path = "";
+	try {
+		const parsed = new URL(tab.url);
+		site = parsed.host;
+		path = parsed.pathname === "/" ? "" : parsed.pathname;
+	} catch {}
+	const where = path === "" ? site : `${site}${path}`;
+	return tab.active ? `${where} · 当前标签页` : where;
+}
+/**
+* Match one tab against the typed query.
+*
+* Title and URL both match: people search for `jira` as often as for the ticket
+* number in the title.
+* @param tab - the tab.
+* @param needle - lowercase query; empty matches everything.
+* @returns whether the row belongs in the answer.
+*/
+function matches(tab, needle) {
+	if (needle === "") return true;
+	return tab.title.toLowerCase().includes(needle) || tab.url.toLowerCase().includes(needle);
+}
+/**
+* Build the browser provider over one CLI handle.
+* @param cli - the shared `bsk` session.
+* @returns the provider the registry holds.
+*/
+function browserMentionProvider(cli) {
+	return {
+		id: PROVIDER_ID,
+		label: PROVIDER_LABEL,
+		async candidates(query, signal) {
+			const needle = query.trim().toLowerCase();
+			const tabs = await cli.listUserTabs(signal);
+			if (signal.aborted) return [];
+			return tabs.filter((tab) => matches(tab, needle)).map((tab) => ({
+				ref: `${PROVIDER_ID}:${tab.tabId}`,
+				label: tab.title,
+				description: describe(tab)
+			}));
+		}
+	};
+}
+//#endregion
+//#region lib/types/mention.js
+/**
+* The mention-provider seam.
+*
+* `@` itself belongs to the harness: `dsh-client-ui-input-trigger` owns the menu
+* and `dsh-client-ui-reference` registers one source into it for files and
+* sessions. This package registers a second source for things that are neither,
+* and the provider registry below is where "things" are listed. Adding a kind of
+* thing later (an application, a plugin) means writing one provider — nothing in
+* this file or in the routes learns its name.
+*
+* @module @free-lzj/dsh-browser-use/mention
+*/
+/**
+* Holds every registered provider, in registration order.
+*
+* A provider that fails is dropped from the answer, the way the harness's own
+* reference source drops a domain that cannot load: the rest of the menu stays
+* usable, and one dead backend never costs the user their `@`.
+*/
+var MentionRegistry = class {
+	#providers = [];
+	/**
+	* Add one provider.
+	* @param provider - the source of one group of candidates.
+	* @returns the disposer removing it; duplicate ids are refused.
+	*/
+	register(provider) {
+		if (this.#providers.some((existing) => existing.id === provider.id)) throw new Error(`mention provider "${provider.id}" is already registered`);
+		this.#providers.push(provider);
+		return () => {
+			const at = this.#providers.indexOf(provider);
+			if (at >= 0) this.#providers.splice(at, 1);
+		};
+	}
+	/** @returns the registered ids, for diagnostics. */
+	ids() {
+		return this.#providers.map((provider) => provider.id);
+	}
+	/**
+	* Collect every provider's answer for one query.
+	* @param query - text after `@`.
+	* @param signal - caller cancellation.
+	* @returns the non-empty groups, plus one line per provider that failed.
+	*/
+	async collect(query, signal) {
+		const settled = await Promise.all(this.#providers.map(async (provider) => {
+			try {
+				return {
+					provider,
+					items: await provider.candidates(query, signal),
+					failure: void 0
+				};
+			} catch (error) {
+				return {
+					provider,
+					items: [],
+					failure: `${provider.id}: ${messageOf(error)}`
+				};
+			}
+		}));
+		if (signal.aborted) return {
+			groups: [],
+			failures: []
+		};
+		const groups = [];
+		const failures = [];
+		for (const entry of settled) {
+			if (entry.failure !== void 0) failures.push(entry.failure);
+			if (entry.items.length === 0) continue;
+			groups.push({
+				id: entry.provider.id,
+				label: entry.provider.label,
+				items: entry.items
+			});
+		}
+		return {
+			groups,
+			failures
+		};
+	}
+};
+/**
+* The sentence an `unknown` failure carries.
+* @param error - whatever was thrown.
+* @returns its message, or the value's own text.
+*/
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region lib/types/protocol.js
+/**
+* Shapes and routes both halves agree on.
+*
+* The browser half never imports the Host half's runtime values — only these
+* types and the small amount of shared protocol they carry — so this module must
+* stay free of `node:*` imports and of anything that only exists on one side.
+*
+* @module @free-lzj/dsh-browser-use/protocol
+*/
+/** Where the browser half asks for mention candidates. */
+const MENTIONS_PATH = "/dsh-browser-use/mentions";
+//#endregion
+//#region lib/types/routes.js
+/**
+* The HTTP surface the browser's `@` menu reads.
+*
+* One read-only route. `dsh-host-webserver` adds no middleware, body parsing or
+* origin policy of its own, so the same-origin guard is stated here by hand, and
+* the method is pinned: a menu lookup has no business writing anything.
+*
+* @module @free-lzj/dsh-browser-use/routes
+*/
+/**
+* Whether a request came from the page this server sent, so a document on
+* another origin cannot enumerate the user's tabs through their browser.
+* @param req - the incoming request.
+* @returns true when the request comes from this server's own page.
+*/
+function isSameOrigin(req) {
+	const site = req.headers["sec-fetch-site"];
+	if (typeof site === "string" && site !== "same-origin" && site !== "none") return false;
+	const origin = req.headers.origin;
+	if (typeof origin !== "string") return true;
+	try {
+		return new URL(origin).host === req.headers.host;
+	} catch {
+		return false;
+	}
+}
+/**
+* Answer one request with a JSON document.
+* @param res - the response to write.
+* @param status - HTTP status.
+* @param body - the document.
+*/
+function respond(res, status, body) {
+	const text = JSON.stringify(body);
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"content-length": Buffer.byteLength(text),
+		"cache-control": "no-store"
+	});
+	res.end(text);
+}
+/**
+* Mount the mention route.
+* @param ctx - the Host plugin context.
+* @param registry - providers to collect from.
+*/
+function registerRoutes(ctx, registry) {
+	ctx.inject(["webServer"], (inner) => {
+		inner.effect(() => inner.webServer.register({
+			kind: "exact",
+			path: MENTIONS_PATH,
+			handler: (req, res) => handleMentions(ctx, registry, req, res)
+		}), "browser-use.mentions-route");
+	});
+}
+/**
+* Answer one candidate request.
+* @param ctx - the Host plugin context, for logging.
+* @param registry - providers to collect from.
+* @param req - the incoming request.
+* @param res - the response to write.
+*/
+async function handleMentions(ctx, registry, req, res) {
+	if (!isSameOrigin(req)) {
+		respond(res, 403, { error: "cross-origin request refused" });
+		return;
+	}
+	if (req.method !== "GET") {
+		res.setHeader("allow", "GET");
+		respond(res, 405, { error: "method not allowed" });
+		return;
+	}
+	const query = new URL(req.url ?? "/", "http://localhost").searchParams.get("q") ?? "";
+	const abort = new AbortController();
+	res.on("close", () => {
+		abort.abort();
+	});
+	try {
+		const collected = await registry.collect(query, abort.signal);
+		for (const failure of collected.failures) ctx.logger.warn(`browser-use: provider failed: ${failure}`);
+		if (abort.signal.aborted) return;
+		respond(res, 200, {
+			groups: collected.groups,
+			...collected.failures.length === 0 ? {} : { failures: collected.failures }
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		ctx.logger.warn(`browser-use: mention lookup failed: ${message}`);
+		respond(res, 400, { error: message });
+	}
+}
+//#endregion
+//#region lib/types/skill.js
+/**
+* The browser skill, shipped inside the plugin.
+*
+* BrowserSkill's own MCP server already delivers a one-paragraph workflow in its
+* `initialize` instructions, but that text is a reminder, not a procedure: it
+* cannot say when to stop, what to do when refs go stale, or where the boundary
+* between the user's tabs and ours sits. Those rules live here so installing
+* this plugin is enough — the separate `browser-skill` agent skill is not needed.
+*
+* The body is written for this plugin against BrowserSkill's public CLI
+* contract; it is not a copy of upstream skill text.
+*
+* @module @free-lzj/dsh-browser-use/skill
+*/
+/** Kebab-case skill id; also the name the model calls. */
+const SKILL_NAME = "browser-use";
+/** The skill this plugin registers, so a separate skill install is unnecessary. */
+const BROWSER_SKILL = {
+	name: SKILL_NAME,
+	description: "操作用户已登录的真实浏览器（Chrome / Edge）：打开页面、读页面、点填、多标签、上传下载、控制台与网络诊断。用 @ 提及用户开着的标签页，或用 bsk_tabs 浏览。",
+	whenToUse: "用户要你去看一个网页、在他开着的浏览器里操作（登录态已就绪）、复现页面问题、抓取页面数据、验证部署页面，或 @ 了一个标签页时。需要新建独立浏览器、无登录态或纯本地 HTML 渲染时不要用。",
+	content: `# 操作用户自己的浏览器
+
+你驱动的是**用户那个已经登录的浏览器**（Chrome 或 Edge），不是无痕窗口。它带着用户真实的 cookie 和登录态——所以你不必、也不应该去登录任何东西。
+
+## 先看有哪些工具
+
+工具前缀 \`mcp__browser-skill__\`，按域分成六个：
+
+- \`bsk_session\` — \`start\` / \`stop\` / \`sync\`
+- \`bsk_page\` — \`navigate\` / \`reload\` / 前进后退 / 等待导航或元素
+- \`bsk_inspect\` — \`observe\` / \`snapshot\` / \`get-html\` / \`console\` / \`network\` / \`extract\`
+- \`bsk_interact\` — 点击、输入、按键、下拉、悬停、拖拽、滚轮、焦点、上传
+- \`bsk_tabs\` — 列出 / 新建 / 选中 / 关闭 / 借用 / 归还
+- \`bsk_assist\` — 请求用户帮忙、处理原生对话框
+
+每个工具的 \`action\` 参数决定具体动作，其余参数在工具 schema 里。
+
+## 一个任务的样子
+
+1. \`bsk_session\` 用 \`start\` 起一个会话（拿到 \`session_id\`，后续每次调用都带上它）。用户用 \`@\` 提过的标签页，直接用 \`bsk_tabs\` 的 \`borrow\` 借过来——\`@[标题](dsh-browser:数字)\` 里那串数字就是 tab id。
+2. \`bsk_session\` 的 \`sync\` 拿当前页面的语义结构（VOM 文本，控件带 \`@eN\` 引用）和 \`context_id\`。
+3. 要操作控件时，\`bsk_interact\` 用最新一次观察里的 \`@eN\`，并把 \`context_id\` 一起带上——协作保护要求"这次动作基于哪次观察"。
+4. 每次有意义的页面变化后重新 \`sync\`，再继续。
+5. **目标达成即 \`bsk_session\` \`stop\`**。别指望空闲超时替你收尾；停掉会话也会把借来的标签页还回去。
+
+## 观察的层次
+
+默认用 \`observe\`（语义结构，够日常交互）。不够时按这个顺序升级，不要一上来就抓 HTML：
+
+1. \`observe\` — 常规理解页面
+2. \`observe\` 带 \`probe-hover\` — 该出现却没出现的控件，通常是 hover 才显形的菜单
+3. \`snapshot\` — 需要更严格的无障碍树时
+4. \`get-html\` — 精确标记或隐藏元数据
+5. \`console\` / \`network\` — 调试证据，只读
+6. \`extract\` — 已加载的表格/列表，带列定义
+7. \`screenshot\` — 只有布局、样式、canvas、图片这类观察文本表达不了的东西才用它
+
+## 两个会咬人的边界
+
+**用户标签页**：\`bsk_tabs\` 列出的 \`scope: user\` 是用户自己的标签页，\`scope: agent\` 是我们在 Agent Window 里开的。默认只动 agent 的那几个；要动用户的，先 \`borrow\`，用完立刻 \`return\`。别凭空编 tab id，也别在一次不相关的任务里一直占着它。
+
+**引用会失效**：导航、重新渲染、大面积 DOM 变化都会让 \`@eN\` 作废。拿不准就重新 \`sync\` 一次——这比猜一个旧引用去点错地方便宜得多。
+
+## 需要人来做的事
+
+登录、验证码、短信码、支付确认、第三方授权——这些不该由你硬试。用 \`bsk_assist\` 的 \`request_help\` 把请求和页面位置说清楚，等用户做完再继续。连试两次没有进展就转人工，不要反复重放同一个失败动作。
+
+## 失败时怎么走
+
+- 引用失效：重新 \`sync\`，重试一次原动作。
+- 找不到控件：先确认是不是 hover 才显形，再降级到 \`snapshot\` 或 \`get-html\`。
+- 超时：先看当前页面状态，再决定要不要等更久；不要连续加长超时。
+- 输入框的值和你要的不一样（页面做了格式化）：看实际值是否可接受，别盲目重填。
+- 无法恢复：说清卡在哪，然后 \`stop\` 会话。
+
+## 不要做的事
+
+- 不要把 cookie、token、密码从页面里读出来。
+- 不要在用户没要求时操作他的标签页。
+- 不要在任务结束后留着会话和借用的标签页。`,
+	source: "bundled"
+};
+//#endregion
+//#region lib/types/index.js
+/**
+* Browser use for DSH — Host half.
+*
+* Two halves of one idea, and they are deliberately different in kind:
+*
+* - **Mentioning** is ours. Nothing in the harness lists what a person has open,
+*   so this plugin contributes that: a provider registry, one read-only route,
+*   and a browser provider on top of `bsk tab list`.
+* - **Operating** is BrowserSkill's. Its CLI already ships an MCP server with the
+*   full action set, and the harness already knows how to give one MCP server to
+*   one Session — `mountSessionMcp` is what the official Chrome DevTools and
+*   Playwright providers use. Rebuilding those tools here would mean shipping a
+*   copy that drifts from upstream on every release.
+*
+* The skill body travels with the plugin for the same reason: installing this is
+* meant to be enough, so the separate `browser-skill` agent skill is not needed.
+*
+* @module @free-lzj/dsh-browser-use
+*/
+/**
+* MCP server name; every tool this plugin contributes is `mcp__<name>__*`.
+*
+* Not `bsk` and not `browser`: the name is a namespace the model reads on every
+* call, so it should say whose tools these are and never collide with a server
+* the person wired up themselves.
+*/
+const MCP_SERVER_NAME = "browser-skill";
+/**
+* The `bsk` executable.
+*
+* An override exists because a machine can have a stale global install next to
+* the one the extension pairs with, and the wrong one fails as an opaque
+* transport error rather than as "wrong binary".
+*/
+function bskCommand() {
+	return process.env["DSH_BSK_PATH"] ?? "bsk";
+}
+/**
+* Mount BrowserSkill's MCP server once, for the whole Host.
+*
+* The harness's experimental browser-use runtime would mount one server per
+* Session, but it ships outside the dsh installation and needs a provider
+* registry (`ctx.browserUse`) that not every profile carries. This plugin mounts
+* one server instead: every Agent sees `mcp__browser-skill__*`, and the cost is
+* that two Sessions driving the browser at once share a single BrowserSkill
+* session — and therefore one Agent Window. For one person in one conversation
+* that is the honest trade; a per-Session server would need the runtime package.
+* @param ctx - the Host plugin context.
+*/
+function mountBrowserTools(ctx) {
+	ctx.inject(["tools", "systemPrompt"], (inner) => {
+		try {
+			inner.plugin(McpClient, McpClient.Config({
+				transport: "stdio",
+				serverName: MCP_SERVER_NAME,
+				command: bskCommand(),
+				args: ["mcp"],
+				failOnStartupError: false,
+				reconnect: { enabled: false }
+			}));
+			inner.logger.info(`browser-use: browser tools mounted as mcp__${MCP_SERVER_NAME}__*`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			inner.logger.warn(`browser-use: could not mount the browser MCP server: ${message}`);
+		}
+	});
+}
+/**
+* Register the skill body that makes a separate `browser-skill` install unnecessary.
+* @param ctx - the Host plugin context.
+*/
+function registerSkill(ctx) {
+	ctx.inject(["skills"], (inner) => {
+		inner.effect(() => inner.skills.register(BROWSER_SKILL), "browser-use: bundled skill");
+		inner.logger.info(`browser-use: skill "${BROWSER_SKILL.name}" registered`);
+	});
+}
+/**
+* Mount the mention route, the provider, the bundled skill, and the browser tools.
+* @param ctx - the Host plugin context.
+*/
+function apply(ctx) {
+	const tabs = new BskMcpChannel();
+	const registry = new MentionRegistry();
+	ctx.effect(() => registry.register(browserMentionProvider(tabs)), "browser-use: browser provider");
+	registerRoutes(ctx, registry);
+	ctx.effect(() => () => {
+		tabs.dispose();
+	}, "browser-use: bsk mcp channel");
+	mountBrowserTools(ctx);
+	registerSkill(ctx);
+	ctx.logger.info("browser-use: mounted");
+}
+//#endregion
+export { BROWSER_SKILL, BskMcpChannel, MCP_SERVER_NAME, MENTIONS_PATH, MentionRegistry, SKILL_NAME, apply, browserMentionProvider, isSameOrigin, mountBrowserTools, registerRoutes, registerSkill, respond };
+
+//# sourceMappingURL=index.js.map