@brierb/brier-cli 0.0.6 → 0.0.8

package/types/definitions/task.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 本地任务执行上下文。
+ *
+ * TunnelClient 收到下行 task-start 消息后，将其转换为本结构交给
+ * TaskExecutor.execute() 执行——是“隧道传输形态”（ServerMessage）
+ * 与“子进程执行形态”之间的进程内中间对象，不上报服务端。
+ */
+export interface TaskInfo {
+    taskId: string;
+    /** 所属 AI runtime 名称；command 模式为空串 */
+    runtime: string;
+    /**
+     * 可执行命令：
+     * - command 模式：服务端下发的显式 shell 命令
+     * - runtime 模式：由 resolveRuntimeExecutable 解析为绝对路径（保证脱离受限 PATH 也能 spawn）
+     */
+    command: string;
+    args: string[];
+    /** 子进程工作目录（可选） */
+    cwd?: string;
+    /** 注入子进程的额外环境变量（可选） */
+    env?: Record<string, string>;
+    /** 自然语言指令（可选）：存在时按 RUNTIME_PROMPT_FLAGS 拼到命令参数中执行 */
+    prompt?: string;
+}

package/types/definitions/tunnel.d.ts

@@ -0,0 +1,112 @@
+/**
+ * 隧道域类型（daemon ⇄ Brier 服务端 的连接与消息）。
+ *
+ * 聚合三组归属不同的类型：
+ * 1. StreamType / ClientMessage / ServerMessage：线协议（WebSocket JSON 文本帧），
+ *    与服务端 Rust `brier_type::tunnel::*` 镜像，任何命名/字段改动两端必须同步；
+ * 2. TunnelState：daemon 进程内的连接状态机（服务端无对应，不上报）。
+ */
+/**
+ * 任务输出流的来源。
+ *
+ * 由 daemon 的 TaskExecutor 转发子进程输出时标记（stdout / stderr），
+ * 随上行消息 task-output 一并上报给服务端。
+ *
+ * 注意：序列化值需与服务端 Rust 侧 `brier_type::tunnel::StreamType` 保持一致（lowercase），
+ * 新增流类型时两端必须同步修改。
+ */
+export type StreamType = 'stdout' | 'stderr';
+/**
+ * 隧道线协议消息（daemon ⇄ Brier 服务端，WebSocket JSON 文本帧）。
+ *
+ * 使用可辨识联合：以 `type` 字段区分消息，type 值为 kebab-case（如 task-output / auth-ok），
+ * 字段名为 camelCase。与服务端 Rust `brier_type::tunnel::{ClientMessage, ServerMessage}`
+ * 经 serde（tag="type", rename_all="kebab-case" + 字段 rename）逐字段对齐，
+ * 任何一端新增/删除字段或改动命名时，另一端必须同步修改，否则 JSON 解析会失败或丢字段。
+ */
+/**
+ * 上行消息（daemon → 服务端）。
+ *
+ * - auth：连接建立后的第一条鉴权消息；token 同时通过 wss Authorization 头携带（双通道，服务端以 header 为准）
+ * - heartbeat：应用层心跳，触发服务端落库 last_seen_at 并回执 heartbeat-ack
+ * - task-output：任务实时输出；当前实现为 stdout/stderr 每收到一个数据块即发一条
+ * - task-complete：子进程正常退出（exitCode 为进程退出码）
+ * - task-error：执行失败（如找不到可执行文件、超过并发上限）
+ * - runtime-info：runtime 清单上报（服务端目前仅记录日志，属预留能力）
+ */
+export type ClientMessage = {
+    type: 'auth';
+    token: string;
+    hostname: string;
+    os: string;
+    runtimes: string[];
+    /** CLI 自身版本（package.json），旧版客户端可能不带该字段 */
+    version?: string;
+} | {
+    type: 'heartbeat';
+    timestamp: number;
+} | {
+    type: 'task-output';
+    taskId: string;
+    stream: StreamType;
+    data: string;
+} | {
+    type: 'task-complete';
+    taskId: string;
+    exitCode: number;
+} | {
+    type: 'task-error';
+    taskId: string;
+    error: string;
+} | {
+    type: 'runtime-info';
+    runtimes: string[];
+};
+/**
+ * 下行消息（服务端 → daemon）。
+ *
+ * - auth-ok：鉴权通过并完成注册，computerId 为本机在服务端的工作电脑 ID
+ * - auth-failed：鉴权失败（令牌无效等），reason 为失败原因
+ * - heartbeat-ack：心跳回执（echo 客户端发送的 timestamp）
+ * - task-start：下发任务执行；prompt 模式由 CLI 按 runtime 拼参数，command 模式直接执行
+ * - task-cancel：请求终止正在执行的子进程（SIGTERM）
+ * - query-runtimes：查询本机 runtime 清单（当前服务端不会主动发送，属预留；CLI 保留处理以兼容旧服务端）
+ */
+export type ServerMessage = {
+    type: 'auth-ok';
+    computerId: string;
+} | {
+    type: 'auth-failed';
+    reason: string;
+} | {
+    type: 'heartbeat-ack';
+    timestamp: number;
+} | {
+    type: 'task-start';
+    taskId: string;
+    /** 所属 AI runtime 名称（如 Claude Code / OpenCode）；command 模式为空串 */
+    runtime: string;
+    /** 可执行命令：command 模式为显式命令；runtime 模式为空，由 CLI 探测解析 */
+    command: string;
+    args: string[];
+    /** 子进程工作目录（可选） */
+    cwd?: string;
+    /** 注入子进程的额外环境变量（可选） */
+    env?: Record<string, string>;
+    /** 自然语言指令（可选）：存在时按 RUNTIME_PROMPT_FLAGS 拼入执行参数 */
+    prompt?: string;
+} | {
+    type: 'task-cancel';
+    taskId: string;
+} | {
+    type: 'query-runtimes';
+};
+/**
+ * 隧道连接状态机。
+ *
+ * 仅存在于 daemon 进程内（TunnelClient 内部维护、DaemonRunner 订阅打印），不上报服务端：
+ * connecting（握手）→ connected（收到 auth-ok）→ 断线进入 reconnecting；
+ * 收到 auth-failed 或重连次数耗尽（50 次退避上限）时进入 error 并停止，
+ * 主动 stop 时进入 disconnected。
+ */
+export type TunnelState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting' | 'error';

package/types/tunnel/backoff.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 重连退避策略（纯逻辑，无 IO、无副作用）。
+ *
+ * 与原实现的等价行为：指数退避（1s 起步、封顶 maxMs），累计 maxAttempts 次后放弃。
+ * next() 返回 -1 表示“已耗尽、应停止重连”；attempts 仅供日志展示尝试次数。
+ */
+export interface BackoffOptions {
+    /** 基础延迟（ms），首次重连即使用该值 */
+    baseMs: number;
+    /** 延迟封顶（ms） */
+    maxMs: number;
+    /** 最大重连尝试次数，达到后放弃 */
+    maxAttempts: number;
+    /**
+     * 是否启用 full jitter：在 [0, 计算延迟] 内取随机值，
+     * 避免大量客户端同时断线后以完全相同的节奏重连（重连风暴）。
+     * 默认开启。
+     */
+    jitter?: boolean;
+}
+export interface Backoff {
+    /**
+     * 计算下一次等待毫秒数。
+     * 已尝试次数达到 maxAttempts 时返回 -1（调用方应停止重连）。
+     */
+    next(): number;
+    /** 已排定/已执行的尝试次数（供日志与判断） */
+    readonly attempts: number;
+    /** 连接成功后归零 */
+    reset(): void;
+}
+export declare const createBackoff: (options: BackoffOptions) => Backoff;

package/types/tunnel/dispatcher.d.ts

@@ -0,0 +1,26 @@
+import type { ServerMessage } from '../definitions/index.js';
+/**
+ * 服务端下行消息解析与分发。
+ *
+ * 只做两件事：把 WS 文本帧 JSON.parse 成 ServerMessage，再按 type 分发给对应回调。
+ * 不接触 ws、状态机或执行器——骨架通过回调把“协议 → 业务动作”接起来，
+ * 本模块因此不依赖网络与运行状态，职责保持单一。
+ */
+export interface ServerMessageHandlers {
+    /** 鉴权通过（携带服务端分配的工作电脑 ID） */
+    onAuthOk: (computerId: string) => void;
+    /** 鉴权失败（reason 为原因） */
+    onAuthFailed: (reason: string) => void;
+    /** 心跳回执 */
+    onHeartbeatAck: (timestamp: number) => void;
+    /** 任务下发 */
+    onTaskStart: (message: Extract<ServerMessage, {
+        type: 'task-start';
+    }>) => void;
+    /** 任务取消 */
+    onTaskCancel: (taskId: string) => void;
+    /** 服务端查询本机 runtime 清单 */
+    onQueryRuntimes: () => void;
+}
+/** 解析并分发一条服务端消息；JSON 解析失败或未知 type 记日志后静默返回。 */
+export declare const dispatchServerMessage: (raw: string, handlers: ServerMessageHandlers) => void;

package/types/tunnel/heartbeat.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 应用层心跳策略。
+ *
+ * 只负责节奏：到点调用 onBeat() 发送心跳；onBeat 返回 true（已发出）时启动
+ * ack 超时计时，收到 ack 由调用方调 ack() 解除；超时触发 onTimeout()。
+ * 本模块“只上报不决策”——超时后如何处理（如关闭连接）由上层骨架决定。
+ *
+ * 注意：每次触发心跳前先清理上一次的 ack 超时计时器，避免重复计时器叠加。
+ */
+export interface HeartbeatOptions {
+    /** 心跳发送间隔（ms） */
+    intervalMs: number;
+    /** 等待 ack 的超时（ms） */
+    timeoutMs: number;
+    /**
+     * 心跳发送回调。返回是否已真正发出（连接未打开时返回 false，
+     * 此时不启动 ack 超时计时）。
+     */
+    onBeat: () => boolean;
+    /** ack 超时（对端无响应）回调，由上层决定如何处置 */
+    onTimeout: () => void;
+    /**
+     * onBeat 抛错时的回调（可选）。setInterval 回调中的异常会作为
+     * uncaughtException 直接杀死进程，因此 beat() 内部必须吞掉。
+     */
+    onBeatError?: (error: unknown) => void;
+}
+export interface Heartbeat {
+    /** 启动心跳（幂等：先停止已有计时器再开始） */
+    start(): void;
+    /** 停止心跳并清理所有计时器 */
+    stop(): void;
+    /** 收到 ack 时调用：解除当前 ack 超时计时 */
+    ack(): void;
+}
+export declare const createHeartbeat: (options: HeartbeatOptions) => Heartbeat;

package/types/tunnel/index.d.ts

@@ -0,0 +1,38 @@
+import type { ClientMessage, DaemonConfig, ServerMessage, TunnelState } from '../definitions/index.js';
+export interface TunnelClient {
+    start: () => void;
+    stop: () => Promise<void>;
+    /** 发送上行消息；返回是否真正发出（未连接时为 false，调用方决定如何处理） */
+    send: (message: ClientMessage) => boolean;
+    getState: () => TunnelState;
+    onStateChange: (callback: (state: TunnelState) => void) => () => void;
+}
+/**
+ * 业务消息处理回调（组合点）。
+ *
+ * 隧道只负责“协议 → 消息分发”，不解释业务：task-start/task-cancel
+ * 原样交给宿主实现（daemon/DaemonRunner 将其翻译成 TaskExecutor 调用）。
+ * 隧道域因此不依赖任务执行域。
+ */
+export interface TunnelMessageHandlers {
+    onTaskStart: (message: Extract<ServerMessage, {
+        type: 'task-start';
+    }>) => void;
+    onTaskCancel: (taskId: string) => void;
+}
+/**
+ * 隧道骨架：连接生命周期编排与状态仲裁的唯一入口。
+ *
+ * 本文件只做“编排”，不接触 ws 细节、不算退避、不解析消息：
+ * - transport：负责底层连接与收发帧
+ * - heartbeat：负责心跳节奏（只上报不决策）
+ * - backoff：负责重连延迟计算（纯逻辑）
+ * - dispatcher：负责服务端消息解析与分发
+ *
+ * 关键时序不变式（重构后保持与原实现一致）：
+ * 1. 心跳仅在 auth-ok 后启动；
+ * 2. close 后仅当 running 才退避重连，stop() 后绝不再连；
+ * 3. 仅 auth-ok 归零退避计数；
+ * 4. stop 时先优雅 close，3s 兜底 terminate。
+ */
+export declare const createTunnelClient: (config: DaemonConfig, messageHandlers: TunnelMessageHandlers) => TunnelClient;

package/types/tunnel/transport.d.ts

@@ -0,0 +1,29 @@
+export interface TransportEventMap {
+    /** 连接建立（TCP+TLS+WS 握手完成） */
+    open: () => void;
+    /** 连接关闭：code 为关闭码，reason 为关闭原因（已转字符串） */
+    close: (code: number, reason: string) => void;
+    /** 收到文本消息（已转字符串） */
+    message: (data: string) => void;
+    /** 底层错误（通常随后触发 close） */
+    error: (message: string) => void;
+}
+export interface Transport {
+    /** 建立到 url 的连接（携带自定义请求头）；会清理上一次连接 */
+    connect(url: string, headers: Record<string, string>): void;
+    /** 发送文本帧；返回是否已入队（未连接或缓冲积压超限时为 false，不抛错） */
+    send(data: string): boolean;
+    /** 优雅关闭（仅当连接处于打开/连接中） */
+    close(code: number, reason: string): void;
+    /** 强制终止底层连接（不触发事件） */
+    terminate(): void;
+    isOpen(): boolean;
+    isConnecting(): boolean;
+    /** 连接是否已完全关闭（不存在或 CLOSED）：close 事件不会再触发 */
+    isClosed(): boolean;
+    /** 等待下一次 close 事件，超时 resolve（用于 stop 的优雅关闭兜底） */
+    waitClosed(timeoutMs: number): Promise<void>;
+    /** 订阅事件，返回取消订阅函数 */
+    on<K extends keyof TransportEventMap>(event: K, callback: TransportEventMap[K]): () => void;
+}
+export declare const createWebSocketTransport: () => Transport;

package/types/tunnel/url.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 隧道接入端点工具：把服务端 http(s) 地址转换为 WebSocket 隧道地址。
+ * 纯字符串转换（wss/ws://host/tunnel），无状态、无副作用。
+ */
+export declare const toWsUrl: (serverUrl: string) => string;

package/dist/config.js

@@ -1,81 +0,0 @@
-import { hostname as getHostname, type as osType, arch, platform, homedir } from 'node:os';
-import { execSync } from 'node:child_process';
-import { accessSync, constants, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { RUNTIME_REGISTRY } from './runtimes.js';
-export const BRIER_DIR = join(homedir(), '.brier');
-export const PID_FILE = join(BRIER_DIR, 'daemon.pid');
-export const LOG_FILE = join(BRIER_DIR, 'daemon.log');
-/** CLI 自身版本（读取 dist 同级的 package.json）。 */
-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';
-    }
-};
-export const loadConfig = (options) => {
-    const serverUrl = options.serverUrl ?? process.env.BRIER_SERVER_URL;
-    const token = options.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: detectRuntimes(),
-        version: readCliVersion(),
-    };
-};
-export const toWsUrl = (serverUrl) => {
-    return (serverUrl
-        .replace(/^https:\/\//, 'wss://')
-        .replace(/^http:\/\//, 'ws://')
-        .replace(/\/$/, '') + '/tunnel');
-};
-// macOS 自带磁盘分区工具 gpt(8) 位于 /usr/sbin/gpt，会与 OpenAI 的 gpt CLI 同名，
-// macOS 自带磁盘分区工具 gpt(8) 位于 /usr/sbin/gpt，会与 OpenAI CLI 同名；
-// 命中 /sbin、/usr/sbin 视为「未安装」，避免误报。
-const SYSTEM_SBIN_RE = /^\/(usr\/)?sbin\//;
-// shell 内建命令（如 continue、cd、type）会被 `command -v` 返回为无路径的裸名，
-// 不是真实可执行文件，需排除。
-const isRealExecutablePath = (hit) => Boolean(hit) && hit.includes('/') && !SYSTEM_SBIN_RE.test(hit);
-const isExecutable = (file) => {
-    try {
-        accessSync(file, constants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-const expandHome = (p) => (p.startsWith('~/') ? join(homedir(), p.slice(2)) : p);
-const detectRuntimes = () => {
-    const runtimes = [];
-    for (const { name, command, fallbacks } of RUNTIME_REGISTRY) {
-        let found = false;
-        try {
-            const hit = execSync(`command -v ${command}`, { stdio: 'pipe' }).toString().trim();
-            found = isRealExecutablePath(hit);
-        }
-        catch {
-            // 不在 PATH
-        }
-        if (!found) {
-            const candidates = fallbacks ?? [`~/.local/bin/${command}`];
-            found = candidates.some((p) => isExecutable(expandHome(p)));
-        }
-        if (found)
-            runtimes.push(name);
-    }
-    return runtimes;
-};

package/dist/runtimes.js

@@ -1,29 +0,0 @@
-export const RUNTIME_REGISTRY = [
-    { name: 'Claude Code', command: 'claude', fallbacks: ['~/.claude/bin/claude'] },
-    { name: 'Codex CLI', command: 'codex' },
-    { name: 'OpenAI CLI', command: 'openai' },
-    { name: 'Gemini CLI', command: 'gemini' },
-    { name: 'Cursor CLI', command: 'cursor' },
-    {
-        name: 'OpenCode',
-        command: 'opencode',
-        fallbacks: ['~/.opencode/bin/opencode', '~/.local/bin/opencode'],
-    },
-    { name: 'Aider', command: 'aider', fallbacks: ['~/.local/bin/aider'] },
-    { name: 'Goose', command: 'goose', fallbacks: ['~/.local/bin/goose'] },
-    { name: 'Cody', command: 'cody', fallbacks: ['~/.local/bin/cody'] },
-];
-export const RUNTIME_COMMANDS = Object.fromEntries(RUNTIME_REGISTRY.map((r) => [r.name, r.command]));
-/**
- * AI runtime 单次（非交互）执行参数模板：命令前缀 flags，后面紧跟 prompt。
- * 服务端 task-start 携带 prompt 时，CLI 用它拼出
- * `spawn(<command>, [...flags, prompt])`；未列出的 runtime 按裸参数执行。
- */
-export const RUNTIME_PROMPT_FLAGS = {
-    'OpenCode': ['run'],
-    'Claude Code': ['-p'],
-    'Codex CLI': ['exec'],
-    'Gemini CLI': ['-p'],
-    'Aider': ['--message'],
-    'Goose': ['run'],
-};

package/dist/tunnel/TunnelClient.js

@@ -1,218 +0,0 @@
-import { WebSocket } from 'ws';
-import { toWsUrl } from '../config.js';
-import { logger } from '../logger.js';
-const HEARTBEAT_INTERVAL_MS = 30_000;
-const HEARTBEAT_TIMEOUT_MS = 10_000;
-const BASE_RECONNECT_DELAY_MS = 1_000;
-const MAX_RECONNECT_DELAY_MS = 30_000;
-const MAX_RECONNECT_ATTEMPTS = 50;
-export const createTunnelClient = (config, taskExecutor) => {
-    let ws = null;
-    let state = 'disconnected';
-    let running = false;
-    let reconnectAttempts = 0;
-    let heartbeatTimer = null;
-    let heartbeatTimeoutTimer = null;
-    let reconnectTimer = null;
-    const listeners = new Set();
-    const notifyStateChange = (newState) => {
-        state = newState;
-        for (const callback of listeners) {
-            callback(newState);
-        }
-    };
-    const onStateChange = (callback) => {
-        listeners.add(callback);
-        return () => {
-            listeners.delete(callback);
-        };
-    };
-    const getState = () => state;
-    const send = (message) => {
-        if (!ws || ws.readyState !== WebSocket.OPEN) {
-            throw new Error('Tunnel is not connected');
-        }
-        ws.send(JSON.stringify(message));
-    };
-    const startHeartbeat = () => {
-        stopHeartbeat();
-        heartbeatTimer = setInterval(() => {
-            if (ws && ws.readyState === WebSocket.OPEN) {
-                send({ type: 'heartbeat', timestamp: Date.now() });
-                heartbeatTimeoutTimer = setTimeout(() => {
-                    logger.warn('Heartbeat timeout, forcing reconnect');
-                    ws?.close(4000, 'heartbeat timeout');
-                }, HEARTBEAT_TIMEOUT_MS);
-            }
-        }, HEARTBEAT_INTERVAL_MS);
-    };
-    const stopHeartbeat = () => {
-        if (heartbeatTimer) {
-            clearInterval(heartbeatTimer);
-            heartbeatTimer = null;
-        }
-        if (heartbeatTimeoutTimer) {
-            clearTimeout(heartbeatTimeoutTimer);
-            heartbeatTimeoutTimer = null;
-        }
-    };
-    const handleServerMessage = (message) => {
-        switch (message.type) {
-            case 'auth-ok':
-                logger.info('Tunnel authenticated, computerId:', message.computerId);
-                reconnectAttempts = 0;
-                notifyStateChange('connected');
-                startHeartbeat();
-                break;
-            case 'auth-failed':
-                logger.error('Authentication failed:', message.reason);
-                notifyStateChange('error');
-                running = false;
-                break;
-            case 'heartbeat-ack':
-                if (heartbeatTimeoutTimer) {
-                    clearTimeout(heartbeatTimeoutTimer);
-                    heartbeatTimeoutTimer = null;
-                }
-                break;
-            case 'task-start':
-                logger.info('Task start:', message.taskId, message.command);
-                taskExecutor.execute({
-                    taskId: message.taskId,
-                    runtime: message.runtime,
-                    command: message.command,
-                    args: message.args,
-                    cwd: message.cwd,
-                    env: message.env,
-                    prompt: message.prompt,
-                });
-                break;
-            case 'task-cancel':
-                logger.info('Task cancel:', message.taskId);
-                taskExecutor.cancel(message.taskId);
-                break;
-            case 'query-runtimes':
-                send({ type: 'runtime-info', runtimes: config.runtimes });
-                break;
-        }
-    };
-    const scheduleReconnect = () => {
-        if (!running)
-            return;
-        if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-            logger.error('Max reconnect attempts reached, stopping');
-            notifyStateChange('error');
-            running = false;
-            return;
-        }
-        reconnectAttempts++;
-        const delay = Math.min(BASE_RECONNECT_DELAY_MS * Math.pow(2, reconnectAttempts - 1), MAX_RECONNECT_DELAY_MS);
-        logger.info(`Reconnecting in ${(delay / 1000).toFixed(0)}s (attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
-        notifyStateChange('reconnecting');
-        reconnectTimer = setTimeout(() => {
-            if (running) {
-                connect();
-            }
-        }, delay);
-    };
-    const connect = () => {
-        if (ws) {
-            ws.removeAllListeners();
-            ws.terminate();
-            ws = null;
-        }
-        const wsUrl = toWsUrl(config.serverUrl);
-        logger.info('Connecting to', wsUrl);
-        notifyStateChange('connecting');
-        ws = new WebSocket(wsUrl, {
-            headers: {
-                Authorization: `Bearer ${config.token}`,
-                'X-Brier-Hostname': config.hostname,
-                'X-Brier-OS': config.os,
-            },
-        });
-        ws.on('open', () => {
-            logger.info('WebSocket connected, authenticating...');
-            send({
-                type: 'auth',
-                token: config.token,
-                hostname: config.hostname,
-                os: config.os,
-                runtimes: config.runtimes,
-                version: config.version,
-            });
-        });
-        ws.on('message', (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                handleServerMessage(message);
-            }
-            catch (err) {
-                logger.error('Failed to parse server message:', err);
-            }
-        });
-        ws.on('close', (code, reason) => {
-            const reasonStr = reason.toString() || `code ${code}`;
-            logger.warn(`WebSocket closed: ${reasonStr}`);
-            stopHeartbeat();
-            if (running) {
-                scheduleReconnect();
-            }
-            else {
-                notifyStateChange('disconnected');
-            }
-        });
-        ws.on('error', (err) => {
-            logger.error('WebSocket error:', err.message);
-        });
-        ws.on('ping', () => {
-            ws?.pong();
-        });
-    };
-    const start = () => {
-        if (running) {
-            logger.warn('Tunnel is already running');
-            return;
-        }
-        running = true;
-        reconnectAttempts = 0;
-        connect();
-    };
-    const stop = async () => {
-        running = false;
-        stopHeartbeat();
-        taskExecutor.cancelAll();
-        if (reconnectTimer) {
-            clearTimeout(reconnectTimer);
-            reconnectTimer = null;
-        }
-        if (ws) {
-            const closePromise = new Promise((resolve) => {
-                if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
-                    ws.once('close', () => resolve());
-                    ws.close(1000, 'client shutdown');
-                    setTimeout(() => {
-                        if (ws && ws.readyState !== WebSocket.CLOSED) {
-                            ws.terminate();
-                        }
-                        resolve();
-                    }, 3000);
-                }
-                else {
-                    resolve();
-                }
-            });
-            await closePromise;
-            ws = null;
-        }
-        notifyStateChange('disconnected');
-        logger.info('Tunnel stopped');
-    };
-    return {
-        start,
-        stop,
-        send,
-        getState,
-        onStateChange,
-    };
-};

package/types/config.d.ts

@@ -1,9 +0,0 @@
-import type { DaemonConfig } from './types.js';
-export declare const BRIER_DIR: string;
-export declare const PID_FILE: string;
-export declare const LOG_FILE: string;
-export declare const loadConfig: (options: {
-    serverUrl?: string;
-    token?: string;
-}) => DaemonConfig;
-export declare const toWsUrl: (serverUrl: string) => string;

package/types/runtimes.d.ts

@@ -1,14 +0,0 @@
-export interface RuntimeEntry {
-    name: string;
-    command: string;
-    /** 命令不在 PATH 时的兜底可执行文件（~ 开头表示用户主目录），存在即视为已安装 */
-    fallbacks?: readonly string[];
-}
-export declare const RUNTIME_REGISTRY: readonly RuntimeEntry[];
-export declare const RUNTIME_COMMANDS: Record<string, string>;
-/**
- * AI runtime 单次（非交互）执行参数模板：命令前缀 flags，后面紧跟 prompt。
- * 服务端 task-start 携带 prompt 时，CLI 用它拼出
- * `spawn(<command>, [...flags, prompt])`；未列出的 runtime 按裸参数执行。
- */
-export declare const RUNTIME_PROMPT_FLAGS: Record<string, readonly string[]>;

package/types/tunnel/TunnelClient.d.ts

@@ -1,10 +0,0 @@
-import type { ClientMessage, DaemonConfig, TunnelState } from '../types.js';
-import type { TaskExecutor } from '../daemon/TaskExecutor.js';
-export interface TunnelClient {
-    start: () => void;
-    stop: () => Promise<void>;
-    send: (message: ClientMessage) => void;
-    getState: () => TunnelState;
-    onStateChange: (callback: (state: TunnelState) => void) => () => void;
-}
-export declare const createTunnelClient: (config: DaemonConfig, taskExecutor: TaskExecutor) => TunnelClient;