@opentiny/webmcp-cli 0.1.0-alpha.1 → 0.1.0-beta.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-alpha.1",
+      version: "0.1.0-beta.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: {
@@ -579,7 +587,7 @@ var init_package = __esm({
       license: "MIT",
       author: "OpenTiny Team",
       engines: {
-        node: ">=16"
+        node: ">=18.19.0"
       },
       publishConfig: {
         access: "public"
@@ -591,6 +599,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",
@@ -819,12 +828,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 +870,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,25 +997,56 @@ function resolveShell(forcePlatform) {
   if (!forcePlatform) cachedShell = fallback;
   return fallback;
 }
-function killProcessTree(child) {
-  if (process.platform === "win32" && child.pid) {
-    try {
-      (0, import_node_child_process.spawn)("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
-        windowsHide: true,
-        stdio: "ignore"
-      });
-    } catch {
-      child.kill("SIGKILL");
+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) {
+  const state = { chunks: [], truncated: false };
+  if (!stream) return state;
+  const decoder = new import_node_string_decoder.StringDecoder("utf8");
+  let bytes = 0;
+  const emit = (buf) => {
+    const text = decoder.write(buf);
+    if (text) onText?.(text);
+  };
+  stream.on("data", (chunk) => {
+    const raw = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const buf = stripCarriageReturn ? withoutCarriageReturn(raw) : raw;
+    if (buf.length === 0) return;
+    if (bytes >= maxBuffer) {
+      state.truncated = true;
+      return;
     }
-  } else {
-    child.kill("SIGTERM");
-    setTimeout(() => {
-      try {
-        child.kill("SIGKILL");
-      } catch {
-      }
-    }, 2e3);
-  }
+    const remaining = maxBuffer - bytes;
+    if (buf.length <= remaining) {
+      state.chunks.push(buf);
+      bytes += buf.length;
+      emit(buf);
+      return;
+    }
+    const kept = buf.subarray(0, remaining);
+    state.chunks.push(kept);
+    bytes += remaining;
+    state.truncated = true;
+    emit(kept);
+  });
+  stream.on("end", () => {
+    const rest = decoder.end();
+    if (rest) onText?.(rest);
+  });
+  return state;
+}
+function decodeLimited(state) {
+  return Buffer.concat(state.chunks).toString("utf8").trim();
 }
 async function executeBash(params) {
   const trimmedCommand = params.command?.trim();
@@ -1005,83 +1065,66 @@ 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 subprocess = useTty ? (0, import_execa.execa)("python3", ["-u", "-c", TTY_HELPER], {
+    cwd,
+    env: {
+      ...env,
+      BASH_TTY_COMMAND: trimmedCommand,
+      BASH_TTY_SHELL: shell
+    },
+    stdin: "ignore",
+    buffer: false,
+    encoding: "buffer",
+    reject: false,
+    timeout: normalizedTimeoutMs,
+    forceKillAfterDelay: FORCE_KILL_AFTER_DELAY_MS,
+    windowsHide: true,
+    stripFinalNewline: false
+  }) : (0, import_execa.execa)(trimmedCommand, {
+    shell,
+    cwd,
+    env,
+    stdin: "ignore",
+    buffer: false,
+    encoding: "buffer",
+    reject: false,
+    timeout: normalizedTimeoutMs,
+    forceKillAfterDelay: FORCE_KILL_AFTER_DELAY_MS,
+    windowsHide: true,
+    stripFinalNewline: false
   });
+  const emit = (stream) => (text) => {
+    params.onOutput?.({ stream, text });
+  };
+  const stdoutState = collectLimited(subprocess.stdout, maxBuffer, emit("stdout"), useTty);
+  const stderrState = collectLimited(subprocess.stderr, maxBuffer, emit("stderr"));
+  const result = await subprocess;
+  if (result.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),
+    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_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;
 var init_bash_executor = __esm({
   "src/bridge/bash-executor.ts"() {
     "use strict";
     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 +1139,46 @@ 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:
+        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)
+`;
   }
 });
 
@@ -1118,7 +1201,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 = (0, import_node_child_process2.spawn)("osascript", ["-e", appleScript], {
+    const child = (0, import_node_child_process.spawn)("osascript", ["-e", appleScript], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -1236,7 +1319,7 @@ $result = [FolderPicker]::Pick("${safeTitle}", "${safeDefaultPath}")
 if ($result) { Write-Output $result }
 `;
   return new Promise((resolve3, reject) => {
-    const child = (0, import_node_child_process2.spawn)("powershell", ["-STA", "-NoProfile", "-WindowStyle", "Hidden", "-Command", psScript], {
+    const child = (0, import_node_child_process.spawn)("powershell", ["-STA", "-NoProfile", "-WindowStyle", "Hidden", "-Command", psScript], {
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
     });
@@ -1267,7 +1350,7 @@ function pickDirectoryLinux(title, defaultPath) {
     args.push(`--filename=${defaultPath}`);
   }
   return new Promise((resolve3, reject) => {
-    const child = (0, import_node_child_process2.spawn)("zenity", args, {
+    const child = (0, import_node_child_process.spawn)("zenity", args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -1299,11 +1382,349 @@ function pickDirectoryLinux(title, defaultPath) {
     });
   });
 }
-var import_node_child_process2;
+var import_node_child_process;
 var init_directory_picker = __esm({
   "src/bridge/directory-picker.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+  }
+});
+
+// src/bridge/pty-backend.ts
+function spawnHostPty(options) {
+  if (process.platform === "win32") {
+    throw new Error("\u5F53\u524D\u5E73\u53F0\u6682\u4E0D\u652F\u6301\u4EA4\u4E92\u5F0F\u7EC8\u7AEF");
+  }
+  const shell = options.shell || resolveShell();
+  const child = (0, import_node_child_process2.spawn)("python3", ["-u", "-c", PTY_HELPER], {
+    cwd: options.cwd,
+    env: {
+      ...process.env,
+      TERM: "xterm-256color",
+      TERMINAL_SHELL: shell,
+      TERMINAL_ROWS: String(options.rows),
+      TERMINAL_COLS: String(options.cols)
+    },
+    stdio: ["pipe", "pipe", "pipe", "pipe"]
+  });
+  const pending = [];
+  let dataCb = null;
+  let exitCb = null;
+  let pendingExit = null;
+  let settled = false;
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  let stderrText = "";
+  const emitData = (data) => {
+    if (!data) return;
+    if (dataCb) dataCb(data);
+    else pending.push(data);
+  };
+  const finish = (info) => {
+    if (settled) return;
+    settled = true;
+    if (stderrText.trim()) emitData(`\r
+${stderrText.trim()}\r
+`);
+    if (exitCb) exitCb(info);
+    else pendingExit = info;
+  };
+  child.stdout.on("data", (buf) => {
+    emitData(decoder.decode(buf, { stream: true }));
+  });
+  child.stderr.on("data", (buf) => {
+    stderrText += buf.toString("utf8");
+  });
+  child.on("error", (err) => {
+    emitData(`\r
+[\u7EC8\u7AEF\u542F\u52A8\u5931\u8D25] ${err.message}\r
+`);
+    finish({ exitCode: null, signal: null });
+  });
+  child.on("exit", (code, signal) => {
+    const rest = decoder.decode();
+    if (rest) emitData(rest);
+    finish({ exitCode: code, signal: signal ?? null });
+  });
+  const control = child.stdio[3];
+  const writeControl = (payload) => {
+    if (!control || !("write" in control)) return;
+    try {
+      ;
+      control.write(`${JSON.stringify(payload)}
+`);
+    } catch {
+    }
+  };
+  return {
+    write(data) {
+      try {
+        child.stdin.write(data);
+      } catch {
+      }
+    },
+    resize(cols, rows) {
+      writeControl({ type: "resize", cols, rows });
+    },
+    kill() {
+      writeControl({ type: "kill" });
+      try {
+        child.kill("SIGTERM");
+      } 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_process2, PTY_HELPER;
+var init_pty_backend = __esm({
+  "src/bridge/pty-backend.ts"() {
     "use strict";
     import_node_child_process2 = require("child_process");
+    init_bash_executor();
+    PTY_HELPER = `
+import errno, fcntl, json, os, pty, select, signal, struct, sys, termios
+
+shell = os.environ.get("TERMINAL_SHELL") or "/bin/bash"
+rows = int(os.environ.get("TERMINAL_ROWS") or "24")
+cols = int(os.environ.get("TERMINAL_COLS") or "80")
+control_fd = 3
+
+def set_winsize(fd, next_rows, next_cols):
+    winsize = struct.pack("HHHH", int(next_rows), int(next_cols), 0, 0)
+    fcntl.ioctl(fd, termios.TIOCSWINSZ, winsize)
+
+pid, master = pty.fork()
+if pid == 0:
+    try:
+        os.close(control_fd)
+    except OSError:
+        pass
+    os.environ["TERM"] = "xterm-256color"
+    try:
+        os.execvp(shell, [shell, "-i"])
+    except OSError:
+        os._exit(127)
+
+def control_loop():
+    try:
+        reader = os.fdopen(control_fd, "r", buffering=1, encoding="utf-8", errors="replace")
+    except OSError:
+        return
+    for line in reader:
+        text = line.strip()
+        if not text:
+            continue
+        try:
+            msg = json.loads(text)
+        except json.JSONDecodeError:
+            continue
+        kind = msg.get("type")
+        if kind == "resize":
+            try:
+                set_winsize(master, msg.get("rows") or rows, msg.get("cols") or cols)
+                os.kill(pid, signal.SIGWINCH)
+            except OSError:
+                pass
+        elif kind == "kill":
+            try:
+                os.kill(pid, signal.SIGHUP)
+            except OSError:
+                pass
+            os._exit(0)
+
+import threading
+threading.Thread(target=control_loop, daemon=True).start()
+
+try:
+    set_winsize(master, rows, cols)
+except OSError:
+    pass
+
+stdin_fd = sys.stdin.fileno()
+stdout_fd = sys.stdout.fileno()
+
+while True:
+    try:
+        readable, _, _ = select.select([master, stdin_fd], [], [])
+    except InterruptedError:
+        continue
+    if master in readable:
+        try:
+            data = os.read(master, 65536)
+        except OSError as err:
+            if err.errno == errno.EIO:
+                break
+            raise
+        if not data:
+            break
+        os.write(stdout_fd, data)
+    if stdin_fd in readable:
+        try:
+            data = os.read(stdin_fd, 65536)
+        except OSError:
+            break
+        if not data:
+            break
+        try:
+            os.write(master, data)
+        except OSError:
+            break
+
+try:
+    _, status = os.waitpid(pid, 0)
+except ChildProcessError:
+    status = 0
+code = os.waitstatus_to_exitcode(status)
+os._exit(0 if code < 0 else code)
+`;
+  }
+});
+
+// src/bridge/terminal-session.ts
+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, 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;
+    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();
+      }
+      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 }
+        });
+      }
+    };
   }
 });
 
@@ -1341,7 +1762,7 @@ function resolveOrCreateAuthToken(explicitToken) {
     }
   } 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 });
@@ -1355,10 +1776,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 +1787,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,19 +1798,20 @@ 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_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 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_crypto2 = require("crypto");
     import_node_fs3 = __toESM(require("fs"), 1);
     import_node_path3 = __toESM(require("path"), 1);
     import_node_os2 = __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;
@@ -1411,6 +1833,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 +2088,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 +2130,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 +2177,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;
@@ -1916,9 +2350,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 +2360,43 @@ 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) {
+          socket.send(JSON.stringify({ jsonrpc: "2.0", method, params }));
+        }
+      }
+      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 (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 +2492,26 @@ 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) {
+                try {
+                  socket.send(JSON.stringify(frame));
+                } catch {
+                }
+              }
+            }
+          });
+        }
+        return this.terminalSessions;
+      }
       /** 销毁服务，断开所有连接 */
       destroy() {
         this.destroyed = true;
+        this.terminalSessions?.disposeAll();
         this._rejectAllPending("ExtensionBridgeClient \u5DF2\u9500\u6BC1");
         this.forwardedRequests.clear();
         if (this.clientSocket) {
@@ -2176,7 +2656,7 @@ __export(daemon_exports, {
   isDaemonProcessAlive: () => isDaemonProcessAlive,
   isProcessAlive: () => isProcessAlive,
   killProcessOnPort: () => killProcessOnPort,
-  killProcessTree: () => killProcessTree2,
+  killProcessTree: () => killProcessTree,
   probeServerReady: () => probeServerReady,
   runDaemonProcess: () => runDaemonProcess,
   stopBridgeDaemon: () => stopBridgeDaemon
@@ -2229,7 +2709,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 +2747,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);
@@ -2449,7 +2929,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 {
@@ -2460,7 +2940,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 {