@brierb/brier-cli 0.0.4

package/dist/commands/restart.js

@@ -0,0 +1,28 @@
+import { createDaemonManager } from '../daemon/DaemonManager.js';
+import { loadConfig } from '../config.js';
+export const restartCommand = async (options) => {
+    let serverUrl = options.serverUrl;
+    let token = options.token ?? process.env.BRIER_TOKEN;
+    if (!serverUrl || !token) {
+        try {
+            const config = loadConfig({});
+            if (!serverUrl)
+                serverUrl = config.serverUrl;
+            if (!token)
+                token = config.token;
+        }
+        catch {
+            // Will be caught below
+        }
+    }
+    if (!serverUrl) {
+        throw new Error('Server URL is required. Pass --server-url or set BRIER_SERVER_URL.');
+    }
+    if (!token) {
+        throw new Error('BRIER_TOKEN is required. Pass --token or set BRIER_TOKEN env var.');
+    }
+    const manager = createDaemonManager();
+    await manager.restart({ serverUrl, token });
+    console.log('✓ 后台服务已重启');
+    console.log(`  Server: ${serverUrl}`);
+};

package/dist/commands/start.js

@@ -0,0 +1,13 @@
+import { createDaemonManager } from '../daemon/DaemonManager.js';
+import { LOG_FILE } from '../config.js';
+export const startCommand = async (options) => {
+    const token = options.token ?? process.env.BRIER_TOKEN;
+    if (!token) {
+        throw new Error('BRIER_TOKEN is required. Pass --token or set BRIER_TOKEN env var.');
+    }
+    const manager = createDaemonManager();
+    await manager.start({ serverUrl: options.serverUrl, token });
+    console.log('✓ 后台服务已启动');
+    console.log(`  Server: ${options.serverUrl}`);
+    console.log(`  Log: ${LOG_FILE}`);
+};

package/dist/commands/status.js

@@ -0,0 +1,27 @@
+import { createDaemonManager } from '../daemon/DaemonManager.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { PID_FILE } from '../config.js';
+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
+            }
+        }
+        console.log('● 后台服务运行中');
+        if (pidInfo) {
+            console.log(`  PID: ${pidInfo.pid}`);
+            console.log(`  Server: ${pidInfo.serverUrl}`);
+            console.log(`  Started: ${new Date(pidInfo.startTime).toLocaleString()}`);
+        }
+    }
+    else {
+        console.log('○ 后台服务未运行');
+    }
+};

package/dist/commands/stop.js

@@ -0,0 +1,6 @@
+import { createDaemonManager } from '../daemon/DaemonManager.js';
+export const stopCommand = async () => {
+    const manager = createDaemonManager();
+    await manager.stop();
+    console.log('✓ 后台服务已停止');
+};

package/dist/config.js

@@ -0,0 +1,44 @@
+import { hostname as getHostname, type as osType, arch, platform } from 'node:os';
+import { execSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+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');
+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(),
+    };
+};
+export const toWsUrl = (serverUrl) => {
+    return (serverUrl
+        .replace(/^https:\/\//, 'wss://')
+        .replace(/^http:\/\//, 'ws://')
+        .replace(/\/$/, '') + '/tunnel');
+};
+const detectRuntimes = () => {
+    const runtimes = [];
+    for (const { name, command } of RUNTIME_REGISTRY) {
+        try {
+            execSync(`command -v ${command}`, { stdio: 'pipe' });
+            runtimes.push(name);
+        }
+        catch {
+            // not installed
+        }
+    }
+    return runtimes;
+};

package/dist/daemon/DaemonManager.js

@@ -0,0 +1,127 @@
+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';
+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();
+    });
+};
+export const createDaemonManager = () => {
+    const start = async (options) => {
+        const existing = readPidFile();
+        if (existing && isProcessRunning(existing.pid)) {
+            throw new Error(`Daemon is already running (PID: ${existing.pid})`);
+        }
+        if (existing) {
+            removePidFile();
+        }
+        const childEnv = {
+            ...process.env,
+            BRIER_TOKEN: options.token,
+            BRIER_SERVER_URL: options.serverUrl,
+            BRIER_DAEMON_MODE: '1',
+        };
+        const child = spawn(process.execPath, [RUNNER_SCRIPT], {
+            detached: true,
+            stdio: 'ignore',
+            env: childEnv,
+        });
+        child.unref();
+        if (typeof child.pid !== 'number') {
+            throw new Error('Failed to spawn daemon process');
+        }
+        writePidFile({
+            pid: child.pid,
+            startTime: Date.now(),
+            serverUrl: options.serverUrl,
+        });
+        logger.info('Daemon started, PID:', child.pid);
+    };
+    const stop = async () => {
+        const data = readPidFile();
+        if (!data) {
+            logger.warn('No PID file found, daemon may not be running');
+            return;
+        }
+        if (!isProcessRunning(data.pid)) {
+            logger.info('Process not running, cleaning up PID file');
+            removePidFile();
+            return;
+        }
+        logger.info('Sending SIGTERM to PID:', data.pid);
+        process.kill(data.pid, 'SIGTERM');
+        const exited = await waitForExit(data.pid, 5000);
+        if (!exited) {
+            logger.warn('Process did not exit, sending SIGKILL');
+            try {
+                process.kill(data.pid, 'SIGKILL');
+            }
+            catch (err) {
+                logger.error('Failed to kill process:', err);
+            }
+        }
+        removePidFile();
+        logger.info('Daemon stopped');
+    };
+    const restart = async (options) => {
+        await stop();
+        await start(options);
+    };
+    const status = () => {
+        const data = readPidFile();
+        if (!data)
+            return 'stopped';
+        if (isProcessRunning(data.pid))
+            return 'running';
+        removePidFile();
+        return 'stopped';
+    };
+    return { start, stop, restart, status };
+};

package/dist/daemon/DaemonRunner.js

@@ -0,0 +1,70 @@
+import { loadConfig, LOG_FILE } from '../config.js';
+import { configureLogger, logger } from '../logger.js';
+import { createTunnelClient } from '../tunnel/TunnelClient.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) => {
+    const safeSend = (message) => {
+        try {
+            tunnel?.send(message);
+        }
+        catch {
+            // Connection not ready, output is dropped
+        }
+    };
+    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 }),
+    });
+    tunnel = createTunnelClient(config, taskExecutor);
+    tunnel.onStateChange((state) => {
+        logger.info('Tunnel state:', state);
+    });
+    tunnel.start();
+    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 main = () => {
+    if (process.env.BRIER_DAEMON_MODE !== '1') {
+        console.error('This script is intended to be run as a daemon. Use "brier daemon start" instead.');
+        process.exit(1);
+    }
+    configureLogger(LOG_FILE);
+    let config;
+    try {
+        config = loadConfig({});
+    }
+    catch (err) {
+        logger.error('Config error:', err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    process.on('SIGINT', () => void shutdown('SIGINT'));
+    process.on('uncaughtException', handleUncaughtError);
+    process.on('unhandledRejection', (reason) => {
+        logger.error('Unhandled rejection:', reason);
+    });
+    run(config);
+};
+main();

package/dist/daemon/TaskExecutor.js

@@ -0,0 +1,76 @@
+import { spawn } from 'node:child_process';
+import { logger } from '../logger.js';
+import { RUNTIME_COMMANDS } from '../runtimes.js';
+const MAX_CONCURRENT = 3;
+export const createTaskExecutor = (callbacks) => {
+    const processes = new Map();
+    const resolveCommand = (task) => {
+        if (task.command)
+            return task.command;
+        const mapped = RUNTIME_COMMANDS[task.runtime];
+        if (mapped)
+            return mapped;
+        throw new Error(`Cannot resolve command for runtime: ${task.runtime}`);
+    };
+    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);
+        const childEnv = task.env ? { ...process.env, ...task.env } : process.env;
+        logger.info(`Task ${task.taskId} starting: ${cmd} ${task.args.join(' ')}`, task.runtime);
+        let child;
+        try {
+            child = spawn(cmd, task.args, {
+                cwd: task.cwd,
+                env: childEnv,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch (err) {
+            callbacks.onError(task.taskId, err instanceof Error ? err.message : String(err));
+            return;
+        }
+        processes.set(task.taskId, child);
+        child.stdout?.on('data', (data) => {
+            callbacks.onOutput(task.taskId, 'stdout', data.toString());
+        });
+        child.stderr?.on('data', (data) => {
+            callbacks.onOutput(task.taskId, 'stderr', data.toString());
+        });
+        child.on('error', (err) => {
+            processes.delete(task.taskId);
+            logger.error(`Task ${task.taskId} process error:`, err.message);
+            callbacks.onError(task.taskId, err.message);
+        });
+        child.on('close', (code) => {
+            processes.delete(task.taskId);
+            const exitCode = code ?? 0;
+            logger.info(`Task ${task.taskId} completed with exit code ${exitCode}`);
+            callbacks.onComplete(task.taskId, exitCode);
+        });
+    };
+    const cancel = (taskId) => {
+        const child = processes.get(taskId);
+        if (!child) {
+            logger.warn(`Task ${taskId} not found, cannot cancel`);
+            return;
+        }
+        child.kill('SIGTERM');
+        processes.delete(taskId);
+        logger.info(`Task ${taskId} cancelled`);
+    };
+    const cancelAll = () => {
+        for (const [taskId, child] of processes) {
+            child.kill('SIGTERM');
+            logger.info(`Task ${taskId} cancelled (shutdown)`);
+        }
+        processes.clear();
+    };
+    return { execute, cancel, cancelAll };
+};

package/dist/index.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { startCommand } from './commands/start.js';
+import { stopCommand } from './commands/stop.js';
+import { restartCommand } from './commands/restart.js';
+import { statusCommand } from './commands/status.js';
+const program = new Command();
+program
+    .name('brier')
+    .description('Brier CLI - Connect to Brier platform via encrypted tunnel')
+    .version('0.0.1');
+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);
+    }
+});
+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);
+    }
+});
+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);
+    }
+});
+daemon
+    .command('status')
+    .description('Check the background service status')
+    .action(() => {
+    statusCommand();
+});
+program.parseAsync(process.argv).catch((err) => {
+    console.error('Fatal:', err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/logger.js

@@ -0,0 +1,60 @@
+import { mkdirSync, appendFileSync, statSync, renameSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+const MAX_LOG_SIZE = 5 * 1024 * 1024;
+let logFile;
+export const configureLogger = (filePath) => {
+    logFile = filePath;
+};
+const formatMessage = (level, message, ...args) => {
+    const timestamp = new Date().toISOString();
+    const levelTag = level.toUpperCase().padEnd(5);
+    const rest = args.length > 0
+        ? ' ' + args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')
+        : '';
+    return `${timestamp} [${levelTag}] ${message}${rest}`;
+};
+const rotateIfNeeded = () => {
+    if (!logFile)
+        return;
+    try {
+        if (!existsSync(logFile))
+            return;
+        if (statSync(logFile).size < MAX_LOG_SIZE)
+            return;
+        const backup = logFile + '.1';
+        if (existsSync(backup)) {
+            try {
+                renameSync(backup, backup + '.old');
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        renameSync(logFile, backup);
+    }
+    catch {
+        // rotation failed, continue writing to current file
+    }
+};
+const write = (level, message, ...args) => {
+    const formatted = formatMessage(level, message, ...args);
+    if (logFile) {
+        try {
+            mkdirSync(dirname(logFile), { recursive: true });
+            rotateIfNeeded();
+            appendFileSync(logFile, formatted + '\n');
+        }
+        catch {
+            console.error(formatted);
+        }
+    }
+    else {
+        const method = level === 'info' ? 'log' : level;
+        console[method](formatted);
+    }
+};
+export const logger = {
+    info: (message, ...args) => write('info', message, ...args),
+    warn: (message, ...args) => write('warn', message, ...args),
+    error: (message, ...args) => write('error', message, ...args),
+};

package/dist/runtimes.js

@@ -0,0 +1,10 @@
+export const RUNTIME_REGISTRY = [
+    { name: 'Claude Code', command: 'claude' },
+    { name: 'Codex CLI', command: 'codex' },
+    { name: 'GPT-4o CLI', command: 'gpt' },
+    { name: 'Gemini CLI', command: 'gemini' },
+    { name: 'Cursor CLI', command: 'cursor' },
+    { name: 'Node.js', command: 'node' },
+    { name: 'Python', command: 'python3' },
+];
+export const RUNTIME_COMMANDS = Object.fromEntries(RUNTIME_REGISTRY.map((r) => [r.name, r.command]));

package/dist/tunnel/TunnelClient.js

@@ -0,0 +1,216 @@
+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,
+                });
+                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,
+            });
+        });
+        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/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@brierb/brier-cli",
+  "version": "0.0.4",
+  "description": "Brier 平台接入命令行工具：通过加密隧道将本机接入 Brier 远程编码池，接收并执行远程任务",
+  "keywords": [
+    "brier",
+    "cli",
+    "tunnel",
+    "agent"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "brier": "./dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./types/index.d.ts"
+    },
+    "./tunnel": {
+      "import": "./dist/tunnel/TunnelClient.js",
+      "types": "./types/tunnel/TunnelClient.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "types"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "pnpm run build",
+    "release:patch": "npm version patch --no-git-tag-version && npm publish --access public",
+    "release:minor": "npm version minor --no-git-tag-version && npm publish --access public",
+    "release:major": "npm version major --no-git-tag-version && npm publish --access public"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.3",
+    "@types/ws": "^8.5.13",
+    "typescript": "^6.0.3"
+  }
+}

package/types/commands/restart.d.ts

@@ -0,0 +1,5 @@
+export interface RestartOptions {
+    serverUrl?: string;
+    token?: string;
+}
+export declare const restartCommand: (options: RestartOptions) => Promise<void>;

package/types/commands/start.d.ts

@@ -0,0 +1,5 @@
+export interface StartOptions {
+    serverUrl: string;
+    token?: string;
+}
+export declare const startCommand: (options: StartOptions) => Promise<void>;

package/types/commands/status.d.ts

@@ -0,0 +1 @@
+export declare const statusCommand: () => void;

package/types/commands/stop.d.ts

@@ -0,0 +1 @@
+export declare const stopCommand: () => Promise<void>;

package/types/config.d.ts

@@ -0,0 +1,9 @@
+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/daemon/DaemonManager.d.ts

@@ -0,0 +1,14 @@
+import type { DaemonStatus } from '../types.js';
+export interface DaemonManager {
+    start: (options: {
+        serverUrl: string;
+        token: string;
+    }) => Promise<void>;
+    stop: () => Promise<void>;
+    restart: (options: {
+        serverUrl: string;
+        token: string;
+    }) => Promise<void>;
+    status: () => DaemonStatus;
+}
+export declare const createDaemonManager: () => DaemonManager;

package/types/daemon/DaemonRunner.d.ts

@@ -0,0 +1 @@
+export {};

package/types/daemon/TaskExecutor.d.ts

@@ -0,0 +1,12 @@
+import type { TaskInfo } from '../types.js';
+export interface TaskExecutorCallbacks {
+    onOutput: (taskId: string, stream: 'stdout' | 'stderr', data: string) => void;
+    onComplete: (taskId: string, exitCode: number) => void;
+    onError: (taskId: string, error: string) => void;
+}
+export interface TaskExecutor {
+    execute: (task: TaskInfo) => void;
+    cancel: (taskId: string) => void;
+    cancelAll: () => void;
+}
+export declare const createTaskExecutor: (callbacks: TaskExecutorCallbacks) => TaskExecutor;

package/types/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/logger.d.ts

@@ -0,0 +1,6 @@
+export declare const configureLogger: (filePath: string | undefined) => void;
+export declare const logger: {
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+};

package/types/runtimes.d.ts

@@ -0,0 +1,6 @@
+export interface RuntimeEntry {
+    name: string;
+    command: string;
+}
+export declare const RUNTIME_REGISTRY: readonly RuntimeEntry[];
+export declare const RUNTIME_COMMANDS: Record<string, string>;

package/types/tunnel/TunnelClient.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,72 @@
+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[];
+} | {
+    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>;
+} | {
+    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>;
+}
+export interface DaemonConfig {
+    serverUrl: string;
+    token: string;
+    hostname: string;
+    os: string;
+    runtimes: string[];
+}
+export interface PidFileData {
+    pid: number;
+    startTime: number;
+    serverUrl: string;
+}