@opentiny/webmcp-cli 0.1.1-alpha.1 → 0.1.1

package/dist/bin.js

@@ -1,192 +1,13 @@
 #!/usr/bin/env node
-
-// src/bin.ts
-import fs2 from "fs";
-import path2 from "path";
-import os2 from "os";
-import { Command } from "commander";
-import pc2 from "picocolors";
-import { readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
-
-// src/expand-file-refs.ts
-import { readFileSync } from "fs";
-import { dirname, isAbsolute, normalize, resolve } from "path";
-import { fileURLToPath } from "url";
-var JSON_STRING_LITERAL = /"(?:[^"\\]|\\.)*"/g;
-var UNQUOTED_FILE_REF = /(?<![\\"])@(base64)?file:([^\s"',}\]]+)/g;
-var FILE_REF_PREFIX = /^@(base64)?file:(.+)$/s;
-function resolveFilePath(filePath, baseDir = process.cwd()) {
-  let normalizedPath = filePath.trim();
-  if (normalizedPath.startsWith('"') && normalizedPath.endsWith('"') || normalizedPath.startsWith("'") && normalizedPath.endsWith("'")) {
-    normalizedPath = normalizedPath.slice(1, -1).trim();
-  }
-  if (normalizedPath.startsWith("file://")) {
-    normalizedPath = fileURLToPath(normalizedPath);
-  }
-  if (isAbsolute(normalizedPath)) {
-    return normalize(normalizedPath);
-  }
-  return resolve(baseDir, normalizedPath);
-}
-function decodeFilePath(rawPath) {
-  return rawPath.replace(/\\\\/g, "\\");
-}
-function readFileRefContent(filePath, baseDir, base64) {
-  const absPath = resolveFilePath(filePath, baseDir);
-  let content;
-  try {
-    content = readFileSync(absPath, "utf-8");
-  } catch (e) {
-    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6\u5F15\u7528 "${filePath}" (${absPath}): ${e.message}`);
-  }
-  return base64 ? Buffer.from(content, "utf-8").toString("base64") : content;
-}
-function expandFileRefValue(rawInner, baseDir) {
-  const match = rawInner.match(FILE_REF_PREFIX);
-  if (!match) {
-    return null;
-  }
-  const [, base64Flag, rawPath] = match;
-  const filePath = decodeFilePath(rawPath);
-  const value = readFileRefContent(filePath, baseDir, Boolean(base64Flag));
-  return JSON.stringify(value);
-}
-function expandQuotedFileRefs(argsJson, baseDir) {
-  return argsJson.replace(JSON_STRING_LITERAL, (jsonStringLiteral) => {
-    const rawInner = jsonStringLiteral.slice(1, -1);
-    const replacement = expandFileRefValue(rawInner, baseDir);
-    return replacement ?? jsonStringLiteral;
-  });
-}
-function expandUnquotedFileRefs(argsJson, baseDir) {
-  return argsJson.replace(UNQUOTED_FILE_REF, (match, base64Flag, filePath) => {
-    const value = readFileRefContent(filePath, baseDir, Boolean(base64Flag));
-    return JSON.stringify(value);
-  });
-}
-function expandFileRefs(argsJson, baseDir = process.cwd()) {
-  const withQuotedExpanded = expandQuotedFileRefs(argsJson, baseDir);
-  return expandUnquotedFileRefs(withQuotedExpanded, baseDir);
-}
-function getFileBaseDir(fileOption) {
-  if (!fileOption) {
-    return process.cwd();
-  }
-  return dirname(resolve(process.cwd(), fileOption));
-}
-
-// src/parse-run-args.ts
-import JSON5 from "json5";
-function cleanJsonString(str) {
-  let cleaned = str.trim();
-  if (cleaned.startsWith("'") && cleaned.endsWith("'")) {
-    cleaned = cleaned.slice(1, -1).trim();
-  }
-  return cleaned;
-}
-function looksLikeObjectBody(raw) {
-  return /^("?[\w-]+"?\s*:)/.test(raw);
-}
-function joinShellArgs(args) {
-  const cleaned = args.map(cleanJsonString);
-  const first = cleaned[0] ?? "";
-  if (first.startsWith("{")) {
-    return cleaned.join(" ");
-  }
-  if (looksLikeObjectBody(first)) {
-    let joined = cleaned.join(" ");
-    if (!joined.startsWith("{")) {
-      joined = `{${joined}}`;
-    }
-    if (!joined.endsWith("}")) {
-      joined = `${joined}}`;
-    }
-    return joined;
-  }
-  return cleaned.join(" ");
-}
-function insertMissingCommas(raw) {
-  return raw.replace(/"(\s+)("?[\w-]+"?\s*:)/g, '",$2');
-}
-function quoteUnquotedStringValues(raw) {
-  return raw.replace(
-    /([{,]\s*(?:"([^"]+)"|([\w-]+))\s*:\s*)(?!"@(?:base64)?file:|"|true|false|null|-?\d|\{|\[)([^",}\]]+?)(?=\s*[,}])/g,
-    (_match, prefix, _quotedKey, _unquotedKey, value) => {
-      const trimmed = value.trim();
-      if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(trimmed)) {
-        return prefix + trimmed;
-      }
-      return prefix + JSON.stringify(trimmed);
-    }
-  );
-}
-function normalizeShellDamagedJson(raw) {
-  let normalized = raw.trim();
-  normalized = insertMissingCommas(normalized);
-  normalized = quoteUnquotedStringValues(normalized);
-  return normalized;
-}
-function buildArgsFromKeyValuePairs(args) {
-  const obj = {};
-  for (const pair of args) {
-    const index = pair.indexOf("=");
-    if (index === -1) {
-      throw new Error(`\u65E0\u6548\u7684\u53C2\u6570\u683C\u5F0F "${pair}"\u3002\u8BF7\u4F7F\u7528 key=value\uFF0C\u6216 JSON / -f \u6587\u4EF6\u3002`);
-    }
-    const key = pair.substring(0, index).trim();
-    let val = cleanJsonString(pair.substring(index + 1).trim());
-    try {
-      obj[key] = JSON.parse(val);
-    } catch {
-      obj[key] = val;
-    }
-  }
-  return JSON.stringify(obj);
-}
-function parseArgsJson(raw) {
-  const trimmed = cleanJsonString(raw);
-  try {
-    return JSON.stringify(JSON5.parse(trimmed));
-  } catch (firstError) {
-    const repaired = normalizeShellDamagedJson(trimmed);
-    try {
-      return JSON.stringify(JSON5.parse(repaired));
-    } catch {
-      const hint = `\u63D0\u793A\uFF1Abash \u4E2D JSON \u5FC5\u987B\u7528\u5355\u5F15\u53F7\u5305\u88F9\uFF0C\u4F8B\u5982 '{"title":"\u6807\u9898","content":"@base64file:./article.md"}'\uFF1B\u6216\u4F7F\u7528 key=value\uFF1Atitle=\u6807\u9898 content=@base64file:./article.md\uFF1B\u6216\u4F7F\u7528 -f args.json\u3002`;
-      const message = firstError instanceof Error ? firstError.message : String(firstError);
-      throw new Error(`\u53C2\u6570\u4E0D\u662F\u6709\u6548\u7684 JSON \u6216 JS \u5BF9\u8C61: ${message}
-${hint}`);
-    }
-  }
-}
-function prepareRunArgsJson(args, fileContent, baseDir) {
-  if (fileContent !== void 0) {
-    const trimmed = fileContent.trim();
-    if (!trimmed) {
-      throw new Error("\u901A\u8FC7 -f/--file \u6307\u5B9A\u7684\u53C2\u6570\u6587\u4EF6\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A");
-    }
-    const expanded2 = expandFileRefs(trimmed, baseDir);
-    return parseArgsJson(expanded2);
-  }
-  if (args.length === 0) {
-    return "{}";
-  }
-  const joined = joinShellArgs(args);
-  let raw = "";
-  if (joined.startsWith("{") || looksLikeObjectBody(joined)) {
-    raw = joined;
-  } else if (args.every((arg) => arg.includes("="))) {
-    raw = buildArgsFromKeyValuePairs(args);
-  } else {
-    raw = joined;
-  }
-  if (!raw.trim()) {
-    throw new Error("\u672A\u63D0\u4F9B\u6709\u6548\u53C2\u6570");
-  }
-  const expanded = expandFileRefs(raw, baseDir);
-  return parseArgsJson(expanded);
-}
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/browser.ts
 import puppeteer from "puppeteer-core";
@@ -197,8 +18,6 @@ import path from "path";
 import http from "http";
 import { spawn } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path.dirname(__filename);
 function getCdpPort() {
   const raw = process.env.WEBMCP_CDP_PORT;
   if (raw) {
@@ -214,6 +33,38 @@ function shouldLaunchHeadless() {
   if (process.env.WEBMCP_HEADLESS === "0") return false;
   return process.env.WEBMCP_HEADLESS === "1" || process.env.CI === "true" || process.env.CI === "1";
 }
+function shouldIgnoreCertificateErrors() {
+  return process.env.WEBMCP_IGNORE_CERTIFICATE_ERRORS === "1";
+}
+function buildChromeLaunchArgs(input) {
+  const launchArgs = [
+    `--remote-debugging-port=${input.cdpPort}`,
+    `--user-data-dir=${input.userDataDir}`,
+    "--no-first-run",
+    "--no-default-browser-check"
+  ];
+  if (input.headless) {
+    launchArgs.push(
+      "--headless=new",
+      "--no-sandbox",
+      "--disable-setuid-sandbox",
+      "--disable-gpu",
+      "--disable-dev-shm-usage"
+    );
+  }
+  const ignoreCertificateErrors = input.ignoreCertificateErrors ?? shouldIgnoreCertificateErrors();
+  if (ignoreCertificateErrors) {
+    launchArgs.push("--ignore-certificate-errors");
+  }
+  return launchArgs;
+}
+function buildPuppeteerConnectOptions(browserBaseUrl) {
+  return {
+    browserURL: browserBaseUrl,
+    defaultViewport: null,
+    ...shouldIgnoreCertificateErrors() ? { ignoreHTTPSErrors: true } : {}
+  };
+}
 function readActivePortFromProfile(userDataDir) {
   try {
     const content = fs.readFileSync(path.join(userDataDir, "DevToolsActivePort"), "utf-8");
@@ -308,7 +159,7 @@ async function findAvailableCdpUrl(addresses, retries = 2) {
 async function connectPuppeteer(browserBaseUrl, attempt = 1, maxAttempts = 3) {
   try {
     return await promiseWithTimeout(
-      puppeteer.connect({ browserURL: browserBaseUrl, defaultViewport: null }),
+      puppeteer.connect(buildPuppeteerConnectOptions(browserBaseUrl)),
       1e4,
       `puppeteer.connect to ${browserBaseUrl} timed out`
     );
@@ -383,21 +234,11 @@ async function startBrowserInBackground() {
     fs.unlinkSync(path.join(userDataDir, "DevToolsActivePort"));
   } catch {
   }
-  const launchArgs = [
-    `--remote-debugging-port=${cdpPort}`,
-    `--user-data-dir=${userDataDir}`,
-    "--no-first-run",
-    "--no-default-browser-check"
-  ];
-  if (shouldLaunchHeadless()) {
-    launchArgs.push(
-      "--headless=new",
-      "--no-sandbox",
-      "--disable-setuid-sandbox",
-      "--disable-gpu",
-      "--disable-dev-shm-usage"
-    );
-  }
+  const launchArgs = buildChromeLaunchArgs({
+    cdpPort,
+    userDataDir,
+    headless: shouldLaunchHeadless()
+  });
   const child = spawn(
     browserInfo.path,
     launchArgs,
@@ -522,156 +363,3446 @@ async function activateTabById(browser, tabid) {
     });
   }
 }
-async function getTargetPage(browser, tabid) {
-  const pageTargets = getPageTargets(browser);
-  if (pageTargets.length === 0) {
-    const newPage = await browser.newPage();
-    await injectWebMCPPolyfillAndTools(newPage);
-    return newPage;
+async function getTargetPage(browser, tabid) {
+  const pageTargets = getPageTargets(browser);
+  if (pageTargets.length === 0) {
+    const newPage = await browser.newPage();
+    await injectWebMCPPolyfillAndTools(newPage);
+    return newPage;
+  }
+  let targetPage = null;
+  if (tabid !== void 0) {
+    const target = findPageTargetByTabId(browser, tabid);
+    if (!target) {
+      throw new Error(`Tab with targetId "${tabid}" not found.`);
+    }
+    targetPage = await target.page();
+  } else {
+    const lastTabId = getLastActiveTabId();
+    if (lastTabId) {
+      const lastTarget = findPageTargetByTabId(browser, lastTabId);
+      if (lastTarget) {
+        targetPage = await lastTarget.page();
+      }
+    }
+    if (!targetPage) {
+      try {
+        const workspaceDir = getWorkspaceDir();
+        const cdpPort = getCdpPort();
+        const recordedPort = readActivePortFromProfile(workspaceDir);
+        const ports = recordedPort && recordedPort !== cdpPort ? [recordedPort, cdpPort] : [cdpPort];
+        const urls = ports.flatMap((port) => candidateCdpBaseUrls(port).map((u) => `${u}/json/list`));
+        let activeTargetId = null;
+        for (const url of urls) {
+          try {
+            const body = await httpGet(url, 1e3);
+            const targetsData = JSON.parse(body);
+            const active = targetsData.find((t) => t.type === "page" && !t.url.startsWith("devtools://"));
+            if (active) {
+              activeTargetId = active.id;
+              break;
+            }
+          } catch {
+          }
+        }
+        if (activeTargetId) {
+          for (const target of pageTargets) {
+            if (getTargetIdFromTarget(target) === activeTargetId) {
+              targetPage = await target.page();
+              break;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    if (!targetPage) {
+      const lastTarget = pageTargets[pageTargets.length - 1];
+      targetPage = await lastTarget.page();
+    }
+  }
+  if (!targetPage) {
+    throw new Error("\u65E0\u6CD5\u83B7\u53D6\u76EE\u6807\u9875\u9762");
+  }
+  await injectWebMCPPolyfillAndTools(targetPage);
+  return targetPage;
+}
+async function injectIntoPage(page) {
+  await injectWebMCPPolyfillAndTools(page);
+}
+async function injectWebMCPPolyfillAndTools(page) {
+  const polyfillReady = await page.evaluate(() => {
+    return !!window.__webmcpcli_init;
+  }).catch(() => false);
+  if (!polyfillReady) {
+    console.log(pc.cyan("\u5F53\u524D\u9875\u9762\u5C1A\u672A\u6CE8\u5165 WebMCP \u73AF\u5883\uFF0C\u6B63\u5728\u6267\u884C\u81EA\u52A8\u6CE8\u5165..."));
+    const injectScriptPath = path.resolve(__dirname, "inject-bundle.js");
+    if (!fs.existsSync(injectScriptPath)) {
+      throw new Error(`Cannot find inject-bundle.js at ${injectScriptPath}. Please ensure you run 'pnpm build:inject' first.`);
+    }
+    const scriptContent = fs.readFileSync(injectScriptPath, "utf-8");
+    try {
+      await page.evaluate(scriptContent);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error("\u81EA\u52A8\u6CE8\u5165\u811A\u672C\u6267\u884C\u5931\u8D25: " + msg);
+    }
+    await page.waitForFunction(() => {
+      const mcp = navigator.modelContext;
+      return mcp && typeof mcp.registerTool === "function";
+    }, { timeout: 1e4 }).catch(() => {
+      console.warn("\u7B49\u5F85 WebMCP registerTool \u63A5\u53E3\u5C31\u7EEA\u8D85\u65F6\uFF0C\u6B63\u5728\u7EE7\u7EED\u6CE8\u5165...");
+    });
+  }
+  await injectDomainTools(page);
+}
+function getToolsBundleName(hostname) {
+  const normalized = hostname.split(":")[0].toLowerCase();
+  const toolsDir = path.resolve(__dirname, "webmcp-tools");
+  if (!fs.existsSync(toolsDir)) {
+    return null;
+  }
+  let files = [];
+  try {
+    files = fs.readdirSync(toolsDir);
+  } catch {
+    return null;
+  }
+  const supportedDomains = files.filter((f) => f.endsWith(".js")).map((f) => f.slice(0, -3));
+  if (supportedDomains.includes(normalized)) {
+    return `webmcp-tools/${normalized}.js`;
+  }
+  for (const domain of supportedDomains) {
+    if (normalized.endsWith("." + domain)) {
+      return `webmcp-tools/${domain}.js`;
+    }
+  }
+  return null;
+}
+async function injectDomainTools(page) {
+  let hostname;
+  try {
+    const url = new URL(page.url());
+    hostname = url.hostname;
+  } catch {
+    return;
+  }
+  const bundleName = getToolsBundleName(hostname);
+  if (!bundleName) {
+    return;
+  }
+  const toolBundlePath = path.resolve(__dirname, bundleName);
+  if (!fs.existsSync(toolBundlePath)) {
+    return;
+  }
+  const bundleKey = bundleName.replace(/^webmcp-tools\//, "").replace(/\.js$/, "");
+  const flagKey = `__webmcptools_${bundleKey.replace(/[^a-zA-Z0-9]/g, "")}`;
+  const alreadyInjected = await page.evaluate((key) => !!window[key], flagKey).catch(() => false);
+  if (alreadyInjected) {
+    return;
+  }
+  console.log(pc.cyan(`\u68C0\u6D4B\u5230\u57DF\u540D ${hostname} \u6709\u9884\u7F6E\u5DE5\u5177\uFF0C\u6B63\u5728\u6CE8\u5165...`));
+  const toolScript = fs.readFileSync(toolBundlePath, "utf-8");
+  try {
+    await page.evaluate(toolScript);
+    console.log(pc.green(`\u5DF2\u4E3A ${hostname} \u6CE8\u5165\u9884\u7F6E\u5DE5\u5177`));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(pc.yellow(`\u57DF\u540D\u5DE5\u5177\u6CE8\u5165\u5931\u8D25 (${hostname}): ${msg}`));
+  }
+}
+var __filename, __dirname;
+var init_browser = __esm({
+  "src/browser.ts"() {
+    "use strict";
+    __filename = fileURLToPath2(import.meta.url);
+    __dirname = path.dirname(__filename);
+  }
+});
+
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "@opentiny/webmcp-cli",
+      version: "0.1.1",
+      type: "module",
+      description: "WebMCP CLI for AI Agents to interact with browser via Puppeteer",
+      repository: {
+        type: "git",
+        url: "git+https://github.com/opentiny/webmcp-sdk.git",
+        directory: "packages/webmcp-cli"
+      },
+      bugs: {
+        url: "https://github.com/opentiny/webmcp-sdk/issues"
+      },
+      main: "dist/index.js",
+      types: "dist/index.d.ts",
+      bin: {
+        "webmcp-cli": "./dist/bin.js"
+      },
+      files: [
+        "dist",
+        "README.md",
+        "scripts/ensure-pty-helper.mjs"
+      ],
+      scripts: {
+        dev: "tsup --watch",
+        "build:inject": "node scripts/build-inject.mjs",
+        build: "tsup && pnpm run build:inject",
+        prepublishOnly: "pnpm run build",
+        "link:global": "npm install -g .",
+        start: "node dist/bin.js",
+        postinstall: "node scripts/ensure-pty-helper.mjs",
+        test: "vitest run",
+        "test:watch": "vitest",
+        "test:browser": "vitest run --config vitest.e2e.config.ts"
+      },
+      keywords: [
+        "chrome",
+        "puppeteer",
+        "cli"
+      ],
+      license: "MIT",
+      author: "OpenTiny Team",
+      engines: {
+        node: ">=18.19.0"
+      },
+      publishConfig: {
+        access: "public"
+      },
+      dependencies: {
+        "@mcp-b/webmcp-polyfill": "catalog:",
+        "@modelcontextprotocol/sdk": "catalog:",
+        "@opentiny/next-sdk": "workspace:^",
+        "@page-agent/page-controller": "catalog:",
+        clipboardy: "^5.3.1",
+        commander: "^11.1.0",
+        execa: "^9.6.1",
+        json5: "^2.2.3",
+        marked: "^15.0.7",
+        picocolors: "^1.0.0",
+        "puppeteer-core": "^22.0.0",
+        ws: "^8.18.0",
+        zod: "^3.23.0"
+      },
+      optionalDependencies: {
+        "node-pty": "^1.1.0"
+      },
+      devDependencies: {
+        "@types/node": "^20.0.0",
+        "@types/ws": "^8.5.10",
+        esbuild: "^0.25.0",
+        tsup: "^8.0.2",
+        tsx: "^4.0.0",
+        typescript: "^5.3.3",
+        vitest: "^4.1.10"
+      }
+    };
+  }
+});
+
+// src/mcp/tools.ts
+import { z } from "zod";
+var BrowserStateInput, BrowserToolCallInput, BrowserTabsOpenInput, BrowserTabsCloseInput, BrowserTabsSwitchInput, BrowserTabsNavInput, BrowserSubAgentRunInput, BrowserSkillsListInput, BrowserSkillsReadInput;
+var init_tools = __esm({
+  "src/mcp/tools.ts"() {
+    "use strict";
+    BrowserStateInput = z.object({
+      tabId: z.union([z.string(), z.number()]).optional().describe(
+        "\u76EE\u6807 tab ID\u3002CDP \u6A21\u5F0F\u4E3A target UUID \u5B57\u7B26\u4E32\uFF1BWXT \u6A21\u5F0F\u4E3A Chrome tab ID \u6570\u503C\u3002\u4E0D\u4F20\u65F6\u4F7F\u7528\u5F53\u524D\u6D3B\u8DC3 tab\u3002"
+      )
+    });
+    BrowserToolCallInput = z.object({
+      toolName: z.string().describe("\u9875\u9762 WebMCP \u5DE5\u5177\u540D\u79F0\uFF08\u53EF\u4ECE browser_state \u8FD4\u56DE\u7684 webmcpTools \u5217\u8868\u4E2D\u83B7\u53D6\uFF09"),
+      toolArgs: z.record(z.unknown()).optional().describe("\u5DE5\u5177\u53C2\u6570\uFF0C\u4E0E\u5DE5\u5177\u7684 inputSchema \u5BF9\u9F50"),
+      tabId: z.union([z.string(), z.number()]).optional().describe("\u76EE\u6807 tab ID\uFF0C\u4E0D\u4F20\u65F6\u4F7F\u7528\u5F53\u524D\u6D3B\u8DC3 tab")
+    });
+    BrowserTabsOpenInput = z.object({
+      url: z.string().url().refine((val) => /^https?:\/\//i.test(val), { message: "\u53EA\u5141\u8BB8\u6253\u5F00 http \u6216 https \u534F\u8BAE\u7684 URL" }).describe("\u8981\u6253\u5F00\u7684 URL\uFF08\u4EC5\u652F\u6301 http/https \u534F\u8BAE\uFF09")
+    });
+    BrowserTabsCloseInput = z.object({
+      tabId: z.union([z.string(), z.number()]).optional().describe(
+        "\u8981\u5173\u95ED\u7684 tab ID\uFF0C\u4E0D\u4F20\u65F6\u5173\u95ED\u5F53\u524D\u6D3B\u8DC3 tab"
+      )
+    });
+    BrowserTabsSwitchInput = z.object({
+      tabId: z.union([z.string(), z.number()]).describe(
+        "\u8981\u5207\u6362\u5230\u7684 tab ID\uFF08\u53EF\u4ECE browser_state \u8FD4\u56DE\u7684 tabs \u5217\u8868\u4E2D\u83B7\u53D6\uFF09"
+      ),
+      activateVisible: z.boolean().optional().describe("\u662F\u5426\u5728\u524D\u53F0\u663E\u5F0F\u5207\u6362 Chrome \u53EF\u89C1\u6D3B\u52A8\u6807\u7B7E\uFF08\u4EC5 WXT \u6A21\u5F0F\u6709\u6548\uFF0C\u9ED8\u8BA4 false\uFF09")
+    });
+    BrowserTabsNavInput = z.object({
+      tabId: z.union([z.string(), z.number()]).optional().describe("\u76EE\u6807 tab ID\uFF0C\u4E0D\u4F20\u65F6\u4F7F\u7528\u5F53\u524D\u6D3B\u8DC3 tab")
+    });
+    BrowserSubAgentRunInput = z.object({
+      instruction: z.string().describe("\u8981\u59D4\u6258\u7ED9 Tiny Robot \u5B50\u4EE3\u7406\u6267\u884C\u7684\u9AD8\u5C42\u81EA\u7136\u8BED\u8A00\u4EFB\u52A1\u6307\u4EE4"),
+      tabId: z.number().optional().describe("\u76EE\u6807 tab ID\uFF0C\u4E0D\u4F20\u65F6\u4F7F\u7528\u5F53\u524D\u6D3B\u8DC3 tab"),
+      maxSteps: z.number().min(1).max(20).optional().describe("\u6700\u5927\u81EA\u4E3B\u89C4\u5212\u6267\u884C\u6B65\u6570\uFF08\u9ED8\u8BA4 8\uFF0C\u6700\u5927 20\uFF09")
+    });
+    BrowserSkillsListInput = z.object({}).describe("\u83B7\u53D6\u5F53\u524D\u6D4F\u89C8\u5668\u6269\u5C55\u4E2D\u5DF2\u6CE8\u518C\u7684\u6240\u6709 Skills \u6280\u80FD\u5143\u6570\u636E\u5217\u8868");
+    BrowserSkillsReadInput = z.object({
+      name: z.string().describe("\u8981\u8BFB\u53D6\u7684\u6280\u80FD\u540D\u79F0\uFF08\u53EF\u4ECE browser_skills_list \u8FD4\u56DE\u7684\u5217\u8868\u4E2D\u83B7\u53D6\uFF09")
+    });
+  }
+});
+
+// src/adapters/cdp-adapter.ts
+var cdp_adapter_exports = {};
+__export(cdp_adapter_exports, {
+  CdpBrowserAdapter: () => CdpBrowserAdapter
+});
+var CdpBrowserAdapter;
+var init_cdp_adapter = __esm({
+  "src/adapters/cdp-adapter.ts"() {
+    "use strict";
+    init_browser();
+    CdpBrowserAdapter = class {
+      browser = null;
+      async getBrowser() {
+        if (!this.browser) {
+          this.browser = await connectBrowser();
+        }
+        return this.browser;
+      }
+      async getState(tabId) {
+        const browser = await this.getBrowser();
+        const tabIdStr = tabId != null ? String(tabId) : void 0;
+        const page = await getTargetPage(browser, tabIdStr);
+        await injectIntoPage(page);
+        const state = await page.evaluate(async () => {
+          const url = document.URL;
+          const title = document.title;
+          const mcp = document.modelContext || navigator.modelContext;
+          let webmcpTools = [];
+          if (mcp && typeof mcp.getTools === "function") {
+            try {
+              const toolsResult = await mcp.getTools();
+              const list = toolsResult?.tools || toolsResult || [];
+              webmcpTools = list.filter((t) => t && typeof t.name === "string").map((t) => ({
+                name: t.name,
+                description: typeof t.description === "string" ? t.description.slice(0, 200) : void 0
+              }));
+            } catch {
+              webmcpTools = [];
+            }
+          }
+          return { url, title, webmcpTools };
+        });
+        const activeTabId = await getPageTargetId(page).catch(() => null);
+        const pages = await browser.pages();
+        const tabs2 = await Promise.all(
+          pages.map(async (p) => {
+            const pUrl = p.url();
+            if (pUrl.startsWith("devtools://")) return null;
+            const pTitle = await Promise.race([
+              p.title().catch(() => "Unknown"),
+              new Promise((resolve3) => setTimeout(() => resolve3("Unknown"), 500))
+            ]);
+            return {
+              tabId: await getPageTargetId(p).catch(() => pUrl),
+              title: pTitle,
+              url: pUrl
+            };
+          })
+        );
+        return {
+          ...state,
+          activeTabId: activeTabId ?? void 0,
+          tabs: tabs2.filter(Boolean)
+        };
+      }
+      async callTool(toolName, args, tabId) {
+        const browser = await this.getBrowser();
+        const tabIdStr = tabId != null ? String(tabId) : void 0;
+        const page = await getTargetPage(browser, tabIdStr);
+        const urlBefore = page.url();
+        await injectIntoPage(page);
+        const argsJson = JSON.stringify(args);
+        try {
+          const result = await page.evaluate(
+            async (name, inputString) => {
+              const mcp = document.modelContext || navigator.modelContext;
+              if (!mcp || typeof mcp.executeTool !== "function") {
+                throw new Error("\u5F53\u524D\u9875\u9762\u6CA1\u6709\u6CE8\u5165 WebMCP \u73AF\u5883 (document.modelContext \u672A\u627E\u5230)");
+              }
+              const tools = await mcp.getTools();
+              const toolObj = tools.find((t) => t.name === name);
+              if (!toolObj) throw new Error(`Tool ${name} not found`);
+              let res = await mcp.executeTool(toolObj, inputString);
+              if (typeof res === "string") {
+                try {
+                  res = JSON.parse(res);
+                } catch {
+                }
+              }
+              if (res === void 0 || res === null) {
+                throw new Error("\u5DE5\u5177 execute \u672A\u8FD4\u56DE\u7ED3\u679C");
+              }
+              if (typeof res === "object" && res.success === false) {
+                const failed = res;
+                throw new Error(failed.error || failed.message || "\u5DE5\u5177\u6267\u884C\u5931\u8D25");
+              }
+              return res;
+            },
+            toolName,
+            argsJson
+          );
+          return result;
+        } catch (evalError) {
+          const errMsg = evalError instanceof Error ? evalError.message : String(evalError);
+          const isContextDestroyed = errMsg.includes("context was destroyed") || errMsg.includes("Execution context was destroyed") || errMsg.includes("Cannot read properties of null") && errMsg.includes("context");
+          if (isContextDestroyed) {
+            await new Promise((resolve3) => setTimeout(resolve3, 800));
+            const newUrl = page.url();
+            if (newUrl && newUrl !== urlBefore) {
+              return { success: true, message: `\u5DE5\u5177 ${toolName} \u6267\u884C\u5B8C\u6210\uFF0C\u9875\u9762\u5DF2\u5BFC\u822A\u81F3 ${newUrl}`, navigatedTo: newUrl };
+            }
+          }
+          throw evalError;
+        }
+      }
+      async tabs(action, options) {
+        const browser = await this.getBrowser();
+        const tabIdStr = options.tabId != null ? String(options.tabId) : void 0;
+        switch (action) {
+          case "open": {
+            if (!options.url) throw new Error("tabs open \u9700\u8981 url \u53C2\u6570");
+            const page = await browser.newPage();
+            await page.goto(options.url);
+            await injectIntoPage(page);
+            const tabId = await getPageTargetId(page);
+            setLastActiveTabId(tabId);
+            return { success: true, tabId, url: options.url };
+          }
+          case "close": {
+            const page = await getTargetPage(browser, tabIdStr);
+            await page.close();
+            return { success: true };
+          }
+          case "switch": {
+            if (!tabIdStr) throw new Error("tabs switch \u9700\u8981 tabId \u53C2\u6570");
+            await activateTabById(browser, tabIdStr);
+            setLastActiveTabId(tabIdStr);
+            return { success: true, tabId: tabIdStr };
+          }
+          case "back": {
+            const page = await getTargetPage(browser, tabIdStr);
+            await page.goBack();
+            return { success: true };
+          }
+          case "forward": {
+            const page = await getTargetPage(browser, tabIdStr);
+            await page.goForward();
+            return { success: true };
+          }
+        }
+      }
+      async dispose() {
+        if (this.browser) {
+          await this.browser.disconnect().catch(() => {
+          });
+          this.browser = null;
+        }
+      }
+    };
+  }
+});
+
+// src/bridge/protocol.ts
+function isTerminalMethod(method) {
+  return TERMINAL_METHOD_SET.has(method);
+}
+var DEFAULT_WS_PORT, PROTOCOL_VERSION, WS_CLOSE_CODE, BRIDGE_ERROR_CODE, BRIDGE_METHODS, TERMINAL_EVENTS, BASH_EVENTS, TERMINAL_METHOD_SET;
+var init_protocol = __esm({
+  "src/bridge/protocol.ts"() {
+    "use strict";
+    DEFAULT_WS_PORT = 18999;
+    PROTOCOL_VERSION = "1.2.0";
+    WS_CLOSE_CODE = {
+      /** 被新接入的扩展连接平滑替换（旧连接触发退避重连） */
+      REPLACED: 4e3,
+      /** 认证未通过（未提供 Token、Token 错误或 HMAC 签名校验失败） */
+      UNAUTHORIZED: 4001,
+      /** 协议主版本号不匹配 */
+      PROTOCOL_MISMATCH: 4002
+    };
+    BRIDGE_ERROR_CODE = {
+      /** 请求执行超时 */
+      REQUEST_TIMEOUT: -32e3,
+      /** 命令执行超时 */
+      EXECUTION_TIMEOUT: -32001,
+      /** 命令或系统操作执行失败 */
+      EXECUTION_FAILED: -32002,
+      /** 无效参数（如 command 为空） */
+      INVALID_PARAMS: -32602,
+      /** 不支持的方法 */
+      METHOD_NOT_FOUND: -32601,
+      /** 扩展尚未连接至桥接服务 */
+      EXTENSION_NOT_CONNECTED: -32051,
+      /** 侧边栏尚未就绪或已关闭 */
+      SIDEPANEL_NOT_READY: -32050
+    };
+    BRIDGE_METHODS = {
+      TOOL_CALL: "tool/call",
+      SUB_AGENT_RUN: "sub_agent/run",
+      BROWSER_TABS: "browser/tabs",
+      BROWSER_STATE: "browser/state",
+      SKILLS_LIST: "skills/list",
+      SKILLS_GET: "skills/get",
+      SKILLS_READ_RESOURCE: "skills/read_resource",
+      SYSTEM_BASH: "system/bash",
+      SYSTEM_PICK_DIRECTORY: "system/pick_directory",
+      TERMINAL_OPEN: "terminal/open",
+      TERMINAL_INPUT: "terminal/input",
+      TERMINAL_RESIZE: "terminal/resize",
+      TERMINAL_CLOSE: "terminal/close"
+    };
+    TERMINAL_EVENTS = {
+      OUTPUT: "notification/terminal_output",
+      EXIT: "notification/terminal_exit"
+    };
+    BASH_EVENTS = {
+      OUTPUT: "notification/bash_output"
+    };
+    TERMINAL_METHOD_SET = /* @__PURE__ */ new Set([
+      BRIDGE_METHODS.TERMINAL_OPEN,
+      BRIDGE_METHODS.TERMINAL_INPUT,
+      BRIDGE_METHODS.TERMINAL_RESIZE,
+      BRIDGE_METHODS.TERMINAL_CLOSE
+    ]);
+  }
+});
+
+// src/bridge/workspace-manager.ts
+import path2 from "path";
+import os2 from "os";
+import fs2 from "fs";
+function resolveBaseWorkspace(params) {
+  if (params.workspacePath && typeof params.workspacePath === "string" && params.workspacePath.trim()) {
+    const trimmedWs = params.workspacePath.trim();
+    return path2.isAbsolute(trimmedWs) ? trimmedWs : path2.resolve(os2.homedir(), trimmedWs);
+  }
+  if (params.conversationId && typeof params.conversationId === "string" && params.conversationId.trim()) {
+    const safeId = params.conversationId.trim().replace(/[/\\?%*:|"<>.]/g, "_");
+    const sessionDir = path2.resolve(WORKSPACES_ROOT, safeId || "default");
+    const relative = path2.relative(WORKSPACES_ROOT, sessionDir);
+    if (!relative || relative.startsWith("..") || path2.isAbsolute(relative)) {
+      return path2.join(WORKSPACES_ROOT, "default");
+    }
+    return sessionDir;
+  }
+  return path2.join(WORKSPACES_ROOT, "default");
+}
+function resolveWorkspaceDir(params = {}) {
+  const baseDir = resolveBaseWorkspace(params);
+  if (!fs2.existsSync(baseDir)) {
+    try {
+      fs2.mkdirSync(baseDir, { recursive: true, mode: 493 });
+    } catch {
+    }
+  }
+  if (!params.cwd || typeof params.cwd !== "string" || !params.cwd.trim()) {
+    return baseDir;
+  }
+  const trimmedCwd = params.cwd.trim();
+  const targetDir = path2.isAbsolute(trimmedCwd) ? path2.resolve(trimmedCwd) : path2.resolve(baseDir, trimmedCwd);
+  const relative = path2.relative(baseDir, targetDir);
+  if (relative.startsWith("..") || path2.isAbsolute(relative)) {
+    throw new BashInvalidParamsError(`\u76EE\u6807\u6267\u884C\u8DEF\u5F84\u8D85\u51FA\u5DF2\u6388\u6743\u5DE5\u4F5C\u7A7A\u95F4\u5B89\u5168\u8FB9\u754C: ${trimmedCwd}`);
+  }
+  return targetDir;
+}
+var WORKSPACES_ROOT, BashInvalidParamsError;
+var init_workspace_manager = __esm({
+  "src/bridge/workspace-manager.ts"() {
+    "use strict";
+    WORKSPACES_ROOT = path2.join(os2.homedir(), ".robot-wxt", "workspaces");
+    BashInvalidParamsError = class extends Error {
+      code = "INVALID_PARAMS";
+      constructor(message = "\u53C2\u6570\u9519\u8BEF") {
+        super(message);
+        this.name = "BashInvalidParamsError";
+      }
+    };
+  }
+});
+
+// src/bridge/bash-executor.ts
+import { spawnSync } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+import { StringDecoder } from "string_decoder";
+import { execa } from "execa";
+function findWindowsBash() {
+  const pathDirs = (process.env.PATH || "").split(path3.delimiter);
+  for (const dir of pathDirs) {
+    if (!dir) continue;
+    const candidate = path3.join(dir, "bash.exe");
+    try {
+      if (fs3.existsSync(candidate)) return candidate;
+    } catch {
+    }
+  }
+  const localAppData = process.env.LOCALAPPDATA || "";
+  const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+  const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
+  const programW6432 = process.env.ProgramW6432 || programFiles;
+  const commonGitBashPaths = [
+    path3.join(programFiles, "Git", "bin", "bash.exe"),
+    path3.join(programFiles, "Git", "usr", "bin", "bash.exe"),
+    path3.join(programW6432, "Git", "bin", "bash.exe"),
+    path3.join(programFilesX86, "Git", "bin", "bash.exe"),
+    path3.join(localAppData, "Programs", "Git", "bin", "bash.exe"),
+    path3.join(localAppData, "Programs", "Git", "usr", "bin", "bash.exe"),
+    path3.join(process.env.SystemRoot || "C:\\Windows", "System32", "bash.exe")
+  ];
+  for (const candidate of commonGitBashPaths) {
+    try {
+      if (fs3.existsSync(candidate)) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveShell(forcePlatform) {
+  const currentPlatform = forcePlatform || process.platform;
+  if (!forcePlatform && cachedShell) {
+    return cachedShell;
+  }
+  if (currentPlatform !== "win32") {
+    const posixShell = process.env.SHELL || "/bin/bash";
+    if (!forcePlatform) cachedShell = posixShell;
+    return posixShell;
+  }
+  const winBash = findWindowsBash();
+  if (winBash) {
+    if (!forcePlatform) cachedShell = winBash;
+    return winBash;
+  }
+  const fallback = "powershell.exe";
+  if (!forcePlatform) cachedShell = fallback;
+  return fallback;
+}
+function stripAnsi(text) {
+  return text.replace(ANSI_PATTERN, "");
+}
+function createAnsiStripper() {
+  let pending = "";
+  const take = (final) => {
+    let out = "";
+    let index = 0;
+    while (index < pending.length) {
+      if (pending[index] !== "\x1B") {
+        out += pending[index];
+        index += 1;
+        continue;
+      }
+      const rest = pending.slice(index);
+      ANSI_PATTERN.lastIndex = 0;
+      const match = ANSI_PATTERN.exec(rest);
+      if (match && match.index === 0) {
+        index += match[0].length;
+        continue;
+      }
+      if (!final && rest.length < 128 && isOpenAnsi(rest)) {
+        pending = rest;
+        return out;
+      }
+      out += pending[index];
+      index += 1;
+    }
+    pending = "";
+    return out;
+  };
+  return {
+    push(text) {
+      pending += text;
+      return take(false);
+    },
+    end() {
+      return take(true);
+    }
+  };
+}
+function isOpenAnsi(text) {
+  if (!text.startsWith("\x1B")) return false;
+  if (text.length === 1) return true;
+  if (text[1] === "[") {
+    let index = 2;
+    while (index < text.length && /[0-?]/.test(text[index])) index += 1;
+    while (index < text.length && /[ -/]/.test(text[index])) index += 1;
+    return index >= text.length;
+  }
+  if (text[1] === "]") return !text.includes("\x07") && !text.includes("\x1B\\");
+  return false;
+}
+function withoutCarriageReturn(buf) {
+  if (!buf.includes(13)) return buf;
+  const out = Buffer.allocUnsafe(buf.length);
+  let size = 0;
+  for (let index = 0; index < buf.length; index += 1) {
+    const byte = buf[index];
+    if (byte === 13) continue;
+    out[size] = byte;
+    size += 1;
+  }
+  return out.subarray(0, size);
+}
+function collectLimited(stream, maxBuffer, onText, stripCarriageReturn = false, ansi) {
+  const state = { chunks: [], truncated: false };
+  if (!stream) return state;
+  const decoder = new StringDecoder("utf8");
+  let bytes = 0;
+  const emitText = (text) => {
+    const cleaned = ansi ? ansi.push(text) : text;
+    if (cleaned) onText?.(cleaned);
+  };
+  const emit = (buf) => {
+    emitText(decoder.write(buf));
+  };
+  stream.on("data", (chunk) => {
+    const raw = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const buf = stripCarriageReturn ? withoutCarriageReturn(raw) : raw;
+    if (buf.length === 0) return;
+    emit(buf);
+    if (bytes >= maxBuffer) {
+      state.truncated = true;
+      return;
+    }
+    const remaining = maxBuffer - bytes;
+    if (buf.length <= remaining) {
+      state.chunks.push(buf);
+      bytes += buf.length;
+      return;
+    }
+    state.chunks.push(buf.subarray(0, remaining));
+    bytes += remaining;
+    state.truncated = true;
+  });
+  stream.on("end", () => {
+    const rest = ansi ? `${ansi.push(decoder.end())}${ansi.end()}` : decoder.end();
+    if (rest) onText?.(rest);
+  });
+  return state;
+}
+function decodeLimited(state, removeAnsi = false) {
+  const decoder = new StringDecoder("utf8");
+  const text = decoder.write(Buffer.concat(state.chunks));
+  const flushed = state.truncated ? "" : decoder.end();
+  const decoded = text + flushed;
+  return (removeAnsi ? stripAnsi(decoded) : decoded).trim();
+}
+function signalProcessTree(pid, signal) {
+  if (!pid || pid <= 0) return;
+  if (process.platform === "win32") {
+    try {
+      spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true, timeout: 5e3 });
+    } catch {
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch {
+    }
+  }
+}
+function ignoreStreamError(stream) {
+  stream?.on("error", () => {
+  });
+}
+async function executeBash(params) {
+  const trimmedCommand = params.command?.trim();
+  if (!trimmedCommand) {
+    throw new BashInvalidParamsError("\u547D\u4EE4\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (/rm\s+(-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+|--recursive\s+--force\s+)\s*(\/|~|\$HOME|\/\*)\s*$/i.test(
+    trimmedCommand
+  ) || /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/i.test(trimmedCommand)) {
+    throw new BashInvalidParamsError("\u5B89\u5168\u62E6\u622A\uFF1A\u7981\u6B62\u5728\u5BBF\u4E3B\u673A\u6267\u884C\u9488\u5BF9\u7CFB\u7EDF\u5173\u952E\u6839\u8DEF\u5F84\u7684\u9AD8\u5371\u7834\u574F\u6027\u547D\u4EE4");
+  }
+  const cwd = resolveWorkspaceDir({
+    cwd: params.cwd,
+    workspacePath: params.workspacePath,
+    conversationId: params.conversationId
+  });
+  const normalizedTimeoutMs = typeof params.timeoutMs === "number" && Number.isFinite(params.timeoutMs) && params.timeoutMs > 0 ? Math.min(params.timeoutMs, MAX_TIMEOUT_MS) : DEFAULT_TIMEOUT_MS;
+  const { env = {}, maxBuffer = DEFAULT_MAX_BUFFER } = params;
+  const shell = resolveShell();
+  const useTty = params.tty === true && process.platform !== "win32";
+  const detached = process.platform !== "win32";
+  const subprocess = useTty ? execa("python3", ["-u", "-c", TTY_HELPER], {
+    cwd,
+    env: {
+      ...env,
+      PAGER: "cat",
+      GIT_PAGER: "cat",
+      BASH_TTY_COMMAND: trimmedCommand,
+      BASH_TTY_SHELL: shell
+    },
+    stdin: "ignore",
+    buffer: false,
+    encoding: "buffer",
+    reject: false,
+    windowsHide: true,
+    stripFinalNewline: false,
+    detached
+  }) : execa(trimmedCommand, {
+    shell,
+    cwd,
+    env,
+    stdin: "ignore",
+    buffer: false,
+    encoding: "buffer",
+    reject: false,
+    windowsHide: true,
+    stripFinalNewline: false,
+    detached
+  });
+  ignoreStreamError(subprocess.stdout);
+  ignoreStreamError(subprocess.stderr);
+  let timedOut = false;
+  let forceTimer;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    signalProcessTree(subprocess.pid, "SIGTERM");
+    forceTimer = setTimeout(() => {
+      signalProcessTree(subprocess.pid, "SIGKILL");
+      subprocess.stdout?.destroy();
+      subprocess.stderr?.destroy();
+    }, FORCE_KILL_AFTER_DELAY_MS);
+  }, normalizedTimeoutMs);
+  const emit = (stream) => (text) => {
+    params.onOutput?.({ stream, text });
+  };
+  const ansi = useTty ? createAnsiStripper() : void 0;
+  const stdoutState = collectLimited(subprocess.stdout, maxBuffer, emit("stdout"), useTty, ansi);
+  const stderrState = collectLimited(subprocess.stderr, maxBuffer, emit("stderr"));
+  let result;
+  try {
+    result = await subprocess;
+  } catch (err) {
+    if (timedOut) throw new BashTimeoutError(normalizedTimeoutMs);
+    throw err;
+  } finally {
+    clearTimeout(timer);
+    if (forceTimer) clearTimeout(forceTimer);
+  }
+  if (timedOut) {
+    throw new BashTimeoutError(normalizedTimeoutMs);
+  }
+  if (result.failed && result.exitCode == null && result.signal == null && !result.isTerminated) {
+    throw new Error(result.shortMessage || result.message || "\u547D\u4EE4\u542F\u52A8\u5931\u8D25");
+  }
+  const truncated = stdoutState.truncated || stderrState.truncated;
+  return {
+    stdout: decodeLimited(stdoutState, useTty),
+    stderr: decodeLimited(stderrState),
+    exitCode: result.exitCode ?? null,
+    signal: result.signal ?? null,
+    durationMs: result.durationMs ?? 0,
+    ...truncated ? { truncated: true } : {}
+  };
+}
+var BashTimeoutError, DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS, DEFAULT_MAX_BUFFER, cachedShell, FORCE_KILL_AFTER_DELAY_MS, TTY_HELPER, ANSI_PATTERN;
+var init_bash_executor = __esm({
+  "src/bridge/bash-executor.ts"() {
+    "use strict";
+    init_workspace_manager();
+    BashTimeoutError = class extends Error {
+      code = "TIMEOUT";
+      timeoutMs;
+      constructor(timeoutMs) {
+        super(`\u547D\u4EE4\u6267\u884C\u8D85\u65F6 (${timeoutMs / 1e3}s)`);
+        this.name = "BashTimeoutError";
+        this.timeoutMs = timeoutMs;
+      }
+    };
+    DEFAULT_TIMEOUT_MS = 3e4;
+    MAX_TIMEOUT_MS = 6e5;
+    DEFAULT_MAX_BUFFER = 512 * 1024;
+    cachedShell = null;
+    FORCE_KILL_AFTER_DELAY_MS = 2e3;
+    TTY_HELPER = `
+import errno, os, sys
+cmd = os.environ.get("BASH_TTY_COMMAND") or ""
+shell = os.environ.get("BASH_TTY_SHELL") or "/bin/bash"
+if not cmd:
+    sys.exit(127)
+import pty
+pid, fd = pty.fork()
+if pid == 0:
+    os.environ.pop("BASH_TTY_COMMAND", None)
+    os.environ.pop("BASH_TTY_SHELL", None)
+    os.environ["TERM"] = "xterm-256color"
+    try:
+        # stdout/stderr \u4ECD\u662F\u7EC8\u7AEF\uFF1Bstdin \u6362\u6210 /dev/null\uFF0C\u8BFB\u53D6\u8F93\u5165\u7684\u547D\u4EE4\u4F1A\u7ACB\u523B\u9047\u5230 EOF
+        null_fd = os.open(os.devnull, os.O_RDONLY)
+        os.dup2(null_fd, 0)
+        os.close(null_fd)
+        os.execvp(shell, [shell, "-c", cmd])
+    except OSError:
+        os._exit(127)
+while True:
+    try:
+        data = os.read(fd, 65536)
+    except OSError as exc:
+        if exc.errno == errno.EINTR:
+            continue
+        break
+    if not data:
+        break
+    try:
+        os.write(1, data)
+    except OSError:
+        break
+try:
+    _, status = os.waitpid(pid, 0)
+except OSError:
+    sys.exit(1)
+if os.WIFEXITED(status):
+    sys.exit(os.WEXITSTATUS(status))
+if os.WIFSIGNALED(status):
+    sys.exit(128 + os.WTERMSIG(status))
+sys.exit(1)
+`;
+    ANSI_PATTERN = /\u001B(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001B\\)|[@-Z\\-_])/g;
+  }
+});
+
+// src/bridge/directory-picker.ts
+import { spawn as spawn2 } from "child_process";
+async function pickDirectory(optionsOrTitle) {
+  const options = typeof optionsOrTitle === "string" ? { title: optionsOrTitle } : optionsOrTitle || {};
+  const title = options.title || "\u8BF7\u9009\u62E9\u5DE5\u4F5C\u7A7A\u95F4\u6587\u4EF6\u5939";
+  const defaultPath = options.defaultPath && typeof options.defaultPath === "string" ? options.defaultPath.trim() : void 0;
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return pickDirectoryMac(title, defaultPath);
+  }
+  if (platform === "win32") {
+    return pickDirectoryWindows(title, defaultPath);
+  }
+  return pickDirectoryLinux(title, defaultPath);
+}
+function pickDirectoryMac(title, defaultPath) {
+  const safeTitle = title.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const defaultClause = defaultPath ? ` default location POSIX file "${defaultPath.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : "";
+  const appleScript = `POSIX path of (choose folder with prompt "${safeTitle}"${defaultClause})`;
+  return new Promise((resolve3, reject) => {
+    const child = spawn2("osascript", ["-e", appleScript], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        const selected = stdout.trim();
+        resolve3(selected || null);
+        return;
+      }
+      if (code === 1 && (stderr.includes("User canceled") || stderr.includes("-128") || !stderr.trim())) {
+        resolve3(null);
+        return;
+      }
+      reject(new Error(`\u5524\u8D77\u7CFB\u7EDF\u6587\u4EF6\u5939\u9009\u62E9\u5668\u5931\u8D25: ${stderr.trim() || `\u9000\u51FA\u7801 ${code}`}`));
+    });
+    child.on("error", (err) => {
+      reject(new Error(`\u5524\u8D77\u7CFB\u7EDF\u6587\u4EF6\u5939\u9009\u62E9\u5668\u5931\u8D25: ${err.message}`));
+    });
+  });
+}
+function escapePowerShellString(str) {
+  return str.replace(/`/g, "``").replace(/"/g, '`"').replace(/\$/g, "`$");
+}
+function pickDirectoryWindows(title, defaultPath) {
+  const safeTitle = escapePowerShellString(title);
+  const safeDefaultPath = escapePowerShellString(defaultPath ?? "");
+  const psScript = `
+$code = @'
+using System;
+using System.Runtime.InteropServices;
+
+[ComImport, Guid("D57C7288-D4AD-4768-BE02-9D969532D960"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+interface IFileOpenDialog {
+    [PreserveSig] int Show(IntPtr hwnd);
+    void SetFileTypes(uint cFileTypes, IntPtr rgFilterSpec);
+    void SetFileTypeIndex(uint iFileType);
+    void GetFileTypeIndex(out uint piFileType);
+    void Advise(IntPtr pfde, out uint pdwCookie);
+    void Unadvise(uint dwCookie);
+    void SetOptions(uint fos);
+    void GetOptions(out uint pfos);
+    void SetDefaultFolder(IntPtr psi);
+    void SetFolder(IntPtr psi);
+    void GetFolder(out IntPtr ppsi);
+    void GetCurrentSelection(out IntPtr ppsi);
+    void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string pszName);
+    void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string pszName);
+    void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
+    void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string pszText);
+    void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string pszLabel);
+    void GetResult(out IntPtr ppsi);
+    void AddPlace(IntPtr psi, int fdap);
+    void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string pszDefaultExtension);
+    void Close(int hr);
+    void SetClientGuid([In] ref Guid guid);
+    void ClearClientData();
+    void SetFilter(IntPtr pFilter);
+    void GetResults(out IntPtr ppenum);
+    void GetSelectedItems(out IntPtr ppsai);
+}
+
+[ComImport, Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+interface IShellItem {
+    void BindToHandler(IntPtr pbc, [In] ref Guid bhid, [In] ref Guid riid, out IntPtr ppv);
+    void GetParent(out IShellItem ppsi);
+    void GetDisplayName(uint sigdnName, [MarshalAs(UnmanagedType.LPWStr)] out string ppszName);
+    void GetAttributes(uint sfgaoMask, out uint psfgaoAttribs);
+    void Compare(IShellItem psi, uint hint, out int piOrder);
+}
+
+public static class FolderPicker {
+    [DllImport("shell32.dll", CharSet = CharSet.Unicode)]
+    static extern int SHCreateItemFromParsingName(string pszPath, IntPtr pbc, [In] ref Guid riid, out IntPtr ppv);
+
+    // FOS_PICKFOLDERS = 0x20, FOS_FORCEFILESYSTEM = 0x40
+    const uint FOS_PICKFOLDERS = 0x00000020;
+    const uint FOS_FORCEFILESYSTEM = 0x00000040;
+
+    public static string Pick(string title, string defaultPath) {
+        var clsid = new Guid("DC1C5A9C-E88A-4dde-A5A1-60F82A20AEF7");
+        var riid  = new Guid("D57C7288-D4AD-4768-BE02-9D969532D960");
+        var obj = Activator.CreateInstance(Type.GetTypeFromCLSID(clsid));
+        var dialog = (IFileOpenDialog)obj;
+        dialog.SetOptions(FOS_PICKFOLDERS | FOS_FORCEFILESYSTEM);
+        dialog.SetTitle(title);
+        if (!string.IsNullOrEmpty(defaultPath)) {
+            var riidShellItem = new Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE");
+            IntPtr psi;
+            if (SHCreateItemFromParsingName(defaultPath, IntPtr.Zero, ref riidShellItem, out psi) == 0) {
+                dialog.SetFolder(psi);
+                Marshal.Release(psi);
+            }
+        }
+        int hr = dialog.Show(IntPtr.Zero);
+        if (hr != 0) return null; // \u7528\u6237\u53D6\u6D88 (HRESULT_FROM_WIN32(ERROR_CANCELLED) = 0x800704C7)
+        IntPtr ppsi;
+        dialog.GetResult(out ppsi);
+        var shellItem = (IShellItem)Marshal.GetTypedObjectForIUnknown(ppsi, typeof(IShellItem));
+        string path;
+        shellItem.GetDisplayName(0x80058000, out path); // SIGDN_FILESYSPATH
+        Marshal.Release(ppsi);
+        return path;
+    }
+}
+'@
+Add-Type -TypeDefinition $code
+$result = [FolderPicker]::Pick("${safeTitle}", "${safeDefaultPath}")
+if ($result) { Write-Output $result }
+`;
+  return new Promise((resolve3, reject) => {
+    const child = spawn2("powershell", ["-STA", "-NoProfile", "-WindowStyle", "Hidden", "-Command", psScript], {
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        const selected = stdout.trim();
+        resolve3(selected || null);
+        return;
+      }
+      reject(new Error(`PowerShell \u6587\u4EF6\u5939\u9009\u62E9\u5668\u6267\u884C\u5931\u8D25: ${stderr.trim() || `\u9000\u51FA\u7801 ${code}`}`));
+    });
+    child.on("error", (err) => {
+      reject(new Error(`\u5524\u8D77 PowerShell \u6587\u4EF6\u5939\u9009\u62E9\u5668\u5931\u8D25: ${err.message}`));
+    });
+  });
+}
+function pickDirectoryLinux(title, defaultPath) {
+  const args = ["--file-selection", "--directory", `--title=${title}`];
+  if (defaultPath) {
+    args.push(`--filename=${defaultPath}`);
+  }
+  return new Promise((resolve3, reject) => {
+    const child = spawn2("zenity", args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        const selected = stdout.trim();
+        resolve3(selected || null);
+        return;
+      }
+      if (code === 1) {
+        resolve3(null);
+        return;
+      }
+      reject(new Error(`zenity \u76EE\u5F55\u9009\u62E9\u5668\u5F02\u5E38\u9000\u51FA (\u9000\u51FA\u7801 ${code}): ${stderr.trim()}`));
+    });
+    child.on("error", (err) => {
+      if (err?.code === "ENOENT") {
+        reject(new Error("\u672A\u68C0\u6D4B\u5230 zenity \u76EE\u5F55\u9009\u62E9\u5668\uFF0C\u8BF7\u5148\u5728\u7CFB\u7EDF\u4E2D\u5B89\u88C5 zenity (\u4F8B\u5982: sudo apt install zenity)"));
+        return;
+      }
+      reject(new Error(`\u5524\u8D77 zenity \u76EE\u5F55\u9009\u62E9\u5668\u5931\u8D25: ${err.message}`));
+    });
+  });
+}
+var init_directory_picker = __esm({
+  "src/bridge/directory-picker.ts"() {
+    "use strict";
+  }
+});
+
+// src/bridge/pty-backend.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { chmodSync, existsSync } from "fs";
+import { createRequire } from "module";
+import path4 from "path";
+import { constants } from "os";
+function interactiveArgs(shell) {
+  if (process.platform !== "win32") return ["-i"];
+  const base = path4.basename(shell).toLowerCase();
+  if (base === "powershell.exe" || base === "pwsh.exe") return ["-NoLogo"];
+  if (base === "cmd.exe") return [];
+  return ["-i"];
+}
+function ptyEnvironment() {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0) env[key] = value;
+  }
+  env.TERM = "xterm-256color";
+  return env;
+}
+function resolveSpawnFile(shell, pathEnv = process.env.PATH || "") {
+  if (!shell || path4.isAbsolute(shell)) return shell;
+  const names = process.platform === "win32" && !shell.toLowerCase().endsWith(".exe") ? [shell, `${shell}.exe`] : [shell];
+  for (const dir of pathEnv.split(path4.delimiter)) {
+    if (!dir) continue;
+    for (const name of names) {
+      const candidate = path4.join(dir, name);
+      try {
+        if (existsSync(candidate)) return candidate;
+      } catch {
+      }
+    }
+  }
+  if (process.platform === "win32") {
+    const systemRoot = process.env.SystemRoot || "C:\\Windows";
+    const fallbacks = [
+      path4.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
+      path4.join(systemRoot, "Sysnative", "WindowsPowerShell", "v1.0", "powershell.exe")
+    ];
+    for (const candidate of fallbacks) {
+      try {
+        if (existsSync(candidate)) return candidate;
+      } catch {
+      }
+    }
+  }
+  return shell;
+}
+function describeSpawnHelperChmodError(helper, code) {
+  if (code !== "EPERM" && code !== "EACCES") return null;
+  return `spawn-helper \u65E0\u6CD5\u8BBE\u7F6E\u4E3A\u53EF\u6267\u884C\uFF08${helper}\uFF09\u3002\u5F53\u524D\u7528\u6237\u6CA1\u6709\u6743\u9650\u4FEE\u6539\u8BE5\u6587\u4EF6\u3002\u8BF7\u7528\u5B89\u88C5\u65F6\u7684\u7528\u6237\u91CD\u65B0\u5B89\u88C5 @opentiny/webmcp-cli\uFF0C\u6216\u5BF9\u8BE5\u6587\u4EF6\u6267\u884C chmod 755\u3002`;
+}
+function loadNodePty() {
+  try {
+    return createRequire(import.meta.url)("node-pty");
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`\u4EA4\u4E92\u7EC8\u7AEF\u4E0D\u53EF\u7528\uFF1A\u672A\u80FD\u52A0\u8F7D node-pty\uFF08${detail}\uFF09\u3002\u5176\u4F59\u6865\u63A5\u547D\u4EE4\u4ECD\u53EF\u4F7F\u7528\u3002`);
+  }
+}
+function spawnHelperPath() {
+  try {
+    const pkgJson = createRequire(import.meta.url).resolve("node-pty/package.json");
+    return path4.join(path4.dirname(pkgJson), "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper");
+  } catch {
+    return null;
+  }
+}
+function ensureSpawnHelper() {
+  if (process.platform === "win32") return null;
+  const helper = spawnHelperPath();
+  if (!helper || !existsSync(helper)) return null;
+  try {
+    chmodSync(helper, 493);
+    return null;
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
+    return describeSpawnHelperChmodError(helper, code);
+  }
+}
+function signalName(code) {
+  if (!code) return null;
+  for (const [name, value] of Object.entries(constants.signals)) {
+    if (value === code) return name;
+  }
+  return String(code);
+}
+function descendantPids(rootPid) {
+  const result = spawnSync2("ps", ["-ax", "-o", "pid=,ppid="], { encoding: "utf8", timeout: 3e3 });
+  if (result.status !== 0 || !result.stdout) return [];
+  const children = /* @__PURE__ */ new Map();
+  for (const line of result.stdout.split("\n")) {
+    const [pidText, ppidText] = line.trim().split(/\s+/);
+    const pid = Number(pidText);
+    const ppid = Number(ppidText);
+    if (!pid || !ppid) continue;
+    const list = children.get(ppid);
+    if (list) list.push(pid);
+    else children.set(ppid, [pid]);
+  }
+  const out = [];
+  const walk = (pid) => {
+    for (const child of children.get(pid) || []) {
+      walk(child);
+      out.push(child);
+    }
+  };
+  walk(rootPid);
+  return out;
+}
+function killPtySession(term) {
+  const pid = term.pid;
+  if (pid && pid > 0) {
+    if (process.platform === "win32") {
+      try {
+        spawnSync2("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true, timeout: 3e3 });
+      } catch {
+      }
+    } else {
+      for (const victim of [...descendantPids(pid), pid]) {
+        try {
+          process.kill(victim, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+  }
+  try {
+    term.kill("SIGHUP");
+  } catch {
+  }
+}
+function spawnHostPty(options) {
+  const pty = loadNodePty();
+  const helperError = ensureSpawnHelper();
+  const shell = resolveSpawnFile(options.shell || resolveShell());
+  const pending = [];
+  let dataCb = null;
+  let exitCb = null;
+  let pendingExit = null;
+  let settled = false;
+  let term = null;
+  const emitData = (data) => {
+    if (!data) return;
+    if (dataCb) dataCb(data);
+    else pending.push(data);
+  };
+  const finish = (info) => {
+    if (settled) return;
+    settled = true;
+    if (exitCb) exitCb(info);
+    else pendingExit = info;
+  };
+  try {
+    term = pty.spawn(shell, interactiveArgs(shell), {
+      name: "xterm-256color",
+      cols: options.cols,
+      rows: options.rows,
+      cwd: options.cwd,
+      env: ptyEnvironment()
+    });
+    term.onData((data) => emitData(data));
+    term.onExit((event) => {
+      finish({ exitCode: event.exitCode, signal: signalName(event.signal) });
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const detail = helperError ? `${helperError} ${message}` : message;
+    setImmediate(() => {
+      emitData(`\r
+[\u7EC8\u7AEF\u542F\u52A8\u5931\u8D25] ${detail}\r
+`);
+      finish({ exitCode: null, signal: null });
+    });
+  }
+  return {
+    write(data) {
+      try {
+        term?.write(data);
+      } catch {
+      }
+    },
+    resize(cols, rows) {
+      try {
+        term?.resize(cols, rows);
+      } catch {
+      }
+    },
+    kill() {
+      if (term) killPtySession(term);
+    },
+    pause() {
+      try {
+        term?.pause();
+      } catch {
+      }
+    },
+    resume() {
+      try {
+        term?.resume();
+      } catch {
+      }
+    },
+    onData(cb) {
+      dataCb = cb;
+      for (const chunk of pending) cb(chunk);
+      pending.length = 0;
+    },
+    onExit(cb) {
+      exitCb = cb;
+      if (pendingExit) cb(pendingExit);
+    }
+  };
+}
+var init_pty_backend = __esm({
+  "src/bridge/pty-backend.ts"() {
+    "use strict";
+    init_bash_executor();
+  }
+});
+
+// src/bridge/terminal-session.ts
+import { randomUUID } from "crypto";
+function applyTerminalBackpressure(bufferedAmount, flow) {
+  if (bufferedAmount > TERMINAL_OUTPUT_HIGH_WATER) flow.pauseOutput();
+  else if (bufferedAmount <= TERMINAL_OUTPUT_HIGH_WATER / 2) flow.resumeOutput();
+}
+function clampDimension(value, fallback) {
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(2, Math.min(500, Math.floor(parsed)));
+}
+var OUTPUT_CHUNK, MAX_INPUT, DEFAULT_COALESCE_MS, TERMINAL_OUTPUT_HIGH_WATER, TerminalSessionManager;
+var init_terminal_session = __esm({
+  "src/bridge/terminal-session.ts"() {
+    "use strict";
+    init_workspace_manager();
+    init_pty_backend();
+    init_protocol();
+    OUTPUT_CHUNK = 32 * 1024;
+    MAX_INPUT = 64 * 1024;
+    DEFAULT_COALESCE_MS = 16;
+    TERMINAL_OUTPUT_HIGH_WATER = 1024 * 1024;
+    TerminalSessionManager = class {
+      session = null;
+      buffer = "";
+      timer = null;
+      send;
+      spawnPty;
+      coalesceMs;
+      constructor(options) {
+        this.send = options.send;
+        this.spawnPty = options.spawnPty ?? ((opts) => spawnHostPty(opts));
+        this.coalesceMs = options.coalesceMs ?? DEFAULT_COALESCE_MS;
+      }
+      open(params = {}) {
+        const cwd = resolveWorkspaceDir(params);
+        const cols = clampDimension(params.cols, 80);
+        const rows = clampDimension(params.rows, 24);
+        this.closeActive();
+        const id = randomUUID();
+        const pty = this.spawnPty({ cwd, cols, rows });
+        this.session = { id, pty, cwd };
+        pty.onData((data) => this.pushOutput(id, data));
+        pty.onExit((info) => {
+          if (this.session?.id !== id) return;
+          this.flush(id);
+          this.session = null;
+          this.send({
+            jsonrpc: "2.0",
+            method: TERMINAL_EVENTS.EXIT,
+            params: {
+              sessionId: id,
+              exitCode: info.exitCode,
+              signal: info.signal
+            }
+          });
+        });
+        return { sessionId: id, cwd };
+      }
+      input(params) {
+        const session = this.requireSession(params.sessionId);
+        if (typeof params.data !== "string") {
+          throw new BashInvalidParamsError("data \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+        }
+        if (params.data.length > MAX_INPUT) {
+          throw new BashInvalidParamsError("\u5355\u6B21\u8F93\u5165\u8FC7\u957F");
+        }
+        session.pty.write(params.data);
+        return { ok: true };
+      }
+      resize(params) {
+        const session = this.requireSession(params.sessionId);
+        session.pty.resize(clampDimension(params.cols, 80), clampDimension(params.rows, 24));
+        return { ok: true };
+      }
+      close(params = {}) {
+        if (!this.session || params.sessionId && params.sessionId !== this.session.id) {
+          return { ok: true };
+        }
+        this.closeActive();
+        return { ok: true };
+      }
+      disposeAll() {
+        this.closeActive();
+      }
+      pauseOutput() {
+        try {
+          this.session?.pty.pause();
+        } catch {
+        }
+      }
+      resumeOutput() {
+        try {
+          this.session?.pty.resume();
+        } catch {
+        }
+      }
+      requireSession(sessionId) {
+        if (!this.session || !sessionId || sessionId !== this.session.id) {
+          throw new Error("\u7EC8\u7AEF\u4F1A\u8BDD\u4E0D\u5B58\u5728");
+        }
+        return this.session;
+      }
+      closeActive() {
+        const current = this.session;
+        this.session = null;
+        this.buffer = "";
+        if (this.timer) {
+          clearTimeout(this.timer);
+          this.timer = null;
+        }
+        current?.pty.kill();
+      }
+      pushOutput(sessionId, chunk) {
+        if (this.session?.id !== sessionId || !chunk) return;
+        this.buffer += chunk;
+        this.flushFullChunks(sessionId);
+        if (!this.buffer) return;
+        if (this.coalesceMs <= 0) {
+          this.flush(sessionId);
+          return;
+        }
+        if (!this.timer) {
+          this.timer = setTimeout(() => this.flush(sessionId), this.coalesceMs);
+        }
+      }
+      flushFullChunks(sessionId) {
+        while (this.buffer.length >= OUTPUT_CHUNK) {
+          const data = this.buffer.slice(0, OUTPUT_CHUNK);
+          this.buffer = this.buffer.slice(OUTPUT_CHUNK);
+          this.emitOutput(sessionId, data);
+        }
+      }
+      flush(sessionId) {
+        if (this.timer) {
+          clearTimeout(this.timer);
+          this.timer = null;
+        }
+        if (!this.buffer || this.session?.id !== sessionId) {
+          this.buffer = "";
+          return;
+        }
+        const data = this.buffer;
+        this.buffer = "";
+        this.emitOutput(sessionId, data);
+      }
+      emitOutput(sessionId, data) {
+        this.send({
+          jsonrpc: "2.0",
+          method: TERMINAL_EVENTS.OUTPUT,
+          params: { sessionId, data }
+        });
+      }
+    };
+  }
+});
+
+// src/bridge/bridge-client.ts
+var bridge_client_exports = {};
+__export(bridge_client_exports, {
+  BRIDGE_ERROR_CODE: () => BRIDGE_ERROR_CODE,
+  ExtensionBridgeClient: () => ExtensionBridgeClient,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  computeHmac: () => computeHmac,
+  deriveSharedSecret: () => deriveSharedSecret,
+  getKillPortHint: () => getKillPortHint,
+  resolveOrCreateAuthToken: () => resolveOrCreateAuthToken,
+  verifyHmacConstantTime: () => verifyHmacConstantTime
+});
+import { WebSocketServer, WebSocket as WsClient } from "ws";
+import { EventEmitter } from "events";
+import { randomUUID as randomUUID2, randomBytes, createHmac, createHash, timingSafeEqual } from "crypto";
+import fs4 from "fs";
+import path5 from "path";
+import os3 from "os";
+function isJsonRpcId(id) {
+  if (id === null || typeof id === "string") return true;
+  return typeof id === "number" && Number.isFinite(id);
+}
+function resolveOrCreateAuthToken(explicitToken) {
+  if (explicitToken && explicitToken.trim()) {
+    const token = explicitToken.trim();
+    try {
+      if (!fs4.existsSync(TOKEN_FILE_DIR)) {
+        fs4.mkdirSync(TOKEN_FILE_DIR, { mode: 448, recursive: true });
+      }
+      fs4.writeFileSync(TOKEN_FILE_PATH, token, { mode: 384, encoding: "utf8" });
+    } catch {
+    }
+    return token;
+  }
+  if (process.env.ROBOT_WXT_BRIDGE_TOKEN) {
+    return process.env.ROBOT_WXT_BRIDGE_TOKEN.trim();
+  }
+  try {
+    if (fs4.existsSync(TOKEN_FILE_PATH)) {
+      const existing = fs4.readFileSync(TOKEN_FILE_PATH, "utf8").trim();
+      if (existing) return existing;
+    }
+  } catch {
+  }
+  const newToken = randomBytes(32).toString("hex");
+  try {
+    if (!fs4.existsSync(TOKEN_FILE_DIR)) {
+      fs4.mkdirSync(TOKEN_FILE_DIR, { mode: 448, recursive: true });
+    }
+    fs4.writeFileSync(TOKEN_FILE_PATH, newToken, { mode: 384, encoding: "utf8" });
+  } catch {
+  }
+  return newToken;
+}
+function parseMajorVersion(v) {
+  return parseInt(v.split(".")[0] ?? "0", 10);
+}
+function deriveSharedSecret(tokenOrExtensionId, hmacSalt) {
+  return createHash("sha256").update(`${tokenOrExtensionId}:${hmacSalt}`).digest();
+}
+function computeHmac(secret, challenge) {
+  return createHmac("sha256", secret).update(challenge).digest("hex");
+}
+function verifyHmacConstantTime(actualHex, expectedHex) {
+  if (!actualHex || typeof actualHex !== "string") return false;
+  try {
+    const actualBuf = Buffer.from(actualHex, "hex");
+    const expectedBuf = Buffer.from(expectedHex, "hex");
+    if (actualBuf.length !== expectedBuf.length) return false;
+    return timingSafeEqual(actualBuf, expectedBuf);
+  } catch {
+    return false;
+  }
+}
+function getKillPortHint(port) {
+  if (process.platform === "win32") {
+    return `netstat -ano | findstr :${port} \uFF08\u627E\u5230 PID \u540E\u6267\u884C: taskkill /pid <PID> /T /F\uFF09`;
+  }
+  return `lsof -ti:${port} | xargs kill -9`;
+}
+var WS_PORT, REQUEST_TIMEOUT_MS, HANDSHAKE_TIMEOUT_MS, WS_OPEN, TOKEN_FILE_DIR, TOKEN_FILE_PATH, ExtensionBridgeClient;
+var init_bridge_client = __esm({
+  "src/bridge/bridge-client.ts"() {
+    "use strict";
+    init_protocol();
+    init_bash_executor();
+    init_directory_picker();
+    init_terminal_session();
+    WS_PORT = DEFAULT_WS_PORT;
+    REQUEST_TIMEOUT_MS = 3e4;
+    HANDSHAKE_TIMEOUT_MS = 5e3;
+    WS_OPEN = 1;
+    TOKEN_FILE_DIR = path5.join(os3.homedir(), ".robot-wxt");
+    TOKEN_FILE_PATH = path5.join(TOKEN_FILE_DIR, "bridge-token");
+    ExtensionBridgeClient = class _ExtensionBridgeClient extends EventEmitter {
+      constructor(port = WS_PORT, authToken) {
+        super();
+        this.port = port;
+        this.explicitAuthToken = authToken;
+        this.authToken = authToken ?? resolveOrCreateAuthToken();
+      }
+      port;
+      wss = null;
+      extensionSocket = null;
+      clientSocket = null;
+      forwardedRequests = /* @__PURE__ */ new Map();
+      pending = /* @__PURE__ */ new Map();
+      socketAuthStates = /* @__PURE__ */ new Map();
+      destroyed = false;
+      terminalSessions = null;
+      idCounter = 0;
+      isClientMode = false;
+      explicitAuthToken;
+      authToken;
+      /** 获取当前服务端使用的认证 Token */
+      get currentAuthToken() {
+        return this.authToken;
+      }
+      /** 获取当前激活的 Socket */
+      _getActiveSocket() {
+        if (this.isClientMode && this.clientSocket) {
+          return this.clientSocket.readyState === WS_OPEN ? this.clientSocket : null;
+        }
+        if (this.extensionSocket && this.extensionSocket.readyState === WS_OPEN) {
+          return this.extensionSocket;
+        }
+        return null;
+      }
+      /** 是否已有就绪的扩展连接（或作为 Client 已连接到 Server） */
+      get isConnected() {
+        return this._getActiveSocket() != null;
+      }
+      /** 等待扩展连接或作为客户端连入服务就绪 */
+      async waitForReady(timeoutMs = 5e3) {
+        if (this.isConnected) return true;
+        return new Promise((resolve3) => {
+          const timer = setTimeout(() => {
+            cleanup();
+            resolve3(this.isConnected);
+          }, timeoutMs);
+          const cleanup = () => {
+            clearTimeout(timer);
+            this.off("connected", onConnected);
+          };
+          const onConnected = () => {
+            cleanup();
+            resolve3(true);
+          };
+          this.on("connected", onConnected);
+        });
+      }
+      /**
+       * 静态探测目标端口的桥接服务状态
+       */
+      static async probe(port = WS_PORT, authToken, timeoutMs = 800) {
+        const client = new _ExtensionBridgeClient(port, authToken);
+        try {
+          const res = await client._probeExistingServer(timeoutMs);
+          if (client.clientSocket) {
+            try {
+              client.clientSocket.close(1e3, "Probe finished");
+            } catch {
+            }
+          }
+          if (res.success) {
+            return { running: true, authed: true };
+          }
+          if (res.error) {
+            const isAuthError = res.error.message.includes("HMAC") || res.error.message.includes("\u8BA4\u8BC1\u5931\u8D25") || res.error.message.includes("Unauthorized");
+            if (isAuthError) {
+              return { running: true, authed: false, error: res.error.message };
+            }
+            return { running: false, authed: false, error: res.error.message };
+          }
+          return { running: false, authed: false };
+        } finally {
+          client.destroy();
+        }
+      }
+      /**
+       * 自动探测模式：
+       * 优先尝试连接已存在的 18999 服务；连接不上时退回启动本机的 WebSocketServer。
+       */
+      async startAuto(probeTimeoutMs = 800) {
+        if (this.destroyed) return;
+        const probe = await this._probeExistingServer(probeTimeoutMs);
+        if (probe.success) {
+          return;
+        }
+        if (probe.error) {
+          throw probe.error;
+        }
+        this.connect();
+      }
+      async _probeExistingServer(timeoutMs) {
+        return new Promise((resolve3) => {
+          let settled = false;
+          let connectionEstablished = false;
+          let authFailedReason = null;
+          const ws = new WsClient(`ws://127.0.0.1:${this.port}`);
+          const timer = setTimeout(() => {
+            if (!settled) {
+              settled = true;
+              try {
+                ws.terminate();
+              } catch {
+              }
+              if (authFailedReason) {
+                resolve3({
+                  success: false,
+                  error: new Error(
+                    `\u672C\u5730\u6865\u63A5\u670D\u52A1\uFF08127.0.0.1:${this.port}\uFF09\u6B63\u5728\u8FD0\u884C\uFF0C\u4F46 HMAC \u8BA4\u8BC1\u5931\u8D25\uFF1A${authFailedReason}\u3002
+\u8BF7\u786E\u8BA4\u5F53\u524D CLI \u4F7F\u7528\u7684 Token \u4E0E\u8BE5\u670D\u52A1\u4E00\u81F4\uFF0C\u6216\u7EC8\u6B62\u5360\u7528\u8FDB\u7A0B\uFF08\u53EF\u6267\u884C: ${getKillPortHint(this.port)}\uFF09\u3002`
+                  )
+                });
+              } else if (connectionEstablished) {
+                resolve3({
+                  success: false,
+                  error: new Error(
+                    `\u672C\u5730 127.0.0.1:${this.port} \u5DF2\u88AB\u5360\u7528\u4E14\u65E0\u54CD\u5E94\uFF08\u53EF\u80FD\u4E0D\u662F\u6709\u6548\u6865\u63A5\u670D\u52A1\uFF09\uFF0C\u8BF7\u5148\u7EC8\u6B62\u5360\u7528\u8FDB\u7A0B\uFF08\u53EF\u6267\u884C: ${getKillPortHint(this.port)}\uFF09\u3002`
+                  )
+                });
+              } else {
+                resolve3({ success: false });
+              }
+            }
+          }, timeoutMs);
+          ws.on("open", () => {
+            connectionEstablished = true;
+          });
+          ws.on("close", (code, reason) => {
+            const reasonStr = reason ? reason.toString() : "";
+            if (code === WS_CLOSE_CODE.UNAUTHORIZED || reasonStr.includes("Unauthorized") || reasonStr.includes("HMAC")) {
+              authFailedReason = reasonStr || "Token \u8BA4\u8BC1\u88AB\u62D2\u7EDD (HMAC verification failed)";
+            }
+            if (!settled && authFailedReason) {
+              settled = true;
+              clearTimeout(timer);
+              resolve3({
+                success: false,
+                error: new Error(
+                  `\u672C\u5730\u6865\u63A5\u670D\u52A1\uFF08127.0.0.1:${this.port}\uFF09\u6B63\u5728\u8FD0\u884C\uFF0C\u4F46 HMAC \u8BA4\u8BC1\u5931\u8D25\uFF1A${authFailedReason}\u3002
+\u8BF7\u786E\u8BA4\u5F53\u524D CLI \u4F7F\u7528\u7684 Token \u4E0E\u8BE5\u670D\u52A1\u4E00\u81F4\uFF0C\u6216\u7EC8\u6B62\u5360\u7528\u8FDB\u7A0B\uFF08\u53EF\u6267\u884C: ${getKillPortHint(this.port)}\uFF09\u3002`
+                )
+              });
+            }
+          });
+          ws.on("message", (data) => {
+            try {
+              const msg = JSON.parse(data.toString());
+              if (msg.type === "BRIDGE_CHALLENGE" && msg.challenge && msg.hmacSalt) {
+                connectionEstablished = true;
+                const secret = deriveSharedSecret(this.authToken, msg.hmacSalt);
+                const hmac = computeHmac(secret, msg.challenge);
+                ws.send(
+                  JSON.stringify({
+                    type: "BRIDGE_AUTH",
+                    clientType: "cli-client",
+                    challenge: msg.challenge,
+                    hmac
+                  })
+                );
+                return;
+              }
+              if (msg.type === "BRIDGE_AUTH_OK" && !settled) {
+                settled = true;
+                clearTimeout(timer);
+                this.isClientMode = true;
+                this.clientSocket = ws;
+                this._bindClientSocket(ws);
+                this.emit("connected");
+                resolve3({ success: true });
+              }
+            } catch {
+            }
+          });
+          ws.once("error", (err) => {
+            if (!settled) {
+              settled = true;
+              clearTimeout(timer);
+              try {
+                ws.terminate();
+              } catch {
+              }
+              if (err?.code === "ECONNREFUSED" || err?.message?.includes("ECONNREFUSED")) {
+                resolve3({ success: false });
+              } else {
+                resolve3({
+                  success: false,
+                  error: new Error(`\u8FDE\u63A5\u672C\u5730 127.0.0.1:${this.port} \u5931\u8D25: ${err?.message || err}`)
+                });
+              }
+            }
+          });
+        });
+      }
+      _bindClientSocket(ws) {
+        ws.on("message", (data) => {
+          let msg;
+          try {
+            msg = JSON.parse(data.toString());
+          } catch {
+            return;
+          }
+          if (msg.type === "BRIDGE_CHALLENGE" || msg.type === "BRIDGE_AUTH_OK") {
+            return;
+          }
+          if (msg.method === "notification/sub_agent_progress") {
+            this.emit("progress", msg.params);
+            return;
+          }
+          const pending = this.pending.get(String(msg.id));
+          if (!pending) return;
+          this.pending.delete(String(msg.id));
+          clearTimeout(pending.timer);
+          if (msg.error) {
+            pending.reject(new Error(`[${msg.error.code}] ${msg.error.message}`));
+          } else {
+            pending.resolve(msg.result);
+          }
+        });
+        ws.on("close", () => {
+          this.clientSocket = null;
+          this.emit("disconnected");
+          this._rejectAllPending("\u4E0E\u670D\u52A1\u7684\u8FDE\u63A5\u5DF2\u65AD\u5F00");
+        });
+      }
+      /** 启动 WebSocket 服务端，等待 Chrome 扩展（Offscreen Document）连入 */
+      connect() {
+        if (this.destroyed) return;
+        if (this.wss) return;
+        try {
+          this.wss = new WebSocketServer({
+            port: this.port,
+            host: "127.0.0.1",
+            verifyClient: (info, callback) => {
+              const origin = info.origin || info.req.headers.origin;
+              if (origin) {
+                const isAllowedExtension = origin.startsWith("chrome-extension://") || origin.startsWith("moz-extension://") || origin.startsWith("extension://");
+                if (!isAllowedExtension) {
+                  callback(false, 403, "Forbidden origin: only browser extensions are allowed");
+                  return;
+                }
+              }
+              callback(true);
+            }
+          });
+        } catch (err) {
+          this.emit("error", err);
+          return;
+        }
+        this.wss.on("listening", () => {
+          this.emit("listening");
+        });
+        this.wss.on("error", (err) => {
+          if (err?.code === "EADDRINUSE") {
+            process.stderr.write(
+              `[webmcp-cli] \u26A0\uFE0F \u7AEF\u53E3 ${this.port} \u5DF2\u88AB\u5360\u7528\uFF0C\u8BF7\u5148\u7EC8\u6B62\u5360\u7528\u8BE5\u7AEF\u53E3\u7684\u65E7\u8FDB\u7A0B\uFF08\u53EF\u6267\u884C: ${getKillPortHint(this.port)}\uFF09
+`
+            );
+          }
+          this.emit("error", err);
+        });
+        this.wss.on("connection", (socket) => {
+          const challenge = randomUUID2();
+          const hmacSalt = randomBytes(16).toString("hex");
+          const authState = {
+            authenticated: false,
+            challenge,
+            hmacSalt,
+            timer: setTimeout(() => {
+              if (!authState.authenticated) {
+                try {
+                  socket.close(WS_CLOSE_CODE.UNAUTHORIZED, "Handshake timeout");
+                } catch {
+                }
+              }
+            }, HANDSHAKE_TIMEOUT_MS)
+          };
+          this.socketAuthStates.set(socket, authState);
+          try {
+            socket.send(
+              JSON.stringify({
+                type: "BRIDGE_CHALLENGE",
+                challenge,
+                hmacSalt,
+                protocolVersion: PROTOCOL_VERSION
+              })
+            );
+          } catch {
+          }
+          socket.on("message", async (data) => {
+            await this.handleSocketMessage(socket, data);
+          });
+          socket.on("close", () => {
+            const auth = this.socketAuthStates.get(socket);
+            if (auth?.timer) clearTimeout(auth.timer);
+            this.socketAuthStates.delete(socket);
+            for (const [reqId, fwdInfo] of this.forwardedRequests.entries()) {
+              if (fwdInfo.socket === socket) {
+                if (fwdInfo.timer) clearTimeout(fwdInfo.timer);
+                this.forwardedRequests.delete(reqId);
+              }
+            }
+            if (socket === this.extensionSocket) {
+              this.extensionSocket = null;
+              this.terminalSessions?.disposeAll();
+              this.emit("disconnected");
+              for (const [reqId, fwdInfo] of this.forwardedRequests.entries()) {
+                if (fwdInfo.timer) clearTimeout(fwdInfo.timer);
+                try {
+                  if (fwdInfo.socket.readyState === WS_OPEN) {
+                    fwdInfo.socket.send(
+                      JSON.stringify({
+                        jsonrpc: "2.0",
+                        id: fwdInfo.originalId,
+                        error: {
+                          code: BRIDGE_ERROR_CODE.EXTENSION_NOT_CONNECTED,
+                          message: "Chrome \u6269\u5C55\u8FDE\u63A5\u5DF2\u65AD\u5F00"
+                        }
+                      })
+                    );
+                  }
+                } catch {
+                }
+                this.forwardedRequests.delete(reqId);
+              }
+              this._rejectAllPending("WebSocket \u8FDE\u63A5\u5DF2\u65AD\u5F00");
+            }
+          });
+          socket.on("error", () => {
+          });
+        });
+        this.wss.on("error", (err) => {
+          this.emit("error", err);
+        });
+      }
+      async handleSocketMessage(socket, data) {
+        let msg;
+        try {
+          msg = JSON.parse(data.toString());
+        } catch {
+          return;
+        }
+        const currentAuth = this.socketAuthStates.get(socket);
+        if (!currentAuth || !currentAuth.authenticated) {
+          await this.handleHandshake(socket, currentAuth, msg);
+          return;
+        }
+        if (msg.type === "KEEP_ALIVE" || msg.type === "WS_BRIDGE_KEEP_ALIVE") {
+          return;
+        }
+        if (msg.method && msg.id) {
+          if (typeof msg.method === "string" && isTerminalMethod(msg.method) && socket !== this.extensionSocket) {
+            this.sendJsonRpcResponse(socket, {
+              id: msg.id,
+              error: {
+                code: BRIDGE_ERROR_CODE.METHOD_NOT_FOUND,
+                message: "\u7EC8\u7AEF\u4F1A\u8BDD\u4EC5\u5141\u8BB8\u5DF2\u8BA4\u8BC1\u7684\u6269\u5C55\u8FDE\u63A5"
+              }
+            });
+            return;
+          }
+          if (socket === this.extensionSocket) {
+            await this.handleExtensionSystemRpc(socket, msg);
+            return;
+          }
+          await this.handleForwardRpc(socket, msg);
+          return;
+        }
+        if (msg.method && !msg.id) {
+          this.handleProgressNotification(msg);
+          return;
+        }
+        if (msg.id) {
+          this.handleIncomingResponse(msg);
+        }
+      }
+      verifyHandshakeHmac(currentAuth, hmac) {
+        if (!currentAuth.hmacSalt || !hmac) return false;
+        const secret = deriveSharedSecret(this.authToken, currentAuth.hmacSalt);
+        const expectedHmac = computeHmac(secret, currentAuth.challenge);
+        if (verifyHmacConstantTime(hmac, expectedHmac)) {
+          return true;
+        }
+        if (!this.explicitAuthToken) {
+          const diskToken = resolveOrCreateAuthToken();
+          if (diskToken && diskToken !== this.authToken) {
+            const diskSecret = deriveSharedSecret(diskToken, currentAuth.hmacSalt);
+            const diskExpectedHmac = computeHmac(diskSecret, currentAuth.challenge);
+            if (verifyHmacConstantTime(hmac, diskExpectedHmac)) {
+              this.authToken = diskToken;
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      async handleHandshake(socket, currentAuth, msg) {
+        if (!currentAuth || msg.type !== "BRIDGE_AUTH" || msg.challenge !== currentAuth.challenge) {
+          try {
+            socket.close(WS_CLOSE_CODE.UNAUTHORIZED, "Unauthorized: Handshake failed");
+          } catch {
+          }
+          return;
+        }
+        const clientVersion = typeof msg.protocolVersion === "string" ? msg.protocolVersion : PROTOCOL_VERSION;
+        if (parseMajorVersion(clientVersion) !== parseMajorVersion(PROTOCOL_VERSION)) {
+          try {
+            socket.close(
+              WS_CLOSE_CODE.PROTOCOL_MISMATCH,
+              `Protocol version mismatch: server=${PROTOCOL_VERSION}, client=${clientVersion}`
+            );
+          } catch {
+          }
+          return;
+        }
+        const verified = this.verifyHandshakeHmac(currentAuth, msg.hmac);
+        if (!verified) {
+          const tokenFingerprint = this.authToken ? `${this.authToken.slice(0, 6)}...` : "none";
+          process.stderr.write(
+            `[webmcp-cli] HMAC \u9A8C\u8BC1\u5931\u8D25\uFF0C\u62D2\u7EDD\u8FDE\u63A5. client extensionId=${msg.extensionId}, server authTokenFingerprint=${tokenFingerprint}
+`
+          );
+          try {
+            socket.close(WS_CLOSE_CODE.UNAUTHORIZED, "Unauthorized: HMAC verification failed");
+          } catch {
+          }
+          return;
+        }
+        clearTimeout(currentAuth.timer);
+        currentAuth.authenticated = true;
+        currentAuth.clientType = msg.clientType;
+        if (msg.clientType === "extension") {
+          if (this.extensionSocket && this.extensionSocket !== socket) {
+            this.terminalSessions?.disposeAll();
+            try {
+              this.extensionSocket.close(WS_CLOSE_CODE.REPLACED, "Replaced by new connection");
+            } catch {
+            }
+          }
+          this.extensionSocket = socket;
+          this.emit("connected");
+        }
+        try {
+          socket.send(
+            JSON.stringify({
+              type: "BRIDGE_AUTH_OK",
+              clientType: msg.clientType
+            })
+          );
+        } catch {
+        }
+      }
+      async handleForwardRpc(socket, msg) {
+        let targetSocket = this._getActiveSocket();
+        if (!targetSocket) {
+          await new Promise((resolve3) => {
+            const timer2 = setTimeout(resolve3, 6e3);
+            this.once("connected", () => {
+              clearTimeout(timer2);
+              resolve3();
+            });
+          });
+          targetSocket = this._getActiveSocket();
+        }
+        if (!targetSocket) {
+          socket.send(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: msg.id,
+              error: {
+                code: BRIDGE_ERROR_CODE.EXTENSION_NOT_CONNECTED,
+                message: "Chrome \u6269\u5C55\u5C1A\u672A\u8FDE\u63A5\u5230\u672C\u5730\u6865\u63A5\u670D\u52A1\u3002\u8BF7\u786E\u4FDD\u6D4F\u89C8\u5668\u5DF2\u542F\u52A8\uFF0C\u4E14\u5728\u4FA7\u8FB9\u680F\u4E2D\u5F00\u542F\u4E86\u300C\u672C\u5730 WebSocket \u6865\u63A5\u300D\u5F00\u5173\u3002"
+              }
+            })
+          );
+          return;
+        }
+        const internalId = `fwd_${++this.idCounter}_${Date.now()}`;
+        const timeoutMs = msg.method === "sub_agent/run" ? 18e4 : REQUEST_TIMEOUT_MS;
+        const timer = setTimeout(() => {
+          const fwd = this.forwardedRequests.get(internalId);
+          if (!fwd) return;
+          this.forwardedRequests.delete(internalId);
+          try {
+            if (fwd.socket.readyState === WS_OPEN) {
+              fwd.socket.send(
+                JSON.stringify({
+                  jsonrpc: "2.0",
+                  id: fwd.originalId,
+                  error: {
+                    code: BRIDGE_ERROR_CODE.REQUEST_TIMEOUT,
+                    message: `\u8BF7\u6C42\u8F6C\u53D1\u81F3 Chrome \u6269\u5C55\u8D85\u65F6 (${timeoutMs / 1e3}s)`
+                  }
+                })
+              );
+            }
+          } catch {
+          }
+        }, timeoutMs);
+        this.forwardedRequests.set(internalId, {
+          socket,
+          originalId: msg.id,
+          progressToken: msg.params?.progressToken,
+          timer
+        });
+        const outgoingMsg = { ...msg, id: internalId };
+        targetSocket.send(JSON.stringify(outgoingMsg));
+      }
+      sendJsonRpcResponse(socket, response) {
+        if (socket.readyState === WS_OPEN) {
+          socket.send(JSON.stringify({ jsonrpc: "2.0", ...response }));
+        }
+      }
+      formatSystemRpcError(err) {
+        if (err instanceof BashInvalidParamsError || err?.code === "INVALID_PARAMS" || err?.message === "\u547D\u4EE4\u4E0D\u80FD\u4E3A\u7A7A") {
+          return { code: BRIDGE_ERROR_CODE.INVALID_PARAMS, message: err?.message || "\u53C2\u6570\u9519\u8BEF" };
+        }
+        if (err instanceof BashTimeoutError || err?.code === "TIMEOUT" || typeof err?.message === "string" && err.message.includes("\u8D85\u65F6")) {
+          return { code: BRIDGE_ERROR_CODE.EXECUTION_TIMEOUT, message: err?.message || "\u547D\u4EE4\u6267\u884C\u8D85\u65F6" };
+        }
+        return { code: BRIDGE_ERROR_CODE.EXECUTION_FAILED, message: err?.message || "\u6267\u884C\u5931\u8D25" };
+      }
+      systemRpcHandlers = Object.assign(
+        /* @__PURE__ */ Object.create(null),
+        {
+          [BRIDGE_METHODS.SYSTEM_PICK_DIRECTORY]: async (params) => {
+            const selectedPath = await pickDirectory({
+              title: params?.title || void 0,
+              defaultPath: params?.defaultPath || void 0
+            });
+            return {
+              path: selectedPath,
+              selectedPath,
+              canceled: selectedPath === null
+            };
+          },
+          [BRIDGE_METHODS.TERMINAL_OPEN]: async (params) => this.getTerminalSessions().open(params || {}),
+          [BRIDGE_METHODS.TERMINAL_INPUT]: async (params) => this.getTerminalSessions().input(params || {}),
+          [BRIDGE_METHODS.TERMINAL_RESIZE]: async (params) => this.getTerminalSessions().resize(params || {}),
+          [BRIDGE_METHODS.TERMINAL_CLOSE]: async (params) => this.getTerminalSessions().close(params || {})
+        }
+      );
+      sendJsonRpcNotification(socket, method, params) {
+        if (socket.readyState !== WS_OPEN) return;
+        let payload;
+        try {
+          payload = JSON.stringify({ jsonrpc: "2.0", method, params });
+        } catch {
+          return;
+        }
+        try {
+          socket.send(payload);
+        } catch {
+        }
+      }
+      async executeHostBash(socket, id, params) {
+        try {
+          const requestParams = params && typeof params === "object" ? params : {};
+          const result = await executeBash({
+            ...requestParams,
+            onOutput: (chunk) => {
+              if (!chunk.text) return;
+              this.sendJsonRpcNotification(socket, BASH_EVENTS.OUTPUT, {
+                id,
+                stream: chunk.stream,
+                text: chunk.text
+              });
+            }
+          });
+          this.sendJsonRpcResponse(socket, { id, result });
+        } catch (err) {
+          this.sendJsonRpcResponse(socket, { id, error: this.formatSystemRpcError(err) });
+        }
+      }
+      async handleExtensionSystemRpc(socket, msg) {
+        const { id, method, params } = msg;
+        if (!isJsonRpcId(id)) {
+          this.sendJsonRpcResponse(socket, {
+            id: null,
+            error: {
+              code: BRIDGE_ERROR_CODE.INVALID_PARAMS,
+              message: "\u65E0\u6548\u7684\u8BF7\u6C42 id"
+            }
+          });
+          return;
+        }
+        if (method === BRIDGE_METHODS.SYSTEM_BASH) {
+          await this.executeHostBash(socket, id, params);
+          return;
+        }
+        const handler = typeof method === "string" && Object.prototype.hasOwnProperty.call(this.systemRpcHandlers, method) ? this.systemRpcHandlers[method] : void 0;
+        if (!handler || typeof handler !== "function") {
+          this.sendJsonRpcResponse(socket, {
+            id,
+            error: {
+              code: BRIDGE_ERROR_CODE.METHOD_NOT_FOUND,
+              message: `\u4E0D\u652F\u6301\u7684\u65B9\u6CD5: ${method}`
+            }
+          });
+          return;
+        }
+        try {
+          const result = await handler(params);
+          this.sendJsonRpcResponse(socket, { id, result });
+        } catch (err) {
+          this.sendJsonRpcResponse(socket, { id, error: this.formatSystemRpcError(err) });
+        }
+      }
+      handleProgressNotification(msg) {
+        const token = msg.params?.progressToken;
+        if (token != null) {
+          for (const [, reqInfo] of this.forwardedRequests) {
+            if (reqInfo.progressToken === token) {
+              try {
+                if (reqInfo.socket.readyState === WS_OPEN) {
+                  reqInfo.socket.send(JSON.stringify(msg));
+                }
+              } catch {
+              }
+            }
+          }
+        }
+        this.emit("progress", msg.params);
+      }
+      handleIncomingResponse(msg) {
+        const fwdInfo = this.forwardedRequests.get(String(msg.id));
+        if (fwdInfo) {
+          if (fwdInfo.timer) clearTimeout(fwdInfo.timer);
+          this.forwardedRequests.delete(String(msg.id));
+          try {
+            if (fwdInfo.socket.readyState === WS_OPEN) {
+              fwdInfo.socket.send(
+                JSON.stringify({
+                  ...msg,
+                  id: fwdInfo.originalId
+                })
+              );
+            }
+          } catch {
+          }
+          return;
+        }
+        const pending = this.pending.get(String(msg.id));
+        if (!pending) return;
+        this.pending.delete(String(msg.id));
+        clearTimeout(pending.timer);
+        if (msg.error) {
+          pending.reject(new Error(`[${msg.error.code}] ${msg.error.message}`));
+        } else {
+          pending.resolve(msg.result);
+        }
+      }
+      /** 发送 JSON-RPC 2.0 请求，返回 result */
+      async call(method, params = {}, timeoutMs, progressToken, autoWaitMs = 0) {
+        if (autoWaitMs > 0 && !this.isConnected) {
+          await this.waitForReady(autoWaitMs);
+        }
+        const targetSocket = this._getActiveSocket();
+        if (!targetSocket) {
+          throw new Error(
+            "\u4E0E Chrome \u6269\u5C55\u7684\u8FDE\u63A5\u5C1A\u672A\u5C31\u7EEA\uFF0C\u8BF7\u786E\u4FDD\uFF1A\n  1. Chrome \u6D4F\u89C8\u5668\u5DF2\u542F\u52A8\n  2. Tiny Robot \u6269\u5C55\u5DF2\u5B89\u88C5\u5E76\u5F00\u542F\n  3. \u6269\u5C55\u4FA7\u8FB9\u680F\u5DF2\u6253\u5F00"
+          );
+        }
+        const effectiveTimeoutMs = timeoutMs ?? (method === "sub_agent/run" ? 18e4 : REQUEST_TIMEOUT_MS);
+        const id = String(++this.idCounter);
+        const requestParams = { ...params };
+        if (progressToken != null) {
+          requestParams.progressToken = progressToken;
+        }
+        const request = { jsonrpc: "2.0", id, method, params: requestParams };
+        return new Promise((resolve3, reject) => {
+          const timer = setTimeout(() => {
+            this.pending.delete(id);
+            reject(new Error(`\u8BF7\u6C42\u8D85\u65F6\uFF08${effectiveTimeoutMs / 1e3}s\uFF09\uFF1A${method}`));
+          }, effectiveTimeoutMs);
+          this.pending.set(id, { resolve: resolve3, reject, timer });
+          try {
+            targetSocket.send(JSON.stringify(request));
+          } catch (err) {
+            this.pending.delete(id);
+            clearTimeout(timer);
+            reject(err instanceof Error ? err : new Error(String(err)));
+          }
+        });
+      }
+      getTerminalSessions() {
+        if (!this.terminalSessions) {
+          this.terminalSessions = new TerminalSessionManager({
+            send: (frame) => {
+              const socket = this.extensionSocket;
+              if (!socket || socket.readyState !== WS_OPEN) return;
+              const sessions = this.terminalSessions;
+              if (sessions) applyTerminalBackpressure(socket.bufferedAmount ?? 0, sessions);
+              let payload;
+              try {
+                payload = JSON.stringify(frame);
+              } catch {
+                return;
+              }
+              try {
+                socket.send(payload, () => {
+                  if (this.terminalSessions && socket.readyState === WS_OPEN) {
+                    applyTerminalBackpressure(socket.bufferedAmount ?? 0, this.terminalSessions);
+                  }
+                });
+              } catch {
+              }
+            }
+          });
+        }
+        return this.terminalSessions;
+      }
+      /** 销毁服务，断开所有连接 */
+      destroy() {
+        this.destroyed = true;
+        this.terminalSessions?.disposeAll();
+        this._rejectAllPending("ExtensionBridgeClient \u5DF2\u9500\u6BC1");
+        this.forwardedRequests.clear();
+        if (this.clientSocket) {
+          try {
+            this.clientSocket.close();
+          } catch {
+          }
+          this.clientSocket = null;
+        }
+        if (this.extensionSocket) {
+          try {
+            this.extensionSocket.close();
+          } catch {
+          }
+          this.extensionSocket = null;
+        }
+        if (this.wss) {
+          try {
+            this.wss.close();
+          } catch {
+          }
+          this.wss = null;
+        }
+      }
+      _rejectAllPending(reason) {
+        for (const [, pending] of this.pending) {
+          clearTimeout(pending.timer);
+          pending.reject(new Error(reason));
+        }
+        this.pending.clear();
+        for (const [, fwdInfo] of this.forwardedRequests) {
+          if (fwdInfo.timer) clearTimeout(fwdInfo.timer);
+        }
+        this.forwardedRequests.clear();
+      }
+    };
+  }
+});
+
+// src/adapters/wxt-adapter.ts
+var wxt_adapter_exports = {};
+__export(wxt_adapter_exports, {
+  WxtBrowserAdapter: () => WxtBrowserAdapter
+});
+var AUTO_WAIT_MS, WxtBrowserAdapter;
+var init_wxt_adapter = __esm({
+  "src/adapters/wxt-adapter.ts"() {
+    "use strict";
+    init_bridge_client();
+    init_protocol();
+    AUTO_WAIT_MS = 6e3;
+    WxtBrowserAdapter = class {
+      client;
+      constructor(token, port) {
+        this.client = new ExtensionBridgeClient(port, token);
+        this.client.on("error", () => {
+        });
+      }
+      /** 确保 WS 桥接服务已启动并连接 */
+      async ensureConnected() {
+        await this.client.startAuto();
+      }
+      async getState(tabId) {
+        const numTabId = typeof tabId === "string" ? parseInt(tabId, 10) || void 0 : tabId;
+        const result = await this.client.call(
+          BRIDGE_METHODS.BROWSER_STATE,
+          { tabId: numTabId },
+          void 0,
+          void 0,
+          AUTO_WAIT_MS
+        );
+        return result;
+      }
+      async callTool(toolName, args, tabId) {
+        const numTabId = typeof tabId === "string" ? parseInt(tabId, 10) || void 0 : tabId;
+        return this.client.call(
+          BRIDGE_METHODS.TOOL_CALL,
+          { toolName, toolArgs: args, tabId: numTabId },
+          void 0,
+          void 0,
+          AUTO_WAIT_MS
+        );
+      }
+      async tabs(action, options) {
+        const numTabId = typeof options.tabId === "string" ? parseInt(options.tabId, 10) || void 0 : options.tabId;
+        return this.client.call(
+          BRIDGE_METHODS.BROWSER_TABS,
+          { tabAction: action, ...options, tabId: numTabId },
+          void 0,
+          void 0,
+          AUTO_WAIT_MS
+        );
+      }
+      /** 委托扩展内 Tiny Robot 子代理闭环执行高层任务 */
+      async runSubAgent(instruction, options = {}, timeoutMs) {
+        const params = { instruction, tabId: options.tabId, maxSteps: options.maxSteps };
+        return this.client.call(
+          BRIDGE_METHODS.SUB_AGENT_RUN,
+          params,
+          timeoutMs,
+          options.progressToken,
+          AUTO_WAIT_MS
+        );
+      }
+      /** 获取已注册的 Skills 列表（L1 索引） */
+      async listSkills() {
+        return this.client.call(BRIDGE_METHODS.SKILLS_LIST, {}, void 0, void 0, AUTO_WAIT_MS);
+      }
+      /** 读取指定 Skill 的详细指令（L2 详情） */
+      async getSkill(name) {
+        return this.client.call(BRIDGE_METHODS.SKILLS_GET, { name }, void 0, void 0, AUTO_WAIT_MS);
+      }
+      /** 读取 Skill 关联资源（L3 资源） */
+      async readSkillResource(name, resourcePath) {
+        return this.client.call(
+          BRIDGE_METHODS.SKILLS_READ_RESOURCE,
+          { name, resourcePath },
+          void 0,
+          void 0,
+          AUTO_WAIT_MS
+        );
+      }
+      /** 获取底层 ExtensionBridgeClient（供 MCP Server 绑定事件） */
+      get bridgeClient() {
+        return this.client;
+      }
+      async dispose() {
+        this.client.destroy();
+      }
+    };
+  }
+});
+
+// src/bridge/daemon.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  PID_FILE: () => PID_FILE,
+  ensureBridgeDaemon: () => ensureBridgeDaemon,
+  findPidByPort: () => findPidByPort,
+  getDaemonPidFile: () => getDaemonPidFile,
+  isBridgeDaemonProcess: () => isBridgeDaemonProcess,
+  isDaemonProcessAlive: () => isDaemonProcessAlive,
+  isProcessAlive: () => isProcessAlive,
+  killProcessOnPort: () => killProcessOnPort,
+  killProcessTree: () => killProcessTree,
+  probeServerReady: () => probeServerReady,
+  runDaemonProcess: () => runDaemonProcess,
+  stopBridgeDaemon: () => stopBridgeDaemon
+});
+import { spawn as spawn3, exec } from "child_process";
+import { promisify } from "util";
+import fs5 from "fs";
+import path6 from "path";
+import os4 from "os";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function getDaemonPidFile(port = WS_PORT2) {
+  if (port === WS_PORT2) {
+    return path6.join(DAEMON_DIR, "daemon.pid");
+  }
+  return path6.join(DAEMON_DIR, `daemon-${port}.pid`);
+}
+function isProcessAlive(pid) {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findPidByPort(port, excludePid) {
+  if (process.platform === "win32") {
+    try {
+      const { stdout } = await execAsync("netstat -ano -p tcp");
+      const lines = stdout.split(/\r?\n/);
+      for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line.toUpperCase().startsWith("TCP")) continue;
+        const parts = line.split(/\s+/);
+        if (parts.length < 5) continue;
+        const localAddr = parts[1];
+        const state = parts[3]?.toUpperCase() || "";
+        const pid = parseInt(parts[parts.length - 1], 10);
+        if (!pid || isNaN(pid) || excludePid && pid === excludePid) continue;
+        if (localAddr.endsWith(`:${port}`)) {
+          if (state.includes("LISTEN") || state.includes("\u4FA6\u542C")) {
+            return pid;
+          }
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  try {
+    const { stdout } = await execAsync(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`);
+    const pids = stdout.trim().split("\n").map((p) => parseInt(p.trim(), 10)).filter((p) => Boolean(p && !isNaN(p) && (!excludePid || p !== excludePid)));
+    return pids[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function killProcessTree(pid) {
+  if (!pid || pid <= 0 || pid === process.pid) return false;
+  if (process.platform === "win32") {
+    try {
+      await execAsync(`taskkill /pid ${pid} /T /F`);
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+    for (let i = 0; i < 15; i++) {
+      await new Promise((r) => setTimeout(r, 100));
+      if (!isProcessAlive(pid)) return true;
+    }
+    return !isProcessAlive(pid);
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  for (let i = 0; i < 10; i++) {
+    await new Promise((r) => setTimeout(r, 100));
+    if (!isProcessAlive(pid)) return true;
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+  for (let i = 0; i < 5; i++) {
+    await new Promise((r) => setTimeout(r, 100));
+    if (!isProcessAlive(pid)) return true;
+  }
+  return !isProcessAlive(pid);
+}
+async function killProcessOnPort(port) {
+  const pid = await findPidByPort(port, process.pid);
+  if (pid) {
+    await killProcessTree(pid);
+    for (let i = 0; i < 20; i++) {
+      await new Promise((r) => setTimeout(r, 100));
+      const remainingPid = await findPidByPort(port, process.pid);
+      if (!remainingPid) return true;
+    }
+  }
+  return false;
+}
+async function probeServerReady(port = WS_PORT2, token, timeoutMs = 1e3) {
+  return ExtensionBridgeClient.probe(port, token ?? resolveOrCreateAuthToken(), timeoutMs);
+}
+function isDaemonProcessAlive(port = WS_PORT2) {
+  const pidFile = getDaemonPidFile(port);
+  if (!fs5.existsSync(pidFile)) return false;
+  try {
+    const pid = parseInt(fs5.readFileSync(pidFile, "utf8").trim(), 10);
+    return Boolean(pid && isProcessAlive(pid));
+  } catch {
+    return false;
+  }
+}
+async function ensureBridgeDaemon(options = {}) {
+  const port = options.port ?? WS_PORT2;
+  const token = options.token ?? resolveOrCreateAuthToken();
+  const timeoutMs = options.timeoutMs ?? 6e3;
+  const probe = await probeServerReady(port, token, 800);
+  if (probe.running && probe.authed) {
+    return { newlyStarted: false };
+  }
+  if (probe.running && !probe.authed) {
+    if (!options.silent) {
+      console.log(
+        `\x1B[33m[webmcp-cli]\x1B[0m \u{1F504} \u68C0\u6D4B\u5230\u540E\u53F0\u6865\u63A5\u670D\u52A1 Token \u4E0D\u5339\u914D\uFF0C\u6B63\u5728\u9A8C\u8BC1\u65E7\u5B88\u62A4\u8FDB\u7A0B\u5F52\u5C5E\u5E76\u5C1D\u8BD5\u81EA\u52A8\u91CD\u542F...`
+      );
+    }
+    const stopped = await stopBridgeDaemon(port, { onlyVerified: true });
+    if (!stopped) {
+      const killTip = getKillPortHint(port);
+      throw new Error(
+        `\u672C\u5730 127.0.0.1:${port} \u6B63\u5728\u8FD0\u884C\u670D\u52A1\uFF0C\u4F46\u8BA4\u8BC1\u672A\u901A\u8FC7\uFF08${probe.error || "Token \u4E0D\u5339\u914D"}\uFF09\u3002
+\u672A\u80FD\u786E\u8BA4\u8BE5\u8FDB\u7A0B\u5F52\u5C5E\u4E8E\u53D7\u7BA1\u7684\u6865\u63A5\u5B88\u62A4\u8FDB\u7A0B\uFF0C\u4E3A\u5B89\u5168\u8D77\u89C1\u5DF2\u963B\u6B62\u81EA\u52A8\u5F3A\u6740\u3002\u8BF7\u68C0\u67E5\u7AEF\u53E3 ${port} \u662F\u5426\u88AB\u5176\u4ED6\u5E94\u7528\u5360\u7528\uFF0C\u6216\u624B\u52A8\u7EC8\u6B62\uFF08\u53EF\u6267\u884C: ${killTip}\uFF09\u3002`
+      );
+    }
+    await new Promise((r) => setTimeout(r, 400));
+  }
+  if (!options.silent) {
+    console.log(`\x1B[36m[webmcp-cli]\x1B[0m \u{1F680} \u672C\u5730\u6865\u63A5\u670D\u52A1\u672A\u8FD0\u884C\uFF0C\u6B63\u5728\u81EA\u52A8\u62C9\u8D77\u5E38\u9A7B\u670D\u52A1 (127.0.0.1:${port})...`);
+  }
+  startDaemonProcessBackground(token, port);
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    await new Promise((r) => setTimeout(r, 200));
+    const check = await probeServerReady(port, token, 400);
+    if (check.running && check.authed) {
+      if (!options.silent) {
+        console.log(`\x1B[32m[webmcp-cli]\x1B[0m \u2705 \u6865\u63A5\u670D\u52A1\u5DF2\u542F\u52A8\uFF0C\u6B63\u5728\u7B49\u5F85 Chrome \u6269\u5C55\u8FDE\u63A5...`);
+      }
+      return { newlyStarted: true };
+    }
+  }
+  throw new Error(`\u542F\u52A8\u540E\u53F0 WebSocket \u6865\u63A5\u670D\u52A1\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09\uFF0C\u8BF7\u68C0\u67E5\u7AEF\u53E3 ${port} \u662F\u5426\u53EF\u7528\u3002`);
+}
+function resolveCliEntry() {
+  const currentDir = path6.dirname(fileURLToPath3(import.meta.url));
+  const distCandidate = path6.join(currentDir, "bin.js");
+  if (fs5.existsSync(distCandidate)) return distCandidate;
+  const projectDistCandidate = path6.resolve(currentDir, "../dist/bin.js");
+  if (fs5.existsSync(projectDistCandidate)) return projectDistCandidate;
+  return distCandidate;
+}
+function startDaemonProcessBackground(token, port) {
+  const cliEntry = resolveCliEntry();
+  if (!fs5.existsSync(DAEMON_DIR)) {
+    fs5.mkdirSync(DAEMON_DIR, { mode: 448, recursive: true });
+  }
+  const child = spawn3(process.execPath, [cliEntry, "--mode", "wxt", "daemon", "--port", String(port)], {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: {
+      ...process.env,
+      ROBOT_WXT_BRIDGE_TOKEN: token
+    }
+  });
+  child.unref();
+}
+async function runDaemonProcess(args) {
+  let port = WS_PORT2;
+  let token;
+  const portIdx = args.indexOf("--port");
+  if (portIdx !== -1 && args[portIdx + 1]) {
+    port = parseInt(args[portIdx + 1], 10);
+  }
+  const tokenIdx = args.indexOf("--token");
+  if (tokenIdx !== -1 && args[tokenIdx + 1]) {
+    token = args[tokenIdx + 1];
+  } else if (process.env.ROBOT_WXT_BRIDGE_TOKEN) {
+    token = process.env.ROBOT_WXT_BRIDGE_TOKEN;
+  }
+  const client = new ExtensionBridgeClient(port, token);
+  client.on("error", (err) => {
+    if (err && (err.code === "EADDRINUSE" || err.message?.includes("EADDRINUSE"))) {
+      process.exit(1);
+    }
+  });
+  const pidFile = getDaemonPidFile(port);
+  client.on("listening", () => {
+    try {
+      if (!fs5.existsSync(DAEMON_DIR)) {
+        fs5.mkdirSync(DAEMON_DIR, { mode: 448, recursive: true });
+      }
+      fs5.writeFileSync(pidFile, String(process.pid), { mode: 384, encoding: "utf8" });
+    } catch {
+    }
+  });
+  client.connect();
+  const shutdown = () => {
+    try {
+      if (fs5.existsSync(pidFile)) {
+        const recordedPid = fs5.readFileSync(pidFile, "utf8").trim();
+        if (recordedPid === String(process.pid)) {
+          fs5.unlinkSync(pidFile);
+        }
+      }
+    } catch {
+    }
+    client.destroy();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("exit", shutdown);
+  setInterval(() => {
+  }, 6e4);
+}
+async function isBridgeDaemonProcess(pid) {
+  if (!pid || pid <= 0 || !isProcessAlive(pid)) return false;
+  try {
+    let cmd = "";
+    if (process.platform === "win32") {
+      const { stdout } = await execAsync(
+        `powershell -NoProfile -Command "(Get-CimInstance Win32_Process -Filter \\"ProcessId = ${pid}\\").CommandLine"`
+      );
+      cmd = stdout.trim();
+    } else {
+      const { stdout } = await execAsync(`ps -p ${pid} -o command=`);
+      cmd = stdout.trim();
+    }
+    if (!cmd) return false;
+    return (cmd.includes("webmcp-cli") || cmd.includes("bin.js") || cmd.includes("daemon.js")) && cmd.includes("daemon");
+  } catch {
+    return false;
+  }
+}
+async function stopBridgeDaemon(port = WS_PORT2, options = {}) {
+  const onlyVerified = options.onlyVerified ?? false;
+  let killedAny = false;
+  const pidFile = getDaemonPidFile(port);
+  let daemonPid = null;
+  if (fs5.existsSync(pidFile)) {
+    try {
+      const pidStr = fs5.readFileSync(pidFile, "utf8").trim();
+      const p = parseInt(pidStr, 10);
+      if (p && isProcessAlive(p)) {
+        daemonPid = p;
+      }
+    } catch {
+    }
+  }
+  if (onlyVerified) {
+    if (!daemonPid) {
+      return false;
+    }
+    const isVerified = await isBridgeDaemonProcess(daemonPid);
+    if (!isVerified) {
+      return false;
+    }
+    const portPid = await findPidByPort(port, process.pid);
+    if (portPid && portPid !== daemonPid) {
+      return false;
+    }
+    const killed = await killProcessTree(daemonPid);
+    if (killed) {
+      killedAny = true;
+      try {
+        if (fs5.existsSync(pidFile)) fs5.unlinkSync(pidFile);
+      } catch {
+      }
+    }
+  } else {
+    if (daemonPid) {
+      try {
+        const killed = await killProcessTree(daemonPid);
+        if (killed) {
+          killedAny = true;
+          try {
+            if (fs5.existsSync(pidFile)) fs5.unlinkSync(pidFile);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    const portPid = await findPidByPort(port, process.pid);
+    if (portPid) {
+      const killedByPort = await killProcessOnPort(port);
+      if (killedByPort) {
+        killedAny = true;
+      }
+    }
+  }
+  let portReleased = false;
+  for (let i = 0; i < 10; i++) {
+    const remainingPid = await findPidByPort(port, process.pid);
+    if (!remainingPid) {
+      portReleased = true;
+      break;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  if (!portReleased) {
+    return false;
+  }
+  return killedAny;
+}
+var execAsync, WS_PORT2, DAEMON_DIR, PID_FILE;
+var init_daemon = __esm({
+  "src/bridge/daemon.ts"() {
+    "use strict";
+    init_bridge_client();
+    execAsync = promisify(exec);
+    WS_PORT2 = 18999;
+    DAEMON_DIR = path6.join(os4.homedir(), ".robot-wxt");
+    PID_FILE = getDaemonPidFile(WS_PORT2);
+  }
+});
+
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startMcpServer: () => startMcpServer
+});
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function startMcpServer(options = {}) {
+  const mode = options.mode ?? "cdp";
+  const agentMode = options.agentMode ?? "tools";
+  const isAgentMode = agentMode === "agent";
+  const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION });
+  if (mode === "cdp") {
+    if (isAgentMode) {
+      throw new Error("--agent \u5B50\u4EE3\u7406\u59D4\u6258\u6A21\u5F0F\u4EC5\u5728 WXT \u6A21\u5F0F\u53EF\u7528\uFF0C\u8BF7\u4F7F\u7528: webmcp-cli --mode wxt mcp --agent");
+    }
+    await startCdpMcpServer(server, isAgentMode);
+  } else {
+    await startWxtMcpServer(server, isAgentMode, options);
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write(
+    `[webmcp-cli] MCP Server \u5DF2\u542F\u52A8\uFF08${SERVER_NAME} v${SERVER_VERSION}\uFF0C\u6A21\u5F0F: ${mode}${isAgentMode ? "/agent" : "/tools"}\uFF09
+`
+  );
+}
+async function startCdpMcpServer(server, isAgentMode) {
+  const { CdpBrowserAdapter: CdpBrowserAdapter2 } = await Promise.resolve().then(() => (init_cdp_adapter(), cdp_adapter_exports));
+  const adapter = new CdpBrowserAdapter2();
+  registerCommonTools(server, adapter, isAgentMode);
+  process.on("SIGINT", async () => {
+    await adapter.dispose();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await adapter.dispose();
+    process.exit(0);
+  });
+}
+async function startWxtMcpServer(server, isAgentMode, options) {
+  const { WxtBrowserAdapter: WxtBrowserAdapter2 } = await Promise.resolve().then(() => (init_wxt_adapter(), wxt_adapter_exports));
+  const { ensureBridgeDaemon: ensureBridgeDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  const daemonResult = await ensureBridgeDaemon2({
+    token: options.token,
+    port: options.wsPort,
+    silent: true
+  });
+  const adapter = new WxtBrowserAdapter2(options.token, options.wsPort);
+  await adapter.ensureConnected();
+  if (daemonResult.newlyStarted) {
+    process.stderr.write("[webmcp-cli] \u{1F680} \u672C\u5730\u6865\u63A5\u670D\u52A1\u5DF2\u542F\u52A8\uFF0C\u6B63\u5728\u7B49\u5F85 Chrome \u6269\u5C55\u8FDE\u63A5...\n");
+  }
+  const client = adapter.bridgeClient;
+  registerCommonTools(server, adapter, isAgentMode);
+  registerWxtTools(server, adapter, isAgentMode, server);
+  registerSkillsResources(server, adapter);
+  client.on("connected", () => {
+    process.stderr.write("[webmcp-cli] \u5DF2\u8FDE\u63A5\u5230 Chrome \u6269\u5C55\n");
+    try {
+      server.server.notification({ method: "notifications/resources/list_changed" });
+    } catch {
+    }
+  });
+  client.on("disconnected", () => {
+    process.stderr.write("[webmcp-cli] \u4E0E Chrome \u6269\u5C55\u7684\u8FDE\u63A5\u5DF2\u65AD\u5F00\n");
+  });
+  process.on("SIGINT", async () => {
+    await adapter.dispose();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await adapter.dispose();
+    process.exit(0);
+  });
+  const tokenFingerprint = options.token ? `${options.token.slice(0, 6)}...` : "(auto)";
+  process.stderr.write(`[webmcp-cli] \u{1F511} Token \u6307\u7EB9: ${tokenFingerprint} (\u5B8C\u6574\u51ED\u636E\u89C1 ~/.robot-wxt/bridge-token)
+`);
+}
+function registerCommonTools(server, adapter, isAgentMode) {
+  server.registerTool(
+    "browser_state",
+    {
+      description: "\u83B7\u53D6\u5F53\u524D\u6D4F\u89C8\u5668\u72B6\u6001\uFF0C\u5305\u62EC\uFF1A\u5F53\u524D tab \u7684 URL / \u6807\u9898\u3001\u6240\u6709\u5DF2\u6253\u5F00\u7684 tab \u5217\u8868\u3001\u5F53\u524D\u9875\u9762\u6CE8\u518C\u7684 WebMCP \u5DE5\u5177\u5217\u8868\u3002\u5728\u6267\u884C\u64CD\u4F5C\u524D\uFF0C\u5EFA\u8BAE\u5148\u8C03\u7528\u6B64\u5DE5\u5177\u4E86\u89E3\u5F53\u524D\u6D4F\u89C8\u5668\u4E0A\u4E0B\u6587\u3002",
+      inputSchema: BrowserStateInput.shape
+    },
+    async (args) => {
+      const result = await adapter.getState(args.tabId);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  if (!isAgentMode) {
+    server.registerTool(
+      "browser_tool_call",
+      {
+        description: "\u6267\u884C\u5F53\u524D\u9875\u9762\u6CE8\u518C\u7684 WebMCP \u5DE5\u5177\uFF08\u5982 click\u3001input\u3001scroll \u7B49\uFF09\u3002\u5DE5\u5177\u540D\u79F0\u548C\u53C2\u6570 schema \u901A\u8FC7 browser_state \u8FD4\u56DE\u7684 webmcpTools \u5B57\u6BB5\u83B7\u53D6\u3002",
+        inputSchema: BrowserToolCallInput.shape
+      },
+      async (args) => {
+        const result = await adapter.callTool(args.toolName, args.toolArgs ?? {}, args.tabId);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    );
+    server.registerTool(
+      "browser_tabs_open",
+      { description: "\u5728\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00\u4E00\u4E2A\u65B0\u6807\u7B7E\u9875\u5E76\u5BFC\u822A\u5230\u6307\u5B9A URL\u3002", inputSchema: BrowserTabsOpenInput.shape },
+      async (args) => {
+        const result = await adapter.tabs("open", { url: args.url });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    );
+    server.registerTool(
+      "browser_tabs_close",
+      { description: "\u5173\u95ED\u6307\u5B9A\u6807\u7B7E\u9875\uFF08\u4E0D\u6307\u5B9A tabId \u65F6\u5173\u95ED\u5F53\u524D\u6D3B\u8DC3\u6807\u7B7E\u9875\uFF09\u3002", inputSchema: BrowserTabsCloseInput.shape },
+      async (args) => {
+        const result = await adapter.tabs("close", { tabId: args.tabId });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    );
+    server.registerTool(
+      "browser_tabs_switch",
+      {
+        description: "\u5C06\u7126\u70B9\u5207\u6362\u5230\u6307\u5B9A\u6807\u7B7E\u9875\uFF08tabId \u901A\u8FC7 browser_state \u8FD4\u56DE\u7684 tabs \u5217\u8868\u83B7\u53D6\uFF09\u3002",
+        inputSchema: BrowserTabsSwitchInput.shape
+      },
+      async (args) => {
+        const result = await adapter.tabs("switch", { tabId: args.tabId, activateVisible: args.activateVisible });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    );
+    server.registerTool(
+      "browser_tabs_back",
+      { description: "\u5728\u6307\u5B9A\u6807\u7B7E\u9875\uFF08\u6216\u5F53\u524D\u6D3B\u8DC3\u6807\u7B7E\u9875\uFF09\u4E2D\u6267\u884C\u6D4F\u89C8\u5668\u540E\u9000\u64CD\u4F5C\u3002", inputSchema: BrowserTabsNavInput.shape },
+      async (args) => {
+        const result = await adapter.tabs("back", { tabId: args.tabId });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    );
+    server.registerTool(
+      "browser_tabs_forward",
+      { description: "\u5728\u6307\u5B9A\u6807\u7B7E\u9875\uFF08\u6216\u5F53\u524D\u6D3B\u8DC3\u6807\u7B7E\u9875\uFF09\u4E2D\u6267\u884C\u6D4F\u89C8\u5668\u524D\u8FDB\u64CD\u4F5C\u3002", inputSchema: BrowserTabsNavInput.shape },
+      async (args) => {
+        const result = await adapter.tabs("forward", { tabId: args.tabId });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    );
+  }
+}
+function registerWxtTools(server, adapter, isAgentMode, mcpServer) {
+  server.registerTool(
+    "browser_sub_agent_run",
+    {
+      description: isAgentMode ? "\u300ATiny Robot \u7AEF\u4FA7\u81EA\u4E3B\u5B50\u4EE3\u7406\u300B\u5C06\u590D\u6742\u6216\u957F\u6D41\u7A0B\u7684\u6D4F\u89C8\u5668\u64CD\u4F5C\u4EFB\u52A1\u59D4\u6258\u7ED9\u6269\u5C55\u7AEF\u4FA7\u7684 Tiny Robot \u5B50\u4EE3\u7406\u95ED\u73AF\u6267\u884C\u3002\u5B50\u4EE3\u7406\u5C06\u5728\u7AEF\u4FA7\u81EA\u4E3B\u89C2\u5BDF\u9875\u9762\u3001\u89C4\u5212\u6B65\u9AA4\u5E76\u6267\u884C\u539F\u5B50\u64CD\u4F5C\uFF0C\u6267\u884C\u5B8C\u6BD5\u540E\u8FD4\u56DE\u6700\u7EC8\u7ED3\u679C\uFF0C\u6781\u5927\u5730\u8282\u7701\u4E3B Agent \u4E0A\u4E0B\u6587 Token\u3002" : "\u300A\u9AD8\u5C42\u4EFB\u52A1\u59D4\u6258\u300B\u5C06\u590D\u6742\u3001\u957F\u6D41\u7A0B\u6216\u9700\u53CD\u590D\u8BD5\u9519\u7684\u6D4F\u89C8\u5668\u64CD\u4F5C\u4EFB\u52A1\u59D4\u6258\u7ED9 Chrome \u6269\u5C55\u5185\u90E8\u7684 Tiny Robot \u5B50\u4EE3\u7406\uFF08Sub-Agent\uFF09\u81EA\u4E3B\u95ED\u73AF\u6267\u884C\u3002\u5B50\u4EE3\u7406\u5C06\u5728\u7AEF\u4FA7\u81EA\u4E3B\u8FDB\u884C\u9875\u9762\u63A2\u7D22\u3001\u89C4\u5212\u548C\u539F\u5B50\u64CD\u4F5C\uFF0C\u6267\u884C\u5B8C\u6BD5\u540E\u8FD4\u56DE\u6700\u7EC8\u7ED3\u679C\uFF0C\u6781\u5927\u5730\u8282\u7701\u5916\u90E8\u4E3B Agent \u7684\u4E0A\u4E0B\u6587 Token\u3002",
+      inputSchema: BrowserSubAgentRunInput.shape
+    },
+    async (args, extra) => {
+      const progressToken = extra?._meta?.progressToken;
+      const onProgress = progressToken != null ? (params) => {
+        if (params?.progressToken && params.progressToken !== progressToken) return;
+        try {
+          mcpServer.server.notification({
+            method: "notifications/progress",
+            params: { progressToken, progress: params?.step ?? 0, total: params?.total ?? args.maxSteps ?? 8, message: params?.message ?? "" }
+          });
+        } catch {
+        }
+      } : void 0;
+      if (onProgress) adapter.bridgeClient.on("progress", onProgress);
+      try {
+        const result = await adapter.runSubAgent(args.instruction, {
+          tabId: args.tabId,
+          maxSteps: args.maxSteps,
+          progressToken
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } finally {
+        if (onProgress) adapter.bridgeClient.off("progress", onProgress);
+      }
+    }
+  );
+  if (!isAgentMode) {
+    server.registerTool(
+      "browser_skills_list",
+      {
+        description: "\u3010\u6280\u80FD\u6E10\u8FDB\u5F0F\u62AB\u9732 - L1 \u7D22\u5F15\u5C42\u3011\u83B7\u53D6\u5F53\u524D\u6D4F\u89C8\u5668\u6269\u5C55\u4E2D\u5DF2\u7EF4\u62A4\u7684\u6240\u6709 Skills \u6280\u80FD\u7B80\u77ED\u6E05\u5355\uFF08\u4EC5\u8FD4\u56DE\u540D\u79F0\u3001\u7B80\u4ECB\uFF0C\u6D88\u8017\u6781\u5C11 Token\uFF09\u3002\u5728\u81EA\u4E3B\u6267\u884C\u590D\u6742\u6216\u5782\u76F4\u9886\u57DF\u4EFB\u52A1\u524D\uFF0C\u53EF\u5148\u8C03\u7528\u6B64\u5DE5\u5177\u5339\u914D\u6700\u9002\u7528\u7684\u6280\u80FD\u3002",
+        inputSchema: BrowserSkillsListInput.shape
+      },
+      async () => {
+        const result = await adapter.listSkills();
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    );
+    server.registerTool(
+      "browser_skills_read",
+      {
+        description: "\u3010\u6280\u80FD\u6E10\u8FDB\u5F0F\u62AB\u9732 - L2 \u5951\u7EA6\u5C42\u3011\u6839\u636E\u6280\u80FD\u540D\u79F0\u6309\u9700\u8BFB\u53D6\u8BE5\u6280\u80FD\u7684\u5B8C\u6574\u8BE6\u7EC6\u6267\u884C\u6307\u4EE4 (instructions)\u3001\u5DE5\u4F5C\u6D41\u89C4\u8303\u4E0E\u8F93\u5165\u8F93\u51FA\u5951\u7EA6\u3002",
+        inputSchema: BrowserSkillsReadInput.shape
+      },
+      async (args) => {
+        const result = await adapter.getSkill(args.name);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    );
+  }
+}
+function registerSkillsResources(server, adapter) {
+  server.registerResource(
+    "skills_index",
+    "skills://index",
+    { description: "Skills L1\uFF1A\u6269\u5C55\u5DF2\u6CE8\u518C\u7684\u6240\u6709\u6280\u80FD\u5217\u8868\uFF08\u4EC5\u5143\u6570\u636E\uFF0C\u6D88\u8017\u6781\u5C11 Token\uFF09", mimeType: "application/json" },
+    async () => {
+      try {
+        const skills = await adapter.listSkills();
+        return { contents: [{ uri: "skills://index", text: JSON.stringify(skills, null, 2), mimeType: "application/json" }] };
+      } catch (err) {
+        return { contents: [{ uri: "skills://index", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }), mimeType: "application/json" }] };
+      }
+    }
+  );
+  const skillDetailTemplate = new ResourceTemplate("skills://{skillName}/detail", { list: void 0 });
+  server.registerResource(
+    "skill_detail",
+    skillDetailTemplate,
+    { description: "Skills L2\uFF1A\u6309\u6280\u80FD\u540D\u5B9E\u65F6\u62C9\u53D6\u5B8C\u6574 SOP \u6267\u884C\u6307\u4EE4\u4E0E\u8F93\u5165\u8F93\u51FA\u5951\u7EA6", mimeType: "application/json" },
+    async (uri, params) => {
+      const { skillName } = params;
+      try {
+        const detail = await adapter.getSkill(skillName);
+        return { contents: [{ uri: uri.href, text: JSON.stringify(detail, null, 2), mimeType: "application/json" }] };
+      } catch (err) {
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }), mimeType: "application/json" }] };
+      }
+    }
+  );
+  const skillResourceTemplate = new ResourceTemplate("skills://{skillName}/{resourcePath}", { list: void 0 });
+  server.registerResource(
+    "skill_resource",
+    skillResourceTemplate,
+    { description: "Skills L3\uFF1A\u8BFB\u53D6\u6280\u80FD\u5173\u8054\u7684\u6DF1\u5165\u53C2\u8003\u8D44\u6599\u6216\u914D\u7F6E\u6587\u4EF6\uFF08\u6309\u9700\u52A0\u8F7D\uFF09", mimeType: "text/plain" },
+    async (uri, params) => {
+      const { skillName, resourcePath } = params;
+      try {
+        const text = await adapter.readSkillResource(skillName, resourcePath);
+        return { contents: [{ uri: uri.href, text: String(text), mimeType: "text/plain" }] };
+      } catch (err) {
+        return { contents: [{ uri: uri.href, text: `\u8BFB\u53D6\u8D44\u6E90\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`, mimeType: "text/plain" }] };
+      }
+    }
+  );
+}
+var SERVER_NAME, SERVER_VERSION;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_package();
+    init_tools();
+    SERVER_NAME = "webmcp-cli";
+    SERVER_VERSION = package_default.version || "0.0.9";
+  }
+});
+
+// src/commands/agent.ts
+var agent_exports = {};
+__export(agent_exports, {
+  handleAgentCommand: () => handleAgentCommand
+});
+async function handleAgentCommand(adapter, args) {
+  const subCommand = args[0];
+  const restArgs = args.slice(1);
+  if (!subCommand || subCommand === "--help" || subCommand === "-h") {
+    printAgentHelp();
+    return;
+  }
+  if (subCommand === "run") {
+    await handleAgentRun(adapter, restArgs);
+    return;
+  }
+  console.error(`[\u9519\u8BEF] \u672A\u77E5\u5B50\u547D\u4EE4: agent ${subCommand}`);
+  console.error("\u8FD0\u884C webmcp-cli --mode wxt agent --help \u67E5\u770B\u652F\u6301\u7684\u547D\u4EE4");
+  process.exit(1);
+}
+async function handleAgentRun(adapter, args) {
+  let instruction = "";
+  let maxSteps;
+  let tabId;
+  const isJson = args.includes("--json");
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--max-steps" && args[i + 1]) {
+      maxSteps = parseInt(args[++i], 10);
+    } else if (arg === "--tab" && args[i + 1]) {
+      tabId = parseInt(args[++i], 10);
+    } else if (!arg.startsWith("-")) {
+      instruction = arg;
+    }
+  }
+  if (!instruction) {
+    console.error('[\u9519\u8BEF] \u8BF7\u63D0\u4F9B\u4EFB\u52A1\u6307\u4EE4\u3002\u793A\u4F8B\uFF1Awebmcp-cli --mode wxt agent run "\u5E2E\u6211\u641C\u7D22\u6700\u65B0\u65B0\u95FB"');
+    process.exit(1);
+  }
+  if (!isJson) {
+    console.log(`\u{1F916} \u6B63\u5728\u59D4\u6258 Tiny Robot \u5B50\u4EE3\u7406\u6267\u884C\u4EFB\u52A1\uFF1A\u300C${instruction}\u300D`);
+    if (maxSteps) console.log(`   \u6700\u5927\u6B65\u6570\uFF1A${maxSteps}`);
+  }
+  try {
+    const result = await adapter.runSubAgent(instruction, { tabId, maxSteps });
+    if (isJson) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log("\n\u2705 \u5B50\u4EE3\u7406\u6267\u884C\u5B8C\u6210\uFF1A");
+      console.log(JSON.stringify(result, null, 2));
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (isJson) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      console.error(`\u274C \u6267\u884C\u5931\u8D25\uFF1A${msg}`);
+    }
+    process.exit(1);
+  }
+}
+function printAgentHelp() {
+  console.log(`
+webmcp-cli --mode wxt agent - \u59D4\u6258 Chrome \u6269\u5C55\u5185 Tiny Robot \u5B50\u4EE3\u7406\u6267\u884C\u9AD8\u5C42\u4EFB\u52A1
+
+\u7528\u6CD5\uFF1A
+  webmcp-cli --mode wxt agent run "<\u6307\u4EE4>"   \u59D4\u6258\u5B50\u4EE3\u7406\u81EA\u4E3B\u6267\u884C\u81EA\u7136\u8BED\u8A00\u4EFB\u52A1
+
+\u9009\u9879\uFF1A
+  --max-steps <n>    \u6700\u5927\u6267\u884C\u6B65\u6570\uFF08\u9ED8\u8BA4 8\uFF0C\u6700\u5927 20\uFF09
+  --tab <tabId>      \u6307\u5B9A\u76EE\u6807\u6807\u7B7E\u9875 ID
+  --json             \u8F93\u51FA JSON \u683C\u5F0F\u7ED3\u679C
+
+\u793A\u4F8B\uFF1A
+  webmcp-cli --mode wxt agent run "\u5E2E\u6211\u628A\u5F53\u524D\u5546\u54C1\u52A0\u5165\u8D2D\u7269\u8F66"
+  webmcp-cli --mode wxt agent run "\u641C\u7D22\u5E76\u6536\u85CF\u524D3\u7BC7\u6587\u7AE0" --max-steps 10
+`.trim());
+}
+var init_agent = __esm({
+  "src/commands/agent.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/skills.ts
+var skills_exports = {};
+__export(skills_exports, {
+  handleSkillsCommand: () => handleSkillsCommand
+});
+async function handleSkillsCommand(adapter, args) {
+  const subCommand = args[0];
+  const restArgs = args.slice(1);
+  const isJson = args.includes("--json");
+  if (!subCommand || subCommand === "--help" || subCommand === "-h") {
+    printSkillsHelp();
+    return;
+  }
+  if (subCommand === "list") {
+    await handleSkillsList(adapter, isJson);
+    return;
+  }
+  if (subCommand === "get") {
+    const skillName = restArgs.find((a) => !a.startsWith("-"));
+    if (!skillName) {
+      console.error("[\u9519\u8BEF] \u8BF7\u63D0\u4F9B\u6280\u80FD\u540D\u79F0\u3002\u793A\u4F8B\uFF1Awebmcp-cli --mode wxt skills get <skillName>");
+      process.exit(1);
+    }
+    await handleSkillsGet(adapter, skillName, isJson);
+    return;
+  }
+  console.error(`[\u9519\u8BEF] \u672A\u77E5\u5B50\u547D\u4EE4: skills ${subCommand}`);
+  printSkillsHelp();
+  process.exit(1);
+}
+async function handleSkillsList(adapter, isJson) {
+  try {
+    const result = await adapter.listSkills();
+    if (isJson) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      const skills = result;
+      if (!skills || skills.length === 0) {
+        console.log("\uFF08\u5F53\u524D\u6269\u5C55\u672A\u6CE8\u518C\u4EFB\u4F55\u6280\u80FD\uFF09");
+        return;
+      }
+      console.log(`
+\u{1F4DA} \u5DF2\u6CE8\u518C Skills\uFF08\u5171 ${skills.length} \u4E2A\uFF09\uFF1A
+`);
+      for (const skill of skills) {
+        console.log(`  \u2022 ${skill.name}`);
+        if (skill.description) {
+          console.log(`    ${skill.description.slice(0, 100)}${skill.description.length > 100 ? "..." : ""}`);
+        }
+      }
+      console.log(`
+\u63D0\u793A\uFF1A\u4F7F\u7528 "webmcp-cli --mode wxt skills get <name>" \u67E5\u770B\u6280\u80FD\u8BE6\u60C5`);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (isJson) {
+      console.log(JSON.stringify({ error: msg }));
+    } else {
+      console.error(`\u274C \u83B7\u53D6\u6280\u80FD\u5217\u8868\u5931\u8D25\uFF1A${msg}`);
+    }
+    process.exit(1);
+  }
+}
+async function handleSkillsGet(adapter, name, isJson) {
+  try {
+    const result = await adapter.getSkill(name);
+    if (isJson) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      const skill = result;
+      console.log(`
+\u{1F4D6} \u6280\u80FD\uFF1A${skill.name}`);
+      if (skill.description) console.log(`\u63CF\u8FF0\uFF1A${skill.description}`);
+      if (skill.instructions) {
+        console.log("\n--- \u6307\u4EE4 ---");
+        console.log(skill.instructions);
+      }
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (isJson) {
+      console.log(JSON.stringify({ error: msg }));
+    } else {
+      console.error(`\u274C \u83B7\u53D6\u6280\u80FD\u8BE6\u60C5\u5931\u8D25\uFF1A${msg}`);
+    }
+    process.exit(1);
+  }
+}
+function printSkillsHelp() {
+  console.log(`
+webmcp-cli --mode wxt skills - \u67E5\u8BE2\u4E0E\u8BFB\u53D6\u6D4F\u89C8\u5668\u6269\u5C55\u4E2D\u6CE8\u518C\u7684 Skills \u6280\u80FD
+
+\u7528\u6CD5\uFF1A
+  webmcp-cli --mode wxt skills list          \u5217\u51FA\u6240\u6709\u5DF2\u6CE8\u518C\u7684\u6280\u80FD
+  webmcp-cli --mode wxt skills get <name>    \u8BFB\u53D6\u6307\u5B9A\u6280\u80FD\u7684\u8BE6\u7EC6\u6267\u884C\u6307\u4EE4
+
+\u9009\u9879\uFF1A
+  --json    \u8F93\u51FA JSON \u683C\u5F0F\u7ED3\u679C
+
+\u793A\u4F8B\uFF1A
+  webmcp-cli --mode wxt skills list
+  webmcp-cli --mode wxt skills get order-management
+`.trim());
+}
+var init_skills = __esm({
+  "src/commands/skills.ts"() {
+    "use strict";
+  }
+});
+
+// src/bin.ts
+import fs6 from "fs";
+import path7 from "path";
+import os5 from "os";
+import { Command } from "commander";
+import pc2 from "picocolors";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/expand-file-refs.ts
+import { readFileSync } from "fs";
+import { dirname, isAbsolute, normalize, resolve } from "path";
+import { fileURLToPath } from "url";
+var JSON_STRING_LITERAL = /"(?:[^"\\]|\\.)*"/g;
+var UNQUOTED_FILE_REF = /(?<![\\"])@(base64)?file:([^\s"',}\]]+)/g;
+var FILE_REF_PREFIX = /^@(base64)?file:(.+)$/s;
+function resolveFilePath(filePath, baseDir = process.cwd()) {
+  let normalizedPath = filePath.trim();
+  if (normalizedPath.startsWith('"') && normalizedPath.endsWith('"') || normalizedPath.startsWith("'") && normalizedPath.endsWith("'")) {
+    normalizedPath = normalizedPath.slice(1, -1).trim();
+  }
+  if (normalizedPath.startsWith("file://")) {
+    normalizedPath = fileURLToPath(normalizedPath);
+  }
+  if (isAbsolute(normalizedPath)) {
+    return normalize(normalizedPath);
+  }
+  return resolve(baseDir, normalizedPath);
+}
+function decodeFilePath(rawPath) {
+  return rawPath.replace(/\\\\/g, "\\");
+}
+function readFileRefContent(filePath, baseDir, base64) {
+  const absPath = resolveFilePath(filePath, baseDir);
+  let content;
+  try {
+    content = readFileSync(absPath, "utf-8");
+  } catch (e) {
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6\u5F15\u7528 "${filePath}" (${absPath}): ${e.message}`);
+  }
+  return base64 ? Buffer.from(content, "utf-8").toString("base64") : content;
+}
+function expandFileRefValue(rawInner, baseDir) {
+  const match = rawInner.match(FILE_REF_PREFIX);
+  if (!match) {
+    return null;
+  }
+  const [, base64Flag, rawPath] = match;
+  const filePath = decodeFilePath(rawPath);
+  const value = readFileRefContent(filePath, baseDir, Boolean(base64Flag));
+  return JSON.stringify(value);
+}
+function expandQuotedFileRefs(argsJson, baseDir) {
+  return argsJson.replace(JSON_STRING_LITERAL, (jsonStringLiteral) => {
+    const rawInner = jsonStringLiteral.slice(1, -1);
+    const replacement = expandFileRefValue(rawInner, baseDir);
+    return replacement ?? jsonStringLiteral;
+  });
+}
+function expandUnquotedFileRefs(argsJson, baseDir) {
+  return argsJson.replace(UNQUOTED_FILE_REF, (match, base64Flag, filePath) => {
+    const value = readFileRefContent(filePath, baseDir, Boolean(base64Flag));
+    return JSON.stringify(value);
+  });
+}
+function expandFileRefs(argsJson, baseDir = process.cwd()) {
+  const withQuotedExpanded = expandQuotedFileRefs(argsJson, baseDir);
+  return expandUnquotedFileRefs(withQuotedExpanded, baseDir);
+}
+function getFileBaseDir(fileOption) {
+  if (!fileOption) {
+    return process.cwd();
+  }
+  return dirname(resolve(process.cwd(), fileOption));
+}
+
+// src/parse-run-args.ts
+import JSON5 from "json5";
+function cleanJsonString(str) {
+  let cleaned = str.trim();
+  if (cleaned.startsWith("'") && cleaned.endsWith("'")) {
+    cleaned = cleaned.slice(1, -1).trim();
+  }
+  return cleaned;
+}
+function looksLikeObjectBody(raw) {
+  return /^("?[\w-]+"?\s*:)/.test(raw);
+}
+function joinShellArgs(args) {
+  const cleaned = args.map(cleanJsonString);
+  const first = cleaned[0] ?? "";
+  if (first.startsWith("{")) {
+    return cleaned.join(" ");
   }
-  let targetPage = null;
-  if (tabid !== void 0) {
-    const target = findPageTargetByTabId(browser, tabid);
-    if (!target) {
-      throw new Error(`Tab with targetId "${tabid}" not found.`);
+  if (looksLikeObjectBody(first)) {
+    let joined = cleaned.join(" ");
+    if (!joined.startsWith("{")) {
+      joined = `{${joined}}`;
     }
-    targetPage = await target.page();
-  } else {
-    const lastTabId = getLastActiveTabId();
-    if (lastTabId) {
-      const lastTarget = findPageTargetByTabId(browser, lastTabId);
-      if (lastTarget) {
-        targetPage = await lastTarget.page();
-      }
+    if (!joined.endsWith("}")) {
+      joined = `${joined}}`;
     }
-    if (!targetPage) {
-      try {
-        const workspaceDir = getWorkspaceDir();
-        const cdpPort = getCdpPort();
-        const recordedPort = readActivePortFromProfile(workspaceDir);
-        const ports = recordedPort && recordedPort !== cdpPort ? [recordedPort, cdpPort] : [cdpPort];
-        const urls = ports.flatMap((port) => candidateCdpBaseUrls(port).map((u) => `${u}/json/list`));
-        let activeTargetId = null;
-        for (const url of urls) {
-          try {
-            const body = await httpGet(url, 1e3);
-            const targetsData = JSON.parse(body);
-            const active = targetsData.find((t) => t.type === "page" && !t.url.startsWith("devtools://"));
-            if (active) {
-              activeTargetId = active.id;
-              break;
-            }
-          } catch {
-          }
-        }
-        if (activeTargetId) {
-          for (const target of pageTargets) {
-            if (getTargetIdFromTarget(target) === activeTargetId) {
-              targetPage = await target.page();
-              break;
-            }
-          }
-        }
-      } catch {
+    return joined;
+  }
+  return cleaned.join(" ");
+}
+function insertMissingCommas(raw) {
+  return raw.replace(/"(\s+)("?[\w-]+"?\s*:)/g, '",$2');
+}
+function quoteUnquotedStringValues(raw) {
+  return raw.replace(
+    /([{,]\s*(?:"([^"]+)"|([\w-]+))\s*:\s*)(?!"@(?:base64)?file:|"|true|false|null|-?\d|\{|\[)([^",}\]]+?)(?=\s*[,}])/g,
+    (_match, prefix, _quotedKey, _unquotedKey, value) => {
+      const trimmed = value.trim();
+      if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(trimmed)) {
+        return prefix + trimmed;
       }
+      return prefix + JSON.stringify(trimmed);
     }
-    if (!targetPage) {
-      const lastTarget = pageTargets[pageTargets.length - 1];
-      targetPage = await lastTarget.page();
-    }
-  }
-  if (!targetPage) {
-    throw new Error("\u65E0\u6CD5\u83B7\u53D6\u76EE\u6807\u9875\u9762");
-  }
-  await injectWebMCPPolyfillAndTools(targetPage);
-  return targetPage;
+  );
 }
-async function injectIntoPage(page) {
-  await injectWebMCPPolyfillAndTools(page);
+function normalizeShellDamagedJson(raw) {
+  let normalized = raw.trim();
+  normalized = insertMissingCommas(normalized);
+  normalized = quoteUnquotedStringValues(normalized);
+  return normalized;
 }
-async function injectWebMCPPolyfillAndTools(page) {
-  const polyfillReady = await page.evaluate(() => {
-    return !!window.__webmcpcli_init;
-  }).catch(() => false);
-  if (!polyfillReady) {
-    console.log(pc.cyan("\u5F53\u524D\u9875\u9762\u5C1A\u672A\u6CE8\u5165 WebMCP \u73AF\u5883\uFF0C\u6B63\u5728\u6267\u884C\u81EA\u52A8\u6CE8\u5165..."));
-    const injectScriptPath = path.resolve(__dirname, "inject-bundle.js");
-    if (!fs.existsSync(injectScriptPath)) {
-      throw new Error(`Cannot find inject-bundle.js at ${injectScriptPath}. Please ensure you run 'pnpm build:inject' first.`);
+function buildArgsFromKeyValuePairs(args) {
+  const obj = {};
+  for (const pair of args) {
+    const index = pair.indexOf("=");
+    if (index === -1) {
+      throw new Error(`\u65E0\u6548\u7684\u53C2\u6570\u683C\u5F0F "${pair}"\u3002\u8BF7\u4F7F\u7528 key=value\uFF0C\u6216 JSON / -f \u6587\u4EF6\u3002`);
     }
-    const scriptContent = fs.readFileSync(injectScriptPath, "utf-8");
+    const key = pair.substring(0, index).trim();
+    let val = cleanJsonString(pair.substring(index + 1).trim());
     try {
-      await page.evaluate(scriptContent);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      throw new Error("\u81EA\u52A8\u6CE8\u5165\u811A\u672C\u6267\u884C\u5931\u8D25: " + msg);
+      obj[key] = JSON.parse(val);
+    } catch {
+      obj[key] = val;
     }
-    await page.waitForFunction(() => {
-      const mcp = navigator.modelContext;
-      return mcp && typeof mcp.registerTool === "function";
-    }, { timeout: 1e4 }).catch(() => {
-      console.warn("\u7B49\u5F85 WebMCP registerTool \u63A5\u53E3\u5C31\u7EEA\u8D85\u65F6\uFF0C\u6B63\u5728\u7EE7\u7EED\u6CE8\u5165...");
-    });
   }
-  await injectDomainTools(page);
+  return JSON.stringify(obj);
 }
-function getToolsBundleName(hostname) {
-  const normalized = hostname.split(":")[0].toLowerCase();
-  const toolsDir = path.resolve(__dirname, "webmcp-tools");
-  if (!fs.existsSync(toolsDir)) {
-    return null;
-  }
-  let files = [];
+function parseArgsJson(raw) {
+  const trimmed = cleanJsonString(raw);
   try {
-    files = fs.readdirSync(toolsDir);
-  } catch {
-    return null;
-  }
-  const supportedDomains = files.filter((f) => f.endsWith(".js")).map((f) => f.slice(0, -3));
-  if (supportedDomains.includes(normalized)) {
-    return `webmcp-tools/${normalized}.js`;
-  }
-  for (const domain of supportedDomains) {
-    if (normalized.endsWith("." + domain)) {
-      return `webmcp-tools/${domain}.js`;
+    return JSON.stringify(JSON5.parse(trimmed));
+  } catch (firstError) {
+    const repaired = normalizeShellDamagedJson(trimmed);
+    try {
+      return JSON.stringify(JSON5.parse(repaired));
+    } catch {
+      const hint = `\u63D0\u793A\uFF1Abash \u4E2D JSON \u5FC5\u987B\u7528\u5355\u5F15\u53F7\u5305\u88F9\uFF0C\u4F8B\u5982 '{"title":"\u6807\u9898","content":"@base64file:./article.md"}'\uFF1B\u6216\u4F7F\u7528 key=value\uFF1Atitle=\u6807\u9898 content=@base64file:./article.md\uFF1B\u6216\u4F7F\u7528 -f args.json\u3002`;
+      const message = firstError instanceof Error ? firstError.message : String(firstError);
+      throw new Error(`\u53C2\u6570\u4E0D\u662F\u6709\u6548\u7684 JSON \u6216 JS \u5BF9\u8C61: ${message}
+${hint}`);
     }
   }
-  return null;
 }
-async function injectDomainTools(page) {
-  let hostname;
-  try {
-    const url = new URL(page.url());
-    hostname = url.hostname;
-  } catch {
-    return;
-  }
-  const bundleName = getToolsBundleName(hostname);
-  if (!bundleName) {
-    return;
+function prepareRunArgsJson(args, fileContent, baseDir) {
+  if (fileContent !== void 0) {
+    const trimmed = fileContent.trim();
+    if (!trimmed) {
+      throw new Error("\u901A\u8FC7 -f/--file \u6307\u5B9A\u7684\u53C2\u6570\u6587\u4EF6\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A");
+    }
+    const expanded2 = expandFileRefs(trimmed, baseDir);
+    return parseArgsJson(expanded2);
   }
-  const toolBundlePath = path.resolve(__dirname, bundleName);
-  if (!fs.existsSync(toolBundlePath)) {
-    return;
+  if (args.length === 0) {
+    return "{}";
   }
-  const bundleKey = bundleName.replace(/^webmcp-tools\//, "").replace(/\.js$/, "");
-  const flagKey = `__webmcptools_${bundleKey.replace(/[^a-zA-Z0-9]/g, "")}`;
-  const alreadyInjected = await page.evaluate((key) => !!window[key], flagKey).catch(() => false);
-  if (alreadyInjected) {
-    return;
+  const joined = joinShellArgs(args);
+  let raw = "";
+  if (joined.startsWith("{") || looksLikeObjectBody(joined)) {
+    raw = joined;
+  } else if (args.every((arg) => arg.includes("="))) {
+    raw = buildArgsFromKeyValuePairs(args);
+  } else {
+    raw = joined;
   }
-  console.log(pc.cyan(`\u68C0\u6D4B\u5230\u57DF\u540D ${hostname} \u6709\u9884\u7F6E\u5DE5\u5177\uFF0C\u6B63\u5728\u6CE8\u5165...`));
-  const toolScript = fs.readFileSync(toolBundlePath, "utf-8");
-  try {
-    await page.evaluate(toolScript);
-    console.log(pc.green(`\u5DF2\u4E3A ${hostname} \u6CE8\u5165\u9884\u7F6E\u5DE5\u5177`));
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.warn(pc.yellow(`\u57DF\u540D\u5DE5\u5177\u6CE8\u5165\u5931\u8D25 (${hostname}): ${msg}`));
+  if (!raw.trim()) {
+    throw new Error("\u672A\u63D0\u4F9B\u6709\u6548\u53C2\u6570");
   }
+  const expanded = expandFileRefs(raw, baseDir);
+  return parseArgsJson(expanded);
 }
 
 // src/commands/state.ts
+init_browser();
 async function stateCommand({ tabid }) {
   const browser = await connectBrowser();
   try {
@@ -725,6 +3856,7 @@ async function stateCommand({ tabid }) {
 }
 
 // src/commands/run.ts
+init_browser();
 async function runCommand({
   toolName,
   argsJson,
@@ -799,6 +3931,7 @@ async function setClipboard(content) {
 }
 
 // src/commands/tabs.ts
+init_browser();
 function normalizeUrl(url) {
   if (!url.startsWith("http://") && !url.startsWith("https://")) {
     return "https://" + url;
@@ -920,75 +4053,26 @@ async function tabsForwardCommand(tabid) {
   }
 }
 
-// package.json
-var package_default = {
-  name: "@opentiny/webmcp-cli",
-  version: "0.1.1-alpha.1",
-  type: "module",
-  description: "WebMCP CLI for AI Agents to interact with browser via Puppeteer",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/opentiny/webmcp-sdk.git",
-    directory: "packages/webmcp-cli"
-  },
-  bugs: {
-    url: "https://github.com/opentiny/webmcp-sdk/issues"
-  },
-  main: "dist/index.js",
-  types: "dist/index.d.ts",
-  bin: {
-    "webmcp-cli": "./dist/bin.js"
-  },
-  files: [
-    "dist",
-    "README.md"
-  ],
-  scripts: {
-    dev: "tsup --watch",
-    "build:inject": "node scripts/build-inject.mjs",
-    build: "tsup && pnpm run build:inject",
-    prepublishOnly: "pnpm run build",
-    "link:global": "npm install -g .",
-    start: "node dist/bin.js",
-    test: "vitest run",
-    "test:watch": "vitest",
-    "test:browser": "vitest run --config vitest.e2e.config.ts"
-  },
-  keywords: [
-    "chrome",
-    "puppeteer",
-    "cli"
-  ],
-  license: "MIT",
-  author: "OpenTiny Team",
-  engines: {
-    node: ">=16"
-  },
-  publishConfig: {
-    access: "public"
-  },
-  dependencies: {
-    "@mcp-b/webmcp-polyfill": "catalog:",
-    "@opentiny/next-sdk": "workspace:^",
-    "@page-agent/page-controller": "catalog:",
-    clipboardy: "^5.3.1",
-    commander: "^11.1.0",
-    json5: "^2.2.3",
-    marked: "^15.0.7",
-    picocolors: "^1.0.0",
-    "puppeteer-core": "^22.0.0"
-  },
-  devDependencies: {
-    "@types/node": "^20.0.0",
-    esbuild: "^0.25.0",
-    tsup: "^8.0.2",
-    tsx: "^4.0.0",
-    typescript: "^5.3.3",
-    vitest: "^4.1.10"
-  }
-};
-
 // src/bin.ts
+init_package();
+function extractMode(argv) {
+  let mode = process.env.WEBMCP_MODE === "wxt" ? "wxt" : "cdp";
+  const filteredArgv = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--mode" && argv[i + 1]) {
+      const val = argv[i + 1].toLowerCase();
+      if (val === "wxt" || val === "cdp") mode = val;
+      i++;
+    } else if (argv[i].startsWith("--mode=")) {
+      const val = argv[i].split("=")[1]?.toLowerCase();
+      if (val === "wxt" || val === "cdp") mode = val;
+    } else {
+      filteredArgv.push(argv[i]);
+    }
+  }
+  return { mode, filteredArgv };
+}
+var { mode: CLI_MODE, filteredArgv: FILTERED_ARGV } = extractMode(process.argv);
 var program = new Command();
 function parseTabId(id) {
   if (!id) return void 0;
@@ -1020,26 +4104,26 @@ function tryParseBrowserStateText(text) {
 }
 function cleanOldLogs(baseDir, logDir) {
   try {
-    const oldLogFile = path2.join(baseDir, "webmcp-cli.log");
-    if (fs2.existsSync(oldLogFile)) {
+    const oldLogFile = path7.join(baseDir, "webmcp-cli.log");
+    if (fs6.existsSync(oldLogFile)) {
       try {
-        fs2.unlinkSync(oldLogFile);
+        fs6.unlinkSync(oldLogFile);
       } catch {
       }
     }
-    if (fs2.existsSync(baseDir)) {
-      const baseFiles = fs2.readdirSync(baseDir);
+    if (fs6.existsSync(baseDir)) {
+      const baseFiles = fs6.readdirSync(baseDir);
       for (const file of baseFiles) {
         if (/^webmcp-cli-\d{4}-\d{2}-\d{2}\.log$/.test(file)) {
           try {
-            fs2.unlinkSync(path2.join(baseDir, file));
+            fs6.unlinkSync(path7.join(baseDir, file));
           } catch {
           }
         }
       }
     }
-    if (!fs2.existsSync(logDir)) return;
-    const files = fs2.readdirSync(logDir);
+    if (!fs6.existsSync(logDir)) return;
+    const files = fs6.readdirSync(logDir);
     const logFilePattern = /^webmcp-cli-(\d{4}-\d{2}-\d{2})\.log$/;
     const now = Date.now();
     const maxAgeMs = 7 * 24 * 60 * 60 * 1e3;
@@ -1051,7 +4135,7 @@ function cleanOldLogs(baseDir, logDir) {
         if (isNaN(fileDate)) continue;
         if (now - fileDate > maxAgeMs) {
           try {
-            fs2.unlinkSync(path2.join(logDir, file));
+            fs6.unlinkSync(path7.join(logDir, file));
           } catch {
           }
         }
@@ -1107,13 +4191,13 @@ ${searchResultStr}`;
 }
 function writeLog(commandName, args, result, error) {
   try {
-    const baseDir = process.env.WEBMCP_WORKSPACE || path2.join(os2.homedir(), ".webmcp_chrome_profile");
-    const logDir = path2.join(baseDir, "logs");
-    if (!fs2.existsSync(logDir)) {
-      fs2.mkdirSync(logDir, { recursive: true });
+    const baseDir = process.env.WEBMCP_WORKSPACE || path7.join(os5.homedir(), ".webmcp_chrome_profile");
+    const logDir = path7.join(baseDir, "logs");
+    if (!fs6.existsSync(logDir)) {
+      fs6.mkdirSync(logDir, { recursive: true });
     }
     const todayStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const logFile = path2.join(logDir, `webmcp-cli-${todayStr}.log`);
+    const logFile = path7.join(logDir, `webmcp-cli-${todayStr}.log`);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     let logText = `========================================
 `;
@@ -1139,7 +4223,7 @@ ${error instanceof Error ? error.stack : String(error)}
     logText += `========================================
 
 `;
-    fs2.appendFileSync(logFile, logText, "utf-8");
+    fs6.appendFileSync(logFile, logText, "utf-8");
     cleanOldLogs(baseDir, logDir);
   } catch (e) {
   }
@@ -1150,11 +4234,22 @@ function handleCommandError(error, commandName, args) {
   console.error(pc2.red(`Error executing ${commandName} command: ${msg}`));
   process.exit(1);
 }
-program.name("webmcp-cli").description("WebMCP CLI for interacting with browser via CDP").version(package_default.version).option("-w, --workspace <path>", "\u6307\u5B9A\u81EA\u5B9A\u4E49\u7684\u6D4F\u89C8\u5668\u5DE5\u4F5C\u7A7A\u95F4\uFF08\u7528\u6237\u914D\u7F6E\u76EE\u5F55\uFF09\u8DEF\u5F84").hook("preAction", (thisCommand) => {
+program.name("webmcp-cli").description(
+  "WebMCP CLI \u2014 \u652F\u6301\u4E24\u79CD\u6D4F\u89C8\u5668\u8FDE\u63A5\u6A21\u5F0F\uFF1A\n  --mode cdp\uFF08\u9ED8\u8BA4\uFF09: \u57FA\u4E8E Puppeteer + CDP \u76F4\u8FDE\u6D4F\u89C8\u5668\uFF08\u72EC\u7ACB profile\uFF09\n  --mode wxt        : \u57FA\u4E8E WebSocket + Chrome \u6269\u5C55\u6865\u63A5\uFF08\u590D\u7528\u7528\u6237\u6570\u636E\uFF09"
+).version(package_default.version).option("-w, --workspace <path>", "\u6307\u5B9A\u81EA\u5B9A\u4E49\u7684\u6D4F\u89C8\u5668\u5DE5\u4F5C\u7A7A\u95F4\uFF08\u7528\u6237\u914D\u7F6E\u76EE\u5F55\uFF09\u8DEF\u5F84\uFF0C\u4EC5 CDP \u6A21\u5F0F\u6709\u6548").option(
+  "--ignore-certificate-errors",
+  "\u5173\u95ED\u53D7\u63A7\u6D4F\u89C8\u5668\u7684 HTTPS \u8BC1\u4E66\u6821\u9A8C\uFF08\u81EA\u7B7E\u540D\u3001\u8FC7\u671F\u6216\u4E3B\u673A\u540D\u4E0D\u5339\u914D\uFF09\u3002\u4E5F\u53EF\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF WEBMCP_IGNORE_CERTIFICATE_ERRORS=1\u3002\u9ED8\u8BA4\u4ECD\u6821\u9A8C\u3002\u4EC5 CDP \u6A21\u5F0F\u6709\u6548"
+).hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
   if (opts.workspace) {
     process.env.WEBMCP_WORKSPACE = opts.workspace;
   }
+  if (opts.ignoreCertificateErrors) {
+    process.env.WEBMCP_IGNORE_CERTIFICATE_ERRORS = "1";
+  }
+  if (process.env.WEBMCP_IGNORE_CERTIFICATE_ERRORS === "1") {
+    console.error(pc2.yellow("\u5F53\u524D\u53D7\u63A7\u6D4F\u89C8\u5668\u5DF2\u5173\u95ED TLS \u8BC1\u4E66\u6821\u9A8C\u3002"));
+  }
 });
 program.command("state").description("\u83B7\u53D6\u6D4F\u89C8\u5668\u5F53\u524D\u9875\u7B7E\u6216\u6307\u5B9A\u9875\u7B7E\u7684\u5BFC\u822A\u5143\u6570\u636E\uFF08url\u3001title\u3001webmcpTools\u3001\u6240\u6709\u9875\u7B7E\u5217\u8868\uFF09").option("-t, --tabid <id>", "\u6307\u5B9A\u9875\u7B7E\u7684 ID").action(async (options) => {
   const args = { tabid: parseTabId(options.tabid) };
@@ -1262,5 +4357,174 @@ tabs.command("forward [tabid]").description("\u5C06\u5F53\u524D\u6216\u6307\u5B9
     handleCommandError(error, "tabs forward", args);
   }
 });
-program.parse(process.argv);
+program.command("mcp").description("\u4EE5\u6807\u51C6 MCP Server \u6A21\u5F0F\u542F\u52A8\uFF08stdio \u4F20\u8F93\uFF0CCDP \u5E95\u5C42\uFF09\u3002\n\u4F7F\u7528 --mode wxt mcp \u5207\u6362\u5230 WXT \u6865\u63A5\u5E95\u5C42\u3002").option("--agent", "\u4EE5\u5B50\u4EE3\u7406\u6A21\u5F0F\u542F\u52A8\uFF08\u6536\u655B\u5DE5\u5177\u4E3A\u9AD8\u5C42\u59D4\u6258\u63A5\u53E3\uFF09").action(async (opts) => {
+  try {
+    const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    await startMcpServer2({ mode: "cdp", agentMode: opts.agent ? "agent" : "tools" });
+  } catch (error) {
+    handleCommandError(error, "mcp", {});
+  }
+});
+if (CLI_MODE === "wxt") {
+  void handleWxtMode(FILTERED_ARGV.slice(2)).catch((error) => {
+    handleCommandError(error, `wxt:${FILTERED_ARGV[2] ?? "help"}`, {});
+  });
+} else {
+  program.parse(FILTERED_ARGV);
+}
+async function handleWxtMode(args) {
+  const command = args[0];
+  if (command === "daemon" || command === "server") {
+    const { runDaemonProcess: runDaemonProcess2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+    await runDaemonProcess2(args.slice(1));
+    return;
+  }
+  if (command === "stop") {
+    const { stopBridgeDaemon: stopBridgeDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+    const stopped = await stopBridgeDaemon2();
+    console.log(stopped ? "\u2705 \u5DF2\u505C\u6B62\u540E\u53F0 WebSocket \u6865\u63A5\u670D\u52A1" : "\u2139\uFE0F \u5F53\u524D\u6CA1\u6709\u8FD0\u884C\u4E2D\u7684\u540E\u53F0\u6865\u63A5\u670D\u52A1");
+    return;
+  }
+  if (command === "token") {
+    const subArgs = args.slice(1);
+    let wsPort2;
+    const cleanArgs = [];
+    for (let i = 0; i < subArgs.length; i++) {
+      if ((subArgs[i] === "--ws-port" || subArgs[i] === "--port") && subArgs[i + 1]) {
+        wsPort2 = parseInt(subArgs[++i], 10) || void 0;
+      } else {
+        cleanArgs.push(subArgs[i]);
+      }
+    }
+    const action = cleanArgs[0];
+    let tokenToSet;
+    if (action === "set" && cleanArgs[1]) {
+      tokenToSet = cleanArgs[1].trim();
+    } else if (action && action !== "get" && !action.startsWith("-")) {
+      tokenToSet = action.trim();
+    }
+    const { resolveOrCreateAuthToken: resolveOrCreateAuthToken2 } = await Promise.resolve().then(() => (init_bridge_client(), bridge_client_exports));
+    if (tokenToSet) {
+      resolveOrCreateAuthToken2(tokenToSet);
+      console.log("\u2705 Token \u5DF2\u6210\u529F\u4FDD\u5B58\u81F3 ~/.robot-wxt/bridge-token");
+      const { stopBridgeDaemon: stopBridgeDaemon2, ensureBridgeDaemon: ensureBridgeDaemon3 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+      await stopBridgeDaemon2(wsPort2);
+      await ensureBridgeDaemon3({ token: tokenToSet, port: wsPort2 });
+      console.log("\u{1F4A1} \u540E\u7EED\u6240\u6709 CLI \u547D\u4EE4\u4E0E MCP \u5DE5\u5177\u5747\u5C06\u81EA\u52A8\u4F7F\u7528\u6B64\u51ED\u636E\uFF0C\u65E0\u9700\u91CD\u590D\u8F93\u5165\u3002");
+      return;
+    }
+    console.log(resolveOrCreateAuthToken2());
+    return;
+  }
+  if (command === "mcp") {
+    const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    const isAgent = args.includes("--agent") || args.includes("--mode=agent");
+    const tokenIdx = args.indexOf("--token");
+    const token2 = tokenIdx !== -1 ? args[tokenIdx + 1] : void 0;
+    const wsPortIdx = args.indexOf("--ws-port");
+    const wsPort2 = wsPortIdx !== -1 ? parseInt(args[wsPortIdx + 1], 10) || void 0 : void 0;
+    await startMcpServer2({ mode: "wxt", agentMode: isAgent ? "agent" : "tools", token: token2, wsPort: wsPort2 });
+    return;
+  }
+  if (!command || command === "--help" || command === "-h") {
+    printWxtHelp();
+    return;
+  }
+  let token;
+  let wsPort;
+  const commandArgs = [];
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--token" && args[i + 1]) {
+      token = args[++i];
+    } else if (args[i] === "--ws-port" && args[i + 1]) {
+      wsPort = parseInt(args[++i], 10) || void 0;
+    } else {
+      commandArgs.push(args[i]);
+    }
+  }
+  const { ensureBridgeDaemon: ensureBridgeDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  const isJson = commandArgs.includes("--json");
+  await ensureBridgeDaemon2({ token, port: wsPort, silent: isJson });
+  const { WxtBrowserAdapter: WxtBrowserAdapter2 } = await Promise.resolve().then(() => (init_wxt_adapter(), wxt_adapter_exports));
+  const adapter = new WxtBrowserAdapter2(token, wsPort);
+  await adapter.ensureConnected();
+  try {
+    switch (command) {
+      case "state": {
+        const tabIdx = commandArgs.indexOf("--tab");
+        const tabId = tabIdx !== -1 ? commandArgs[tabIdx + 1] : void 0;
+        const result = await adapter.getState(tabId ? parseInt(tabId, 10) : void 0);
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+      case "run": {
+        const toolName = commandArgs.find((a) => !a.startsWith("-"));
+        const argsStr = commandArgs.slice(commandArgs.indexOf(toolName) + 1).find((a) => !a.startsWith("-"));
+        if (!toolName) {
+          console.error("[\u9519\u8BEF] \u8BF7\u63D0\u4F9B\u5DE5\u5177\u540D\u79F0");
+          process.exit(1);
+        }
+        const toolArgs = argsStr ? JSON.parse(argsStr) : {};
+        const result = await adapter.callTool(toolName, toolArgs);
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+      case "tabs": {
+        const tabAction = commandArgs[0];
+        const tabArgs = commandArgs.slice(1);
+        const url = tabArgs.find((a) => a.startsWith("http"));
+        const tabIdVal = tabArgs.find((a) => !a.startsWith("-") && !a.startsWith("http"));
+        const result = await adapter.tabs(tabAction, {
+          url,
+          tabId: tabIdVal ? parseInt(tabIdVal, 10) : void 0
+        });
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+      case "agent": {
+        const { handleAgentCommand: handleAgentCommand2 } = await Promise.resolve().then(() => (init_agent(), agent_exports));
+        await handleAgentCommand2(adapter, commandArgs);
+        break;
+      }
+      case "skills":
+      case "skill": {
+        const { handleSkillsCommand: handleSkillsCommand2 } = await Promise.resolve().then(() => (init_skills(), skills_exports));
+        await handleSkillsCommand2(adapter, commandArgs);
+        break;
+      }
+      default:
+        console.error(`[\u9519\u8BEF] WXT \u6A21\u5F0F\u4E0B\u672A\u77E5\u547D\u4EE4: ${command}`);
+        printWxtHelp();
+        process.exit(1);
+    }
+  } finally {
+    await adapter.dispose();
+  }
+}
+function printWxtHelp() {
+  console.log(`
+webmcp-cli --mode wxt \u2014 WXT \u6865\u63A5\u6A21\u5F0F\uFF08\u901A\u8FC7 Chrome \u6269\u5C55\u8FDE\u63A5\uFF0C\u590D\u7528\u7528\u6237\u6570\u636E\uFF09
+
+\u547D\u4EE4\uFF1A
+  state                   \u83B7\u53D6\u5F53\u524D\u6D3B\u8DC3 tab \u4FE1\u606F\u4E0E\u9875\u9762\u5DE5\u5177\u5217\u8868
+  run <tool> [args]       \u8C03\u7528\u9875\u9762 WebMCP \u5DE5\u5177
+  tabs <action> [...]     \u7BA1\u7406\u6807\u7B7E\u9875\uFF08open/close/switch/back/forward\uFF09
+  agent run "<\u6307\u4EE4>"      \u59D4\u6258 Tiny Robot \u5B50\u4EE3\u7406\u81EA\u4E3B\u6267\u884C\u9AD8\u5C42\u4EFB\u52A1
+  skills list             \u5217\u51FA\u5DF2\u6CE8\u518C\u7684 Skills \u6280\u80FD
+  skills get <name>       \u8BFB\u53D6\u6307\u5B9A\u6280\u80FD\u7684\u8BE6\u7EC6\u6307\u4EE4
+  token [get|set <t>]     \u67E5\u770B\u6216\u4FDD\u5B58\u8BA4\u8BC1 Token
+  stop                    \u505C\u6B62\u540E\u53F0 WebSocket \u6865\u63A5\u670D\u52A1
+  mcp                     \u4EE5 MCP Server \u6A21\u5F0F\u542F\u52A8
+
+\u9009\u9879\uFF1A
+  --token <token>         \u8BA4\u8BC1 Token\uFF08\u4F18\u5148\u4E8E ~/.robot-wxt/bridge-token\uFF09
+  --ws-port <port>        WS \u6865\u63A5\u7AEF\u53E3\uFF08\u9ED8\u8BA4 18999\uFF09
+  --json                  \u8F93\u51FA JSON \u683C\u5F0F
+
+\u793A\u4F8B\uFF1A
+  webmcp-cli --mode wxt state
+  webmcp-cli --mode wxt agent run "\u5E2E\u6211\u628A\u5546\u54C1\u52A0\u5165\u8D2D\u7269\u8F66"
+  webmcp-cli --mode wxt mcp --agent
+  `.trim());
+}
 //# sourceMappingURL=bin.js.map