@opentiny/webmcp-cli 0.1.0 → 0.1.1

package/dist/bin.cjs

@@ -548,9 +548,17 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@opentiny/webmcp-cli",
-      version: "0.1.0",
+      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: {
@@ -558,7 +566,8 @@ var init_package = __esm({
       },
       files: [
         "dist",
-        "README.md"
+        "README.md",
+        "scripts/ensure-pty-helper.mjs"
       ],
       scripts: {
         dev: "tsup --watch",
@@ -567,6 +576,7 @@ var init_package = __esm({
         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"
@@ -579,7 +589,7 @@ var init_package = __esm({
       license: "MIT",
       author: "OpenTiny Team",
       engines: {
-        node: ">=16"
+        node: ">=18.19.0"
       },
       publishConfig: {
         access: "public"
@@ -591,6 +601,7 @@ var init_package = __esm({
         "@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",
@@ -598,6 +609,9 @@ var init_package = __esm({
         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",
@@ -819,12 +833,15 @@ var init_cdp_adapter = __esm({
 });
 
 // src/bridge/protocol.ts
-var DEFAULT_WS_PORT, PROTOCOL_VERSION, WS_CLOSE_CODE, BRIDGE_ERROR_CODE, BRIDGE_METHODS;
+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.1.0";
+    PROTOCOL_VERSION = "1.2.0";
     WS_CLOSE_CODE = {
       /** 被新接入的扩展连接平滑替换（旧连接触发退避重连） */
       REPLACED: 4e3,
@@ -858,8 +875,25 @@ var init_protocol = __esm({
       SKILLS_GET: "skills/get",
       SKILLS_READ_RESOURCE: "skills/read_resource",
       SYSTEM_BASH: "system/bash",
-      SYSTEM_PICK_DIRECTORY: "system/pick_directory"
+      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
+    ]);
   }
 });
 
@@ -968,26 +1002,137 @@ function resolveShell(forcePlatform) {
   if (!forcePlatform) cachedShell = fallback;
   return fallback;
 }
-function killProcessTree(child) {
-  if (process.platform === "win32" && child.pid) {
+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 import_node_string_decoder.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 import_node_string_decoder.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 {
-      (0, import_node_child_process.spawn)("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
-        windowsHide: true,
-        stdio: "ignore"
-      });
+      (0, import_node_child_process.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 {
-      child.kill("SIGKILL");
     }
-  } else {
-    child.kill("SIGTERM");
-    setTimeout(() => {
-      try {
-        child.kill("SIGKILL");
-      } catch {
-      }
-    }, 2e3);
   }
 }
+function ignoreStreamError(stream) {
+  stream?.on("error", () => {
+  });
+}
 async function executeBash(params) {
   const trimmedCommand = params.command?.trim();
   if (!trimmedCommand) {
@@ -1005,83 +1150,91 @@ async function executeBash(params) {
   });
   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 startTime = Date.now();
   const shell = resolveShell();
-  return new Promise((resolve3, reject) => {
-    const stdoutChunks = [];
-    let stdoutBytes = 0;
-    const stderrChunks = [];
-    let stderrBytes = 0;
-    let truncated = false;
-    let isKilled = false;
-    const child = (0, import_node_child_process.spawn)(trimmedCommand, {
-      shell,
-      cwd,
-      env: { ...process.env, ...env },
-      windowsHide: true
-    });
-    const killTimeoutTimer = setTimeout(() => {
-      isKilled = true;
-      killProcessTree(child);
-      reject(new BashTimeoutError(normalizedTimeoutMs));
-    }, normalizedTimeoutMs);
-    child.stdout.on("data", (chunk) => {
-      if (stdoutBytes < maxBuffer) {
-        const remaining = maxBuffer - stdoutBytes;
-        if (chunk.length <= remaining) {
-          stdoutChunks.push(chunk);
-          stdoutBytes += chunk.length;
-        } else {
-          stdoutChunks.push(chunk.subarray(0, remaining));
-          stdoutBytes += remaining;
-          truncated = true;
-        }
-      } else {
-        truncated = true;
-      }
-    });
-    child.stderr.on("data", (chunk) => {
-      if (stderrBytes < maxBuffer) {
-        const remaining = maxBuffer - stderrBytes;
-        if (chunk.length <= remaining) {
-          stderrChunks.push(chunk);
-          stderrBytes += chunk.length;
-        } else {
-          stderrChunks.push(chunk.subarray(0, remaining));
-          stderrBytes += remaining;
-          truncated = true;
-        }
-      } else {
-        truncated = true;
-      }
-    });
-    child.on("error", (err) => {
-      clearTimeout(killTimeoutTimer);
-      reject(err);
-    });
-    child.on("close", (exitCode, signal) => {
-      clearTimeout(killTimeoutTimer);
-      if (isKilled) return;
-      const stdout = Buffer.concat(stdoutChunks).toString("utf8").trim();
-      const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
-      resolve3({
-        stdout,
-        stderr,
-        exitCode,
-        signal,
-        durationMs: Date.now() - startTime,
-        ...truncated ? { truncated: true } : {}
-      });
-    });
+  const useTty = params.tty === true && process.platform !== "win32";
+  const detached = process.platform !== "win32";
+  const subprocess = useTty ? (0, import_execa.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
+  }) : (0, import_execa.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 import_node_fs2, import_node_path2, import_node_child_process, BashTimeoutError, DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS, DEFAULT_MAX_BUFFER, cachedShell;
+var import_node_child_process, import_node_fs2, import_node_path2, import_node_string_decoder, import_execa, 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";
+    import_node_child_process = require("child_process");
     import_node_fs2 = __toESM(require("fs"), 1);
     import_node_path2 = __toESM(require("path"), 1);
-    import_node_child_process = require("child_process");
+    import_node_string_decoder = require("string_decoder");
+    import_execa = require("execa");
     init_workspace_manager();
     BashTimeoutError = class extends Error {
       code = "TIMEOUT";
@@ -1096,6 +1249,51 @@ var init_bash_executor = __esm({
     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;
   }
 });
 
@@ -1307,6 +1505,387 @@ var init_directory_picker = __esm({
   }
 });
 
+// src/bridge/pty-backend.ts
+function interactiveArgs(shell) {
+  if (process.platform !== "win32") return ["-i"];
+  const base = import_node_path3.default.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 || import_node_path3.default.isAbsolute(shell)) return shell;
+  const names = process.platform === "win32" && !shell.toLowerCase().endsWith(".exe") ? [shell, `${shell}.exe`] : [shell];
+  for (const dir of pathEnv.split(import_node_path3.default.delimiter)) {
+    if (!dir) continue;
+    for (const name of names) {
+      const candidate = import_node_path3.default.join(dir, name);
+      try {
+        if ((0, import_node_fs3.existsSync)(candidate)) return candidate;
+      } catch {
+      }
+    }
+  }
+  if (process.platform === "win32") {
+    const systemRoot = process.env.SystemRoot || "C:\\Windows";
+    const fallbacks = [
+      import_node_path3.default.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
+      import_node_path3.default.join(systemRoot, "Sysnative", "WindowsPowerShell", "v1.0", "powershell.exe")
+    ];
+    for (const candidate of fallbacks) {
+      try {
+        if ((0, import_node_fs3.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 (0, import_node_module.createRequire)(import_meta2.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 = (0, import_node_module.createRequire)(import_meta2.url).resolve("node-pty/package.json");
+    return import_node_path3.default.join(import_node_path3.default.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 || !(0, import_node_fs3.existsSync)(helper)) return null;
+  try {
+    (0, import_node_fs3.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(import_node_os2.constants.signals)) {
+    if (value === code) return name;
+  }
+  return String(code);
+}
+function descendantPids(rootPid) {
+  const result = (0, import_node_child_process3.spawnSync)("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 {
+        (0, import_node_child_process3.spawnSync)("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 import_node_child_process3, import_node_fs3, import_node_module, import_node_path3, import_node_os2, import_meta2;
+var init_pty_backend = __esm({
+  "src/bridge/pty-backend.ts"() {
+    "use strict";
+    import_node_child_process3 = require("child_process");
+    import_node_fs3 = require("fs");
+    import_node_module = require("module");
+    import_node_path3 = __toESM(require("path"), 1);
+    import_node_os2 = require("os");
+    init_bash_executor();
+    import_meta2 = {};
+  }
+});
+
+// src/bridge/terminal-session.ts
+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 import_node_crypto, OUTPUT_CHUNK, MAX_INPUT, DEFAULT_COALESCE_MS, TERMINAL_OUTPUT_HIGH_WATER, TerminalSessionManager;
+var init_terminal_session = __esm({
+  "src/bridge/terminal-session.ts"() {
+    "use strict";
+    import_node_crypto = require("crypto");
+    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 = (0, import_node_crypto.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, {
@@ -1319,14 +1898,18 @@ __export(bridge_client_exports, {
   resolveOrCreateAuthToken: () => resolveOrCreateAuthToken,
   verifyHmacConstantTime: () => verifyHmacConstantTime
 });
+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 (!import_node_fs3.default.existsSync(TOKEN_FILE_DIR)) {
-        import_node_fs3.default.mkdirSync(TOKEN_FILE_DIR, { mode: 448, recursive: true });
+      if (!import_node_fs4.default.existsSync(TOKEN_FILE_DIR)) {
+        import_node_fs4.default.mkdirSync(TOKEN_FILE_DIR, { mode: 448, recursive: true });
       }
-      import_node_fs3.default.writeFileSync(TOKEN_FILE_PATH, token, { mode: 384, encoding: "utf8" });
+      import_node_fs4.default.writeFileSync(TOKEN_FILE_PATH, token, { mode: 384, encoding: "utf8" });
     } catch {
     }
     return token;
@@ -1335,18 +1918,18 @@ function resolveOrCreateAuthToken(explicitToken) {
     return process.env.ROBOT_WXT_BRIDGE_TOKEN.trim();
   }
   try {
-    if (import_node_fs3.default.existsSync(TOKEN_FILE_PATH)) {
-      const existing = import_node_fs3.default.readFileSync(TOKEN_FILE_PATH, "utf8").trim();
+    if (import_node_fs4.default.existsSync(TOKEN_FILE_PATH)) {
+      const existing = import_node_fs4.default.readFileSync(TOKEN_FILE_PATH, "utf8").trim();
       if (existing) return existing;
     }
   } catch {
   }
-  const newToken = (0, import_node_crypto.randomBytes)(32).toString("hex");
+  const newToken = (0, import_node_crypto2.randomBytes)(32).toString("hex");
   try {
-    if (!import_node_fs3.default.existsSync(TOKEN_FILE_DIR)) {
-      import_node_fs3.default.mkdirSync(TOKEN_FILE_DIR, { mode: 448, recursive: true });
+    if (!import_node_fs4.default.existsSync(TOKEN_FILE_DIR)) {
+      import_node_fs4.default.mkdirSync(TOKEN_FILE_DIR, { mode: 448, recursive: true });
     }
-    import_node_fs3.default.writeFileSync(TOKEN_FILE_PATH, newToken, { mode: 384, encoding: "utf8" });
+    import_node_fs4.default.writeFileSync(TOKEN_FILE_PATH, newToken, { mode: 384, encoding: "utf8" });
   } catch {
   }
   return newToken;
@@ -1355,10 +1938,10 @@ function parseMajorVersion(v) {
   return parseInt(v.split(".")[0] ?? "0", 10);
 }
 function deriveSharedSecret(tokenOrExtensionId, hmacSalt) {
-  return (0, import_node_crypto.createHash)("sha256").update(`${tokenOrExtensionId}:${hmacSalt}`).digest();
+  return (0, import_node_crypto2.createHash)("sha256").update(`${tokenOrExtensionId}:${hmacSalt}`).digest();
 }
 function computeHmac(secret, challenge) {
-  return (0, import_node_crypto.createHmac)("sha256", secret).update(challenge).digest("hex");
+  return (0, import_node_crypto2.createHmac)("sha256", secret).update(challenge).digest("hex");
 }
 function verifyHmacConstantTime(actualHex, expectedHex) {
   if (!actualHex || typeof actualHex !== "string") return false;
@@ -1366,7 +1949,7 @@ function verifyHmacConstantTime(actualHex, expectedHex) {
     const actualBuf = Buffer.from(actualHex, "hex");
     const expectedBuf = Buffer.from(expectedHex, "hex");
     if (actualBuf.length !== expectedBuf.length) return false;
-    return (0, import_node_crypto.timingSafeEqual)(actualBuf, expectedBuf);
+    return (0, import_node_crypto2.timingSafeEqual)(actualBuf, expectedBuf);
   } catch {
     return false;
   }
@@ -1377,25 +1960,26 @@ function getKillPortHint(port) {
   }
   return `lsof -ti:${port} | xargs kill -9`;
 }
-var import_ws, import_node_events, import_node_crypto, import_node_fs3, import_node_path3, import_node_os2, WS_PORT, REQUEST_TIMEOUT_MS, HANDSHAKE_TIMEOUT_MS, WS_OPEN, TOKEN_FILE_DIR, TOKEN_FILE_PATH, ExtensionBridgeClient;
+var import_ws, import_node_events, import_node_crypto2, import_node_fs4, import_node_path4, import_node_os3, 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";
     import_ws = require("ws");
     import_node_events = require("events");
-    import_node_crypto = require("crypto");
-    import_node_fs3 = __toESM(require("fs"), 1);
-    import_node_path3 = __toESM(require("path"), 1);
-    import_node_os2 = __toESM(require("os"), 1);
+    import_node_crypto2 = require("crypto");
+    import_node_fs4 = __toESM(require("fs"), 1);
+    import_node_path4 = __toESM(require("path"), 1);
+    import_node_os3 = __toESM(require("os"), 1);
     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 = import_node_path3.default.join(import_node_os2.default.homedir(), ".robot-wxt");
-    TOKEN_FILE_PATH = import_node_path3.default.join(TOKEN_FILE_DIR, "bridge-token");
+    TOKEN_FILE_DIR = import_node_path4.default.join(import_node_os3.default.homedir(), ".robot-wxt");
+    TOKEN_FILE_PATH = import_node_path4.default.join(TOKEN_FILE_DIR, "bridge-token");
     ExtensionBridgeClient = class _ExtensionBridgeClient extends import_node_events.EventEmitter {
       constructor(port = WS_PORT, authToken) {
         super();
@@ -1411,6 +1995,7 @@ var init_bridge_client = __esm({
       pending = /* @__PURE__ */ new Map();
       socketAuthStates = /* @__PURE__ */ new Map();
       destroyed = false;
+      terminalSessions = null;
       idCounter = 0;
       isClientMode = false;
       explicitAuthToken;
@@ -1665,8 +2250,8 @@ var init_bridge_client = __esm({
           this.emit("error", err);
         });
         this.wss.on("connection", (socket) => {
-          const challenge = (0, import_node_crypto.randomUUID)();
-          const hmacSalt = (0, import_node_crypto.randomBytes)(16).toString("hex");
+          const challenge = (0, import_node_crypto2.randomUUID)();
+          const hmacSalt = (0, import_node_crypto2.randomBytes)(16).toString("hex");
           const authState = {
             authenticated: false,
             challenge,
@@ -1707,6 +2292,7 @@ var init_bridge_client = __esm({
             }
             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);
@@ -1753,6 +2339,16 @@ var init_bridge_client = __esm({
           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;
@@ -1825,6 +2421,7 @@ var init_bridge_client = __esm({
         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 {
@@ -1916,9 +2513,6 @@ var init_bridge_client = __esm({
       systemRpcHandlers = Object.assign(
         /* @__PURE__ */ Object.create(null),
         {
-          [BRIDGE_METHODS.SYSTEM_BASH]: async (params) => {
-            return executeBash(params || {});
-          },
           [BRIDGE_METHODS.SYSTEM_PICK_DIRECTORY]: async (params) => {
             const selectedPath = await pickDirectory({
               title: params?.title || void 0,
@@ -1929,11 +2523,61 @@ var init_bridge_client = __esm({
               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, {
@@ -2029,9 +2673,37 @@ var init_bridge_client = __esm({
           }
         });
       }
+      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) {
@@ -2176,16 +2848,16 @@ __export(daemon_exports, {
   isDaemonProcessAlive: () => isDaemonProcessAlive,
   isProcessAlive: () => isProcessAlive,
   killProcessOnPort: () => killProcessOnPort,
-  killProcessTree: () => killProcessTree2,
+  killProcessTree: () => killProcessTree,
   probeServerReady: () => probeServerReady,
   runDaemonProcess: () => runDaemonProcess,
   stopBridgeDaemon: () => stopBridgeDaemon
 });
 function getDaemonPidFile(port = WS_PORT2) {
   if (port === WS_PORT2) {
-    return import_node_path4.default.join(DAEMON_DIR, "daemon.pid");
+    return import_node_path5.default.join(DAEMON_DIR, "daemon.pid");
   }
-  return import_node_path4.default.join(DAEMON_DIR, `daemon-${port}.pid`);
+  return import_node_path5.default.join(DAEMON_DIR, `daemon-${port}.pid`);
 }
 function isProcessAlive(pid) {
   if (!pid || pid <= 0) return false;
@@ -2229,7 +2901,7 @@ async function findPidByPort(port, excludePid) {
     return null;
   }
 }
-async function killProcessTree2(pid) {
+async function killProcessTree(pid) {
   if (!pid || pid <= 0 || pid === process.pid) return false;
   if (process.platform === "win32") {
     try {
@@ -2267,7 +2939,7 @@ async function killProcessTree2(pid) {
 async function killProcessOnPort(port) {
   const pid = await findPidByPort(port, process.pid);
   if (pid) {
-    await killProcessTree2(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);
@@ -2281,9 +2953,9 @@ async function probeServerReady(port = WS_PORT2, token, timeoutMs = 1e3) {
 }
 function isDaemonProcessAlive(port = WS_PORT2) {
   const pidFile = getDaemonPidFile(port);
-  if (!import_node_fs4.default.existsSync(pidFile)) return false;
+  if (!import_node_fs5.default.existsSync(pidFile)) return false;
   try {
-    const pid = parseInt(import_node_fs4.default.readFileSync(pidFile, "utf8").trim(), 10);
+    const pid = parseInt(import_node_fs5.default.readFileSync(pidFile, "utf8").trim(), 10);
     return Boolean(pid && isProcessAlive(pid));
   } catch {
     return false;
@@ -2331,19 +3003,19 @@ async function ensureBridgeDaemon(options = {}) {
   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 = import_node_path4.default.dirname((0, import_node_url.fileURLToPath)(import_meta2.url));
-  const distCandidate = import_node_path4.default.join(currentDir, "bin.js");
-  if (import_node_fs4.default.existsSync(distCandidate)) return distCandidate;
-  const projectDistCandidate = import_node_path4.default.resolve(currentDir, "../dist/bin.js");
-  if (import_node_fs4.default.existsSync(projectDistCandidate)) return projectDistCandidate;
+  const currentDir = import_node_path5.default.dirname((0, import_node_url.fileURLToPath)(import_meta3.url));
+  const distCandidate = import_node_path5.default.join(currentDir, "bin.js");
+  if (import_node_fs5.default.existsSync(distCandidate)) return distCandidate;
+  const projectDistCandidate = import_node_path5.default.resolve(currentDir, "../dist/bin.js");
+  if (import_node_fs5.default.existsSync(projectDistCandidate)) return projectDistCandidate;
   return distCandidate;
 }
 function startDaemonProcessBackground(token, port) {
   const cliEntry = resolveCliEntry();
-  if (!import_node_fs4.default.existsSync(DAEMON_DIR)) {
-    import_node_fs4.default.mkdirSync(DAEMON_DIR, { mode: 448, recursive: true });
+  if (!import_node_fs5.default.existsSync(DAEMON_DIR)) {
+    import_node_fs5.default.mkdirSync(DAEMON_DIR, { mode: 448, recursive: true });
   }
-  const child = (0, import_node_child_process3.spawn)(process.execPath, [cliEntry, "--mode", "wxt", "daemon", "--port", String(port)], {
+  const child = (0, import_node_child_process4.spawn)(process.execPath, [cliEntry, "--mode", "wxt", "daemon", "--port", String(port)], {
     detached: true,
     stdio: "ignore",
     windowsHide: true,
@@ -2376,20 +3048,20 @@ async function runDaemonProcess(args) {
   const pidFile = getDaemonPidFile(port);
   client.on("listening", () => {
     try {
-      if (!import_node_fs4.default.existsSync(DAEMON_DIR)) {
-        import_node_fs4.default.mkdirSync(DAEMON_DIR, { mode: 448, recursive: true });
+      if (!import_node_fs5.default.existsSync(DAEMON_DIR)) {
+        import_node_fs5.default.mkdirSync(DAEMON_DIR, { mode: 448, recursive: true });
       }
-      import_node_fs4.default.writeFileSync(pidFile, String(process.pid), { mode: 384, encoding: "utf8" });
+      import_node_fs5.default.writeFileSync(pidFile, String(process.pid), { mode: 384, encoding: "utf8" });
     } catch {
     }
   });
   client.connect();
   const shutdown = () => {
     try {
-      if (import_node_fs4.default.existsSync(pidFile)) {
-        const recordedPid = import_node_fs4.default.readFileSync(pidFile, "utf8").trim();
+      if (import_node_fs5.default.existsSync(pidFile)) {
+        const recordedPid = import_node_fs5.default.readFileSync(pidFile, "utf8").trim();
         if (recordedPid === String(process.pid)) {
-          import_node_fs4.default.unlinkSync(pidFile);
+          import_node_fs5.default.unlinkSync(pidFile);
         }
       }
     } catch {
@@ -2427,9 +3099,9 @@ async function stopBridgeDaemon(port = WS_PORT2, options = {}) {
   let killedAny = false;
   const pidFile = getDaemonPidFile(port);
   let daemonPid = null;
-  if (import_node_fs4.default.existsSync(pidFile)) {
+  if (import_node_fs5.default.existsSync(pidFile)) {
     try {
-      const pidStr = import_node_fs4.default.readFileSync(pidFile, "utf8").trim();
+      const pidStr = import_node_fs5.default.readFileSync(pidFile, "utf8").trim();
       const p = parseInt(pidStr, 10);
       if (p && isProcessAlive(p)) {
         daemonPid = p;
@@ -2449,22 +3121,22 @@ async function stopBridgeDaemon(port = WS_PORT2, options = {}) {
     if (portPid && portPid !== daemonPid) {
       return false;
     }
-    const killed = await killProcessTree2(daemonPid);
+    const killed = await killProcessTree(daemonPid);
     if (killed) {
       killedAny = true;
       try {
-        if (import_node_fs4.default.existsSync(pidFile)) import_node_fs4.default.unlinkSync(pidFile);
+        if (import_node_fs5.default.existsSync(pidFile)) import_node_fs5.default.unlinkSync(pidFile);
       } catch {
       }
     }
   } else {
     if (daemonPid) {
       try {
-        const killed = await killProcessTree2(daemonPid);
+        const killed = await killProcessTree(daemonPid);
         if (killed) {
           killedAny = true;
           try {
-            if (import_node_fs4.default.existsSync(pidFile)) import_node_fs4.default.unlinkSync(pidFile);
+            if (import_node_fs5.default.existsSync(pidFile)) import_node_fs5.default.unlinkSync(pidFile);
           } catch {
           }
         }
@@ -2493,21 +3165,21 @@ async function stopBridgeDaemon(port = WS_PORT2, options = {}) {
   }
   return killedAny;
 }
-var import_node_child_process3, import_node_util, import_node_fs4, import_node_path4, import_node_os3, import_node_url, import_meta2, execAsync, WS_PORT2, DAEMON_DIR, PID_FILE;
+var import_node_child_process4, import_node_util, import_node_fs5, import_node_path5, import_node_os4, import_node_url, import_meta3, execAsync, WS_PORT2, DAEMON_DIR, PID_FILE;
 var init_daemon = __esm({
   "src/bridge/daemon.ts"() {
     "use strict";
-    import_node_child_process3 = require("child_process");
+    import_node_child_process4 = require("child_process");
     import_node_util = require("util");
-    import_node_fs4 = __toESM(require("fs"), 1);
-    import_node_path4 = __toESM(require("path"), 1);
-    import_node_os3 = __toESM(require("os"), 1);
+    import_node_fs5 = __toESM(require("fs"), 1);
+    import_node_path5 = __toESM(require("path"), 1);
+    import_node_os4 = __toESM(require("os"), 1);
     import_node_url = require("url");
     init_bridge_client();
-    import_meta2 = {};
-    execAsync = (0, import_node_util.promisify)(import_node_child_process3.exec);
+    import_meta3 = {};
+    execAsync = (0, import_node_util.promisify)(import_node_child_process4.exec);
     WS_PORT2 = 18999;
-    DAEMON_DIR = import_node_path4.default.join(import_node_os3.default.homedir(), ".robot-wxt");
+    DAEMON_DIR = import_node_path5.default.join(import_node_os4.default.homedir(), ".robot-wxt");
     PID_FILE = getDaemonPidFile(WS_PORT2);
   }
 });