iobroker.zigbee2mqtt 3.0.21 → 3.1.5

package/lib/imageController.js

@@ -2,65 +2,85 @@ const axios = require('axios').default;
 const sharp = require('sharp');
 
 /**
- *
+ * Lädt Geräte-Icons von zigbee2mqtt.io herunter, cacht sie im ioBroker-Dateisystem
+ * und skaliert sie auf die konfigurierte Größe.
  */
 class ImageController {
     /**
+     * Erstellt eine neue ImageController-Instanz.
      *
-     * @param adapter
+     * @param {object} adapter Die ioBroker-Adapter-Instanz
      */
     constructor(adapter) {
         this.adapter = adapter;
     }
 
     /**
+     * Bereinigt eine Model-ID für die Verwendung in einer URL (ersetzt '/' durch '_').
      *
-     * @param modelName
+     * @param {string} modelName Die zu bereinigende Model-ID
+     * @returns {string}         Bereinigte Model-ID oder 'NA' wenn leer
      */
     sanitizeModelIDForImageUrl(modelName) {
-        const modelNameString = modelName.replace('/', '_');
+        if (!modelName) { return 'NA'; }
         // eslint-disable-next-line no-control-regex
-        return modelNameString.replace(/\u0000/g, '');
+        return modelName.replace(/\//g, '_').replace(/\u0000/g, '');
     }
 
     /**
+     * Bereinigt einen Z2M-Gerätenamen für die Verwendung in einer URL.
      *
-     * @param deviceName
+     * @param {string} deviceName Der zu bereinigende Gerätename
+     * @returns {string}          Bereinigter Name oder 'NA' wenn leer
      */
     sanitizeZ2MDeviceName(deviceName) {
-        const deviceNameString = deviceName.replace(/:|\s|\//g, '-');
+        if (!deviceName) { return 'NA'; }
         // eslint-disable-next-line no-control-regex
-        return deviceName ? deviceNameString.replace(/\u0000/g, '') : 'NA';
+        return deviceName.replace(/:|\s|\//g, '-').replace(/\u0000/g, '');
     }
 
     /**
+     * Erstellt die zigbee2mqtt.io-Bild-URL für ein Gerät.
      *
-     * @param device
+     * @param {object} device Das Geräteobjekt aus dem Z2M-Payload
+     * @param {string} ext    Dateiendung ('jpg' oder 'png')
+     * @returns {string|undefined} Die Bild-URL oder undefined wenn kein Modell vorhanden
      */
-    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;
+    }
+
+    /**
+     * Gibt die JPG-Bild-URL des Geräts auf zigbee2mqtt.io zurück.
+     *
+     * @param {object} device Das Geräteobjekt
+     * @returns {string|undefined} Die JPG-URL oder undefined
+     */
+    getZ2mDeviceImageModelJPG(device) {
+        return this._buildZ2mImageUrl(device, 'jpg');
     }
 
     /**
+     * Gibt die PNG-Bild-URL des Geräts auf zigbee2mqtt.io zurück.
      *
-     * @param device
+     * @param {object} device Das Geräteobjekt
+     * @returns {string|undefined} Die PNG-URL oder undefined
      */
     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');
     }
 
 
     /**
+     * Gibt die SLS-Bild-URL des Geräts (alternative Quelle) zurück.
      *
-     * @param device
+     * @param {object} device Das Geräteobjekt mit model_id-Feld
+     * @returns {string|undefined} Die Bild-URL oder undefined
      */
     getSlsDeviceImage(device) {
         if (device && device.model_id) {
@@ -68,22 +88,29 @@ class ImageController {
             // eslint-disable-next-line no-control-regex
             return icoString.replace(/\u0000/g, '');
         }
+        return undefined;
     }
 
     /**
+     * Lädt das Icon eines Geräts herunter (falls noch nicht gecacht), skaliert es
+     * auf die konfigurierte Größe und gibt es als Base64-Data-URL zurück.
      *
-     * @param device
+     * @param {object} device Das Geräteobjekt aus dem Z2M-bridge/devices-Payload
+     * @returns {Promise<string>} Base64-kodiertes Icon als Data-URL oder ''
      */
     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 +120,7 @@ return '';
                 this.getZ2mDeviceImageModelJPG(device),
                 this.getZ2mDeviceImageModelPNG(device),
                 this.getSlsDeviceImage(device)
-            ];
+            ].filter(Boolean);
 
             for (const iconUrl of iconUrls) {
                 try {
@@ -103,47 +130,48 @@ return '';
                         break;
                     }
                 } catch (ex) {
-                    //  check next pic
+                    this.adapter.log.debug(`Icon download failed for ${iconUrl}: ${ex && ex.message ? ex.message : ex}`);
                 }
             }
         }
 
-        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);
-            }
+        }
 
-            // Create and output Base64
-            return `data:image/png;base64,${icon.file.toString('base64')}`;
-        
+        const icon = await this.adapter.readFileAsync(this.adapter.namespace, iconFileName);
+        if (!icon || !icon.file) {
+            this.adapter.log.warn(`Failed to read icon file: ${iconFileName}`);
+            return '';
+        }
+        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);
+        }
+
+        return `data:image/png;base64,${icon.file.toString('base64')}`;
     }
+
     /**
+     * Extrahiert den Dateinamen (mit Erweiterung) aus einer URL.
      *
-     * @param url
+     * @param {string} url Die vollständige URL
+     * @returns {string}   Dateiname (z.B. "TRADFRI_bulb.jpg")
      */
     getFileNameWithExtension(url) {
         const path = new URL(url).pathname;
@@ -153,26 +181,30 @@ return '';
     }
 
     /**
+     * Lädt ein Icon von der angegebenen URL herunter und speichert es im ioBroker-Dateisystem.
      *
-     * @param adapter
-     * @param url
-     * @param namespace
+     * @param {object} adapter   Die ioBroker-Adapter-Instanz
+     * @param {string} url       Download-URL des Icons
+     * @param {string} namespace ioBroker-Namespace (z.B. "zigbee2mqtt.0")
+     * @returns {Promise<boolean>} true bei Erfolg, false bei Fehler
      */
     async downloadIcon(adapter, url, namespace) {
         try {
-            const res = await axios.get(url, { responseType: 'arraybuffer' });
+            const res = await axios.get(url, { responseType: 'arraybuffer', timeout: 10000 });
             await adapter.writeFileAsync(namespace, this.getFileNameWithExtension(url), res.data);
             return true;
         } catch (ex) {
-            //adapter.log.warn(ex);
             return false;
         }
     }
+
     /**
+     * Prüft welcher lokale Icon-Dateiname bereits im ioBroker-Dateisystem existiert.
      *
-     * @param z2mIconFileNameJPG
-     * @param z2mIconFileNamePNG
-     * @param slsIconFileName
+     * @param {string} z2mIconFileNameJPG JPG-Dateiname (Z2M-Format)
+     * @param {string} z2mIconFileNamePNG PNG-Dateiname (Z2M-Format)
+     * @param {string} slsIconFileName    PNG-Dateiname (SLS-Format)
+     * @returns {Promise<string|null>}    Erster gefundener Dateiname oder null
      */
     async getExistingIconFileName(z2mIconFileNameJPG, z2mIconFileNamePNG, slsIconFileName) {
         if (await this.adapter.fileExistsAsync(this.adapter.namespace, z2mIconFileNameJPG)) {

package/lib/messages.js

@@ -1,31 +1,35 @@
 /**
+ * Gibt die aktuelle Adapter-Konfiguration formatiert als Log-Block aus.
  *
- * @param config
- * @param log
+ * @param {object} config Die Adapter-Konfiguration (this.config)
+ * @param {object} log    Das ioBroker-Log-Objekt (this.log)
  */
-async function adapterInfo(config, log) {
+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}`);
     log.info(`|| Zigbee2MQTT Frontend Port: ${config.webUIPort}`);
     log.info(`|| Zigbee2MQTT Connection Type: ${config.connectionType}`);
-    if (config.connectionType == 'ws') {
+    if (config.connectionType === 'ws') {
         log.info(`|| Zigbee2MQTT Websocket Scheme: ${config.wsScheme}`);
         log.info(`|| Zigbee2MQTT Websocket Server: ${config.wsServerIP}`);
         log.info(`|| Zigbee2MQTT Websocket Port: ${config.wsServerPort}`);
         log.info(`|| Zigbee2MQTT Websocket Auth-Token: ${config.wsTokenEnabled ? 'use' : 'unused'}`);
         log.info(`|| Zigbee2MQTT Websocket Dummy MQTT-Server: ${config.dummyMqtt ? 'activated' : 'deactivated'}`);
-        if (config.dummyMqtt == true) {
+        if (config.dummyMqtt === true) {
             log.info(`|| Zigbee2MQTT Dummy MQTT IP-Bind: ${config.mqttServerIPBind}`);
             log.info(`|| Zigbee2MQTT Dummy MQTT Port: ${config.mqttServerPort}`);
         }
-    } else if (config.connectionType == 'exmqtt') {
-        log.info(`|| Zigbee2MQTT Externanl MQTT Server: ${config.externalMqttServerIP}`);
-        log.info(`|| Zigbee2MQTT Externanl MQTT Port: ${config.externalMqttServerPort}`);
+    } else if (config.connectionType === 'exmqtt') {
+        log.info(`|| Zigbee2MQTT External MQTT Server: ${config.externalMqttServerIP}`);
+        log.info(`|| Zigbee2MQTT External MQTT Port: ${config.externalMqttServerPort}`);
         log.info(
-            `|| Zigbee2MQTT Externanl MQTT Credentials: ${config.externalMqttServerCredentials ? 'use' : 'unused'}`
+            `|| Zigbee2MQTT External MQTT Credentials: ${config.externalMqttServerCredentials ? 'use' : 'unused'}`
         );
-    } else if (config.connectionType == 'intmqtt') {
+    } else if (config.connectionType === 'intmqtt') {
         log.info(`|| Zigbee2MQTT Internal MQTT IP-Bind: ${config.mqttServerIPBind}`);
         log.info(`|| Zigbee2MQTT Internal MQTT Port: ${config.mqttServerPort}`);
     }
@@ -47,19 +51,25 @@ async function adapterInfo(config, log) {
 }
 
 /**
+ * Gibt die Zigbee2MQTT-Bridge-Informationen formatiert als Log-Block aus.
  *
- * @param payload
- * @param log
+ * @param {object} payload Der Payload des bridge/info-Topics
+ * @param {object} log     Das ioBroker-Log-Objekt (this.log)
  */
-async function zigbee2mqttInfo(payload, log) {
+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,162 @@
+'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');
 
 /**
- *
+ * Verwaltet den internen oder Dummy-MQTT-Server (Aedes) für den Zigbee2MQTT-Adapter.
+ * Wird im intmqtt- und ws-Modus (dummyMqtt) verwendet.
  */
 class MqttServerController {
     /**
+     * Erstellt eine neue MqttServerController-Instanz.
      *
-     * @param adapter
+     * @param {object} adapter Die ioBroker-Adapter-Instanz
      */
     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} true wenn die Konfiguration vollständig ist, sonst false
+     */
+    _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-Event-Handler an den internen net.Server.
      *
+     * @param {string} label Bezeichnung des Servers für Log-Ausgaben (z.B. "MQTT-Server")
+     */
+    _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 nedb-Persistenz (aedes + aedes-persistence-nedb).
+     * Wartet auf den erfolgreichen listen()-Aufruf bevor die Methode zurückkehrt.
      */
     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.
+     * Wird im WebSocket-Modus (dummyMqtt=true) benötigt damit Z2M einen MQTT-Broker findet.
      */
     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 sicher.
+     * Wird beim Adapter-Stop oder nach einem Fehler beim Start aufgerufen.
      */
     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/nonGenericDevicesExtension.js

@@ -40,9 +40,8 @@ function getStateDefinition(model) {
     const stateDef = nonGenDevStatesDefs[model];
     if (stateDef) {
         return stateDef;
-    } 
-        return [];
-    
+    }
+    return [];
 }
 
 module.exports = {