@brierb/brier-cli 0.0.7 → 0.0.9

package/dist/daemon/TaskExecutor.js

@@ -1,9 +1,36 @@
 import { spawn } from 'node:child_process';
-import { logger } from '../logger.js';
-import { resolveRuntimeExecutable, 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：直接用（调用方负责其可执行性）
@@ -64,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);
@@ -81,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();
+        },
+    };
+};

package/dist/tunnel/index.js

@@ -0,0 +1,220 @@
+import { toWsUrl } from './url.js';
+import { logger } from '../core/index.js';
+import { createBackoff } from './backoff.js';
+import { dispatchServerMessage } from './dispatcher.js';
+import { createHeartbeat } from './heartbeat.js';
+import { createWebSocketTransport } from './transport.js';
+const HEARTBEAT_INTERVAL_MS = 30_000;
+const HEARTBEAT_TIMEOUT_MS = 10_000;
+/** auth 消息发出后等待 auth-ok/auth-failed 的最长时间，超时视为握手失败并重连 */
+const AUTH_HANDSHAKE_TIMEOUT_MS = 10_000;
+const BASE_RECONNECT_DELAY_MS = 1_000;
+const MAX_RECONNECT_DELAY_MS = 30_000;
+const MAX_RECONNECT_ATTEMPTS = 50;
+/**
+ * 隧道骨架：连接生命周期编排与状态仲裁的唯一入口。
+ *
+ * 本文件只做“编排”，不接触 ws 细节、不算退避、不解析消息：
+ * - transport：负责底层连接与收发帧
+ * - heartbeat：负责心跳节奏（只上报不决策）
+ * - backoff：负责重连延迟计算（纯逻辑）
+ * - dispatcher：负责服务端消息解析与分发
+ *
+ * 关键时序不变式（重构后保持与原实现一致）：
+ * 1. 心跳仅在 auth-ok 后启动；
+ * 2. close 后仅当 running 才退避重连，stop() 后绝不再连；
+ * 3. 仅 auth-ok 归零退避计数；
+ * 4. stop 时先优雅 close，3s 兜底 terminate。
+ */
+export const createTunnelClient = (config, messageHandlers) => {
+    const transport = createWebSocketTransport();
+    const backoff = createBackoff({
+        baseMs: BASE_RECONNECT_DELAY_MS,
+        maxMs: MAX_RECONNECT_DELAY_MS,
+        maxAttempts: MAX_RECONNECT_ATTEMPTS,
+    });
+    let state = 'disconnected';
+    let running = false;
+    let reconnectTimer = null;
+    /** auth 握手超时计时器（open 后启动，auth-ok/auth-failed/close 时清除） */
+    let handshakeTimer = null;
+    /**
+     * 本次运行是否以“错误”终止（auth 失败 / 重连耗尽）。
+     * 区分于 stop() 的正常停止：保证随后的 close 事件不把 error 覆盖成 disconnected。
+     */
+    let exitAsError = false;
+    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) => transport.send(JSON.stringify(message));
+    const sendHeartbeat = () => send({ type: 'heartbeat', timestamp: Date.now() });
+    const clearHandshakeTimer = () => {
+        if (handshakeTimer) {
+            clearTimeout(handshakeTimer);
+            handshakeTimer = null;
+        }
+    };
+    /**
+     * 启动握手超时：若服务端不回 auth-ok/auth-failed，10s 后主动断开走重连，
+     * 避免永久停留在 connecting（此时心跳尚未启动，无其他自愈路径）。
+     */
+    const armHandshakeTimeout = () => {
+        clearHandshakeTimer();
+        handshakeTimer = setTimeout(() => {
+            logger.warn('Auth handshake timed out, reconnecting');
+            transport.close(4000, 'auth timeout');
+        }, AUTH_HANDSHAKE_TIMEOUT_MS);
+    };
+    const heartbeat = createHeartbeat({
+        intervalMs: HEARTBEAT_INTERVAL_MS,
+        timeoutMs: HEARTBEAT_TIMEOUT_MS,
+        onBeat: sendHeartbeat,
+        onTimeout: () => {
+            logger.warn('Heartbeat timeout, forcing reconnect');
+            transport.close(4000, 'heartbeat timeout');
+        },
+        onBeatError: (error) => {
+            logger.error('Heartbeat send failed:', error);
+        },
+    });
+    const connect = () => {
+        logger.info('Connecting to', toWsUrl(config.serverUrl));
+        notifyStateChange('connecting');
+        transport.connect(toWsUrl(config.serverUrl), {
+            Authorization: `Bearer ${config.token}`,
+            'X-Brier-Hostname': config.hostname,
+            'X-Brier-OS': config.os,
+        });
+    };
+    const scheduleReconnect = () => {
+        if (!running)
+            return;
+        const delay = backoff.next();
+        if (delay < 0) {
+            logger.error('Max reconnect attempts reached, stopping');
+            exitAsError = true;
+            running = false;
+            notifyStateChange('error');
+            return;
+        }
+        logger.info(`Reconnecting in ${(delay / 1000).toFixed(0)}s (attempt ${backoff.attempts}/${MAX_RECONNECT_ATTEMPTS})`);
+        notifyStateChange('reconnecting');
+        reconnectTimer = setTimeout(() => {
+            if (running) {
+                connect();
+            }
+        }, delay);
+    };
+    const dispatchHandlers = {
+        onAuthOk: (computerId) => {
+            clearHandshakeTimer();
+            logger.info('Tunnel authenticated, computerId:', computerId);
+            backoff.reset();
+            notifyStateChange('connected');
+            heartbeat.start();
+        },
+        onAuthFailed: (reason) => {
+            clearHandshakeTimer();
+            logger.error('Authentication failed:', reason);
+            exitAsError = true;
+            running = false;
+            notifyStateChange('error');
+        },
+        onHeartbeatAck: () => {
+            heartbeat.ack();
+        },
+        onTaskStart: (message) => {
+            logger.info('Task start:', message.taskId, message.command);
+            messageHandlers.onTaskStart(message);
+        },
+        onTaskCancel: (taskId) => {
+            logger.info('Task cancel:', taskId);
+            messageHandlers.onTaskCancel(taskId);
+        },
+        onQueryRuntimes: () => {
+            send({ type: 'runtime-info', runtimes: config.runtimes });
+        },
+    };
+    // 传输事件 → 骨架仲裁（订阅一次，跨多次重连保持有效）
+    transport.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,
+        });
+        armHandshakeTimeout();
+    });
+    transport.on('message', (data) => dispatchServerMessage(data, dispatchHandlers));
+    transport.on('close', (code, reason) => {
+        const reasonStr = reason || `code ${code}`;
+        logger.warn(`WebSocket closed: ${reasonStr}`);
+        clearHandshakeTimer();
+        heartbeat.stop();
+        if (running) {
+            scheduleReconnect();
+        }
+        else {
+            // 失败停机（auth 失败/重连耗尽）保持 error，正常 stop 才是 disconnected
+            notifyStateChange(exitAsError ? 'error' : 'disconnected');
+        }
+    });
+    transport.on('error', (err) => {
+        logger.error('WebSocket error:', err);
+    });
+    const start = () => {
+        if (running) {
+            logger.warn('Tunnel is already running');
+            return;
+        }
+        running = true;
+        exitAsError = false;
+        backoff.reset();
+        connect();
+    };
+    const stop = async () => {
+        running = false;
+        heartbeat.stop();
+        clearHandshakeTimer();
+        // 取消运行中任务由宿主（DaemonRunner）在自身 shutdown 里处理，隧道只负责关闭连接
+        if (reconnectTimer) {
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+        }
+        // 连接已完全关闭（从未连接/已断开/已 teardown）：close 事件不会再触发，
+        // 直接返回，避免空等 waitClosed 的 3s 兜底超时。
+        if (transport.isClosed()) {
+            notifyStateChange('disconnected');
+            logger.info('Tunnel stopped');
+            return;
+        }
+        transport.close(1000, 'client shutdown');
+        await transport.waitClosed(3000);
+        if (transport.isOpen() || transport.isConnecting()) {
+            transport.terminate();
+        }
+        notifyStateChange('disconnected');
+        logger.info('Tunnel stopped');
+    };
+    return {
+        start,
+        stop,
+        send,
+        getState,
+        onStateChange,
+    };
+};