@brierb/brier-cli 0.0.6 → 0.0.8

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();
+        },
+    };
+};

package/dist/daemon/TaskExecutor.js

@@ -1,14 +1,46 @@
 import { spawn } from 'node:child_process';
-import { logger } from '../logger.js';
-import { RUNTIME_COMMANDS, RUNTIME_PROMPT_FLAGS } from '../runtimes.js';
+import { logger, resolveRuntimeExecutable, RUNTIME_PROMPT_FLAGS } from '../core/index.js';
 const MAX_CONCURRENT = 3;
+/** 取消后等待 SIGTERM 生效的时间，超时升级 SIGKILL */
+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 */
+    const cancelRequested = new Set();
+    /** 已上报终态（error/complete 二选一，防双重上报）的任务 */
+    const finished = new Set();
+    /** 取消后的 SIGKILL 升级计时器 */
+    const killTimers = new Map();
+    const clearKillTimer = (taskId) => {
+        const timer = killTimers.get(taskId);
+        if (timer) {
+            clearTimeout(timer);
+            killTimers.delete(taskId);
+        }
+    };
+    const armKillTimer = (taskId, child, delayMs) => {
+        clearKillTimer(taskId);
+        killTimers.set(taskId, setTimeout(() => {
+            killTimers.delete(taskId);
+            if (processes.get(taskId) === child) {
+                logger.warn(`Task ${taskId} did not exit after SIGTERM, sending SIGKILL`);
+                child.kill('SIGKILL');
+            }
+        }, delayMs));
+    };
+    /**
+     * 解析要执行的命令：
+     * - 显式 command：直接用（调用方负责其可执行性）
+     * - runtime 模式：解析为**绝对路径**（PATH 或官方安装目录），
+     *   避免 daemon 进程 PATH 不含 runtime 目录时 spawn ENOENT
+     */
     const resolveCommand = (task) => {
         if (task.command)
             return task.command;
-        const mapped = RUNTIME_COMMANDS[task.runtime];
-        return mapped ?? null;
+        return resolveRuntimeExecutable(task.runtime);
     };
     /**
      * 拼执行参数：
@@ -59,12 +91,26 @@ export const createTaskExecutor = (callbacks) => {
             callbacks.onOutput(task.taskId, 'stderr', data.toString());
         });
         child.on('error', (err) => {
+            // error 后可能仍触发 close：终态只上报一次
+            if (finished.has(task.taskId))
+                return;
+            finished.add(task.taskId);
+            clearKillTimer(task.taskId);
             processes.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))
+                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`);
+                return;
+            }
             const exitCode = code ?? 0;
             logger.info(`Task ${task.taskId} completed with exit code ${exitCode}`);
             callbacks.onComplete(task.taskId, exitCode);
@@ -76,16 +122,39 @@ export const createTaskExecutor = (callbacks) => {
             logger.warn(`Task ${taskId} not found, cannot cancel`);
             return;
         }
+        if (cancelRequested.has(taskId)) {
+            return;
+        }
+        cancelRequested.add(taskId);
+        logger.info(`Task ${taskId} cancelling (SIGTERM)`);
         child.kill('SIGTERM');
-        processes.delete(taskId);
-        logger.info(`Task ${taskId} cancelled`);
+        armKillTimer(taskId, child, KILL_GRACE_MS);
     };
-    const cancelAll = () => {
+    const dispose = () => {
+        if (processes.size === 0)
+            return Promise.resolve();
         for (const [taskId, child] of processes) {
+            cancelRequested.add(taskId);
+            logger.info(`Task ${taskId} cancelling (shutdown, SIGTERM)`);
             child.kill('SIGTERM');
-            logger.info(`Task ${taskId} cancelled (shutdown)`);
+            armKillTimer(taskId, child, KILL_GRACE_MS);
         }
-        processes.clear();
+        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) {
+                        logger.warn(`Task ${taskId} force killed during shutdown`);
+                        child.kill('SIGKILL');
+                    }
+                    resolve();
+                    return;
+                }
+                setTimeout(check, DISPOSE_POLL_MS);
+            };
+            check();
+        });
     };
-    return { execute, cancel, cancelAll };
+    return { execute, cancel, dispose };
 };

package/dist/daemon/index.js

@@ -0,0 +1,13 @@
+/**
+ * daemon 域统一出口。
+ *
+ * 说明：DaemonRunner.ts 是 daemon 子进程的入口脚本（模块顶层即执行 main()，
+ * 并校验 BRIER_DAEMON_MODE），由 DaemonManager 以文件路径 spawn，
+ * 不应被 import，故不在此导出。本目录其余模块均无副作用，可安全经此导入。
+ */
+/** daemon 进程生命周期管理（前台 CLI 使用） */
+export { createDaemonManager } from './DaemonManager.js';
+/** 任务执行器（daemon 子进程内 spawn runtime） */
+export { createTaskExecutor, } from './TaskExecutor.js';
+/** daemon 运行状态读取（status/restart 展示与回退） */
+export { readDaemonState } from './state.js';

package/dist/daemon/state.js

@@ -0,0 +1,100 @@
+import { execSync } from 'node:child_process';
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { BRIER_DIR, DAEMON_STATE_FILE } from '../config/index.js';
+/**
+ * daemon 运行状态契约（~/.brier/daemon.json，JSON）。
+ *
+ * 前台 CLI 与 daemon 子进程之间唯一的持久契约：Manager 写初始记录并轮询 ready，
+ * Runner 进入运行后置 ready/写 bootError、随隧道状态更新 tunnelState。
+ * 本模块同时提供进程存活与身份校验，避免 PID 被系统复用后误判/误杀。
+ */
+const WAIT_POLL_MS = 200;
+/** 仅判断 pid 是否存活（kill 0）。 */
+export const isProcessAlive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err instanceof Error && 'code' in err && err.code === 'EPERM';
+    }
+};
+/** 读取进程命令行；ps 不可用或进程不存在时返回 null。 */
+const readProcessCommand = (pid) => {
+    try {
+        const out = execSync(`ps -p ${pid} -o command=`, { stdio: ['ignore', 'pipe', 'ignore'] });
+        return out.toString().trim();
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * 校验状态记录对应的 daemon 是否存活：
+ * pid 存活 + 命令行含 DaemonRunner（防止 PID 复用后指向无关进程）。
+ * ps 不可用时退化为仅存活判断，避免跨平台误伤。
+ */
+export const isDaemonRunning = (state) => {
+    if (!isProcessAlive(state.pid))
+        return false;
+    const command = readProcessCommand(state.pid);
+    return command === null || command.includes('DaemonRunner');
+};
+/** 读取运行状态；文件缺失或字段不全（含旧版格式）时返回 null。 */
+export const readDaemonState = () => {
+    try {
+        const data = JSON.parse(readFileSync(DAEMON_STATE_FILE, 'utf-8'));
+        if (typeof data.pid !== 'number' ||
+            typeof data.startTime !== 'number' ||
+            typeof data.serverUrl !== 'string' ||
+            typeof data.ready !== 'boolean') {
+            return null;
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
+};
+/** 写入完整运行状态（Manager 启动时调用）。 */
+export const writeDaemonState = (state) => {
+    mkdirSync(BRIER_DIR, { recursive: true });
+    writeFileSync(DAEMON_STATE_FILE, JSON.stringify(state, null, 2));
+};
+/** 合并更新状态（Runner 侧置 ready/bootError/tunnelState，保留其余字段）。 */
+export const updateDaemonState = (patch) => {
+    const current = readDaemonState() ?? {
+        pid: process.pid,
+        startTime: Date.now(),
+        serverUrl: '',
+        ready: false,
+    };
+    writeDaemonState({ ...current, ...patch });
+};
+/** 清理运行状态文件（不存在时静默）。 */
+export const removeDaemonState = () => {
+    try {
+        unlinkSync(DAEMON_STATE_FILE);
+    }
+    catch {
+        /* 文件不存在则忽略 */
+    }
+};
+/** 轮询等待 pid 退出；超时返回 false。 */
+export const waitForProcessExit = (pid, timeoutMs = 5_000) => {
+    return new Promise((resolve) => {
+        const start = Date.now();
+        const check = () => {
+            if (!isProcessAlive(pid)) {
+                resolve(true);
+                return;
+            }
+            if (Date.now() - start >= timeoutMs) {
+                resolve(false);
+                return;
+            }
+            setTimeout(check, WAIT_POLL_MS);
+        };
+        check();
+    });
+};

package/dist/definitions/daemon.js

@@ -0,0 +1,5 @@
+/**
+ * daemon 的装配配置、生命周期状态与进程间通信文件。
+ * 本文件三个类型均为“daemon 进程自身/前台 CLI 管理 daemon”使用，不参与隧道线协议。
+ */
+export {};

package/dist/definitions/index.js

@@ -0,0 +1,12 @@
+/**
+ * 类型契约统一出口。
+ *
+ * 目录按功能域拆分：
+ * - tunnel.ts：隧道域（线协议 StreamType / ClientMessage / ServerMessage + 连接状态机 TunnelState）
+ * - task.ts：  本地任务执行上下文（消息 → 子进程执行）
+ * - daemon.ts：daemon 装配配置 / 生命周期状态 / PID 文件
+ *
+ * 约定：业务模块一律从本文件（'../definitions/index.js'）导入，不要跨层直接引用子文件，
+ * 以便后续调整目录结构时只需改这里，不动各调用方。
+ */
+export {};

package/dist/definitions/tunnel.js

@@ -0,0 +1,9 @@
+/**
+ * 隧道域类型（daemon ⇄ Brier 服务端 的连接与消息）。
+ *
+ * 聚合三组归属不同的类型：
+ * 1. StreamType / ClientMessage / ServerMessage：线协议（WebSocket JSON 文本帧），
+ *    与服务端 Rust `brier_type::tunnel::*` 镜像，任何命名/字段改动两端必须同步；
+ * 2. TunnelState：daemon 进程内的连接状态机（服务端无对应，不上报）。
+ */
+export {};

package/dist/index.js

@@ -1,61 +1,42 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { readCliVersion } from './config/index.js';
 import { startCommand } from './commands/start.js';
 import { stopCommand } from './commands/stop.js';
 import { restartCommand } from './commands/restart.js';
 import { statusCommand } from './commands/status.js';
+import { logCommand } from './commands/log.js';
+import { runCommand } from './commands/run.js';
 const program = new Command();
 program
     .name('brier')
     .description('Brier CLI - Connect to Brier platform via encrypted tunnel')
-    .version('0.0.1');
+    .version(readCliVersion());
 const daemon = program.command('daemon').description('Manage the brier background service');
 daemon
     .command('start')
     .description('Start the background service')
     .requiredOption('--server-url <url>', 'Brier server URL')
     .option('--token <token>', 'BRIER_TOKEN (or set BRIER_TOKEN env var)')
-    .action(async (opts) => {
-    try {
-        await startCommand(opts);
-    }
-    catch (err) {
-        console.error('Error:', err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-});
+    .action((opts) => runCommand(() => startCommand(opts)));
 daemon
     .command('stop')
     .description('Stop the background service')
-    .action(async () => {
-    try {
-        await stopCommand();
-    }
-    catch (err) {
-        console.error('Error:', err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-});
+    .action(() => runCommand(stopCommand));
 daemon
     .command('restart')
     .description('Restart the background service')
     .option('--server-url <url>', 'Brier server URL (defaults to previous config)')
     .option('--token <token>', 'BRIER_TOKEN (or set BRIER_TOKEN env var)')
-    .action(async (opts) => {
-    try {
-        await restartCommand(opts);
-    }
-    catch (err) {
-        console.error('Error:', err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-});
+    .action((opts) => runCommand(() => restartCommand(opts)));
 daemon
     .command('status')
     .description('Check the background service status')
-    .action(() => {
-    statusCommand();
-});
+    .action(() => runCommand(statusCommand));
+daemon
+    .command('log')
+    .description('Show the latest daemon log lines')
+    .action(() => runCommand(logCommand));
 program.parseAsync(process.argv).catch((err) => {
     console.error('Fatal:', err instanceof Error ? err.message : String(err));
     process.exit(1);

package/dist/tunnel/backoff.js

@@ -0,0 +1,21 @@
+export const createBackoff = (options) => {
+    let attempts = 0;
+    const useJitter = options.jitter ?? true;
+    return {
+        next() {
+            if (attempts >= options.maxAttempts) {
+                return -1;
+            }
+            attempts += 1;
+            const delay = Math.min(options.baseMs * Math.pow(2, attempts - 1), options.maxMs);
+            // full jitter：与指数退避正交，仅打散“同一时刻重连”的相位
+            return useJitter ? Math.floor(Math.random() * (delay + 1)) : delay;
+        },
+        get attempts() {
+            return attempts;
+        },
+        reset() {
+            attempts = 0;
+        },
+    };
+};

package/dist/tunnel/dispatcher.js

@@ -0,0 +1,35 @@
+import { logger } from '../core/index.js';
+/** 解析并分发一条服务端消息；JSON 解析失败或未知 type 记日志后静默返回。 */
+export const dispatchServerMessage = (raw, handlers) => {
+    let message;
+    try {
+        message = JSON.parse(raw);
+    }
+    catch (err) {
+        logger.error('Failed to parse server message:', err);
+        return;
+    }
+    switch (message.type) {
+        case 'auth-ok':
+            handlers.onAuthOk(message.computerId);
+            break;
+        case 'auth-failed':
+            handlers.onAuthFailed(message.reason);
+            break;
+        case 'heartbeat-ack':
+            handlers.onHeartbeatAck(message.timestamp);
+            break;
+        case 'task-start':
+            handlers.onTaskStart(message);
+            break;
+        case 'task-cancel':
+            handlers.onTaskCancel(message.taskId);
+            break;
+        case 'query-runtimes':
+            handlers.onQueryRuntimes();
+            break;
+        default:
+            // 协议演进中可能出现未知消息，忽略即可（记录以利于排查）
+            logger.warn('Unknown server message type:', message.type);
+    }
+};

package/dist/tunnel/heartbeat.js

@@ -0,0 +1,55 @@
+/**
+ * 应用层心跳策略。
+ *
+ * 只负责节奏：到点调用 onBeat() 发送心跳；onBeat 返回 true（已发出）时启动
+ * ack 超时计时，收到 ack 由调用方调 ack() 解除；超时触发 onTimeout()。
+ * 本模块“只上报不决策”——超时后如何处理（如关闭连接）由上层骨架决定。
+ *
+ * 注意：每次触发心跳前先清理上一次的 ack 超时计时器，避免重复计时器叠加。
+ */
+export const createHeartbeat = (options) => {
+    let intervalTimer = null;
+    let timeoutTimer = null;
+    const clearTimeoutTimer = () => {
+        if (timeoutTimer) {
+            clearTimeout(timeoutTimer);
+            timeoutTimer = null;
+        }
+    };
+    const clearAllTimers = () => {
+        if (intervalTimer) {
+            clearInterval(intervalTimer);
+            intervalTimer = null;
+        }
+        clearTimeoutTimer();
+    };
+    const armTimeout = () => {
+        clearTimeoutTimer();
+        timeoutTimer = setTimeout(() => {
+            timeoutTimer = null;
+            options.onTimeout();
+        }, options.timeoutMs);
+    };
+    const beat = () => {
+        try {
+            if (options.onBeat()) {
+                armTimeout();
+            }
+        }
+        catch (error) {
+            options.onBeatError?.(error);
+        }
+    };
+    return {
+        start() {
+            clearAllTimers();
+            intervalTimer = setInterval(beat, options.intervalMs);
+        },
+        stop() {
+            clearAllTimers();
+        },
+        ack() {
+            clearTimeoutTimer();
+        },
+    };
+};