@brierb/brier-cli 0.0.7 → 0.0.8

package/dist/commands/log.js

@@ -0,0 +1,28 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { LOG_FILE } from '../config/index.js';
+/** 默认打印的最近日志行数 */
+const TAIL_LINES = 100;
+/**
+ * `brier daemon log`：查看后台服务日志。
+ * 输出 ~/.brier/daemon.log 最近 100 行；文件不存在时给出提示与路径。
+ */
+export const logCommand = () => {
+    if (!existsSync(LOG_FILE)) {
+        console.log('尚未生成日志，daemon 可能从未启动过');
+        console.log(`  日志路径: ${LOG_FILE}`);
+        return;
+    }
+    const content = readFileSync(LOG_FILE, 'utf-8');
+    const allLines = content.split('\n');
+    // 去掉文件末尾换行产生的空行
+    if (allLines.length > 0 && allLines[allLines.length - 1] === '') {
+        allLines.pop();
+    }
+    const tail = allLines.slice(-TAIL_LINES);
+    if (tail.length === 0) {
+        console.log(`日志为空（${LOG_FILE}）`);
+        return;
+    }
+    console.log(`最近 ${tail.length} 行日志（${LOG_FILE}）：`);
+    console.log(tail.join('\n'));
+};

package/dist/commands/restart.js

@@ -1,11 +1,16 @@
-import { createDaemonManager } from '../daemon/DaemonManager.js';
-import { loadConfig } from '../config.js';
+import { createDaemonManager, readDaemonState } from '../daemon/index.js';
+import { loadConfig, readStoredToken } from '../config/index.js';
 export const restartCommand = async (options) => {
     let serverUrl = options.serverUrl;
-    let token = options.token ?? process.env.BRIER_TOKEN;
+    // token 优先级：--token → BRIER_TOKEN 环境变量 → 持久化的接入令牌（0600 的 credentials.json）
+    let token = options.token ?? process.env.BRIER_TOKEN ?? readStoredToken();
+    // 未显式指定 server-url 时，优先沿用当前 daemon 记录的地址（状态文件），再退回环境变量
+    if (!serverUrl) {
+        serverUrl = readDaemonState()?.serverUrl;
+    }
     if (!serverUrl || !token) {
         try {
-            const config = loadConfig({});
+            const config = loadConfig();
             if (!serverUrl)
                 serverUrl = config.serverUrl;
             if (!token)

package/dist/commands/run.js

@@ -0,0 +1,13 @@
+/**
+ * 命令执行包装：统一 try/catch 与失败退出码。
+ * commander 的 action 直接返回 runCommand(...)，消除各命令重复的错误处理样板。
+ */
+export const runCommand = async (fn) => {
+    try {
+        await fn();
+    }
+    catch (err) {
+        console.error('Error:', err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+};

package/dist/commands/start.js

@@ -1,5 +1,5 @@
-import { createDaemonManager } from '../daemon/DaemonManager.js';
-import { LOG_FILE } from '../config.js';
+import { createDaemonManager } from '../daemon/index.js';
+import { LOG_FILE } from '../config/index.js';
 export const startCommand = async (options) => {
     const token = options.token ?? process.env.BRIER_TOKEN;
     if (!token) {

package/dist/commands/status.js

@@ -1,24 +1,19 @@
-import { createDaemonManager } from '../daemon/DaemonManager.js';
-import { existsSync, readFileSync } from 'node:fs';
-import { PID_FILE } from '../config.js';
+import { createDaemonManager, readDaemonState } from '../daemon/index.js';
+/** `brier daemon status`：展示 daemon 运行状态与状态文件详情。 */
 export const statusCommand = () => {
     const manager = createDaemonManager();
     const status = manager.status();
     if (status === 'running') {
-        let pidInfo = null;
-        if (existsSync(PID_FILE)) {
-            try {
-                pidInfo = JSON.parse(readFileSync(PID_FILE, 'utf-8'));
-            }
-            catch {
-                // ignore
-            }
-        }
+        const state = readDaemonState();
         console.log('● 后台服务运行中');
-        if (pidInfo) {
-            console.log(`  PID: ${pidInfo.pid}`);
-            console.log(`  Server: ${pidInfo.serverUrl}`);
-            console.log(`  Started: ${new Date(pidInfo.startTime).toLocaleString()}`);
+        if (state) {
+            console.log(`  PID: ${state.pid}`);
+            console.log(`  Server: ${state.serverUrl}`);
+            console.log(`  Started: ${new Date(state.startTime).toLocaleString()}`);
+            console.log(`  Ready: ${state.ready ? '是' : '否（启动中）'}`);
+            if (state.tunnelState) {
+                console.log(`  隧道状态: ${state.tunnelState}`);
+            }
         }
     }
     else {

package/dist/commands/stop.js

@@ -1,4 +1,4 @@
-import { createDaemonManager } from '../daemon/DaemonManager.js';
+import { createDaemonManager } from '../daemon/index.js';
 export const stopCommand = async () => {
     const manager = createDaemonManager();
     await manager.stop();

package/dist/config/credentials.js

@@ -0,0 +1,25 @@
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { CREDENTIALS_FILE } from './paths.js';
+/** 读取持久化的接入令牌；文件缺失或损坏时返回 undefined。 */
+export const readStoredToken = () => {
+    try {
+        const data = JSON.parse(readFileSync(CREDENTIALS_FILE, 'utf-8'));
+        return typeof data.token === 'string' && data.token.length > 0 ? data.token : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * 持久化接入令牌到 ~/.brier/credentials.json。
+ * 写入使用 mode 0600，并对已存在的文件强制收紧权限（防止先前被宽权限创建）。
+ * 失败会抛错，由调用方决定是否阻断启动。
+ */
+export const writeCredentials = (token) => {
+    mkdirSync(dirname(CREDENTIALS_FILE), { recursive: true });
+    writeFileSync(CREDENTIALS_FILE, JSON.stringify({ token }, null, 2), {
+        mode: 0o600,
+    });
+    chmodSync(CREDENTIALS_FILE, 0o600);
+};

package/dist/config/index.js

@@ -0,0 +1,16 @@
+/**
+ * 配置域统一出口：提供 daemon 装配所需的全部环境信息。
+ *
+ * 目录内文件职责：
+ * - load.ts：  loadConfig()，从环境变量装配 DaemonConfig
+ * - paths.ts： 应用路径常量（~/.brier 下的 PID/日志文件）
+ * - version.ts：CLI 版本读取（package.json）
+ */
+/** daemon 装配配置（BRIER_SERVER_URL / BRIER_TOKEN → DaemonConfig） */
+export { loadConfig } from './load.js';
+/** 应用路径常量：BRIER_DIR / DAEMON_STATE_FILE / LOG_FILE / CREDENTIALS_FILE */
+export { BRIER_DIR, DAEMON_STATE_FILE, LOG_FILE, CREDENTIALS_FILE } from './paths.js';
+/** CLI 版本读取 */
+export { readCliVersion } from './version.js';
+/** 接入令牌持久化（credentials.json，0600） */
+export { readStoredToken, writeCredentials } from './credentials.js';

package/dist/config/load.js

@@ -0,0 +1,26 @@
+import { arch, hostname as getHostname, platform, type as osType } from 'node:os';
+import { detectInstalledRuntimes } from '../core/index.js';
+import { readCliVersion } from './version.js';
+/**
+ * daemon 装配配置加载：从 BRIER_SERVER_URL / BRIER_TOKEN 环境变量
+ * 读取 serverUrl / token，并组合本机信息（hostname/os/runtimes/version）。
+ * 校验失败（缺少必填项）时抛出带说明的错误。
+ */
+export const loadConfig = () => {
+    const serverUrl = process.env.BRIER_SERVER_URL;
+    const token = process.env.BRIER_TOKEN;
+    if (!serverUrl) {
+        throw new Error('Server URL is required. Use --server-url or set BRIER_SERVER_URL');
+    }
+    if (!token) {
+        throw new Error('BRIER_TOKEN is required. Pass --token or set BRIER_TOKEN env var');
+    }
+    return {
+        serverUrl,
+        token,
+        hostname: getHostname(),
+        os: `${osType()} ${platform()} ${arch()}`,
+        runtimes: detectInstalledRuntimes(),
+        version: readCliVersion(),
+    };
+};

package/dist/config/paths.js

@@ -0,0 +1,14 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * 应用文件路径常量。
+ * 集中到 ~/.brier/ 下，保证与 daemon 启动时的工作目录无关。
+ */
+/** Brier 用户数据目录（~/.brier） */
+export const BRIER_DIR = join(homedir(), '.brier');
+/** daemon 运行状态文件（JSON，结构见 definitions/daemon.ts 的 DaemonState） */
+export const DAEMON_STATE_FILE = join(BRIER_DIR, 'daemon.json');
+/** daemon 运行日志文件 */
+export const LOG_FILE = join(BRIER_DIR, 'daemon.log');
+/** daemon 接入令牌持久化文件（0600，供 `daemon restart` 无参回退） */
+export const CREDENTIALS_FILE = join(BRIER_DIR, 'credentials.json');

package/dist/config/version.js

@@ -0,0 +1,13 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+/** CLI 自身版本：读取 dist 两级的 package.json（与 `brier --version` 同源）。 */
+export const readCliVersion = () => {
+    try {
+        const pkgPath = fileURLToPath(new URL('../../package.json', import.meta.url));
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        return pkg.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+};

package/dist/core/index.js

@@ -0,0 +1,11 @@
+/**
+ * 公共底座统一出口：无业务依赖的基础能力，供 config/daemon/tunnel/commands 各域使用。
+ *
+ * 目录内文件职责：
+ * - logger.ts： 文件日志（configureLogger / logger）
+ * - runtimes.ts：AI runtime 注册表、可执行文件解析与已安装探测
+ */
+/** 文件日志 */
+export { configureLogger, logger } from './logger.js';
+/** AI runtime 注册表 / 命令 / prompt 参数 / 解析 / 探测 */
+export * from './runtimes.js';

package/dist/{runtimes.js → core/runtimes.js}

@@ -66,3 +66,9 @@ export const resolveRuntimeExecutable = (runtime) => {
     const candidates = entry.fallbacks ?? [`~/.local/bin/${entry.command}`];
     return candidates.map(expandHome).find(isExecutable) ?? null;
 };
+/**
+ * 探测本机已安装的 AI runtime 名称列表。
+ * 过滤注册表：只保留 resolveRuntimeExecutable 能解析出可执行文件的项
+ * （探测与执行共用同一解析，保证“探测到”的 runtime 一定能被 spawn）。
+ */
+export const detectInstalledRuntimes = () => RUNTIME_REGISTRY.filter((r) => resolveRuntimeExecutable(r.name) !== null).map((r) => r.name);

package/dist/daemon/DaemonManager.js

@@ -1,66 +1,30 @@
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { BRIER_DIR, PID_FILE } from '../config.js';
-import { logger } from '../logger.js';
+import { writeCredentials } from '../config/index.js';
+import { logger } from '../core/index.js';
+import { isDaemonRunning, readDaemonState, removeDaemonState, waitForProcessExit, writeDaemonState, } from './state.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const RUNNER_SCRIPT = join(__dirname, 'DaemonRunner.js');
-const isProcessRunning = (pid) => {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (err) {
-        return err instanceof Error && 'code' in err && err.code === 'EPERM';
-    }
-};
-const readPidFile = () => {
-    if (!existsSync(PID_FILE))
-        return null;
-    try {
-        const data = readFileSync(PID_FILE, 'utf-8');
-        return JSON.parse(data);
-    }
-    catch {
-        return null;
-    }
-};
-const writePidFile = (data) => {
-    mkdirSync(BRIER_DIR, { recursive: true });
-    writeFileSync(PID_FILE, JSON.stringify(data, null, 2));
-};
-const removePidFile = () => {
-    if (existsSync(PID_FILE)) {
-        unlinkSync(PID_FILE);
-    }
-};
-const waitForExit = (pid, timeoutMs = 5000) => {
-    return new Promise((resolve) => {
-        const startTime = Date.now();
-        const check = () => {
-            if (!isProcessRunning(pid)) {
-                resolve(true);
-                return;
-            }
-            if (Date.now() - startTime >= timeoutMs) {
-                resolve(false);
-                return;
-            }
-            setTimeout(check, 200);
-        };
-        check();
-    });
-};
+/** 启动后等待子进程就绪（ready/bootError）的时限 */
+const READY_TIMEOUT_MS = 3_000;
+const READY_POLL_MS = 150;
 export const createDaemonManager = () => {
     const start = async (options) => {
-        const existing = readPidFile();
-        if (existing && isProcessRunning(existing.pid)) {
+        const existing = readDaemonState();
+        if (existing && isDaemonRunning(existing)) {
             throw new Error(`Daemon is already running (PID: ${existing.pid})`);
         }
         if (existing) {
-            removePidFile();
+            removeDaemonState();
+        }
+        // 持久化接入令牌（0600），供 `daemon restart` 无参回退；失败仅告警，不阻断启动
+        try {
+            writeCredentials(options.token);
+        }
+        catch (err) {
+            logger.warn('Failed to persist credentials:', err instanceof Error ? err.message : String(err));
         }
         const childEnv = {
             ...process.env,
@@ -77,27 +41,62 @@ export const createDaemonManager = () => {
         if (typeof child.pid !== 'number') {
             throw new Error('Failed to spawn daemon process');
         }
-        writePidFile({
+        // 先写“未就绪”状态，等子进程通过 ready/bootError 完成就绪握手
+        const startTime = Date.now();
+        writeDaemonState({
             pid: child.pid,
-            startTime: Date.now(),
+            startTime,
             serverUrl: options.serverUrl,
+            ready: false,
         });
-        logger.info('Daemon started, PID:', child.pid);
+        logger.info('Daemon spawned, waiting for ready (PID:', child.pid, ')');
+        const deadline = Date.now() + READY_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, READY_POLL_MS));
+            const state = readDaemonState();
+            if (state?.ready) {
+                logger.info('Daemon started, PID:', child.pid);
+                return;
+            }
+            if (state?.bootError) {
+                removeDaemonState();
+                throw new Error(`Daemon failed to start: ${state.bootError}`);
+            }
+        }
+        // 超时：进程若已退出则清理并报错，否则强杀后清理
+        removeDaemonState();
+        if (!(await waitForProcessExit(child.pid, 500))) {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                /* already gone */
+            }
+        }
+        throw new Error('Daemon start timed out, please check ~/.brier/daemon.log');
     };
     const stop = async () => {
-        const data = readPidFile();
+        const data = readDaemonState();
         if (!data) {
-            logger.warn('No PID file found, daemon may not be running');
+            logger.warn('No state file found, daemon may not be running');
             return;
         }
-        if (!isProcessRunning(data.pid)) {
-            logger.info('Process not running, cleaning up PID file');
-            removePidFile();
+        if (!isDaemonRunning(data)) {
+            // 身份校验不通过：PID 已复用或进程已退出，只清理状态，不误杀其他进程
+            logger.warn('Daemon not running or PID reused, cleaning up state file');
+            removeDaemonState();
             return;
         }
         logger.info('Sending SIGTERM to PID:', data.pid);
-        process.kill(data.pid, 'SIGTERM');
-        const exited = await waitForExit(data.pid, 5000);
+        try {
+            process.kill(data.pid, 'SIGTERM');
+        }
+        catch {
+            removeDaemonState();
+            logger.warn('Process already exited, cleaning up');
+            return;
+        }
+        const exited = await waitForProcessExit(data.pid, 5000);
         if (!exited) {
             logger.warn('Process did not exit, sending SIGKILL');
             try {
@@ -107,7 +106,7 @@ export const createDaemonManager = () => {
                 logger.error('Failed to kill process:', err);
             }
         }
-        removePidFile();
+        removeDaemonState();
         logger.info('Daemon stopped');
     };
     const restart = async (options) => {
@@ -115,12 +114,12 @@ export const createDaemonManager = () => {
         await start(options);
     };
     const status = () => {
-        const data = readPidFile();
+        const data = readDaemonState();
         if (!data)
             return 'stopped';
-        if (isProcessRunning(data.pid))
+        if (isDaemonRunning(data))
             return 'running';
-        removePidFile();
+        removeDaemonState();
         return 'stopped';
     };
     return { start, stop, restart, status };

package/dist/daemon/DaemonRunner.js

@@ -1,49 +1,91 @@
-import { loadConfig, LOG_FILE } from '../config.js';
-import { configureLogger, logger } from '../logger.js';
-import { createTunnelClient } from '../tunnel/TunnelClient.js';
+import { loadConfig, LOG_FILE } from '../config/index.js';
+import { configureLogger, logger } from '../core/index.js';
+import { createTunnelClient, } from '../tunnel/index.js';
 import { createTaskExecutor } from './TaskExecutor.js';
-let tunnel = null;
-const shutdown = async (signal) => {
-    logger.info(`Received ${signal}, shutting down...`);
-    if (tunnel) {
-        await tunnel.stop();
-        tunnel = null;
-    }
-    process.exit(0);
-};
-const handleUncaughtError = (err) => {
-    logger.error('Uncaught error:', err.message);
-    if (tunnel) {
-        tunnel.stop().finally(() => process.exit(1));
-    }
-    else {
-        process.exit(1);
-    }
-};
-const run = (config) => {
+import { createOutputBatcher } from './OutputBatcher.js';
+import { updateDaemonState } from './state.js';
+/**
+ * 组合根：装配并启动 daemon 的全部运行时组件。
+ * 纯装配职责，不注册信号、不触碰 process；进程级接线由 main 完成。
+ */
+const startDaemon = (config) => {
+    // 先声明后赋值：safeSend 闭包在隧道启动后才被事件触发，此处为延迟引用
+    let tunnel = null;
+    // send() 不抛异常（未连接/背压返回 false）；未发出的帧按设计丢弃（断线窗口不上行，属已知边界）
     const safeSend = (message) => {
-        try {
-            tunnel?.send(message);
-        }
-        catch {
-            // Connection not ready, output is dropped
-        }
+        tunnel?.send(message);
     };
+    // task-output 走批量发送（高频小消息合并，见 OutputBatcher）；终态/控制消息仍即时上报
+    const outputBatcher = createOutputBatcher({
+        onFlush: (chunks) => {
+            for (const chunk of chunks) {
+                safeSend({
+                    type: 'task-output',
+                    taskId: chunk.taskId,
+                    stream: chunk.stream,
+                    data: chunk.data,
+                });
+            }
+        },
+    });
     const taskExecutor = createTaskExecutor({
-        onOutput: (taskId, stream, data) => safeSend({ type: 'task-output', taskId, stream, data }),
-        onComplete: (taskId, exitCode) => safeSend({ type: 'task-complete', taskId, exitCode }),
-        onError: (taskId, error) => safeSend({ type: 'task-error', taskId, error }),
+        onOutput: (taskId, stream, data) => outputBatcher.push(taskId, stream, data),
+        onComplete: (taskId, exitCode) => {
+            outputBatcher.flushTask(taskId); // 终态前先发出该任务残留输出，避免被服务端终态过滤丢弃
+            safeSend({ type: 'task-complete', taskId, exitCode });
+        },
+        onError: (taskId, error) => {
+            outputBatcher.flushTask(taskId);
+            safeSend({ type: 'task-error', taskId, error });
+        },
     });
-    tunnel = createTunnelClient(config, taskExecutor);
-    tunnel.onStateChange((state) => {
+    // 组合点：把隧道下发的业务消息翻译成任务执行动作
+    const messageHandlers = {
+        onTaskStart: (message) => {
+            taskExecutor.execute({
+                taskId: message.taskId,
+                runtime: message.runtime,
+                command: message.command,
+                args: message.args,
+                cwd: message.cwd,
+                env: message.env,
+                prompt: message.prompt,
+            });
+        },
+        onTaskCancel: (taskId) => {
+            taskExecutor.cancel(taskId);
+        },
+    };
+    const client = createTunnelClient(config, messageHandlers);
+    tunnel = client;
+    client.onStateChange((state) => {
         logger.info('Tunnel state:', state);
+        // 状态落盘（低频状态切换），供 `daemon status` 展示
+        updateDaemonState({ tunnelState: state });
     });
-    tunnel.start();
+    client.start();
+    updateDaemonState({ ready: true }); // 就绪握手：告知前台 Manager 启动成功
     logger.info('Daemon runner started');
     logger.info('Server:', config.serverUrl);
     logger.info('Hostname:', config.hostname);
     logger.info('OS:', config.os);
     logger.info('Runtimes:', config.runtimes.join(', ') || 'none detected');
+    const stop = async () => {
+        outputBatcher.flushAll(); // 连接关闭前先把残留的任务输出发出去
+        await client.stop();
+        await taskExecutor.dispose();
+        outputBatcher.dispose();
+    };
+    return { tunnel: client, taskExecutor, outputBatcher, stop };
+};
+const shutdown = async (ctx, signal) => {
+    logger.info(`Received ${signal}, shutting down...`);
+    try {
+        await ctx.stop();
+    }
+    finally {
+        process.exit(0);
+    }
 };
 const main = () => {
     if (process.env.BRIER_DAEMON_MODE !== '1') {
@@ -53,18 +95,34 @@ const main = () => {
     configureLogger(LOG_FILE);
     let config;
     try {
-        config = loadConfig({});
+        config = loadConfig();
     }
     catch (err) {
-        logger.error('Config error:', err instanceof Error ? err.message : String(err));
+        const message = err instanceof Error ? err.message : String(err);
+        updateDaemonState({ bootError: message }); // 启动失败原因回写，Manager 据此中止
+        logger.error('Config error:', message);
         process.exit(1);
     }
-    process.on('SIGTERM', () => void shutdown('SIGTERM'));
-    process.on('SIGINT', () => void shutdown('SIGINT'));
+    // 进程级接线：句柄只存于 main 作用域，注册信号/异常处理都显式接收它
+    let ctx = null;
+    const handleSignal = (signal) => () => {
+        if (ctx) {
+            void shutdown(ctx, signal);
+        }
+    };
+    const handleUncaughtError = (err) => {
+        logger.error('Uncaught error:', err.stack ?? err.message);
+        const cleanup = ctx ? ctx.stop() : Promise.resolve();
+        void cleanup.finally(() => process.exit(1));
+    };
+    process.on('SIGTERM', handleSignal('SIGTERM'));
+    process.on('SIGINT', handleSignal('SIGINT'));
     process.on('uncaughtException', handleUncaughtError);
     process.on('unhandledRejection', (reason) => {
         logger.error('Unhandled rejection:', reason);
+        const cleanup = ctx ? ctx.stop() : Promise.resolve();
+        void cleanup.finally(() => process.exit(1));
     });
-    run(config);
+    ctx = startDaemon(config);
 };
 main();

package/dist/daemon/OutputBatcher.js

@@ -0,0 +1,77 @@
+const DEFAULT_MAX_BATCH_BYTES = 16 * 1024;
+const DEFAULT_FLUSH_INTERVAL_MS = 50;
+const keyOf = (taskId, stream) => `${taskId}\u0000${stream}`;
+export const createOutputBatcher = (options) => {
+    const maxBatchBytes = options.maxBatchBytes ?? DEFAULT_MAX_BATCH_BYTES;
+    const flushIntervalMs = options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+    const pending = new Map();
+    let timer = null;
+    const flushEntry = (key, entry) => {
+        pending.delete(key);
+        options.onFlush([
+            {
+                taskId: entry.taskId,
+                stream: entry.stream,
+                data: entry.parts.join(''),
+            },
+        ]);
+    };
+    const ensureTimer = () => {
+        if (timer)
+            return;
+        timer = setInterval(() => {
+            if (pending.size === 0)
+                return;
+            const entries = [...pending.entries()];
+            for (const [key, entry] of entries) {
+                if (pending.has(key)) {
+                    try {
+                        flushEntry(key, entry);
+                    }
+                    catch (err) {
+                        pending.delete(key);
+                        // flush 回调抛错不应杀死进程（setInterval 回调中的异常成为 uncaughtException）
+                        // 丢弃该缓冲项，其余继续
+                    }
+                }
+            }
+        }, flushIntervalMs);
+    };
+    return {
+        push(taskId, stream, data) {
+            if (data.length === 0)
+                return;
+            ensureTimer();
+            const key = keyOf(taskId, stream);
+            let entry = pending.get(key);
+            if (!entry) {
+                entry = { taskId, stream, parts: [], bytes: 0 };
+                pending.set(key, entry);
+            }
+            entry.parts.push(data);
+            entry.bytes += data.length;
+            if (entry.bytes >= maxBatchBytes) {
+                flushEntry(key, entry);
+            }
+        },
+        flushTask(taskId) {
+            const entries = [...pending.entries()].filter(([, e]) => e.taskId === taskId);
+            for (const [key, entry] of entries) {
+                flushEntry(key, entry);
+            }
+        },
+        flushAll() {
+            const entries = [...pending.entries()];
+            for (const [key, entry] of entries) {
+                flushEntry(key, entry);
+            }
+        },
+        dispose() {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            pending.clear();
+        },
+    };
+};