@brierb/brier-cli 0.0.9 → 0.0.11

package/dist/daemon/DaemonRunner.js

@@ -50,11 +50,19 @@ const startDaemon = (config) => {
                 cwd: message.cwd,
                 env: message.env,
                 prompt: message.prompt,
+                execMode: message.execMode,
             });
         },
         onTaskCancel: (taskId) => {
             taskExecutor.cancel(taskId);
         },
+        onTaskInput: (message) => {
+            // 回答 AI 提问 / 交互输入：写入执行器；任务不存在/不可写时记录即可（无应答通道，靠输出侧感知）
+            const ok = taskExecutor.writeInput(message.taskId, message.data);
+            if (!ok) {
+                logger.warn(`Task ${message.taskId} input ignored: task not running or not writable`);
+            }
+        },
     };
     const client = createTunnelClient(config, messageHandlers);
     tunnel = client;

package/dist/daemon/TaskExecutor.js

@@ -1,19 +1,24 @@
 import { spawn } from 'node:child_process';
+import pty from 'node-pty';
 import { logger, resolveRuntimeExecutable, RUNTIME_PROMPT_FLAGS } from '../core/index.js';
 const MAX_CONCURRENT = 3;
-/** 取消后等待 SIGTERM 生效的时间，超时升级 SIGKILL */
+/** 取消后等待 SIGTERM 生效的时间，超时升级 SIGKILL（仅 pipe 模式需要；pty.kill 为同步终止） */
 const KILL_GRACE_MS = 2_000;
 /** dispose 整体等待上限 */
 const DISPOSE_TIMEOUT_MS = 2_000;
 const DISPOSE_POLL_MS = 100;
 export const createTaskExecutor = (callbacks) => {
-    const processes = new Map();
-    /** 已请求取消的任务：其 close 不再上报 complete */
+    /** pipe 模式子进程（ChildProcess，原有实现） */
+    const pipeProcs = new Map();
+    /** pty 模式伪终端会话 */
+    const ptyProcs = new Map();
+    /** 已请求取消的任务：其 close/onExit 不再上报 complete */
     const cancelRequested = new Set();
-    /** 已上报终态（error/complete 二选一，防双重上报）的任务 */
+    /** 已上报终态（error/complete 二选一，防双重上报） */
     const finished = new Set();
-    /** 取消后的 SIGKILL 升级计时器 */
+    /** 取消后的 SIGKILL 升级计时器（仅 pipe 模式使用） */
     const killTimers = new Map();
+    const runningCount = () => pipeProcs.size + ptyProcs.size;
     const clearKillTimer = (taskId) => {
         const timer = killTimers.get(taskId);
         if (timer) {
@@ -25,12 +30,22 @@ export const createTaskExecutor = (callbacks) => {
         clearKillTimer(taskId);
         killTimers.set(taskId, setTimeout(() => {
             killTimers.delete(taskId);
-            if (processes.get(taskId) === child) {
+            if (pipeProcs.get(taskId) === child) {
                 logger.warn(`Task ${taskId} did not exit after SIGTERM, sending SIGKILL`);
                 child.kill('SIGKILL');
             }
         }, delayMs));
     };
+    /** 终态去重 + 统一清理（出表/清定时器）。注意：不清 cancelRequested，由调用分支决定取消语义 */
+    const markFinished = (taskId) => {
+        if (finished.has(taskId))
+            return false;
+        finished.add(taskId);
+        clearKillTimer(taskId);
+        pipeProcs.delete(taskId);
+        ptyProcs.delete(taskId);
+        return true;
+    };
     /**
      * 解析要执行的命令：
      * - 显式 command：直接用（调用方负责其可执行性）
@@ -54,36 +69,24 @@ export const createTaskExecutor = (callbacks) => {
         }
         return task.args ?? [];
     };
-    const execute = (task) => {
-        if (processes.has(task.taskId)) {
-            logger.warn(`Task ${task.taskId} is already running, cancelling previous instance`);
-            cancel(task.taskId);
-        }
-        if (processes.size >= MAX_CONCURRENT) {
-            callbacks.onError(task.taskId, `Max concurrent tasks (${MAX_CONCURRENT}) reached`);
-            return;
-        }
-        const cmd = resolveCommand(task);
-        if (!cmd) {
-            callbacks.onError(task.taskId, `Cannot resolve command for runtime: ${task.runtime} (no command provided)`);
-            return;
-        }
-        const args = buildArgs(task);
-        const childEnv = task.env ? { ...process.env, ...task.env } : process.env;
-        logger.info(`Task ${task.taskId} starting: ${cmd} ${args.join(' ')}`, task.runtime);
+    const buildEnv = (task) => task.env ? { ...process.env, ...task.env } : process.env;
+    /** pipe 模式：非交互子进程，stdout/stderr 管道直传（原有行为，保持逐字节 toString 语义） */
+    const executePipe = (task, cmd, args, childEnv) => {
         let child;
         try {
             child = spawn(cmd, args, {
                 cwd: task.cwd,
                 env: childEnv,
-                stdio: ['pipe', 'pipe', 'pipe'],
+                // stdin 置 ignore：非交互任务输入全部来自 prompt/command 参数，runtime 无交互输入。
+                // 若用 pipe 且不关闭，TUI 类 runtime（opencode 等）会因 stdin 永不 EOF 而挂起不执行。
+                stdio: ['ignore', 'pipe', 'pipe'],
             });
         }
         catch (err) {
             callbacks.onError(task.taskId, err instanceof Error ? err.message : String(err));
             return;
         }
-        processes.set(task.taskId, child);
+        pipeProcs.set(task.taskId, child);
         child.stdout?.on('data', (data) => {
             callbacks.onOutput(task.taskId, 'stdout', data.toString());
         });
@@ -92,20 +95,15 @@ export const createTaskExecutor = (callbacks) => {
         });
         child.on('error', (err) => {
             // error 后可能仍触发 close：终态只上报一次
-            if (finished.has(task.taskId))
+            if (!markFinished(task.taskId))
                 return;
-            finished.add(task.taskId);
-            clearKillTimer(task.taskId);
-            processes.delete(task.taskId);
+            cancelRequested.delete(task.taskId);
             logger.error(`Task ${task.taskId} process error:`, err.message);
             callbacks.onError(task.taskId, err.message);
         });
         child.on('close', (code) => {
-            if (finished.has(task.taskId))
+            if (!markFinished(task.taskId))
                 return;
-            finished.add(task.taskId);
-            clearKillTimer(task.taskId);
-            processes.delete(task.taskId);
             if (cancelRequested.has(task.taskId)) {
                 cancelRequested.delete(task.taskId);
                 logger.info(`Task ${task.taskId} cancelled`);
@@ -116,24 +114,134 @@ export const createTaskExecutor = (callbacks) => {
             callbacks.onComplete(task.taskId, exitCode);
         });
     };
-    const cancel = (taskId) => {
-        const child = processes.get(taskId);
-        if (!child) {
-            logger.warn(`Task ${taskId} not found, cannot cancel`);
+    /**
+     * pty 模式：伪终端交互子进程。
+     * CLI 检测到 tty 后进入交互模式（会提问、渲染进度、等待输入）；
+     * 屏幕字节经 onData 上行（含 ANSI），用户输入经 writeInput 写入（模拟击键）。
+     */
+    const executePty = (task, cmd, args, childEnv) => {
+        let handle;
+        try {
+            handle = pty.spawn(cmd, args, {
+                name: 'xterm-256color',
+                cols: 120,
+                rows: 32,
+                cwd: task.cwd,
+                env: childEnv,
+            });
+        }
+        catch (err) {
+            callbacks.onError(task.taskId, err instanceof Error ? err.message : String(err));
             return;
         }
-        if (cancelRequested.has(taskId)) {
+        ptyProcs.set(task.taskId, handle);
+        logger.info(`Task ${task.taskId} started in pty mode: ${cmd} ${args.join(' ')}`, task.runtime);
+        handle.onData((data) => {
+            // pty 只有一路输出（合并 stdout/stderr 的终端字节流），统一按 stdout 上行；
+            // 前端如需区分文本/控制序列，属于展示层解析，不在执行层拆流。
+            callbacks.onOutput(task.taskId, 'stdout', data);
+        });
+        handle.onExit(({ exitCode }) => {
+            if (!markFinished(task.taskId))
+                return;
+            if (cancelRequested.has(task.taskId)) {
+                cancelRequested.delete(task.taskId);
+                logger.info(`Task ${task.taskId} cancelled`);
+                return;
+            }
+            const code = exitCode ?? 0;
+            logger.info(`Task ${task.taskId} completed with exit code ${code}`);
+            callbacks.onComplete(task.taskId, code);
+        });
+    };
+    const execute = (task) => {
+        if (pipeProcs.has(task.taskId) || ptyProcs.has(task.taskId)) {
+            logger.warn(`Task ${task.taskId} is already running, cancelling previous instance`);
+            cancel(task.taskId);
+        }
+        if (runningCount() >= MAX_CONCURRENT) {
+            callbacks.onError(task.taskId, `Max concurrent tasks (${MAX_CONCURRENT}) reached`);
             return;
         }
+        const cmd = resolveCommand(task);
+        if (!cmd) {
+            callbacks.onError(task.taskId, `Cannot resolve command for runtime: ${task.runtime} (no command provided)`);
+            return;
+        }
+        const args = buildArgs(task);
+        const childEnv = buildEnv(task);
+        if (task.execMode === 'pty') {
+            executePty(task, cmd, args, childEnv);
+            return;
+        }
+        executePipe(task, cmd, args, childEnv);
+    };
+    const writeInput = (taskId, data) => {
+        if (!data)
+            return false;
+        const handle = ptyProcs.get(taskId);
+        if (handle) {
+            try {
+                handle.write(data);
+                return true;
+            }
+            catch (err) {
+                logger.error(`Task ${taskId} pty write failed:`, err);
+                return false;
+            }
+        }
+        const child = pipeProcs.get(taskId);
+        if (child?.stdin?.writable) {
+            child.stdin.write(data);
+            return true;
+        }
+        return false;
+    };
+    const cancel = (taskId) => {
+        if (cancelRequested.has(taskId))
+            return;
         cancelRequested.add(taskId);
+        const handle = ptyProcs.get(taskId);
+        if (handle) {
+            logger.info(`Task ${taskId} cancelling (pty kill)`);
+            try {
+                handle.kill();
+            }
+            catch (err) {
+                logger.warn(`Task ${taskId} pty kill failed, escalating SIGKILL:`, err);
+                try {
+                    handle.kill('SIGKILL');
+                }
+                catch {
+                    // 兜底：升级失败也收口，避免悬挂
+                    if (markFinished(taskId)) {
+                        callbacks.onError(taskId, 'cancel failed');
+                    }
+                }
+            }
+            return;
+        }
+        const child = pipeProcs.get(taskId);
+        if (!child)
+            return;
         logger.info(`Task ${taskId} cancelling (SIGTERM)`);
         child.kill('SIGTERM');
         armKillTimer(taskId, child, KILL_GRACE_MS);
     };
     const dispose = () => {
-        if (processes.size === 0)
+        if (runningCount() === 0)
             return Promise.resolve();
-        for (const [taskId, child] of processes) {
+        for (const taskId of [...ptyProcs.keys()]) {
+            cancelRequested.add(taskId);
+            logger.info(`Task ${taskId} cancelling (shutdown, pty kill)`);
+            try {
+                ptyProcs.get(taskId)?.kill();
+            }
+            catch {
+                markFinished(taskId);
+            }
+        }
+        for (const [taskId, child] of pipeProcs) {
             cancelRequested.add(taskId);
             logger.info(`Task ${taskId} cancelling (shutdown, SIGTERM)`);
             child.kill('SIGTERM');
@@ -142,9 +250,9 @@ export const createTaskExecutor = (callbacks) => {
         return new Promise((resolve) => {
             const start = Date.now();
             const check = () => {
-                if (processes.size === 0 || Date.now() - start >= DISPOSE_TIMEOUT_MS) {
-                    // 仍未退出的升级为 SIGKILL；close 事件随后清理各集合
-                    for (const [taskId, child] of processes) {
+                if (runningCount() === 0 || Date.now() - start >= DISPOSE_TIMEOUT_MS) {
+                    // 仍未退出的 pipe 子进程升级为 SIGKILL；pty 已同步 kill
+                    for (const [taskId, child] of pipeProcs) {
                         logger.warn(`Task ${taskId} force killed during shutdown`);
                         child.kill('SIGKILL');
                     }
@@ -156,5 +264,5 @@ export const createTaskExecutor = (callbacks) => {
             check();
         });
     };
-    return { execute, cancel, dispose };
+    return { execute, writeInput, cancel, dispose };
 };

package/dist/tunnel/dispatcher.js

@@ -25,6 +25,9 @@ export const dispatchServerMessage = (raw, handlers) => {
         case 'task-cancel':
             handlers.onTaskCancel(message.taskId);
             break;
+        case 'task-input':
+            handlers.onTaskInput(message);
+            break;
         case 'query-runtimes':
             handlers.onQueryRuntimes();
             break;

package/dist/tunnel/index.js

@@ -142,6 +142,10 @@ export const createTunnelClient = (config, messageHandlers) => {
             logger.info('Task cancel:', taskId);
             messageHandlers.onTaskCancel(taskId);
         },
+        onTaskInput: (message) => {
+            logger.info('Task input:', message.taskId);
+            messageHandlers.onTaskInput(message);
+        },
         onQueryRuntimes: () => {
             send({ type: 'runtime-info', runtimes: config.runtimes });
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brierb/brier-cli",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Brier 平台接入命令行工具：通过加密隧道将本机接入 Brier 远程编码池，接收并执行远程任务",
   "keywords": [
     "brier",
@@ -43,6 +43,7 @@
   },
   "dependencies": {
     "commander": "^12.1.0",
+    "node-pty": "^1.1.0",
     "ws": "^8.18.0"
   },
   "devDependencies": {

package/types/daemon/TaskExecutor.d.ts

@@ -6,9 +6,11 @@ export interface TaskExecutorCallbacks {
 }
 export interface TaskExecutor {
     execute: (task: TaskInfo) => void;
-    /** 取消单个任务：SIGTERM，宽限期后 SIGKILL */
+    /** 向运行中任务写入输入（pty = 模拟击键；pipe = 写 stdin）。任务不存在/不可写返回 false */
+    writeInput: (taskId: string, data: string) => boolean;
+    /** 取消单个任务：pipe 走 SIGTERM（宽限期后 SIGKILL）；pty 直接终止伪终端会话 */
     cancel: (taskId: string) => void;
-    /** 停止并收尾：对全部运行中任务 SIGTERM，等待退出，未退出的 SIGKILL */
+    /** 停止并收尾：对全部运行中任务终止，等待退出；pipe 超时升级 SIGKILL */
     dispose: () => Promise<void>;
 }
 export declare const createTaskExecutor: (callbacks: TaskExecutorCallbacks) => TaskExecutor;

package/types/definitions/task.d.ts

@@ -1,3 +1,4 @@
+import type { ExecMode } from './tunnel.js';
 /**
  * 本地任务执行上下文。
  *
@@ -22,4 +23,6 @@ export interface TaskInfo {
     env?: Record<string, string>;
     /** 自然语言指令（可选）：存在时按 RUNTIME_PROMPT_FLAGS 拼到命令参数中执行 */
     prompt?: string;
+    /** 执行形态（可选）：缺省 pipe（非交互，向后兼容）；pty 为伪终端交互（支持 task-input） */
+    execMode?: ExecMode;
 }

package/types/definitions/tunnel.d.ts

@@ -16,6 +16,12 @@
  * 新增流类型时两端必须同步修改。
  */
 export type StreamType = 'stdout' | 'stderr';
+/**
+ * 子进程执行形态（随 task-start 下发，两端同步）：
+ * - pipe：非交互，stdout/stderr 管道直传（默认，向后兼容旧行为）
+ * - pty：伪终端交互，可接收 task-input 写入（AI 提问等场景）
+ */
+export type ExecMode = 'pipe' | 'pty';
 /**
  * 隧道线协议消息（daemon ⇄ Brier 服务端，WebSocket JSON 文本帧）。
  *
@@ -70,6 +76,7 @@ export type ClientMessage = {
  * - heartbeat-ack：心跳回执（echo 客户端发送的 timestamp）
  * - task-start：下发任务执行；prompt 模式由 CLI 按 runtime 拼参数，command 模式直接执行
  * - task-cancel：请求终止正在执行的子进程（SIGTERM）
+ * - task-input：向运行中任务写入输入（pty 模式 = 模拟键盘击键；pipe 模式写入 stdin）
  * - query-runtimes：查询本机 runtime 清单（当前服务端不会主动发送，属预留；CLI 保留处理以兼容旧服务端）
  */
 export type ServerMessage = {
@@ -95,9 +102,15 @@ export type ServerMessage = {
     env?: Record<string, string>;
     /** 自然语言指令（可选）：存在时按 RUNTIME_PROMPT_FLAGS 拼入执行参数 */
     prompt?: string;
+    /** 执行形态（可选）：缺省 pipe（向后兼容旧服务端） */
+    execMode?: ExecMode;
 } | {
     type: 'task-cancel';
     taskId: string;
+} | {
+    type: 'task-input';
+    taskId: string;
+    data: string;
 } | {
     type: 'query-runtimes';
 };

package/types/tunnel/dispatcher.d.ts

@@ -19,6 +19,10 @@ export interface ServerMessageHandlers {
     }>) => void;
     /** 任务取消 */
     onTaskCancel: (taskId: string) => void;
+    /** 向运行中任务写入输入（回答 AI 提问 / pty 击键） */
+    onTaskInput: (message: Extract<ServerMessage, {
+        type: 'task-input';
+    }>) => void;
     /** 服务端查询本机 runtime 清单 */
     onQueryRuntimes: () => void;
 }

package/types/tunnel/index.d.ts

@@ -19,6 +19,9 @@ export interface TunnelMessageHandlers {
         type: 'task-start';
     }>) => void;
     onTaskCancel: (taskId: string) => void;
+    onTaskInput: (message: Extract<ServerMessage, {
+        type: 'task-input';
+    }>) => void;
 }
 /**
  * 隧道骨架：连接生命周期编排与状态仲裁的唯一入口。