lark-remote 0.1.10 → 0.1.11

package/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.11] - 2026-08-24
+
+### 新增
+
+- kimi ACP 支持 Bash 命令自主执行：`terminal/*` reverse RPC 将 Bash 工具下放到本地子进程（一次性 `bash -c <script>`），yolo/auto 模式自主跑命令，manual 模式仍走审批；run 卡片显示带真实命令与本地输出的 Bash 面板，并过滤 kimi 自产的双份 Bash 通知
+
+### 变更
+
+- kimi ACP 能力声明：`fs` 保持关闭（走本地磁盘兜底，避免未实现的 `fs/*` RPC 报 `METHOD_NOT_FOUND`），`terminal` 打开
+- 文档清理：移除设计文档中对内部文档名（`lessons-redlines`）与本地仓库路径（`/Users/.../lark-remote`）的引用
+
 ## [0.1.10] - 2026-08-22
 
 ### 新增

package/dist/runner/common/acp/protocol-types.d.ts

@@ -39,7 +39,7 @@ export declare const RpcErrorCode: {
 export interface InitializeParams {
     /** Protocol version — must be 1 (number, not string). */
     protocolVersion: number;
-    /** Client capabilities: explicitly declare what we support (all off). */
+    /** Client capabilities: declare only reverse-RPC surfaces we implement. */
     clientCapabilities: {
         fs: {
             readTextFile: boolean;
@@ -209,6 +209,12 @@ export declare const ServerRequestMethod: {
     readonly REQUEST_PERMISSION: "session/request_permission";
     /** Kimi AskUserQuestion elicitation form（客户端广告 elicitation.form 时启用）。 */
     readonly ELICITATION_CREATE: "elicitation/create";
+    /** kimi terminal 工具 reverse RPC：Bash 执行下放客户端（acp-terminal）。 */
+    readonly TERMINAL_CREATE: "terminal/create";
+    readonly TERMINAL_OUTPUT: "terminal/output";
+    readonly TERMINAL_WAIT_FOR_EXIT: "terminal/wait_for_exit";
+    readonly TERMINAL_KILL: "terminal/kill";
+    readonly TERMINAL_RELEASE: "terminal/release";
 };
 export interface PermissionOption {
     /** Opaque option identifier — echo back in response outcome.optionId. */
@@ -269,3 +275,34 @@ export interface ElicitationCreateResponse {
     /** accept 时的答案，key 为 q0..qn（按问题顺序）。 */
     content?: Record<string, string | string[]>;
 }
+export interface TerminalCreateParams {
+    sessionId: string;
+    /** 恒为 'bash'（服务端 spawn 只接受 bash -c）。 */
+    command: string;
+    /** ['-c', <script>]：-c 在 args[0]，脚本在 args[1]。 */
+    args: string[];
+    env?: Array<{
+        name: string;
+        value: string;
+    }>;
+    /** 可能为 null → 回退 session cwd。 */
+    cwd?: string | null;
+    /** 输出缓冲上限（字节），默认 4MB。 */
+    outputByteLimit?: number;
+}
+export interface TerminalOutputParams {
+    sessionId: string;
+    terminalId: string;
+}
+export interface TerminalWaitForExitParams {
+    sessionId: string;
+    terminalId: string;
+}
+export interface TerminalKillParams {
+    sessionId: string;
+    terminalId: string;
+}
+export interface TerminalReleaseParams {
+    sessionId: string;
+    terminalId: string;
+}

package/dist/runner/common/acp/protocol-types.js

@@ -73,5 +73,11 @@ export const ServerRequestMethod = {
     REQUEST_PERMISSION: 'session/request_permission',
     /** Kimi AskUserQuestion elicitation form（客户端广告 elicitation.form 时启用）。 */
     ELICITATION_CREATE: 'elicitation/create',
+    /** kimi terminal 工具 reverse RPC：Bash 执行下放客户端（acp-terminal）。 */
+    TERMINAL_CREATE: 'terminal/create',
+    TERMINAL_OUTPUT: 'terminal/output',
+    TERMINAL_WAIT_FOR_EXIT: 'terminal/wait_for_exit',
+    TERMINAL_KILL: 'terminal/kill',
+    TERMINAL_RELEASE: 'terminal/release',
 };
 //# sourceMappingURL=protocol-types.js.map

package/dist/runner/kimi/acp/runner.d.ts

@@ -46,6 +46,21 @@ export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient,
     private readonly compactPollTimeoutMs;
     /** Pending approval requests: requestId → kind + view + options. */
     private pendingApprovals;
+    /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
+    private terminals;
+    /** terminalId 自增序号（term-1, term-2, …）。 */
+    private terminalSeq;
+    /**
+     * kimi 服务端对 Bash 工具的 tool_call/tool_call_update 通知（title='Bash'）。
+     * Bash 的真实执行走 terminal/* reverse RPC 下放客户端，tool 事件由本 runner
+     * 自产（tool_use 带命令、tool_result 带本地输出）；这些通知必须过滤，否则
+     * 卡片出现双份 Bash 面板（通知版无 rawInput、terminal embed 无 rawOutput，
+     * 只能渲染「_无输出_」）。收集到的 toolCallId 用于过滤对应的 update。
+     */
+    private bashToolCallIds;
+    /** 当前 run 的 session cwd（terminal/create 未给 cwd 时回退用）。 */
+    private activeCwd;
+    private readonly processStopper;
     /** Tracker for the in-flight prompt request — needed for cancellation. */
     private promptSettled;
     constructor(opts: KimiAcpRunnerOptions);
@@ -102,5 +117,41 @@ export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient,
      */
     private waitForCompactionRecord;
     private handleNotification;
+    /**
+     * Filter kimi's own Bash tool notifications so the run card doesn't get a
+     * duplicate, output-less Bash panel alongside the runner-produced one.
+     *
+     * - tool_call title='Bash' → remember the toolCallId, drop the notification
+     *   (the tool_use comes from terminal/create with the real command).
+     * - tool_call_update for a remembered id → drop (streaming args deltas and
+     *   the terminal embed final update; the tool_result is emitted locally).
+     * Returns true when the notification should be swallowed.
+     */
+    private filterBashNotifications;
     private handleServerRequest;
+    /**
+     * Handle a kimi terminal/* reverse RPC by spawning a one-shot local process.
+     *
+     * 契约（kimi-code acp-terminal/acpTerminalRunner.ts）：
+     *   create → 立即回 {terminalId}，进程异步跑，不阻塞 RPC；
+     *   output → 回累计 stdout（非增量，服务端按 emitted 偏移切片）；
+     *   wait_for_exit → 未退出则等 exit 再回 {exitCode, signal}；
+     *   kill/release → 杀进程并回 {}。
+     */
+    private handleTerminalRequest;
+    /**
+     * terminal/create: spawn 一次性进程（bash -c <script>），流式累积
+     * stdout(+stderr) 到缓冲，立即回 {terminalId}。
+     */
+    private handleTerminalCreate;
+    /** terminal/output: 回累计全量输出 + truncated + 当前退出状态（可未退出）。 */
+    private handleTerminalOutput;
+    /** terminal/wait_for_exit: 未退出则等 exit promise 再回 {exitCode, signal}。 */
+    private handleTerminalWaitForExit;
+    /** terminal/kill: 立即杀进程组，回 {}。 */
+    private handleTerminalKill;
+    /** terminal/release: 从 map 删除；进程仍在则一并杀，回 {}。 */
+    private handleTerminalRelease;
+    /** Kill every live terminal (dispose/connection-close 清理钩子)。 */
+    private cleanupTerminals;
 }

package/dist/runner/kimi/acp/runner.js

@@ -11,19 +11,31 @@
  * pattern, same forceFinish/stopRequested semantics, same turn idle timeout,
  * same ConnectionLostError retry.
  */
+import { spawn } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
 import { ConnectionManager as KimiAcpConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { KimiAcpTranslator } from './translator.js';
-import { RpcErrorCode, ServerRequestMethod, } from '../../common/acp/protocol-types.js';
+import { NotificationMethod, RpcErrorCode, ServerRequestMethod, } from '../../common/acp/protocol-types.js';
 import { findOptionIdByKind } from '../../common/acp/protocol-helpers.js';
 import { mapAnswersByIndex } from '../../question-common.js';
 import { getLogger } from '../../../logger/index.js';
 import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
+import { ProcessStopper } from '../../common/process-stopper.js';
 /** R2: how long to wait for the background compaction record after the
  *  /compact prompt settles (design doc §6.1). Real kimi 0.36.0 lands
  *  context.apply_compaction ~8s after end_turn. */
 const COMPACT_POLL_TIMEOUT_MS = 30_000;
 /** Poll interval for the wire.jsonl compaction record. */
 const COMPACT_POLL_INTERVAL_MS = 1_000;
+// =============================================================================
+// kimi terminal 工具（Bash 执行下放客户端）
+// 契约：kimi-code/packages/acp-server/src/acp-terminal/acpTerminalRunner.ts
+//   一次性 bash -c <script>，非交互 PTY、无 stdin；服务端每 250ms 轮询
+//   terminal/output，客户端只回累计 stdout。创建/轮询/等待/杀/释放五个
+//   reverse RPC 全部由本 runner 本地 spawn 子进程实现。
+// =============================================================================
+/** terminal/create 未显式给 outputByteLimit 时的缓冲上限（对齐服务端默认 4MB）。 */
+const TERMINAL_DEFAULT_OUTPUT_LIMIT = 4 * 1024 * 1024;
 /**
  * Map user-facing permission mode to ACP mode id.
  *
@@ -162,6 +174,21 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
     compactPollTimeoutMs;
     /** Pending approval requests: requestId → kind + view + options. */
     pendingApprovals = new Map();
+    /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
+    terminals = new Map();
+    /** terminalId 自增序号（term-1, term-2, …）。 */
+    terminalSeq = 0;
+    /**
+     * kimi 服务端对 Bash 工具的 tool_call/tool_call_update 通知（title='Bash'）。
+     * Bash 的真实执行走 terminal/* reverse RPC 下放客户端，tool 事件由本 runner
+     * 自产（tool_use 带命令、tool_result 带本地输出）；这些通知必须过滤，否则
+     * 卡片出现双份 Bash 面板（通知版无 rawInput、terminal embed 无 rawOutput，
+     * 只能渲染「_无输出_」）。收集到的 toolCallId 用于过滤对应的 update。
+     */
+    bashToolCallIds = new Set();
+    /** 当前 run 的 session cwd（terminal/create 未给 cwd 时回退用）。 */
+    activeCwd = null;
+    processStopper = new ProcessStopper({ graceMs: 2_000 });
     /** Tracker for the in-flight prompt request — needed for cancellation. */
     promptSettled = false;
     constructor(opts) {
@@ -178,8 +205,13 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
             initializeParams: {
                 protocolVersion: 1,
                 clientCapabilities: {
+                    // fs 保持关闭：kimi 服务端在 fs 能力为 false 时走本地磁盘兜底
+                    // （acpFsService.ts AcpHostFileSystem.inner），kimi 是本地子进程，
+                    // 本地盘即工作区盘，读写正常；声明 true 则服务端改发 fs/* reverse
+                    // RPC，lark-remote 未实现该面，文件读写会 METHOD_NOT_FOUND 失败。
                     fs: { readTextFile: false, writeTextFile: false },
-                    terminal: false,
+                    // terminal 常开：yolo/auto 自主跑命令；manual 走 session/request_permission 审批。
+                    terminal: true,
                     // AskUserQuestion 走 elicitation form（原生多题+多选；form 失败时
                     // kimi 服务端自动回退 request_permission 桥，客户端两者都处理）。
                     // 注意：ACP SDK 对 elicitation.form 的 zod schema 是对象
@@ -223,6 +255,7 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         this.currentTranslator = null;
         this.promptSettled = false;
         this.activeSessionId = null;
+        this.activeCwd = null;
     }
     async releaseConnection(cwd) {
         await this.connectionManager.release(cwd);
@@ -231,6 +264,8 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         this.connectionManager.notifyIdle(cwd);
     }
     async disposeConnections() {
+        // 关闭前 kill/release 所有存活 terminal，避免孤儿 bash 进程。
+        await this.cleanupTerminals();
         await this.connectionManager.disposeAll();
     }
     /**
@@ -245,10 +280,14 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
             const client = await this.connectionManager.acquire(opts.cwd);
             this.connectionManager.notifyActivity(opts.cwd);
             this.currentClient = client;
+            this.activeCwd = opts.cwd;
             client.setHooks({
                 onNotification: (method, params) => this.handleNotification(method, params),
                 onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
-                onClose: () => this.failTurn('Kimi ACP connection closed'),
+                onClose: () => {
+                    void this.cleanupTerminals();
+                    this.failTurn('Kimi ACP connection closed');
+                },
             });
             const sessionId = opts.sessionId;
             if (!sessionId) {
@@ -382,11 +421,13 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         const client = await this.connectionManager.acquire(opts.cwd);
         this.connectionManager.notifyActivity(opts.cwd);
         this.currentClient = client;
+        this.activeCwd = opts.cwd;
         client.setHooks({
             onNotification: (method, params) => this.handleNotification(method, params),
             onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
             onClose: () => {
                 getLogger().warn(`[${this.logTag}] client connection closed`);
+                void this.cleanupTerminals();
                 this.failTurn('Kimi ACP connection closed');
             },
         });
@@ -494,10 +535,61 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         getLogger().warn(`[${this.logTag}] compaction record not observed within ${this.compactPollTimeoutMs}ms (baseline=${baselineCount}); proceeding without confirmation`);
     }
     handleNotification(method, params) {
+        // Terminal-backed Bash 的通知走 runner 自产事件（见 bashToolCallIds），
+        // 不交给 translator；其余通知（Read/Edit/text/thinking）正常翻译。
+        if (method === NotificationMethod.SESSION_UPDATE && this.filterBashNotifications(params)) {
+            return;
+        }
         const events = this.currentTranslator?.handleNotification(method, params) ?? [];
         this.pushEvents(events);
     }
+    /**
+     * Filter kimi's own Bash tool notifications so the run card doesn't get a
+     * duplicate, output-less Bash panel alongside the runner-produced one.
+     *
+     * - tool_call title='Bash' → remember the toolCallId, drop the notification
+     *   (the tool_use comes from terminal/create with the real command).
+     * - tool_call_update for a remembered id → drop (streaming args deltas and
+     *   the terminal embed final update; the tool_result is emitted locally).
+     * Returns true when the notification should be swallowed.
+     */
+    filterBashNotifications(params) {
+        if (typeof params !== 'object' || params === null)
+            return false;
+        const update = params.update;
+        if (!update || typeof update !== 'object')
+            return false;
+        if (update.sessionUpdate === 'tool_call') {
+            if (update.title === 'Bash') {
+                if (typeof update.toolCallId === 'string') {
+                    this.bashToolCallIds.add(update.toolCallId);
+                }
+                return true;
+            }
+            return false;
+        }
+        if (update.sessionUpdate === 'tool_call_update') {
+            const toolCallId = update.toolCallId;
+            if (typeof toolCallId === 'string' && this.bashToolCallIds.has(toolCallId)) {
+                // 终态后清掉 id，避免集合随会话无限增长（漏清无碍：id 全局唯一）。
+                if (update.status === 'completed' || update.status === 'failed') {
+                    this.bashToolCallIds.delete(toolCallId);
+                }
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
     handleServerRequest(id, method, params) {
+        // kimi terminal 工具：Bash 执行下放客户端（acp-terminal reverse RPC）。
+        // 请求本身是纯 request/response I/O，不交给 translator（避免落入下方
+        // 「空事件 → 拒绝」兜底）；对应的 tool_use/tool_result 事件由
+        // handleTerminalCreate 自产（带本地命令与输出，见 bashToolCallIds）。
+        if (method.startsWith('terminal/')) {
+            void this.handleTerminalRequest(id, method, params);
+            return;
+        }
         const events = this.currentTranslator?.handleServerRequest(id, method, params) ?? [];
         if (events.length === 0) {
             // Unhandled/unsupported server request must be explicitly responded to
@@ -527,5 +619,221 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         }
         this.pushEvents(events);
     }
+    /**
+     * Handle a kimi terminal/* reverse RPC by spawning a one-shot local process.
+     *
+     * 契约（kimi-code acp-terminal/acpTerminalRunner.ts）：
+     *   create → 立即回 {terminalId}，进程异步跑，不阻塞 RPC；
+     *   output → 回累计 stdout（非增量，服务端按 emitted 偏移切片）；
+     *   wait_for_exit → 未退出则等 exit 再回 {exitCode, signal}；
+     *   kill/release → 杀进程并回 {}。
+     */
+    async handleTerminalRequest(id, method, params) {
+        try {
+            switch (method) {
+                case ServerRequestMethod.TERMINAL_CREATE:
+                    this.handleTerminalCreate(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_OUTPUT:
+                    this.handleTerminalOutput(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_WAIT_FOR_EXIT:
+                    await this.handleTerminalWaitForExit(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_KILL:
+                    await this.handleTerminalKill(id, params);
+                    return;
+                case ServerRequestMethod.TERMINAL_RELEASE:
+                    await this.handleTerminalRelease(id, params);
+                    return;
+                default:
+                    this.currentClient?.respondError(id, RpcErrorCode.METHOD_NOT_FOUND, `Unsupported server request: ${method}`);
+            }
+        }
+        catch (err) {
+            getLogger().warn(`[${this.logTag}] terminal request failed method=${method}: ${err.message}`);
+            this.currentClient?.respondError(id, RpcErrorCode.INTERNAL_ERROR, `Terminal request failed: ${err.message}`);
+        }
+    }
+    /**
+     * terminal/create: spawn 一次性进程（bash -c <script>），流式累积
+     * stdout(+stderr) 到缓冲，立即回 {terminalId}。
+     */
+    handleTerminalCreate(id, params) {
+        const env = params.env
+            ? Object.fromEntries(params.env.map((e) => [e.name, e.value]))
+            : undefined;
+        const cwd = params.cwd ?? this.activeCwd ?? undefined;
+        const outputLimit = params.outputByteLimit ?? TERMINAL_DEFAULT_OUTPUT_LIMIT;
+        const proc = spawn(params.command, params.args ?? [], {
+            cwd,
+            env: env ? { ...process.env, ...env } : undefined,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            // ProcessStopper 用负 PID 杀进程组（kill(-pgid)）；子进程必须是组长
+            // 才能命中，否则 kill(-pid) 抛 ESRCH 被吞 → kill/release/清理全失效。
+            // 与 JsonlRpcTransport / spawning-runner 的 detached:true 同模式。
+            detached: true,
+        });
+        // 每个流独立 decoder：多字节字符跨 chunk 拆分时由 decoder 保留不完整
+        // 序列，避免按 chunk 单独 toString 产生 U+FFFD 替换符。
+        const stdoutDecoder = new StringDecoder('utf8');
+        const stderrDecoder = new StringDecoder('utf8');
+        const append = (chunk, decoder) => {
+            if (handle.truncated)
+                return;
+            const remaining = handle.outputLimit - handle.outputBytes;
+            if (remaining > 0 && chunk.length <= remaining) {
+                handle.output += decoder.write(chunk);
+                handle.outputBytes += chunk.length;
+            }
+            else if (remaining > 0) {
+                // 只喂 remaining 字节；decoder 内部保留末尾不完整序列，不会在字节
+                // 边界产生替换符。outputBytes 按「喂入字节」计，保证不超过上限。
+                handle.output += decoder.write(chunk.subarray(0, remaining));
+                handle.outputBytes += remaining;
+            }
+            // 契约（手册）：truncated = 缓冲 >= limit——恰好填满也标 true。
+            if (handle.outputBytes >= handle.outputLimit)
+                handle.truncated = true;
+        };
+        proc.stdout?.on('data', (chunk) => append(chunk, stdoutDecoder));
+        proc.stderr?.on('data', (chunk) => append(chunk, stderrDecoder));
+        // spawn 失败（如 ENOENT）只发 'error' 不发 'exit'——一并 resolve，防止
+        // wait_for_exit 永久挂起（runner 层 ENOENT 兜底红线）。
+        // 用 resolveExit 承接，避免回调在 handle 初始化前引用它（TDZ）。
+        let resolveExit;
+        const exitPromise = new Promise((resolve) => {
+            resolveExit = resolve;
+        });
+        // 与 resolveExit 同款 TDZ 规避：tool_result 发射闭包在 terminalId 初始化
+        // 后赋值，exit/error 回调执行时经 emitResult 间接调用。
+        let emitTerminalResult = undefined;
+        const emitResult = () => {
+            emitTerminalResult?.();
+        };
+        const handle = {
+            proc,
+            output: '',
+            outputBytes: 0,
+            outputLimit,
+            truncated: false,
+            exitCode: null,
+            signal: null,
+            exitPromise,
+        };
+        proc.once('exit', (code, signal) => {
+            handle.exitCode = code;
+            handle.signal = signal;
+            resolveExit?.();
+            emitResult();
+        });
+        proc.once('error', (err) => {
+            getLogger().warn(`[${this.logTag}] terminal process error: ${err.message}`);
+            if (handle.exitCode === null && handle.signal === null) {
+                handle.exitCode = 1;
+                handle.signal = null;
+            }
+            resolveExit?.();
+            emitResult();
+        });
+        const terminalId = `term-${++this.terminalSeq}`;
+        this.terminals.set(terminalId, handle);
+        // Bash 工具事件由本 runner 自产（kimi 通知已过滤）：create 即推 tool_use
+        // 带真实命令，让 run 卡立刻出现可识别的 Bash 面板。
+        const script = Array.isArray(params.args) && params.args.length > 1 ? params.args[1] : params.command;
+        let resultEmitted = false;
+        emitTerminalResult = () => {
+            if (resultEmitted)
+                return;
+            resultEmitted = true;
+            this.pushEvents([
+                {
+                    type: 'user',
+                    message: {
+                        content: [
+                            {
+                                type: 'tool_result',
+                                tool_use_id: terminalId,
+                                content: handle.output,
+                                is_error: handle.exitCode !== 0,
+                            },
+                        ],
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+            ]);
+        };
+        this.pushEvents([
+            {
+                type: 'assistant',
+                message: {
+                    content: [
+                        {
+                            type: 'tool_use',
+                            id: terminalId,
+                            name: 'Bash',
+                            input: { command: script, cwd },
+                        },
+                    ],
+                },
+                timestamp: new Date().toISOString(),
+            },
+        ]);
+        getLogger().info(`[${this.logTag}] terminal created id=${terminalId} command=${params.command} args=${JSON.stringify(params.args ?? [])}`);
+        this.currentClient?.respond(id, { terminalId });
+    }
+    /** terminal/output: 回累计全量输出 + truncated + 当前退出状态（可未退出）。 */
+    handleTerminalOutput(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        this.currentClient?.respond(id, {
+            output: handle.output,
+            truncated: handle.truncated,
+            exitStatus: { exitCode: handle.exitCode, signal: handle.signal },
+        });
+    }
+    /** terminal/wait_for_exit: 未退出则等 exit promise 再回 {exitCode, signal}。 */
+    async handleTerminalWaitForExit(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        await handle.exitPromise;
+        this.currentClient?.respond(id, { exitCode: handle.exitCode, signal: handle.signal });
+    }
+    /** terminal/kill: 立即杀进程组，回 {}。 */
+    async handleTerminalKill(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        await this.processStopper.stop(handle.proc, { immediate: true });
+        this.currentClient?.respond(id, {});
+    }
+    /** terminal/release: 从 map 删除；进程仍在则一并杀，回 {}。 */
+    async handleTerminalRelease(id, params) {
+        const handle = this.terminals.get(params.terminalId);
+        if (!handle) {
+            this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
+            return;
+        }
+        this.terminals.delete(params.terminalId);
+        // stop 对已退出进程是 no-op；仍在跑则立即 SIGTERM+SIGKILL。
+        await this.processStopper.stop(handle.proc, { immediate: true });
+        this.currentClient?.respond(id, {});
+    }
+    /** Kill every live terminal (dispose/connection-close 清理钩子)。 */
+    async cleanupTerminals() {
+        const handles = [...this.terminals.values()];
+        this.terminals.clear();
+        for (const handle of handles) {
+            await this.processStopper.stop(handle.proc, { immediate: true });
+        }
+    }
 }
 //# sourceMappingURL=runner.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",