iobroker.zigbee2mqtt 3.0.20 → 3.1.1

package/lib/imageController.js

@@ -18,6 +18,7 @@ class ImageController {
      * @param modelName
      */
     sanitizeModelIDForImageUrl(modelName) {
+        if (!modelName) {return 'NA';}
         const modelNameString = modelName.replace('/', '_');
         // eslint-disable-next-line no-control-regex
         return modelNameString.replace(/\u0000/g, '');
@@ -28,33 +29,37 @@ class ImageController {
      * @param deviceName
      */
     sanitizeZ2MDeviceName(deviceName) {
+        if (!deviceName) {return 'NA';}
         const deviceNameString = deviceName.replace(/:|\s|\//g, '-');
         // eslint-disable-next-line no-control-regex
-        return deviceName ? deviceNameString.replace(/\u0000/g, '') : 'NA';
+        return deviceNameString.replace(/\u0000/g, '');
     }
 
     /**
-     *
      * @param device
+     * @param ext
      */
-    getZ2mDeviceImageModelJPG(device) {
+    _buildZ2mImageUrl(device, ext) {
         if (device && device.definition && device.definition.model) {
-            const icoString = `https://www.zigbee2mqtt.io/images/devices/${this.sanitizeZ2MDeviceName(device.definition.model)}.jpg`;
+            const icoString = `https://www.zigbee2mqtt.io/images/devices/${this.sanitizeZ2MDeviceName(device.definition.model)}.${ext}`;
             // eslint-disable-next-line no-control-regex
             return icoString.replace(/\u0000/g, '');
         }
+        return undefined;
+    }
+
+    /**
+     * @param device
+     */
+    getZ2mDeviceImageModelJPG(device) {
+        return this._buildZ2mImageUrl(device, 'jpg');
     }
 
     /**
-     *
      * @param device
      */
     getZ2mDeviceImageModelPNG(device) {
-        if (device && device.definition && device.definition.model) {
-            const icoString = `https://www.zigbee2mqtt.io/images/devices/${this.sanitizeZ2MDeviceName(device.definition.model)}.png`;
-            // eslint-disable-next-line no-control-regex
-            return icoString.replace(/\u0000/g, '');
-        }
+        return this._buildZ2mImageUrl(device, 'png');
     }
 
 
@@ -76,14 +81,17 @@ class ImageController {
      */
     async getDeviceIcon(device) {
         if (!this.adapter.config.useDeviceIcons) {
-return '';
-}
-
-        const imageSize         = this.adapter.config.deviceIconsSize;
+            return '';
+        }
+        if (!device || !device.definition || !device.definition.model) {
+            return '';
+        }
 
-        const z2mIconFileNameJPG = `${this.sanitizeZ2MDeviceName(device.definition.model)}.jpg`;
-        const z2mIconFileNamePNG = `${this.sanitizeZ2MDeviceName(device.definition.model)}.png`;
-        const slsIconFileName = `${this.sanitizeModelIDForImageUrl(device.model_id)}.png`;
+        const imageSize = this.adapter.config.deviceIconsSize;
+        const z2mModel = device.definition.model || '';
+        const z2mIconFileNameJPG = `${this.sanitizeZ2MDeviceName(z2mModel)}.jpg`;
+        const z2mIconFileNamePNG = `${this.sanitizeZ2MDeviceName(z2mModel)}.png`;
+        const slsIconFileName = `${this.sanitizeModelIDForImageUrl(device.model_id || z2mModel)}.png`;
 
         let iconFileName = await this.getExistingIconFileName(z2mIconFileNameJPG, z2mIconFileNamePNG, slsIconFileName);
         let iconFound = true;
@@ -93,7 +101,7 @@ return '';
                 this.getZ2mDeviceImageModelJPG(device),
                 this.getZ2mDeviceImageModelPNG(device),
                 this.getSlsDeviceImage(device)
-            ];
+            ].filter(Boolean);
 
             for (const iconUrl of iconUrls) {
                 try {
@@ -108,38 +116,32 @@ return '';
             }
         }
 
-        if (!iconFound) {
+        if (!iconFound || !iconFileName) {
             this.adapter.log.warn(`Failed to download image for device model: ${device.definition.model} - ${device.definition.description}`);
             return '';
-        } 
-            // Load image from the Meta-Store
-            const icon = await this.adapter.readFileAsync(this.adapter.namespace, iconFileName);
-            // Load Image Metadata
-            const origIconMeta = await sharp(icon.file).metadata();
-            // Check whether the image needs to be resized
-            if (
-                (origIconMeta.height && origIconMeta.height > imageSize) ||
-                (origIconMeta.width && origIconMeta.width > imageSize)
-            ) {
-                // Resize image to 28x28 pixel
-                this.adapter.log.info(
-                    `Resize image for device model ${device.definition.model} from: ${origIconMeta.width}x${origIconMeta.height} to ${imageSize}x${imageSize}`
-                );
-                icon.file = await sharp(icon.file)
-                    .resize({
-                        width: imageSize,
-                        height: imageSize,
-                        fit: sharp.fit.cover,
-                        position: sharp.strategy.entropy,
-                    })
-                    .toBuffer();
-                // Replace the original image with the resize image.
-                await this.adapter.writeFileAsync(this.adapter.namespace, iconFileName, icon.file);
-            }
+        }
+
+        const icon = await this.adapter.readFileAsync(this.adapter.namespace, iconFileName);
+        const origIconMeta = await sharp(icon.file).metadata();
+        if (
+            (origIconMeta.height && origIconMeta.height > imageSize) ||
+            (origIconMeta.width && origIconMeta.width > imageSize)
+        ) {
+            this.adapter.log.info(
+                `Resize image for device model ${device.definition.model} from: ${origIconMeta.width}x${origIconMeta.height} to ${imageSize}x${imageSize}`
+            );
+            icon.file = await sharp(icon.file)
+                .resize({
+                    width: imageSize,
+                    height: imageSize,
+                    fit: sharp.fit.cover,
+                    position: sharp.strategy.entropy,
+                })
+                .toBuffer();
+            await this.adapter.writeFileAsync(this.adapter.namespace, iconFileName, icon.file);
+        }
 
-            // Create and output Base64
-            return `data:image/png;base64,${icon.file.toString('base64')}`;
-        
+        return `data:image/png;base64,${icon.file.toString('base64')}`;
     }
     /**
      *

package/lib/messages.js

@@ -4,6 +4,9 @@
  * @param log
  */
 async function adapterInfo(config, log) {
+    if (!config || !log) {
+        return;
+    }
     log.info('================================= Adapter Config =================================');
     log.info(`|| Zigbee2MQTT Frontend Scheme: ${config.webUIScheme}`);
     log.info(`|| Zigbee2MQTT Frontend Server: ${config.webUIServer}`);
@@ -52,14 +55,19 @@ async function adapterInfo(config, log) {
  * @param log
  */
 async function zigbee2mqttInfo(payload, log) {
+    if (!payload || !log) {
+        return;
+    }
     log.info('============================ Zigbee2MQTT Information =============================');
     log.info(`|| Zigbee2MQTT Version: ${payload.version} `);
-    log.info(
-        `|| Coordinator type: ${payload.coordinator.type} Version: ${payload.coordinator.meta.revision} Serial: ${payload.config.serial.port}`
-    );
-    log.info(
-        `|| Network panid ${payload.network.pan_id} channel: ${payload.network.channel} ext_pan_id: ${payload.network.extended_pan_id}`
-    );
+    const coordType     = payload.coordinator && payload.coordinator.type ? payload.coordinator.type : 'unknown';
+    const coordRev      = payload.coordinator && payload.coordinator.meta ? payload.coordinator.meta.revision : 'unknown';
+    const serialPort    = payload.config && payload.config.serial ? payload.config.serial.port : 'unknown';
+    const panId         = payload.network ? payload.network.pan_id : 'unknown';
+    const channel       = payload.network ? payload.network.channel : 'unknown';
+    const extPanId      = payload.network ? payload.network.extended_pan_id : 'unknown';
+    log.info(`|| Coordinator type: ${coordType} Version: ${coordRev} Serial: ${serialPort}`);
+    log.info(`|| Network panid ${panId} channel: ${channel} ext_pan_id: ${extPanId}`);
     log.info('==================================================================================');
 }
 

package/lib/mqttServerController.js

@@ -1,65 +1,156 @@
+'use strict';
+
 const core = require('@iobroker/adapter-core');
-const Aedes = require('aedes');
-const net = require('net');
-let mqttServer;
+const { Aedes } = require('aedes');
+const net = require('node:net');
 
 /**
  *
  */
 class MqttServerController {
     /**
-     *
      * @param adapter
      */
     constructor(adapter) {
-        this.adapter = adapter;
+        this.adapter     = adapter;
+        this.mqttServer  = null;
+        this.aedesBroker = null;
     }
 
     /**
+     * Prüft ob Port und Bind-Adresse konfiguriert sind.
      *
+     * @returns {boolean}
+     */
+    _checkConfig() {
+        if (!this.adapter.config.mqttServerPort || !this.adapter.config.mqttServerIPBind) {
+            this.adapter.log.error('MQTT server config incomplete (mqttServerPort / mqttServerIPBind missing).');
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Hängt error- und close-Events an einen net.Server.
+     *
+     * @param {string} label
+     */
+    _attachServerEvents(label) {
+        if (!this.mqttServer) {
+            return;
+        }
+        this.mqttServer.on('error', (err) => {
+            this.adapter.log.error(`${label} error: ${err && err.message ? err.message : String(err)}`);
+        });
+        this.mqttServer.on('close', () => {
+            this.adapter.log.debug(`${label} closed.`);
+        });
+    }
+
+    /**
+     * Startet den internen MQTT-Server mit Persistenz (aedes + nedb).
      */
     async createMQTTServer() {
+        if (!this._checkConfig()) {
+            return;
+        }
         try {
             const NedbPersistence = require('aedes-persistence-nedb');
             const db = new NedbPersistence({
                 path: `${core.getAbsoluteInstanceDataDir(this.adapter)}/mqttData`,
                 prefix: '',
-            });          
-            const aedes = Aedes({ persistence: db });
-            mqttServer = net.createServer(aedes.handle);
-            mqttServer.listen(this.adapter.config.mqttServerPort, this.adapter.config.mqttServerIPBind, () => {
-                this.adapter.log.info(
-                    `Starting MQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`
+            });
+            // aedes-persistence-nedb does not implement the async setup() interface
+            // required by aedes v1.x → no-op shim
+            if (!db.setup) {
+                db.setup = async () => {};
+            }
+            this.aedesBroker = await Aedes.createBroker({ persistence: db });
+            this.mqttServer  = net.createServer(this.aedesBroker.handle);
+            this._attachServerEvents('MQTT-Server');
+
+            await new Promise((resolve, reject) => {
+                this.mqttServer.listen(
+                    this.adapter.config.mqttServerPort,
+                    this.adapter.config.mqttServerIPBind,
+                    () => {
+                        this.adapter.log.info(
+                            `Starting MQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`
+                        );
+                        resolve();
+                    }
                 );
+                this.mqttServer.once('error', reject);
             });
         } catch (err) {
-            this.adapter.log.error(err);
+            this.adapter.log.error(`createMQTTServer error: ${err && err.message ? err.message : String(err)}`);
+            // Sicherstellen dass kein halboffener Server übrig bleibt
+            this.closeServer();
         }
     }
 
     /**
-     *
+     * Startet einen Dummy-MQTT-Server ohne Persistenz (für WS-Modus).
      */
     async createDummyMQTTServer() {
+        if (!this._checkConfig()) {
+            return;
+        }
         try {
-            const aedes = Aedes();
-            mqttServer = net.createServer(aedes.handle);
-            mqttServer.listen(this.adapter.config.mqttServerPort, this.adapter.config.mqttServerIPBind, () => {
-                this.adapter.log.info(
-                    `Starting DummyMQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`
+            this.aedesBroker = await Aedes.createBroker();
+            this.mqttServer  = net.createServer(this.aedesBroker.handle);
+            this._attachServerEvents('DummyMQTT-Server');
+
+            await new Promise((resolve, reject) => {
+                this.mqttServer.listen(
+                    this.adapter.config.mqttServerPort,
+                    this.adapter.config.mqttServerIPBind,
+                    () => {
+                        this.adapter.log.info(
+                            `Starting DummyMQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`
+                        );
+                        resolve();
+                    }
                 );
+                this.mqttServer.once('error', reject);
             });
         } catch (err) {
-            this.adapter.log.error(err);
+            this.adapter.log.error(`createDummyMQTTServer error: ${err && err.message ? err.message : String(err)}`);
+            this.closeServer();
         }
     }
 
     /**
-     *
+     * Schließt den MQTT-Server und den Aedes-Broker.
      */
     closeServer() {
-        if (mqttServer && !mqttServer.close()) {
-            mqttServer.close();
+        if (this.mqttServer) {
+            const server = this.mqttServer;
+            this.mqttServer = null;
+            try {
+                server.close((err) => {
+                    if (err) {
+                        this.adapter.log.debug(`MQTT server close callback error: ${err.message}`);
+                    }
+                });
+            } catch (err) {
+                this.adapter.log.error(`closeServer mqttServer.close() error: ${err}`);
+            }
+        }
+        if (this.aedesBroker) {
+            const broker = this.aedesBroker;
+            this.aedesBroker = null;
+            try {
+                broker.close((err) => {
+                    if (err) {
+                        this.adapter.log.debug(`Aedes broker close callback error: ${err}`);
+                    } else {
+                        this.adapter.log.debug('Aedes broker closed.');
+                    }
+                });
+            } catch (err) {
+                this.adapter.log.error(`closeServer aedesBroker.close() error: ${err}`);
+            }
         }
     }
 }

package/lib/states.js

@@ -3,9 +3,7 @@
 
 /*eslint no-unused-vars: ['off']*/
 
-const rgb = require('./rgb.js');
 const utils = require('./utils.js');
-const colors = require('./colors.js');
 
 /* states for device:
    id - sysname of state, id
@@ -58,8 +56,6 @@ const unitLookup = {
     illuminance_lux: 'lx',
 };
 
-const timers = {};
-
 const states = {
     link_quality: {
         id: 'link_quality',
@@ -98,7 +94,18 @@ const states = {
         type: 'string',
         def: '',
         getter: (payload) => {
-            return payload.last_seen.replace('T', ' ').split('+')[0];
+            const val = payload.last_seen;
+            if (val == null) {
+                return undefined;
+            }
+            // Z2M kann last_seen als Unix-Timestamp (number in ms) ODER als ISO-String senden
+            if (typeof val === 'number') {
+                return new Date(val).toISOString().replace('T', ' ').split('.')[0];
+            }
+            if (typeof val === 'string') {
+                return val.replace('T', ' ').split('+')[0].split('.')[0];
+            }
+            return String(val);
         },
     },
 

package/lib/statesController.js

@@ -1,6 +1,4 @@
 const utils = require('./utils');
-const incStatsQueue = [];
-const timeOutCache = {};
 
 /**
  *
@@ -20,27 +18,37 @@ class StatesController {
         this.deviceCache = deviceCache;
         this.logCustomizations = logCustomizations;
         this.createCache = createCache;
+        this.incStatsQueue = [];
+        this.timeOutCache = {};
     }
 
     /**
      *
      * @param messageObj
      */
-    processDeviceMessage(messageObj) {
-        // Is payload present?
-        if (messageObj.payload == '' || messageObj.payload == undefined || messageObj.payload == null) {
+    async processDeviceMessage(messageObj) {
+        if (!messageObj || typeof messageObj !== 'object') {
+            return;
+        }
+        if (messageObj.payload === '' || messageObj.payload === undefined || messageObj.payload === null) {
             return;
         }
 
-        const device = this.groupCache.concat(this.deviceCache).find((x) => x.id == messageObj.topic);
+        const device = this.groupCache.concat(this.deviceCache).find((x) => x.id === messageObj.topic);
         if (device) {
             try {
-                this.setDeviceStateSafely(messageObj, device);
+                await this.setDeviceStateSafely(messageObj, device);
             } catch (error) {
-                this.adapter.log.error(error);
+                this.adapter.log.error(`setDeviceStateSafely error for ${messageObj.topic}: ${error}`);
             }
         } else {
-            incStatsQueue[incStatsQueue.length] = messageObj;
+            if (!this.incStatsQueue.some((x) => x && x.topic === messageObj.topic)) {
+                if (this.incStatsQueue.length < 500) {
+                    this.incStatsQueue.push(messageObj);
+                } else {
+                    this.adapter.log.warn(`incStatsQueue is full (500), dropping message for ${messageObj.topic}`);
+                }
+            }
             this.adapter.log.debug(`Device: ${messageObj.topic} not found, queue state in incStatsQueue!`);
         }
     }
@@ -56,6 +64,17 @@ class StatesController {
         }
 
         const actionStates = [];
+        // Fix 1: Flag damit messageObj nur EINMAL in die Queue kommt, egal wie viele
+        //         States noch nicht im createCache sind (verhindert N-faches Requeue)
+        let queuedThisRound = false;
+
+        const pushToQueue = (msg) => {
+            if (!queuedThisRound && this.incStatsQueue.length < 500
+                && !this.incStatsQueue.some((x) => x && x.topic === msg.topic)) {
+                this.incStatsQueue.push(msg);
+                queuedThisRound = true;
+            }
+        };
 
         for (let [key, value] of Object.entries(messageObj.payload)) {
             if (value === undefined || value === null) {
@@ -66,12 +85,12 @@ class StatesController {
                 return state.prop && state.prop === key;
             });
 
-            if (states.length == 0) {
-                states = device.states.filter((x) => x.id == key);
+            if (states.length === 0) {
+                states = device.states.filter((x) => x.id === key);
             }
 
-            if (states.length == 0) {
-                if (key == 'device' || device.ieee_address.includes('group')) {
+            if (states.length === 0) {
+                if (key === 'device' || device.ieee_address.includes('group')) {
                     // do nothing
                 } else {
                     // some devices has addition information in payload
@@ -89,13 +108,13 @@ class StatesController {
                         common: {
                             name: key,
                             role: 'state',
-                            type: value !== null ? typeof value : 'mixed',
+                            type: typeof value,
                             write: false,
                             read: true,
                         },
                         native: {},
                     });
-                    if (typeof value == 'object') {
+                    if (typeof value === 'object') {
                         value = JSON.stringify(value);
                     }
                     this.adapter.setState(`${fullPath}.${key}`, value, true);
@@ -111,26 +130,22 @@ class StatesController {
                     await this.setStateSafelyAsync(`${device.ieee_address}.available`, true);
                 }
 
-                // It may be that the state has not yet been created!
+                // State noch nicht erstellt? → einmal in Queue legen und weiter
                 if (!this.createCache[device.ieee_address]
-				||	!this.createCache[device.ieee_address][state.id]
-				||	!this.createCache[device.ieee_address][state.id].created == true) {
-                    incStatsQueue[incStatsQueue.length] = messageObj;
+                ||  !this.createCache[device.ieee_address][state.id]
+                ||  this.createCache[device.ieee_address][state.id].created !== true) {
+                    pushToQueue(messageObj);
                     continue;
                 }
 
                 try {
                     //  Is an action
-                    if (state.prop && state.prop == 'action') {
+                    if (state.prop && state.prop === 'action') {
                         actionStates.push(state);
                     }
-                    // Is not an action
-                    // check if its a motion sensor (occupancy state) and if configuration is set to update state every time
-                    // if yes, use setStateSafelyAsync instead of setStateChangedSafelyAsync
-                    else if (this.adapter.config.allwaysUpdateOccupancyState === true && state.id === 'occupancy' &&	value === true) {
+                    else if (this.adapter.config.allwaysUpdateOccupancyState === true && state.id === 'occupancy' && value === true) {
                         await this.setStateSafelyAsync(stateName, value);
                     }
-                    // end section for motion sensor update
                     else {
                         if (state.getter) {
                             await this.setStateChangedSafelyAsync(stateName, state.getter(messageObj.payload));
@@ -139,7 +154,8 @@ class StatesController {
                         }
                     }
                 } catch (err) {
-                    incStatsQueue[incStatsQueue.length] = messageObj;
+                    // Fix 2: Größenlimit auch hier
+                    pushToQueue(messageObj);
                     this.adapter.log.debug(`Can not set ${stateName}, queue state in incStatsQueue!`);
                 }
             }
@@ -150,11 +166,10 @@ class StatesController {
 
             try {
                 const getterPayload = state.getter(messageObj.payload);
-                if (getterPayload != undefined) {
-                    if (state.isEvent && state.isEvent == true) {
-                        if (state.type == 'boolean') {
+                if (getterPayload !== undefined) {
+                    if (state.isEvent && state.isEvent === true) {
+                        if (state.type === 'boolean') {
                             await this.setStateWithTimeoutAsync(stateName, getterPayload, 250);
-
                         } else {
                             await this.setStateSafelyAsync(stateName, getterPayload);
                         }
@@ -163,7 +178,8 @@ class StatesController {
                     }
                 }
             } catch (err) {
-                incStatsQueue[incStatsQueue.length] = messageObj;
+                // Fix 2: Größenlimit auch hier
+                pushToQueue(messageObj);
                 this.adapter.log.debug(`Can not set ${stateName}, queue state in incStatsQueue!`);
             }
         }
@@ -205,22 +221,25 @@ class StatesController {
         }
 
         await this.adapter.setStateAsync(stateName, value, true);
-        if (timeOutCache[stateName]) {
-            clearTimeout(timeOutCache[stateName]);
+        if (this.timeOutCache[stateName]) {
+            clearTimeout(this.timeOutCache[stateName]);
         }
-        timeOutCache[stateName] = setTimeout(() => {
-            this.adapter.setStateAsync(stateName, !value, true);
+        this.timeOutCache[stateName] = setTimeout(() => {
+            this.adapter.setStateAsync(stateName, !value, true).catch((err) => {
+                this.adapter.log.debug(`setStateWithTimeout reset error for ${stateName}: ${err}`);
+            });
         }, timeout);
     }
 
     /**
      *
      */
-    processQueue() {
+    async processQueue() {
         const oldIncStatsQueue = [];
-        utils.moveArray(incStatsQueue, oldIncStatsQueue);
+        utils.moveArray(this.incStatsQueue, oldIncStatsQueue);
         while (oldIncStatsQueue.length > 0) {
-            this.processDeviceMessage(oldIncStatsQueue.shift());
+            // seriell abarbeiten – nicht parallel feuern
+            await this.processDeviceMessage(oldIncStatsQueue.shift());
         }
     }
 
@@ -228,10 +247,14 @@ class StatesController {
      *
      */
     async subscribeWritableStates() {
-        await this.adapter.unsubscribeObjectsAsync('*');
+        // Alle bestehenden State-Subscriptions zuerst abmelden
+        this.adapter.unsubscribeStates('*');
         for (const device of this.groupCache.concat(this.deviceCache)) {
+            if (!device || !Array.isArray(device.states)) {
+                continue;
+            }
             for (const state of device.states) {
-                if (state.write == true) {
+                if (state && state.write === true) {
                     this.adapter.subscribeStates(`${device.ieee_address}.${state.id}`);
                 }
             }
@@ -246,7 +269,8 @@ class StatesController {
      */
     async setAllAvailableToFalse() {
         const availableStates = await this.adapter.getStatesAsync('*.available');
-        for (const availableState in availableStates) {
+        // Fix: Object.keys() statt for...in verhindert ungewollte Prototype-Properties
+        for (const availableState of Object.keys(availableStates)) {
             await this.adapter.setStateChangedAsync(availableState, false, true);
         }
     }
@@ -255,9 +279,10 @@ class StatesController {
      *
      */
     async allTimerClear() {
-        for (const timer in timeOutCache) {
-            clearTimeout(timeOutCache[timer]);
+        for (const timer of Object.keys(this.timeOutCache)) {
+            clearTimeout(this.timeOutCache[timer]);
         }
+        this.timeOutCache = {};
     }
 }