@opentiny/webmcp-cli 0.1.0 → 0.1.1

package/dist/bin.js

@@ -526,9 +526,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: {
@@ -536,7 +544,8 @@ var init_package = __esm({
       },
       files: [
         "dist",
-        "README.md"
+        "README.md",
+        "scripts/ensure-pty-helper.mjs"
       ],
       scripts: {
         dev: "tsup --watch",
@@ -545,6 +554,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"
@@ -557,7 +567,7 @@ var init_package = __esm({
       license: "MIT",
       author: "OpenTiny Team",
       engines: {
-        node: ">=16"
+        node: ">=18.19.0"
       },
       publishConfig: {
         access: "public"
@@ -569,6 +579,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",
@@ -576,6 +587,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",
@@ -797,12 +811,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,
@@ -836,8 +853,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
+    ]);
   }
 });
 
@@ -896,9 +930,11 @@ var init_workspace_manager = __esm({
 });
 
 // src/bridge/bash-executor.ts
+import { spawnSync } from "child_process";
 import fs3 from "fs";
 import path3 from "path";
-import { spawn as spawn2 } from "child_process";
+import { StringDecoder } from "string_decoder";
+import { execa } from "execa";
 function findWindowsBash() {
   const pathDirs = (process.env.PATH || "").split(path3.delimiter);
   for (const dir of pathDirs) {
@@ -949,25 +985,136 @@ 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 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 {
-      spawn2("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
-        windowsHide: true,
-        stdio: "ignore"
-      });
+      spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true, timeout: 5e3 });
     } catch {
-      child.kill("SIGKILL");
     }
-  } else {
-    child.kill("SIGTERM");
-    setTimeout(() => {
-      try {
-        child.kill("SIGKILL");
-      } catch {
-      }
-    }, 2e3);
+    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();
@@ -986,77 +1133,83 @@ 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 = spawn2(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 ? 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;
+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";
@@ -1074,11 +1227,56 @@ 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;
   }
 });
 
 // src/bridge/directory-picker.ts
-import { spawn as spawn3 } from "child_process";
+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";
@@ -1097,7 +1295,7 @@ function pickDirectoryMac(title, defaultPath) {
   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 = spawn3("osascript", ["-e", appleScript], {
+    const child = spawn2("osascript", ["-e", appleScript], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -1215,7 +1413,7 @@ $result = [FolderPicker]::Pick("${safeTitle}", "${safeDefaultPath}")
 if ($result) { Write-Output $result }
 `;
   return new Promise((resolve3, reject) => {
-    const child = spawn3("powershell", ["-STA", "-NoProfile", "-WindowStyle", "Hidden", "-Command", psScript], {
+    const child = spawn2("powershell", ["-STA", "-NoProfile", "-WindowStyle", "Hidden", "-Command", psScript], {
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
     });
@@ -1246,7 +1444,7 @@ function pickDirectoryLinux(title, defaultPath) {
     args.push(`--filename=${defaultPath}`);
   }
   return new Promise((resolve3, reject) => {
-    const child = spawn3("zenity", args, {
+    const child = spawn2("zenity", args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -1284,6 +1482,385 @@ var init_directory_picker = __esm({
   }
 });
 
+// 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, {
@@ -1298,10 +1875,14 @@ __export(bridge_client_exports, {
 });
 import { WebSocketServer, WebSocket as WsClient } from "ws";
 import { EventEmitter } from "events";
-import { randomUUID, randomBytes, createHmac, createHash, timingSafeEqual } from "crypto";
+import { randomUUID as randomUUID2, randomBytes, createHmac, createHash, timingSafeEqual } from "crypto";
 import fs4 from "fs";
-import path4 from "path";
+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();
@@ -1367,12 +1948,13 @@ var init_bridge_client = __esm({
     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 = path4.join(os3.homedir(), ".robot-wxt");
-    TOKEN_FILE_PATH = path4.join(TOKEN_FILE_DIR, "bridge-token");
+    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();
@@ -1388,6 +1970,7 @@ var init_bridge_client = __esm({
       pending = /* @__PURE__ */ new Map();
       socketAuthStates = /* @__PURE__ */ new Map();
       destroyed = false;
+      terminalSessions = null;
       idCounter = 0;
       isClientMode = false;
       explicitAuthToken;
@@ -1642,7 +2225,7 @@ var init_bridge_client = __esm({
           this.emit("error", err);
         });
         this.wss.on("connection", (socket) => {
-          const challenge = randomUUID();
+          const challenge = randomUUID2();
           const hmacSalt = randomBytes(16).toString("hex");
           const authState = {
             authenticated: false,
@@ -1684,6 +2267,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);
@@ -1730,6 +2314,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;
@@ -1802,6 +2396,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 {
@@ -1893,9 +2488,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,
@@ -1906,11 +2498,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, {
@@ -2006,9 +2648,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) {
@@ -2153,22 +2823,22 @@ __export(daemon_exports, {
   isDaemonProcessAlive: () => isDaemonProcessAlive,
   isProcessAlive: () => isProcessAlive,
   killProcessOnPort: () => killProcessOnPort,
-  killProcessTree: () => killProcessTree2,
+  killProcessTree: () => killProcessTree,
   probeServerReady: () => probeServerReady,
   runDaemonProcess: () => runDaemonProcess,
   stopBridgeDaemon: () => stopBridgeDaemon
 });
-import { spawn as spawn4, exec } from "child_process";
+import { spawn as spawn3, exec } from "child_process";
 import { promisify } from "util";
 import fs5 from "fs";
-import path5 from "path";
+import path6 from "path";
 import os4 from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getDaemonPidFile(port = WS_PORT2) {
   if (port === WS_PORT2) {
-    return path5.join(DAEMON_DIR, "daemon.pid");
+    return path6.join(DAEMON_DIR, "daemon.pid");
   }
-  return path5.join(DAEMON_DIR, `daemon-${port}.pid`);
+  return path6.join(DAEMON_DIR, `daemon-${port}.pid`);
 }
 function isProcessAlive(pid) {
   if (!pid || pid <= 0) return false;
@@ -2212,7 +2882,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 {
@@ -2250,7 +2920,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);
@@ -2314,10 +2984,10 @@ 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 = path5.dirname(fileURLToPath3(import.meta.url));
-  const distCandidate = path5.join(currentDir, "bin.js");
+  const currentDir = path6.dirname(fileURLToPath3(import.meta.url));
+  const distCandidate = path6.join(currentDir, "bin.js");
   if (fs5.existsSync(distCandidate)) return distCandidate;
-  const projectDistCandidate = path5.resolve(currentDir, "../dist/bin.js");
+  const projectDistCandidate = path6.resolve(currentDir, "../dist/bin.js");
   if (fs5.existsSync(projectDistCandidate)) return projectDistCandidate;
   return distCandidate;
 }
@@ -2326,7 +2996,7 @@ function startDaemonProcessBackground(token, port) {
   if (!fs5.existsSync(DAEMON_DIR)) {
     fs5.mkdirSync(DAEMON_DIR, { mode: 448, recursive: true });
   }
-  const child = spawn4(process.execPath, [cliEntry, "--mode", "wxt", "daemon", "--port", String(port)], {
+  const child = spawn3(process.execPath, [cliEntry, "--mode", "wxt", "daemon", "--port", String(port)], {
     detached: true,
     stdio: "ignore",
     windowsHide: true,
@@ -2432,7 +3102,7 @@ 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 {
@@ -2443,7 +3113,7 @@ async function stopBridgeDaemon(port = WS_PORT2, options = {}) {
   } else {
     if (daemonPid) {
       try {
-        const killed = await killProcessTree2(daemonPid);
+        const killed = await killProcessTree(daemonPid);
         if (killed) {
           killedAny = true;
           try {
@@ -2483,7 +3153,7 @@ var init_daemon = __esm({
     init_bridge_client();
     execAsync = promisify(exec);
     WS_PORT2 = 18999;
-    DAEMON_DIR = path5.join(os4.homedir(), ".robot-wxt");
+    DAEMON_DIR = path6.join(os4.homedir(), ".robot-wxt");
     PID_FILE = getDaemonPidFile(WS_PORT2);
   }
 });
@@ -2945,7 +3615,7 @@ var init_skills = __esm({
 
 // src/bin.ts
 import fs6 from "fs";
-import path6 from "path";
+import path7 from "path";
 import os5 from "os";
 import { Command } from "commander";
 import pc2 from "picocolors";
@@ -3434,7 +4104,7 @@ function tryParseBrowserStateText(text) {
 }
 function cleanOldLogs(baseDir, logDir) {
   try {
-    const oldLogFile = path6.join(baseDir, "webmcp-cli.log");
+    const oldLogFile = path7.join(baseDir, "webmcp-cli.log");
     if (fs6.existsSync(oldLogFile)) {
       try {
         fs6.unlinkSync(oldLogFile);
@@ -3446,7 +4116,7 @@ function cleanOldLogs(baseDir, logDir) {
       for (const file of baseFiles) {
         if (/^webmcp-cli-\d{4}-\d{2}-\d{2}\.log$/.test(file)) {
           try {
-            fs6.unlinkSync(path6.join(baseDir, file));
+            fs6.unlinkSync(path7.join(baseDir, file));
           } catch {
           }
         }
@@ -3465,7 +4135,7 @@ function cleanOldLogs(baseDir, logDir) {
         if (isNaN(fileDate)) continue;
         if (now - fileDate > maxAgeMs) {
           try {
-            fs6.unlinkSync(path6.join(logDir, file));
+            fs6.unlinkSync(path7.join(logDir, file));
           } catch {
           }
         }
@@ -3521,13 +4191,13 @@ ${searchResultStr}`;
 }
 function writeLog(commandName, args, result, error) {
   try {
-    const baseDir = process.env.WEBMCP_WORKSPACE || path6.join(os5.homedir(), ".webmcp_chrome_profile");
-    const logDir = path6.join(baseDir, "logs");
+    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 = path6.join(logDir, `webmcp-cli-${todayStr}.log`);
+    const logFile = path7.join(logDir, `webmcp-cli-${todayStr}.log`);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     let logText = `========================================
 `;