node-red-contrib-symi-mesh 1.9.8 → 1.9.9

package/README.md

@@ -681,6 +681,20 @@ RS485通信桥接，支持Modbus协议透传与自定义指令映射。
 
 ## 更新日志
 
+### v1.9.9 (2026-03-28，2026-03-30 行为补充)
+
+#### KNX 桥同步可靠性（推荐所有 KNX 项目升级）
+- **Mesh 写 KNX 后的对称主控**：`Mesh→KNX` 反馈确认成功后，在数秒内登记 **Mesh 侧意图**；独立 **状态地址**上与该意图**相反**的滞后电报**不再**触发「校准到 Mesh」，避免「刚关又被状态反馈拉成开」等误动作。
+- **KNX 面板优先**：发起 **KNX→Mesh** 开关时自动清除上述 Mesh 主控记录，避免挡住真实面板操作。
+- **去重**：状态反馈若与**尚在确认中**的 **KNX→Mesh** 目标一致，**不再重复**下发同向同步。
+- **场景遮蔽（SceneVeil）**：收到 **KNX 场景、按键场景**或网关 **场景执行**事件后，默认约 **6 秒**内**仅因状态地址与缓存不一致**时**不会**向 Mesh 批量拉闸校准，减轻场景执行后的总线反馈风暴；时长可通过环境变量 **`SYMI_KNX_SCENE_VEIL_MS`**（毫秒，例如 `8000`）调整。
+- **Last Write Wins（LWW）**：**默认关闭**；仅在需要「KNX 强纠偏」的现场设 **`SYMI_KNX_LWW_ENABLED=1`** 恢复此前行为。
+- **DelayedSync 与 Mesh 查询回包（2026-03-30）**：开启「自动同步状态」时，步骤 1 会对 Mesh 发 `0x32` 并登记 `pendingMeshQueries`。在**延迟约 1 秒后进入 KNX GroupValue_Read 阶段时**会**清除**本轮待查标记；**约 650ms** 再做一次带时间戳的早清（`MESH_QUERY_PENDING_EARLY_CLEAR_MS`）；「查询回包」抑制窗口 **900ms**（`MESH_QUERY_RESPONSE_SUPPRESS_MS`）。**仅当**网关把查询回报误标为 **`isUserControl===true`** 时才改为 `false`，避免把米家/App 已标为用户的帧一律压成非用户而导致 **`正确忽略Mesh反馈`**、**Mesh→KNX 不写字**。
+- **DelayedSync 校准下发**：校准仅使用已存在的 **`gateway.sendControl`**，不再调用不存在的 `sendSwitchCommand`（否则日志会出现 `sendSwitchCommand is not a function` 且校准失败）。
+- **MQTT 节点防崩**：修复 `simi-mqtt` 在 MQTT `connack timeout` 阶段可能触发 `Uncaught Exception` 的问题；通过保留 `error` 监听与增加 `connectTimeout` 兜底，避免单次握手失败导致 Node-RED 侧异常退出。
+- **「自动同步状态」勾选与运行一致**：`symi-knx-bridge` 运行时与编辑器对 **`autoSyncEnabled`** 的 `true` / `1` / `"1"` / `"on"` 等同开启，避免界面看似关闭仍执行 DelayedSync。
+- **现场日志说明**：某项目 1.9.8 原始日志与问题列表见 **`docs/日志.md`**（含客户未主动描述但在日志中可见的现象）。
+
 ### v1.9.8 (2026-03-23)
 
 #### 稳定性、协议兼容性与合规性增强

package/nodes/symi-knx-bridge.html

@@ -68,7 +68,14 @@
             // 自动同步状态初始化
             const $autoSyncEnabled = $('#node-input-autoSyncEnabled');
             const $autoSyncDelay = $('#node-input-autoSyncDelay');
-            $autoSyncEnabled.prop('checked', node.autoSyncEnabled === true || node.autoSyncEnabled === 'true');
+            // 注意：Node-RED/历史 flows 里该字段可能是 true/"true"/1/"1"/"on"
+            $autoSyncEnabled.prop('checked',
+                node.autoSyncEnabled === true ||
+                node.autoSyncEnabled === 'true' ||
+                node.autoSyncEnabled === 1 ||
+                node.autoSyncEnabled === '1' ||
+                node.autoSyncEnabled === 'on'
+            );
             $autoSyncDelay.val(parseInt(node.autoSyncDelay, 10) || 3);
             function applyAutoSyncUi() {
                 const en = $autoSyncEnabled.is(':checked');

package/nodes/symi-knx-bridge.js

@@ -32,6 +32,13 @@ module.exports = function(RED) {
     // KNX 主控保护窗口（防止快速操作后的 Mesh 尾帧回写 KNX 造成“停下后又被改状态”）
     // DEFAULT_TIMEOUT(800ms) 对“连续快速点按”场景偏短，这里提升到 3 秒确保尾部反馈不会反控 KNX
     const KNX_MASTER_WINDOW_MS = 3000;
+    // KNX 场景触发后的遮蔽时间：期内禁止仅因「状态地址与 Mesh 缓存不一致」向 Mesh 下发开关校准，避免总线暴风反馈拉闸
+    const SCENE_VEIL_MS_DEFAULT = 6000;
+    // 主动查询 Mesh 状态(0x32)后，部分网关在回包里错误标记 isUserControl=true；此窗口内强制视为非用户控制以防 Mesh→KNX 回环。
+    // 窗口过长会在 DelayedSync「查 Mesh → 约 1s 后查 KNX」之后仍把真实米家/App 控制误判为查询回包（日志：正确忽略Mesh反馈）。
+    const MESH_QUERY_RESPONSE_SUPPRESS_MS = 900;
+    // DelayedSync / 重试查询后，pending 早清时间（ms）；0x32 回报多在数百 ms 内，缩短与 step2(+1s) 之间的空窗
+    const MESH_QUERY_PENDING_EARLY_CLEAR_MS = 650;
 
     function SymiKNXBridgeNode(config) {
         RED.nodes.createNode(this, config);
@@ -60,10 +67,12 @@ module.exports = function(RED) {
         node.echoWindow = echoWindowEnabled ? (parseInt(config.echoWindow) || 500) : 500;
 
         // 【新增】自动同步状态配置：KNX动作后延迟读取状态并同步到Mesh
+        // 注意：Node-RED/历史 flows 里 checkbox 可能以 true/false、"true"/"false"、1/0、"1"/"0"、"on" 表示
         node.autoSyncEnabled = config.autoSyncEnabled === true ||
             config.autoSyncEnabled === "true" ||
             config.autoSyncEnabled === 1 ||
-            config.autoSyncEnabled === "1";
+            config.autoSyncEnabled === "1" ||
+            config.autoSyncEnabled === "on";
         node.autoSyncDelay = Math.max(1, Math.min(3600, parseInt(config.autoSyncDelay, 10) || 3)); // 1-3600秒
         node.autoSyncTimer = null; // 延迟校准定时器
         node.autoSyncPending = false; // 是否有待执行的校准
@@ -193,8 +202,15 @@ module.exports = function(RED) {
                         node.gateway.queryDeviceStatus(device.networkAddress, 0x00)
                             .then(success => {
                                 if (success) {
-                                    // 标记该设备刚刚被查询，handleMeshStateChange 会据此防止反向回环
-                                    node.pendingMeshQueries.set(mac, Date.now());
+                                    // 标记该设备刚刚被查询；约 650ms 后清除，避免距 step2 仍有空隙时误把真实 App 控制当回包
+                                    const ts = Date.now();
+                                    node.pendingMeshQueries.set(mac, ts);
+                                    setTimeout(() => {
+                                        if (node.isClosed) return;
+                                        if (node.pendingMeshQueries.get(mac) === ts) {
+                                            node.pendingMeshQueries.delete(mac);
+                                        }
+                                    }, MESH_QUERY_PENDING_EARLY_CLEAR_MS);
                                 }
                             })
                             .catch(err => node.warn(`[DelayedSync] 查询Mesh设备失败: ${mac}, ${err.message}`));
@@ -206,6 +222,9 @@ module.exports = function(RED) {
 
             // 步骤2：延迟 1 秒后读取 KNX 状态（仅对已配置独立状态地址的开关发 GroupValue_Read），给 Mesh 0x32 响应留出时间
             setTimeout(() => {
+                // 0x32 正常已在数百 ms 内回报；此处已与步骤1间隔 1s，清除 pending，避免之后用户操作仍被当作「查询回包」而忽略 Mesh→KNX
+                meshMacs.forEach(mac => node.pendingMeshQueries.delete(mac));
+
                 node.log("[DelayedSync] 开始读取所有KNX开关状态...");
                 
                 // 收集所有需要读取的KNX开关组地址（去重）
@@ -577,6 +596,24 @@ module.exports = function(RED) {
         // 目的：快速点按时，即使设备尾帧抖动/补发导致最终状态跑偏，也要在窗口内持续纠正到“最后一次KNX命令”的目标值
         // key: `${macNormalized}_${channel}` -> { desired, setAt, retryCount, lastRetryAt, networkAddress, totalChannels, channel }
         node.knxDesiredStates = new Map();
+        // Mesh 近期写 KNX 的权威意图（对称于 knxDesiredStates）：防止独立状态地址上的滞后电报触发对 Mesh 的反向误控
+        // key: `${macNormalized}_${channel}` -> { value: boolean, until: number }
+        node.meshKnxAuthority = new Map();
+        // 场景场景遮蔽截止时间（ms 时间戳），0 表示未激活
+        node.sceneVeilUntil = 0;
+        node.triggerSceneVeil = function(reason) {
+            const ms = Math.max(2000, Math.min(30000, parseInt(process.env.SYMI_KNX_SCENE_VEIL_MS || String(SCENE_VEIL_MS_DEFAULT), 10) || SCENE_VEIL_MS_DEFAULT));
+            node.sceneVeilUntil = Date.now() + ms;
+            node.debug(`[SceneVeil] ${reason || "场景"} 遮蔽 ${ms}ms`);
+        };
+        node.recordMeshKnxAuthority = function(mapping, expectedBool) {
+            if (!mapping || mapping.deviceType !== "switch") return;
+            const macN = (mapping.meshMac || "").toLowerCase().replace(/:/g, "");
+            const ch = mapping.meshChannel;
+            if (!macN || ch === undefined || ch === null) return;
+            const pk = `${macN}_${ch}`;
+            node.meshKnxAuthority.set(pk, { value: !!expectedBool, until: Date.now() + KNX_MASTER_WINDOW_MS });
+        };
         
         // 初始化标记
         node.initializing = true;
@@ -699,15 +736,16 @@ module.exports = function(RED) {
             const queryTimestamp = node.pendingMeshQueries.get(macNormalized);
             if (queryTimestamp) {
                 const delta = Date.now() - queryTimestamp;
-                // 查询后 1500ms 内到达的状态变化，一律视为“查询响应”
-                if (delta >= 0 && delta < 1500) {
-                    if (eventData.isUserControl) {
+                // 仅当网关把「查询回包」误标为 isUserControl=true 时改为 false；勿对 false/undefined 强行清零，
+                // 否则会把本为 true 的米家/App 控制在 pending 窗口内一律压成「非用户」导致 Mesh→KNX 不写字。
+                if (delta >= 0 && delta < MESH_QUERY_RESPONSE_SUPPRESS_MS) {
+                    if (eventData.isUserControl === true) {
                         node.debug(`[Mesh事件] 检测到查询响应，强制标记为非用户控制: MAC=${macNormalized}, delta=${delta}ms`);
+                        eventData.isUserControl = false;
                     }
-                    eventData.isUserControl = false;
                 }
                 // 清理过期记录
-                if (delta >= 1500) {
+                if (delta >= MESH_QUERY_RESPONSE_SUPPRESS_MS) {
                     node.pendingMeshQueries.delete(macNormalized);
                 }
             }
@@ -771,10 +809,9 @@ module.exports = function(RED) {
 
             // ========================= KNX 期望状态闭环（Last Write Wins） =========================
             // 默认开启此功能：在 KNX 主控窗口内，只要 Mesh 最终状态 != 最后一次 KNX 期望值，就会在限频+最多5次的前提下自动纠偏。
-            // 如需在某些场景下完全关闭“期望状态纠错”逻辑，可在 Node-RED 运行环境中显式设置：
-            //   SYMI_KNX_LWW_ENABLED=0
+            // v1.9.9 起默认关闭 LWW，避免与状态反馈路径叠加导致多路开关抖动；需纠错时在环境中设置 SYMI_KNX_LWW_ENABLED=1
             const LWW_ENV = (process.env.SYMI_KNX_LWW_ENABLED || "").toString().toLowerCase();
-            const LWW_ENABLED = (LWW_ENV !== "0" && LWW_ENV !== "false");
+            const LWW_ENABLED = (LWW_ENV === "1" || LWW_ENV === "true" || LWW_ENV === "yes");
             if (LWW_ENABLED) {
                 try {
                     const nowTs = Date.now();
@@ -2293,8 +2330,15 @@ module.exports = function(RED) {
                             const msgType = (meshDevice.channels >= 6) ? 0x45 : 0x02;
                             
                             const queryFrame = node.gateway.protocolHandler.buildDeviceStatusQueryFrame(meshDevice.networkAddress, msgType);
-                            node.pendingMeshQueries.set(macNormalized, Date.now());
-                            
+                            const pendingTs = Date.now();
+                            node.pendingMeshQueries.set(macNormalized, pendingTs);
+                            setTimeout(() => {
+                                if (node.isClosed) return;
+                                if (node.pendingMeshQueries.get(macNormalized) === pendingTs) {
+                                    node.pendingMeshQueries.delete(macNormalized);
+                                }
+                            }, MESH_QUERY_PENDING_EARLY_CLEAR_MS);
+
                             node.gateway.client.sendFrame(queryFrame, 2).then(() => {
                                 // 延迟500ms后检查
                                 setTimeout(() => {
@@ -2459,6 +2503,11 @@ module.exports = function(RED) {
         // ========== KNX -> Mesh 同步 ==========
         node.syncKnxToMesh = async function(cmd) {
             const { mapping, type, value, key, isStatusFeedback, isCalibration } = cmd;
+            const macNormCmd = (mapping.meshMac || "").toLowerCase().replace(/:/g, "");
+            const meshAuthKeyCmd = `${macNormCmd}_${mapping.meshChannel}`;
+            if (type === "switch" && !isStatusFeedback) {
+                node.meshKnxAuthority.delete(meshAuthKeyCmd);
+            }
             
             // 【关键优化】如果是状态反馈触发的同步，不记录时间戳，不触发反向控制保护
             // 因为状态反馈地址本身就是只读的，不应该触发反向控制
@@ -2624,11 +2673,9 @@ module.exports = function(RED) {
                     // - 普通命令：继续使用完整的反馈确认+重试闭环，确保 KNX 控制 Mesh 必须成功
                     // - 校准命令(isCalibration=true)：仅发送一次，不进入反馈确认闭环，避免在设备离线时产生周期性 5 次重试告警
                     if (cmd.isCalibration) {
-                        node.debug(`[KNX->Mesh] 发送开关(校准): ${meshDevice.name} CH${channel} = ${finalValue ? "ON" : "OFF"}`);
-                        // 即使是校准，也要发送给 Mesh
-                        node.gateway.sendSwitchCommand(meshDevice, channel, finalValue)
-                            .then(() => node.debug(`[KNX->Mesh] ✓ 校准命令已发送: ${meshDevice.name} CH${channel}`))
-                            .catch(err => node.warn(`[KNX->Mesh] 校准命令发送失败: ${err.message}`));
+                        // 校准命令在上方已通过 gateway.sendControl(...) 同步下发到 Mesh；
+                        // 这里仅跳过反馈确认闭环，避免重复发送和调用不存在的方法。
+                        node.debug(`[KNX->Mesh] 校准命令已下发，跳过反馈确认闭环: ${meshDevice.name} CH${channel} = ${finalValue ? "ON" : "OFF"}`);
                         return;
                     }
 
@@ -2705,8 +2752,14 @@ module.exports = function(RED) {
                             
                             // 查询Mesh设备实际状态
                             const queryFrame = node.gateway.protocolHandler.buildDeviceStatusQueryFrame(meshDevice.networkAddress, msgType);
-                            // 【关键修复】记录本次查询，用于后续识别“查询响应”事件，避免被当成用户控制
-                            node.pendingMeshQueries.set(macNormalized, Date.now());
+                            const pendingTsRetry = Date.now();
+                            node.pendingMeshQueries.set(macNormalized, pendingTsRetry);
+                            setTimeout(() => {
+                                if (node.isClosed) return;
+                                if (node.pendingMeshQueries.get(macNormalized) === pendingTsRetry) {
+                                    node.pendingMeshQueries.delete(macNormalized);
+                                }
+                            }, MESH_QUERY_PENDING_EARLY_CLEAR_MS);
                             node.gateway.client.sendFrame(queryFrame, 2).then(() => {
                                 node.log(`[反馈确认] 已查询Mesh设备状态: ${mapping.name} (地址=0x${meshDevice.networkAddress.toString(16).toUpperCase()}, msgType=0x${msgType.toString(16).toUpperCase()})`);
                                 
@@ -3200,6 +3253,7 @@ module.exports = function(RED) {
             // 【关键修复】在回显检测之前，先检查是否有待确认的Mesh控制KNX命令
             // 如果有待确认的命令且值匹配，则确认成功，不应该被当作回显
             let isPendingConfirmation = false;
+            let meshToKnxConfirmedPending = null;
             if (isControlAddr && !isResponse) {
                 for (const [commandId, pending] of node.pendingConfirmations.entries()) {
                     if (pending.direction === "mesh-to-knx" && 
@@ -3210,6 +3264,7 @@ module.exports = function(RED) {
                             // 值匹配，确认成功
                             const elapsed = Date.now() - pending.sentTime;
                             node.log(`[反馈确认] ✓ Mesh控制KNX成功: ${pending.mapping.name || "未知设备"} ${groupAddr} = ${pending.expectedValue ? "ON" : "OFF"} (${elapsed}ms)`);
+                            meshToKnxConfirmedPending = pending;
                             node.pendingConfirmations.delete(commandId);
                             isPendingConfirmation = true;
                             break;
@@ -3217,6 +3272,9 @@ module.exports = function(RED) {
                     }
                 }
             }
+            if (meshToKnxConfirmedPending && meshToKnxConfirmedPending.mapping) {
+                node.recordMeshKnxAuthority(meshToKnxConfirmedPending.mapping, meshToKnxConfirmedPending.expectedValue);
+            }
             
             // 只有控制地址才需要回显检测（正常情况下状态地址不会回显）
             // 【关键修复】如果这是待确认命令的反馈，不应该被当作回显
@@ -3336,6 +3394,7 @@ module.exports = function(RED) {
                             // 记录KNX控制时间戳
                             node.knxControlTimestamps[deviceKey] = Date.now();
                             node.recordSyncTime("knx-to-mesh", loopKey);
+                            node.triggerSceneVeil(`KNX按键场景${sceneId}`);
                             
                             node.log(`[KNX->Mesh] 按键场景触发: ${mapping.name} -> 场景${sceneId}`);
                             node.queueCommand({
@@ -3477,6 +3536,7 @@ module.exports = function(RED) {
                                 // 值匹配，确认成功
                                 const elapsed = Date.now() - pending.sentTime;
                                 node.log(`[反馈确认] ✓ Mesh控制KNX成功: ${pending.mapping.name || "未知设备"} ${groupAddr} = ${pending.expectedValue ? "ON" : "OFF"} (${elapsed}ms)`);
+                                node.recordMeshKnxAuthority(pending.mapping, pending.expectedValue);
                                 node.pendingConfirmations.delete(commandId);
                             }
                         }
@@ -3497,6 +3557,25 @@ module.exports = function(RED) {
                             }
                         }
 
+                        const meshAuth = node.meshKnxAuthority.get(deviceKey);
+                        if (meshAuth && Date.now() < meshAuth.until && switchValue !== meshAuth.value) {
+                            node.debug(`[KNX状态反馈] 忽略滞后状态电报(与 Mesh 近期写 KNX 意图冲突): ${mapping.name} CH${mapping.meshChannel} 电报=${switchValue ? "ON" : "OFF"} Mesh意图=${meshAuth.value ? "ON" : "OFF"}`);
+                            done && done();
+                            return;
+                        }
+
+                        for (const [, pSync] of node.pendingConfirmations.entries()) {
+                            if (pSync.direction === "knx-to-mesh" && pSync.type === "switch" && pSync.mapping &&
+                                (pSync.mapping.meshMac || "").toLowerCase().replace(/:/g, "") === (mapping.meshMac || "").toLowerCase().replace(/:/g, "") &&
+                                Number(pSync.channel) === Number(mapping.meshChannel)) {
+                                if (pSync.expectedValue === switchValue) {
+                                    node.debug(`[KNX状态反馈] 与待确认 KNX->Mesh 一致，跳过重复同步: ${mapping.name} CH${mapping.meshChannel}`);
+                                    done && done();
+                                    return;
+                                }
+                            }
+                        }
+
                         // 检查Mesh当前状态
                         const macNormalized = (mapping.meshMac || "").toLowerCase().replace(/:/g, "");
                         const meshDevice = node.gateway.getDevice(macNormalized);
@@ -3513,6 +3592,11 @@ module.exports = function(RED) {
                                 const meshBool = (actualMeshState === true || actualMeshState === 1 || actualMeshState === "on" || actualMeshState === "ON");
                                 
                                 if (meshBool !== switchValue) {
+                                    if (node.sceneVeilUntil && Date.now() < node.sceneVeilUntil) {
+                                        node.debug(`[KNX状态反馈] 场景遮蔽期内跳过 Mesh 校准: ${mapping.name} CH${mapping.meshChannel}`);
+                                        done && done();
+                                        return;
+                                    }
                                     // 状态不一致，同步到Mesh（但不记录时间戳，不触发反向控制保护）
                                     node.log(`[KNX状态反馈] 状态不一致: ${mapping.name}, KNX=${switchValue?"ON":"OFF"}, Mesh=${meshBool?"ON":"OFF"} -> 同步到Mesh`);
                                     
@@ -3557,6 +3641,7 @@ module.exports = function(RED) {
                                     // 值匹配，确认成功
                                     const elapsed = Date.now() - pending.sentTime;
                                     node.log(`[反馈确认] ✓ Mesh控制KNX成功: ${pending.mapping.name || "未知设备"} ${groupAddr} = ${pending.expectedValue ? "ON" : "OFF"} (${elapsed}ms)`);
+                                    node.recordMeshKnxAuthority(pending.mapping, pending.expectedValue);
                                     node.pendingConfirmations.delete(commandId);
                                 }
                             }
@@ -3578,6 +3663,7 @@ module.exports = function(RED) {
                     node.knxControlTimestamps[deviceKey] = Date.now();
                     // 同时记录防死循环时间
                     node.recordSyncTime("knx-to-mesh", loopKey);
+                    node.meshKnxAuthority.delete(deviceKey);
                     
                     // 【已删除】不再使用AutoSync 3秒倒计时，完全依赖设备主动上报和首次部署查询
 
@@ -3638,6 +3724,7 @@ module.exports = function(RED) {
                         // 【关键】场景触发时记录KNX控制时间戳
                         node.knxControlTimestamps[deviceKey] = Date.now();
                         node.recordSyncTime("knx-to-mesh", loopKey);
+                        node.triggerSceneVeil(`KNX DPT 场景${receivedScene + 1}`);
 
                         const actionStr = action === "toggle" ? "Toggle" : (action ? "ON" : "OFF");
                         node.log(`[KNX->Mesh] 场景触发: 收到场景${receivedScene+1} -> Mesh开关=${actionStr} (mac=${macNormalized}, key=${loopKey})`);
@@ -3992,7 +4079,8 @@ module.exports = function(RED) {
             if (node.initializing) return;
             
             node.log(`[场景面板] 检测到设备0x${(eventData.triggerAddress || 0).toString(16).toUpperCase()}触发场景事件，延迟查询设备状态`);
-            
+            node.triggerSceneVeil("Mesh 场景执行");
+
             // 延迟300ms后查询设备状态，给设备执行时间
             setTimeout(async () => {
                 // 收集所有已映射的唯一设备地址

package/nodes/symi-mqtt.js

@@ -268,8 +268,22 @@ module.exports = function(RED) {
             
             // 清理MQTT资源
             if (node.mqttClient) {
-                // 移除所有监听器
-                node.mqttClient.removeAllListeners();
+                // 重要：不要无差别移除所有 listeners（尤其是 `error`）。
+                // 否则在断开/重连握手阶段触发的 `connack timeout` 可能会因为没有 `error` 监听器而变成 Uncaught Exception。
+                // 只移除非关键监听，保留 error 兜底。
+                try {
+                    node.mqttClient.removeAllListeners("message");
+                    node.mqttClient.removeAllListeners("connect");
+                    node.mqttClient.removeAllListeners("reconnect");
+                    node.mqttClient.removeAllListeners("offline");
+                    node.mqttClient.removeAllListeners("close");
+                    // 若之前 error 监听器已被清理，兜底再挂一个，确保不会抛未捕获 error。
+                    if (node.mqttClient.listenerCount && node.mqttClient.listenerCount("error") === 0) {
+                        node.mqttClient.on("error", () => {});
+                    }
+                } catch (e) {
+                    // 静默，避免 close 流程被异常打断
+                }
 
                 if (node.mqttClient.connected) {
                     const devices = node.gateway.deviceManager.getAllDevices();
@@ -321,6 +335,8 @@ module.exports = function(RED) {
             const options = {
                 clientId: `symi-mesh-${Math.random().toString(16).substring(2, 10)}`,
                 clean: true,
+                // 避免握手阶段长时间卡住；错误会走 `error` 事件监听兜底，不应导致 Uncaught Exception。
+                connectTimeout: 10000,
                 reconnectPeriod: 5000
             };
             

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-mesh",
-  "version": "1.9.8",
+  "version": "1.9.9",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "nodes/symi-gateway.js",
   "scripts": {
@@ -56,6 +56,7 @@
   "dependencies": {
     "axios": "^1.7.9",
     "mqtt": "^5.10.0",
+    "node-red-contrib-symi-mesh": "file:node-red-contrib-symi-mesh-1.9.9.tgz",
     "serialport": "^12.0.0"
   },
   "engines": {