iobroker.zigbee2mqtt 3.0.21 → 3.1.5

package/lib/websocketController.js

@@ -1,128 +1,265 @@
+'use strict';
+
 const WebSocket = require('ws');
-let wsClient;
 const wsHeartbeatIntervall = 5000;
 const restartTimeout = 1000;
-let ping;
-let pingTimeout;
-let autoRestartTimeout;
+/** Maximum reconnect delay in milliseconds (caps exponential backoff) */
+const MAX_RESTART_TIMEOUT = 30000;
 
 /**
- *
+ * Verwaltet die WebSocket-Verbindung zu Zigbee2MQTT inklusive
+ * Heartbeat-Überwachung und exponentiellem Reconnect-Backoff.
  */
 class WebsocketController {
     /**
+     * Erstellt eine neue WebsocketController-Instanz.
      *
-     * @param adapter
+     * @param {object} adapter Die ioBroker-Adapter-Instanz
      */
     constructor(adapter) {
         this.adapter = adapter;
+        this.wsClient  = null;
+        this.ping      = null;
+        this.pingTimeout      = null;
+        this.autoRestartTimeout = null;
+        // Flag: wird bei closeConnection() gesetzt damit autoRestart() nicht feuert
+        this._intentionalClose = false;
+        /** Aktueller Reconnect-Delay (exponentielles Backoff) */
+        this._reconnectDelay = restartTimeout;
     }
 
     /**
-     *
+     * Baut eine neue WebSocket-Verbindung auf.
+     * Bestehende Verbindung und alle Timer werden zuerst sicher bereinigt.
      */
     initWsClient() {
+        // Config-Guard: Pflichtfelder müssen vorhanden sein
+        if (!this.adapter.config.wsScheme || !this.adapter.config.wsServerIP || !this.adapter.config.wsServerPort) {
+            this.adapter.log.error('WebSocket config incomplete (wsScheme / wsServerIP / wsServerPort missing).');
+            return;
+        }
+
+        this._intentionalClose = false;
+
+        // Vorherige Timer stoppen
+        this.adapter.clearTimeout(this.ping);
+        this.adapter.clearTimeout(this.pingTimeout);
+        this.adapter.clearTimeout(this.autoRestartTimeout);
+
+        // Vorherige Verbindung sicher schließen und null setzen
+        if (this.wsClient) {
+            this.wsClient.removeAllListeners();
+            if (this.wsClient.readyState !== WebSocket.CLOSED &&
+                this.wsClient.readyState !== WebSocket.CLOSING) {
+                try {
+                    this.wsClient.terminate();
+                } catch (e) {
+                    this.adapter.log.debug(`initWsClient: old socket terminate error: ${e}`);
+                }
+            }
+            this.wsClient = null;
+        }
+
         try {
             let wsURL = `${this.adapter.config.wsScheme}://${this.adapter.config.wsServerIP}:${this.adapter.config.wsServerPort}/api`;
+            // Für Logging: URL ohne Token (Sicherheit)
+            const wsURLSafe = wsURL;
 
-            if (this.adapter.config.wsTokenEnabled == true) {
+            if (this.adapter.config.wsTokenEnabled === true) {
                 wsURL += `?token=${this.adapter.config.wsToken}`;
             }
 
-            wsClient = new WebSocket(wsURL, { rejectUnauthorized: false });
+            this.adapter.log.debug(`WebSocket connecting to ${wsURLSafe}`);
+            this.wsClient = new WebSocket(wsURL, { rejectUnauthorized: false });
 
-            wsClient.on('open', () => {
-                // Send ping to server
+            this.wsClient.on('open', () => {
+                this._reconnectDelay = restartTimeout; // Backoff zurücksetzen bei Erfolg
+                this.adapter.log.info('Connect to Zigbee2MQTT over websocket connection.');
                 this.sendPingToServer();
-                // Start Heartbeat
                 this.wsHeartbeat();
             });
 
-            wsClient.on('pong', () => {
+            this.wsClient.on('pong', () => {
                 this.wsHeartbeat();
             });
 
-            wsClient.on('close', async () => {
-                clearTimeout(pingTimeout);
-                clearTimeout(ping);
-
-                if (wsClient.readyState === WebSocket.CLOSED) {
-                    this.autoRestart();
+            // ws@8 liefert Buffer, nicht String → immer .toString() verwenden
+            this.wsClient.on('message', (message) => {
+                let messageObj;
+                try {
+                    messageObj = JSON.parse(message.toString());
+                } catch {
+                    this.adapter.log.debug(`Invalid WebSocket message: ${message.toString().slice(0, 200)}`);
+                    return;
                 }
+                // messageParse ist async – Fehler mit .catch() abfangen
+                this.adapter.messageParse(messageObj).catch((err) => {
+                    this.adapter.log.error(`messageParse error: ${err}`);
+                });
             });
 
-            wsClient.on('message', () => {});
+            this.wsClient.on('close', (code, reason) => {
+                this._onWsClose(code, reason).catch((err) => {
+                    this.adapter.log.error(`WebSocket close handler error: ${err}`);
+                });
+            });
 
-            wsClient.on('error', (err) => {
-                this.adapter.log.debug(err);
+            this.wsClient.on('error', (err) => {
+                // err kann undefined sein oder kein Error-Objekt
+                const msg = err && err.message ? err.message : String(err || 'unknown');
+                this.adapter.log.debug(`WebSocket error: ${msg}`);
+                // Kein throw – der 'close'-Event folgt nach 'error' immer automatisch
             });
 
-            return wsClient;
         } catch (err) {
-            this.adapter.log.error(err);
+            this.adapter.log.error(`WebSocket init error: ${err}`);
+            // Retry nach restartTimeout
+            if (!this._intentionalClose) {
+                this.autoRestart();
+            }
+        }
+    }
+
+    /**
+     * Interner async Handler für den WebSocket-close-Event.
+     *
+     * @param {number} code   WebSocket-Close-Code (z.B. 1000 = normal, 1006 = abnormal)
+     * @param {Buffer} reason Optionaler Grund-Text des Close-Events
+     */
+    async _onWsClose(code, reason) {
+        this.adapter.clearTimeout(this.pingTimeout);
+        this.adapter.clearTimeout(this.ping);
+
+        this.adapter.log.debug(`WebSocket closed – code: ${code}, reason: ${reason ? reason.toString() : 'none'}`);
+
+        try {
+            if (this.adapter.statesController) {
+                this.adapter.setStateChanged('info.connection', false, true);
+                await this.adapter.statesController.setAllAvailableToFalse();
+            }
+        } catch (err) {
+            this.adapter.log.error(`close handler setAllAvailableToFalse error: ${err}`);
+        }
+
+        // Caches leeren
+        this.adapter.deviceCache.length = 0;
+        this.adapter.groupCache.length = 0;
+        for (const key of Object.keys(this.adapter.createCache)) {
+            delete this.adapter.createCache[key];
+        }
+
+        // Nur reconnecten wenn kein intentionales Shutdown
+        if (!this._intentionalClose) {
+            this.autoRestart();
         }
     }
 
     /**
+     * Sendet eine serialisierte Nachricht an Zigbee2MQTT über den WebSocket.
      *
-     * @param message
+     * @param {string} message JSON-String der zu sendenden Nachricht
      */
     send(message) {
-        if (wsClient.readyState !== WebSocket.OPEN) {
+        if (!this.wsClient || this.wsClient.readyState !== WebSocket.OPEN) {
             this.adapter.log.warn('Cannot set State, no websocket connection to Zigbee2MQTT!');
             return;
         }
-        wsClient.send(message);
+        try {
+            this.wsClient.send(message);
+        } catch (err) {
+            this.adapter.log.error(`WebSocket send error: ${err && err.message ? err.message : String(err)}`);
+        }
     }
 
     /**
-     *
+     * Sendet regelmäßig WebSocket-Pings an den Z2M-Server
+     * und plant den nächsten Ping nach wsHeartbeatIntervall Millisekunden.
      */
     sendPingToServer() {
-        //this.logDebug('Send ping to server');
-        wsClient.ping();
-        ping = setTimeout(() => {
+        if (!this.wsClient || this.wsClient.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        try {
+            this.wsClient.ping();
+        } catch (err) {
+            this.adapter.log.debug(`WebSocket ping error: ${err && err.message ? err.message : String(err)}`);
+            return;
+        }
+        this.ping = this.adapter.setTimeout(() => {
             this.sendPingToServer();
         }, wsHeartbeatIntervall);
     }
 
     /**
-     *
+     * Startet oder erneuert den Heartbeat-Timeout.
+     * Wenn innerhalb von wsHeartbeatIntervall + 3000 ms kein Pong eintrifft,
+     * wird die Verbindung terminiert und autoRestart() ausgelöst.
      */
     wsHeartbeat() {
-        clearTimeout(pingTimeout);
-        pingTimeout = setTimeout(() => {
-            this.adapter.log.warn('Websocked connection timed out');
-            wsClient.terminate();
+        this.adapter.clearTimeout(this.pingTimeout);
+        this.pingTimeout = this.adapter.setTimeout(() => {
+            this.adapter.log.warn('WebSocket connection timed out – terminating.');
+            try {
+                if (this.wsClient) {
+                    this.wsClient.terminate();
+                }
+            } catch (err) {
+                this.adapter.log.debug(`wsHeartbeat terminate error: ${err}`);
+            }
+            // terminate() feuert 'close' → autoRestart() wird dort aufgerufen
         }, wsHeartbeatIntervall + 3000);
     }
 
     /**
-     *
+     * Plant einen Reconnect-Versuch mit exponentiellem Backoff.
+     * Der Delay verdoppelt sich mit jedem Versuch bis maximal MAX_RESTART_TIMEOUT ms.
      */
-    async autoRestart() {
-        this.adapter.log.warn(`Start try again in ${restartTimeout / 1000} seconds...`);
-        autoRestartTimeout = setTimeout(() => {
-            this.adapter.startWebsocket();
-        }, restartTimeout);
+    autoRestart() {
+        const delay = this._reconnectDelay;
+        this._reconnectDelay = Math.min(this._reconnectDelay * 2, MAX_RESTART_TIMEOUT);
+        this.adapter.log.warn(`WebSocket disconnected – reconnecting in ${delay / 1000} second(s)...`);
+        this.adapter.clearTimeout(this.autoRestartTimeout);
+        this.autoRestartTimeout = this.adapter.setTimeout(() => {
+            try {
+                this.initWsClient();
+            } catch (err) {
+                this.adapter.log.error(`autoRestart initWsClient error: ${err}`);
+            }
+        }, delay);
     }
 
     /**
-     *
+     * Schließt die WebSocket-Verbindung intentional (kein autoRestart).
+     * Wird beim Adapter-Stop aufgerufen.
      */
     closeConnection() {
-        if (wsClient && wsClient.readyState !== WebSocket.CLOSED) {
-            wsClient.close();
+        this._intentionalClose = true;
+        this._reconnectDelay = restartTimeout; // Backoff zurücksetzen
+        this.adapter.clearTimeout(this.ping);
+        this.adapter.clearTimeout(this.pingTimeout);
+        this.adapter.clearTimeout(this.autoRestartTimeout);
+        if (this.wsClient) {
+            this.wsClient.removeAllListeners();
+            try {
+                if (this.wsClient.readyState !== WebSocket.CLOSED &&
+                    this.wsClient.readyState !== WebSocket.CLOSING) {
+                    this.wsClient.close();
+                }
+            } catch (err) {
+                this.adapter.log.debug(`closeConnection error: ${err}`);
+            }
+            this.wsClient = null;
         }
     }
 
     /**
-     *
+     * Stoppt alle laufenden Timer (ping, pingTimeout, autoRestartTimeout).
+     * Wird beim Adapter-Stop aufgerufen.
      */
-    async allTimerClear() {
-        clearTimeout(pingTimeout);
-        clearTimeout(ping);
-        clearTimeout(autoRestartTimeout);
+    allTimerClear() {
+        this.adapter.clearTimeout(this.pingTimeout);
+        this.adapter.clearTimeout(this.ping);
+        this.adapter.clearTimeout(this.autoRestartTimeout);
     }
 }
 

package/lib/z2mController.js

@@ -1,13 +1,15 @@
 /**
- *
+ * Übersetzt ioBroker-State-Änderungen in Zigbee2MQTT-MQTT-Nachrichten
+ * und leitet Z2M-Log-Nachrichten in den ioBroker-Logger weiter.
  */
 class Z2mController {
     /**
+     * Erstellt eine neue Z2mController-Instanz.
      *
-     * @param adapter
-     * @param deviceCache
-     * @param groupCache
-     * @param logCustomizations
+     * @param {object} adapter           Die ioBroker-Adapter-Instanz
+     * @param {Array}  deviceCache       Gemeinsamer Cache aller bekannten Geräte
+     * @param {Array}  groupCache        Gemeinsamer Cache aller bekannten Gruppen
+     * @param {object} logCustomizations Debug/Filter-Einstellungen (debugDevices, logfilter)
      */
     constructor(adapter, deviceCache, groupCache, logCustomizations) {
         this.adapter = adapter;
@@ -17,9 +19,12 @@ class Z2mController {
     }
 
     /**
+     * Erzeugt aus einer ioBroker-State-Änderung eine Zigbee2MQTT-Nachricht.
+     * Gibt null zurück wenn kein Gerät/State gefunden wurde oder der Setter undefined liefert.
      *
-     * @param id
-     * @param state
+     * @param {string}         id    Vollständige State-ID (z.B. "zigbee2mqtt.0.0xAABB.state")
+     * @param {ioBroker.State} state Das neue State-Objekt mit val und ack
+     * @returns {Promise<{topic: string, payload: object}|undefined>} Die Z2M-Nachricht oder undefined
      */
     async createZ2MMessage(id, state) {
         const splitedID = id.split('.');
@@ -29,25 +34,38 @@ class Z2mController {
         }
 
         if (id.endsWith('info.coordinator_check')) {
-            return { topic: 'bridge/request/coordinator_check', payload: '' };
+            // Fix 1: Z2M erwartet JSON-Objekt {} nicht leeren String ''
+            return { topic: 'bridge/request/coordinator_check', payload: {} };
         }
 
         const ieee_address = splitedID[2];
         const stateName = splitedID[3];
 
-        const device = this.groupCache.concat(this.deviceCache).find((d) => d.ieee_address == ieee_address);
+        const device = this.groupCache.concat(this.deviceCache).find((d) => d.ieee_address === ieee_address);
         if (!device) {
             return;
         }
 
-        const deviceState = device.states.find((s) => s.id == stateName);
+        const deviceState = device.states.find((s) => s.id === stateName);
         if (!deviceState) {
             return;
         }
 
         let stateVal = state.val;
         if (deviceState.setter) {
-            stateVal = deviceState.setter(state.val);
+            // Fix 3: setter kann crashen (z.B. ungültiger Farbwert) → try/catch
+            try {
+                stateVal = deviceState.setter(state.val);
+            } catch (err) {
+                this.adapter.log.warn(`${device.ieee_address} state: ${stateName} setter error: ${err.message || err}`);
+                return;
+            }
+        }
+
+        // Fix 5: wenn setter undefined zurückgibt (z.B. Toggle-Release) → nichts senden
+        if (stateVal === undefined) {
+            this.adapter.log.debug(`${device.ieee_address} state: ${stateName} setter returned undefined, skipping`);
+            return;
         }
 
         let stateID = deviceState.id;
@@ -66,16 +84,18 @@ class Z2mController {
             topic: `${device.id}/set`,
         };
 
-        if (stateID == 'send_payload') {
+        if (stateID === 'send_payload') {
             try {
                 controlObj.payload = JSON.parse(stateVal);
-                this.adapter.setState(id, state, true);
+                await this.adapter.setStateAsync(id, state.val, true);
             } catch (error) {
-                controlObj.payload = stateVal.replaceAll(' ', '').replaceAll('\n', '');
+                // Fix 9: rawStr als String direkt als payload – wird in main.js via
+                // JSON.stringify() nochmals gewrappt → würde doppelt quoten.
+                // Stattdessen: Fehler loggen und NICHT senden (ungültiges JSON bleibt ungültig)
                 this.adapter.log.warn(
-                    `${device.ieee_address} state: ${stateID} error: value passed is not a valid JSON`
+                    `${device.ieee_address} state: ${stateID} error: value passed is not a valid JSON – not sent`
                 );
-                this.adapter.log.debug(`${device.ieee_address} states: ${JSON.stringify(controlObj)} error: ${error}`);
+                this.adapter.log.debug(`${device.ieee_address} raw value: ${stateVal}`);
                 return;
             }
         }
@@ -83,17 +103,13 @@ class Z2mController {
         // if available read option and set payload
         if (deviceState.options) {
             for (const option of deviceState.options) {
-                // if optionsValues not set, set it!
-                if (!device.optionsValues[option]) {
-                    const optionValue = (
-                        await this.adapter.getStateAsync(`${splitedID[0]}.${splitedID[1]}.${splitedID[2]}.${option}`)
-                    ).val;
-                    // optionsValues Cache
-                    device.optionsValues[option] = optionValue;
+                // Fix: "in"-Prüfung statt === undefined, damit null als gültiger gecachter Wert behandelt wird
+                if (!(option in device.optionsValues)) {
+                    const optState = await this.adapter.getStateAsync(`${splitedID[0]}.${splitedID[1]}.${splitedID[2]}.${option}`);
+                    device.optionsValues[option] = optState ? optState.val : null;
                 }
 
-                // if transition value == -1 it will be ignored. -1 stands for no overwrite!
-                if (option == 'transition' && device.optionsValues[option] == -1) {
+                if (option === 'transition' && device.optionsValues[option] === -1) {
                     continue;
                 }
 
@@ -103,38 +119,40 @@ class Z2mController {
 
         // If an option datapoint has been set, it does not have to be sent.
         // This is confirmed directly by the adapter (ack = true)
-        if (deviceState.isOption && deviceState.isOption == true) {
+        if (deviceState.isOption) {
             // set optionsValues 'Cache'
             device.optionsValues[stateName] = state.val;
-            this.adapter.setState(id, state, true);
+            await this.adapter.setStateAsync(id, state.val, true);
             return;
         }
 
-        // set stats with the mentioned roles or always immediately to ack = true, because these are not reported back by Zigbee2MQTT
-        if (['button'].includes(deviceState.role)) {
-            this.adapter.setState(id, state, true);
-        }
-        // set stats with the mentioned ids always immediately to ack = true, because these are not reported back by Zigbee2MQTT
-        if (
-            ['brightness_move', 'colortemp_move', 'brightness_move', 'brightness_step', 'effect'].includes(
-                deviceState.id
-            )
-        ) {
-            this.adapter.setState(id, state, true);
+        // States die nicht von Z2M zurückgemeldet werden → sofort ack=true setzen
+        const immediateAckRole = ['button'].includes(deviceState.role);
+        const immediateAckId = ['brightness_move', 'colortemp_move', 'brightness_step', 'effect'].includes(deviceState.id);
+        if (immediateAckRole || immediateAckId) {
+            await this.adapter.setStateAsync(id, state.val, true);
         }
 
-        if (this.logCustomizations.debugDevices.includes(device.ieee_address)) {
-            this.adapter.log.warn(`<<<--- toZ2M -> ${device.ieee_address} states: ${JSON.stringify(controlObj)}`);
+        if (this.logCustomizations.debugDevices) {
+            const debugList = String(this.logCustomizations.debugDevices).split(',').map((s) => s.trim());
+            if (debugList.includes(device.ieee_address)) {
+                this.adapter.log.warn(`<<<--- toZ2M -> ${device.ieee_address} states: ${JSON.stringify(controlObj)}`);
+            }
         }
         return controlObj;
     }
 
     /**
+     * Leitet eine Z2M-Log-Nachricht (bridge/logging) an den ioBroker-Logger weiter.
+     * Nachrichten die dem konfigurierten Logfilter entsprechen werden unterdrückt.
      *
-     * @param messageObj
+     * @param {{ payload: { message: string, level: string } }} messageObj Die Log-Nachricht
      */
     async proxyZ2MLogs(messageObj) {
-        const logMessage = messageObj.payload.message;
+        const logMessage = messageObj.payload && messageObj.payload.message;
+        if (!logMessage) {
+            return;
+        }
         if (this.logCustomizations.logfilter.some((x) => logMessage.includes(x))) {
             return;
         }
@@ -149,6 +167,9 @@ class Z2mController {
             case 'warning':
                 this.adapter.log.warn(logMessage);
                 break;
+            default:
+                this.adapter.log.debug(`Z2M [${logLevel}]: ${logMessage}`);
+                break;
         }
     }
 }