rol-websocket-channel 1.0.0

package/dist/src/admin/types.js

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

package/dist/src/mqtt/connection-manager.js

@@ -0,0 +1,155 @@
+// MQTT 连接管理器
+// 负责管理 MQTT 连接的建立和维护（使用 MQTT.js 自带的重连功能）
+// 全局连接存储
+const connections = new Map();
+/**
+ * 获取连接
+ */
+export function getConnection(accountId) {
+    const conn = connections.get(accountId);
+    console.log(`[MQTT] getConnection(${accountId}): ${conn ? 'found' : 'not found'}`);
+    return conn;
+}
+/**
+ * 检查连接是否存在且已连接
+ */
+export function isConnected(accountId) {
+    const conn = connections.get(accountId);
+    const connected = !!(conn && conn.ws && conn.ws.connected);
+    console.log(`[MQTT] isConnected(${accountId}): ${connected}`);
+    return connected;
+}
+/**
+ * 删除连接
+ */
+export function removeConnection(accountId) {
+    console.log(`[MQTT] removeConnection(${accountId})`);
+    connections.delete(accountId);
+}
+/**
+ * 创建 MQTT 连接
+ * 使用 MQTT.js 自带的重连功能
+ */
+export async function createMqttConnection(config, callbacks) {
+    const { mqttUrl, mqttTopic, accountId } = config;
+    console.log(`[MQTT] createMqttConnection(${accountId}): url=${mqttUrl}, topic=${mqttTopic}`);
+    // 如果已有活跃连接，直接返回（防止重复创建）
+    const existingConn = connections.get(accountId);
+    if (existingConn && existingConn.ws && existingConn.ws.connected) {
+        console.log(`[MQTT] createMqttConnection(${accountId}): connection already exists and connected, skipping`);
+        return existingConn;
+    }
+    // 如果有未连接的旧连接，先关闭
+    if (existingConn) {
+        console.log(`[MQTT] createMqttConnection(${accountId}): closing existing disconnected connection`);
+        existingConn.ws.end(true);
+        connections.delete(accountId);
+    }
+    // 动态导入 mqtt 库
+    console.log(`[MQTT] createMqttConnection(${accountId}): importing mqtt library...`);
+    const mqtt = await import("mqtt");
+    console.log(`[MQTT] createMqttConnection(${accountId}): mqtt library imported`);
+    // 创建 MQTT 客户端，启用自带的重连功能
+    console.log(`[MQTT] createMqttConnection(${accountId}): creating client with reconnect...`);
+    const client = mqtt.default.connect(mqttUrl, {
+        reconnectPeriod: 5000, // 5秒后自动重连
+        connectTimeout: 30000, // 连接超时 30秒
+        keepalive: 30, // 心跳 30秒
+        clean: true, // 清理会话
+    });
+    console.log(`[MQTT] createMqttConnection(${accountId}): client created`);
+    // 存储连接
+    const connection = {
+        ws: client,
+        accountId,
+        mqttTopic,
+    };
+    connections.set(accountId, connection);
+    console.log(`[MQTT] createMqttConnection(${accountId}): connection stored, total connections=${connections.size}`);
+    // 设置事件处理器
+    setupEventHandlers(client, accountId, mqttTopic, callbacks);
+    console.log(`[MQTT] createMqttConnection(${accountId}): event handlers set up`);
+    return connection;
+}
+/**
+ * 设置 MQTT 事件处理器
+ */
+function setupEventHandlers(client, accountId, mqttTopic, callbacks) {
+    const { onConnect, onDisconnect, onError, onClose, onMessage } = callbacks;
+    // 连接成功
+    client.on("connect", () => {
+        console.log(`[MQTT] ✅ Connected to broker for account: ${accountId}`);
+        // 订阅 topic
+        console.log(`[MQTT] subscribing to topic: ${mqttTopic} for account: ${accountId}`);
+        client.subscribe(mqttTopic, (err) => {
+            if (err) {
+                console.error(`[MQTT] ❌ Failed to subscribe: ${err.message}`);
+            }
+            else {
+                console.log(`[MQTT] ✅ Subscribed to: ${mqttTopic}`);
+            }
+        });
+        onConnect?.();
+    });
+    // 收到消息
+    client.on("message", (topic, payload) => {
+        console.log(`[MQTT] 📨 message received on topic: ${topic}, size: ${payload.length} bytes`);
+        onMessage?.(topic, payload);
+    });
+    // 连接错误
+    client.on("error", (err) => {
+        console.error(`[MQTT] ❌ Error for account ${accountId}: ${err.message}`);
+        onError?.(err);
+        // MQTT.js 会自动处理重连，不需要我们干预
+    });
+    // 连接断开
+    client.on("disconnect", () => {
+        console.log(`[MQTT] 🔴 Disconnected for account: ${accountId}`);
+        onDisconnect?.();
+    });
+    // 连接关闭
+    client.on("close", () => {
+        console.log(`[MQTT] 🔴 Connection closed for account: ${accountId}`);
+        // 注意：MQTT.js 会自动重连，不要在这里删除连接
+        // 只有在手动停止时才删除
+        onClose?.();
+    });
+    // 重连开始
+    client.on("reconnect", () => {
+        console.log(`[MQTT] 🔄 Reconnecting for account: ${accountId}...`);
+    });
+    // 离线
+    client.on("offline", () => {
+        console.log(`[MQTT] 😴 Client offline for account: ${accountId}`);
+    });
+}
+/**
+ * 关闭连接（手动停止时使用）
+ */
+export function closeConnection(accountId) {
+    console.log(`[MQTT] closeConnection(${accountId}): closing connection...`);
+    const conn = connections.get(accountId);
+    if (conn) {
+        console.log(`[MQTT] closeConnection(${accountId}): ending mqtt client...`);
+        // force=true 立即关闭，不触发重连
+        conn.ws.end(true);
+        removeConnection(accountId);
+        console.log(`[MQTT] closeConnection(${accountId}): connection closed`);
+    }
+    else {
+        console.log(`[MQTT] closeConnection(${accountId}): no connection found`);
+    }
+}
+/**
+ * 发布消息
+ */
+export function publishMessage(accountId, topic, message) {
+    const conn = connections.get(accountId);
+    if (!conn || !conn.ws || !conn.ws.connected) {
+        console.error(`[MQTT] ❌ No connection available for account: ${accountId}`);
+        return false;
+    }
+    console.log(`[MQTT] publishMessage(${accountId}): publishing to ${topic}`);
+    conn.ws.publish(topic, message);
+    return true;
+}

package/dist/src/mqtt/index.js

@@ -0,0 +1,5 @@
+// MQTT 模块入口
+// 导出所有 MQTT 相关的类型和功能
+export * from "./types.js";
+export * from "./connection-manager.js";
+export * from "./mqtt-client.js";

package/dist/src/mqtt/mqtt-client.js

@@ -0,0 +1,86 @@
+// MQTT 客户端类
+// 封装 MQTT 连接和消息处理逻辑（使用 MQTT.js 自带的重连功能）
+import * as ConnectionManager from "./connection-manager.js";
+export class MqttClient {
+    constructor(options) {
+        this.config = options.config;
+        this.abortSignal = options.abortSignal;
+        this.onMessage = options.onMessage;
+        this.onConnect = options.onConnect;
+        this.onDisconnect = options.onDisconnect;
+        this.onError = options.onError;
+    }
+    /**
+     * 连接到 MQTT Broker
+     * 使用 MQTT.js 自带的重连功能
+     */
+    async connect() {
+        const { accountId, mqttUrl, mqttTopic } = this.config;
+        console.log(`[MQTT] MqttClient.connect(${accountId}): starting connection to ${mqttUrl}...`);
+        // 检查是否已中止
+        if (this.abortSignal.aborted) {
+            console.log(`[MQTT] MqttClient.connect(${accountId}): aborted before starting`);
+            return;
+        }
+        // 创建连接
+        await ConnectionManager.createMqttConnection(this.config, {
+            onConnect: () => {
+                console.log(`[MQTT] MqttClient(${accountId}): onConnect callback`);
+                this.onConnect?.();
+            },
+            onDisconnect: () => {
+                console.log(`[MQTT] MqttClient(${accountId}): onDisconnect callback`);
+                this.onDisconnect?.();
+            },
+            onError: (err) => {
+                console.error(`[MQTT] MqttClient(${accountId}): onError callback - ${err.message}`);
+                this.onError?.(err);
+            },
+            onClose: () => {
+                console.log(`[MQTT] MqttClient(${accountId}): onClose callback`);
+                // MQTT.js 会自动重连，不需要我们干预
+                // 只有在 abortSignal 触发时才真正关闭
+                if (this.abortSignal.aborted) {
+                    console.log(`[MQTT] MqttClient(${accountId}): abort signaled, cleaning up`);
+                    ConnectionManager.removeConnection(accountId);
+                }
+            },
+            onMessage: this.onMessage,
+        });
+        console.log(`[MQTT] MqttClient.connect(${accountId}): connection created, waiting for abort signal...`);
+        // 等待中止信号
+        await new Promise((resolve) => {
+            const handleAbort = () => {
+                console.log(`[MQTT] MqttClient(${accountId}): abort signal received`);
+                this.disconnect();
+                resolve();
+            };
+            this.abortSignal.addEventListener("abort", handleAbort, { once: true });
+        });
+        console.log(`[MQTT] MqttClient.connect(${accountId}): connection loop ended`);
+    }
+    /**
+     * 断开连接（手动停止时使用）
+     */
+    disconnect() {
+        const { accountId } = this.config;
+        console.log(`[MQTT] MqttClient.disconnect(${accountId}): disconnecting...`);
+        ConnectionManager.closeConnection(accountId);
+        console.log(`[MQTT] MqttClient.disconnect(${accountId}): disconnected`);
+    }
+    /**
+     * 发布消息
+     */
+    publish(topic, message) {
+        const { accountId } = this.config;
+        console.log(`[MQTT] MqttClient.publish(${accountId}): publishing to ${topic}`);
+        return ConnectionManager.publishMessage(accountId, topic, message);
+    }
+    /**
+     * 检查是否已连接
+     */
+    isConnected() {
+        const { accountId } = this.config;
+        return ConnectionManager.isConnected(accountId);
+    }
+}

package/dist/src/mqtt/types.js

@@ -0,0 +1,2 @@
+// MQTT 连接管理类型定义
+export {};

package/dist/src/shared/context.js

@@ -0,0 +1,24 @@
+/**
+ * 共享 Context 管理
+ * 用于在 MQTT handler 和 admin 方法之间共享上下文
+ */
+import { getOpenClawRoot, getProjectRoot } from '../admin/lib/paths.js';
+let cachedContext = null;
+/**
+ * 初始化全局 context
+ */
+export function initializeContext() {
+    cachedContext = {
+        projectRoot: getProjectRoot(),
+        openclawRoot: getOpenClawRoot(),
+    };
+}
+/**
+ * 获取当前 context
+ */
+export function getContext() {
+    if (!cachedContext) {
+        initializeContext();
+    }
+    return cachedContext;
+}

package/dist/src/shared/wrapper.js

@@ -0,0 +1,23 @@
+/**
+ * 统一的方法调用包装器
+ * 提供统一的错误处理和返回格式
+ */
+/**
+ * 包装 admin 方法调用，统一返回格式
+ */
+export async function wrapAdminCall(fn) {
+    try {
+        const result = await fn();
+        return { ok: true, result };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: {
+                message: error instanceof Error ? error.message : String(error),
+                code: error.code,
+                data: error.data,
+            },
+        };
+    }
+}