@brierb/brier-cli 0.0.7 → 0.0.9

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,45 +0,0 @@
-import { hostname as getHostname, type as osType, arch, platform, homedir } from 'node:os';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { resolveRuntimeExecutable, 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');
-};
-/** 探测本机已安装的 AI runtime（与执行共用同一可执行文件解析）。 */
-const detectRuntimes = () => RUNTIME_REGISTRY.filter((r) => resolveRuntimeExecutable(r.name) !== null).map((r) => r.name);

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/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;

package/types/types.d.ts

@@ -1,78 +0,0 @@
-export type DaemonStatus = 'running' | 'stopped' | 'error';
-export type TunnelState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting' | 'error';
-export type StreamType = 'stdout' | 'stderr';
-export type ClientMessage = {
-    type: 'auth';
-    token: string;
-    hostname: string;
-    os: string;
-    runtimes: string[];
-    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[];
-};
-export type ServerMessage = {
-    type: 'auth-ok';
-    computerId: string;
-} | {
-    type: 'auth-failed';
-    reason: string;
-} | {
-    type: 'heartbeat-ack';
-    timestamp: number;
-} | {
-    type: 'task-start';
-    taskId: string;
-    runtime: string;
-    command: string;
-    args: string[];
-    cwd?: string;
-    env?: Record<string, string>;
-    prompt?: string;
-} | {
-    type: 'task-cancel';
-    taskId: string;
-} | {
-    type: 'query-runtimes';
-};
-export interface TaskInfo {
-    taskId: string;
-    runtime: string;
-    command: string;
-    args: string[];
-    cwd?: string;
-    env?: Record<string, string>;
-    /** 自然语言指令（AI runtime 模式：拼到 runtime 命令参数中执行） */
-    prompt?: string;
-}
-export interface DaemonConfig {
-    serverUrl: string;
-    token: string;
-    hostname: string;
-    os: string;
-    runtimes: string[];
-    /** CLI 自身版本（package.json），Auth 时上报给服务端展示。 */
-    version: string;
-}
-export interface PidFileData {
-    pid: number;
-    startTime: number;
-    serverUrl: string;
-}