iobroker.zigbee2mqtt 3.0.21 → 3.1.1

package/lib/utils.js

@@ -46,17 +46,6 @@ function adapterLevelToBulbLevel(adapterLevel) {
      // else
 }
 
-/**
- *
- * @param ba
- */
-function bytesArrayToWordArray(ba) {
-    const wa = [];
-    for (let i = 0; i < ba.length; i++) {
-        wa[(i / 2) | 0] |= ba[i] << (8 * (i % 2));
-    }
-    return wa;
-}
 
 // If the value is greater than 1000, kelvin is assumed.
 // If smaller, it is assumed to be mired.
@@ -88,7 +77,7 @@ function miredKelvinConversion(t) {
  */
 function decimalToHex(decimal, padding) {
     let hex = Number(decimal).toString(16);
-    padding = typeof padding === 'undefined' || padding === null ? (padding = 2) : padding;
+    padding = typeof padding === 'undefined' || padding === null ? 2 : padding;
 
     while (hex.length < padding) {
         hex = `0${hex}`;
@@ -97,26 +86,6 @@ function decimalToHex(decimal, padding) {
     return hex;
 }
 
-/**
- *
- * @param adapterDevId
- */
-function getZbId(adapterDevId) {
-    const idx = adapterDevId.indexOf('group');
-    if (idx > 0) {
-return adapterDevId.substr(idx + 6);
-}
-    return `0x${  adapterDevId.split('.')[2]}`;
-}
-
-/**
- *
- * @param adapter
- * @param id
- */
-function getAdId(adapter, id) {
-    return `${adapter.namespace  }.${  id.split('.')[2]}`; // iobroker device id
-}
 
 /**
  *
@@ -147,32 +116,14 @@ function isObject(item) {
     return typeof item === 'object' && !Array.isArray(item) && item !== null;
 }
 
-/**
- *
- * @param item
- */
-function isJson(item) {
-    let value = typeof item !== 'string' ? JSON.stringify(item) : item;
-    try {
-        value = JSON.parse(value);
-    } catch (e) {
-        return false;
-    }
-
-    return typeof value === 'object' && value !== null;
-}
 
 module.exports = {
     bulbLevelToAdapterLevel,
     adapterLevelToBulbLevel,
-    bytesArrayToWordArray,
     toMired,
     miredKelvinConversion,
     decimalToHex,
-    getZbId,
-    getAdId,
     clearArray,
     moveArray,
     isObject,
-    isJson,
 };

package/lib/websocketController.js

@@ -1,128 +1,233 @@
+'use strict';
+
 const WebSocket = require('ws');
-let wsClient;
 const wsHeartbeatIntervall = 5000;
 const restartTimeout = 1000;
-let ping;
-let pingTimeout;
-let autoRestartTimeout;
 
 /**
  *
  */
 class WebsocketController {
     /**
-     *
      * @param adapter
      */
     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;
     }
 
     /**
-     *
+     * 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
+        clearTimeout(this.ping);
+        clearTimeout(this.pingTimeout);
+        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`;
 
-            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.wsClient = new WebSocket(wsURL, { rejectUnauthorized: false });
 
-            wsClient.on('open', () => {
-                // Send ping to server
+            this.wsClient.on('open', () => {
+                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);
+            // 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}`);
+                });
+            });
+
+            this.wsClient.on('close', async (code, reason) => {
+                clearTimeout(this.pingTimeout);
+                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];
+                }
 
-                if (wsClient.readyState === WebSocket.CLOSED) {
+                // Nur reconnecten wenn kein intentionales Shutdown
+                if (!this._intentionalClose) {
                     this.autoRestart();
                 }
             });
 
-            wsClient.on('message', () => {});
-
-            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();
+            }
         }
     }
 
     /**
+     * Sendet eine Nachricht an Z2M.
      *
-     * @param message
+     * @param {string} message
      */
     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 Pings an den Server.
      */
     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 = setTimeout(() => {
             this.sendPingToServer();
         }, wsHeartbeatIntervall);
     }
 
     /**
-     *
+     * Überwacht den Heartbeat. Wenn kein Pong innerhalb des Timeouts kommt, wird die Verbindung getrennt.
      */
     wsHeartbeat() {
-        clearTimeout(pingTimeout);
-        pingTimeout = setTimeout(() => {
-            this.adapter.log.warn('Websocked connection timed out');
-            wsClient.terminate();
+        clearTimeout(this.pingTimeout);
+        this.pingTimeout = 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);
     }
 
     /**
-     *
+     * Wartet kurz und baut dann die Verbindung neu auf.
      */
-    async autoRestart() {
-        this.adapter.log.warn(`Start try again in ${restartTimeout / 1000} seconds...`);
-        autoRestartTimeout = setTimeout(() => {
-            this.adapter.startWebsocket();
+    autoRestart() {
+        this.adapter.log.warn(`WebSocket disconnected – reconnecting in ${restartTimeout / 1000} second(s)...`);
+        clearTimeout(this.autoRestartTimeout);
+        this.autoRestartTimeout = setTimeout(() => {
+            try {
+                this.initWsClient();
+            } catch (err) {
+                this.adapter.log.error(`autoRestart initWsClient error: ${err}`);
+            }
         }, restartTimeout);
     }
 
     /**
-     *
+     * Schließt die Verbindung intentional (kein autoRestart).
      */
     closeConnection() {
-        if (wsClient && wsClient.readyState !== WebSocket.CLOSED) {
-            wsClient.close();
+        this._intentionalClose = true;
+        clearTimeout(this.ping);
+        clearTimeout(this.pingTimeout);
+        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 Timer (z.B. beim Adapter-Stop).
      */
     async allTimerClear() {
-        clearTimeout(pingTimeout);
-        clearTimeout(ping);
-        clearTimeout(autoRestartTimeout);
+        clearTimeout(this.pingTimeout);
+        clearTimeout(this.ping);
+        clearTimeout(this.autoRestartTimeout);
     }
 }
 

package/lib/z2mController.js

@@ -29,25 +29,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 +79,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);
             } 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 +98,14 @@ 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 2: Cache-Check mit === undefined statt !value
+                // Falsy-Check schlägt bei 0, false, null fehl (z.B. transition=0 = sofort)
+                if (device.optionsValues[option] === undefined) {
+                    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,23 +115,17 @@ 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);
             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
-            )
-        ) {
+        // 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) {
             this.adapter.setState(id, state, true);
         }
 
@@ -134,7 +140,10 @@ class Z2mController {
      * @param messageObj
      */
     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;
         }