iobroker.zwavews 0.1.5 → 0.2.0

package/README.md

@@ -17,6 +17,13 @@
 
 The `zwavews` adapter connects a [`zwave-js-ui`](https://zwave-js.github.io/zwave-js-ui/#/) to ioBroker and creates corresponding data points for devices, values, and statuses. This allows Z-Wave devices to be conveniently used in visualizations, logic, and automations.
 
+### Features
+* **Real-time communication**: Instantly receives updates of device values and statuses via WebSocket or MQTT.
+* **Auto-Discovery**: Automatically creates and updates the device and state structure in ioBroker from the `zwave-js-ui` nodes.
+* **Device Management**: View battery levels, connection status, and detailed device metrics right from the ioBroker interface.
+* **Firmware Updates**: Observe firmware update progress directly via the adapter's logs and states.
+* **State Control**: Send commands and update values natively through the ioBroker object tree.
+* **Support for multiple protocols**: You can connect to `zwave-js-ui` using WebSocket, External MQTT, or an Internal Dummy MQTT server.
 
 ## Adapter Documentation
 
@@ -35,6 +42,12 @@ Activate WS Server Settings in `zwave-js-ui` we use the Home Assistant Settings
 
 
 ## Changelog
+### 0.2.0 (2026-04-26)
+* (arteck) del deprectated setStateAsync
+
+### 0.1.6 (2026-04-23)
+* (arteck) add test
+
 ### 0.1.5 (2026-04-21)
 * (arteck) upd devicemanager
 

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "zwavews",
-    "version": "0.1.5",
+    "version": "0.2.0",
     "news": {
+      "0.2.0": {
+        "en": "del deprectated setStateAsync",
+        "de": "del deprected setStateAsync",
+        "ru": "обсуждение StateAsync",
+        "pt": "del deprectated setStateAsync",
+        "nl": "del deprectated setStateAsync",
+        "fr": "set dépréciéStateAsync",
+        "it": "del set deprettatoStateAsync",
+        "es": "del deprectated setStateAsync",
+        "pl": "del deprectated setStateAsync",
+        "uk": "deprectated setStateAsync",
+        "zh-cn": "已贬值的设置"
+      },
+      "0.1.6": {
+        "en": "add test",
+        "de": "test hinzufügen",
+        "ru": "добавить тест",
+        "pt": "adicionar teste",
+        "nl": "test toevoegen",
+        "fr": "ajouter un essai",
+        "it": "aggiungere test",
+        "es": "agregar la prueba",
+        "pl": "dodać test",
+        "uk": "додати тест",
+        "zh-cn": "添加测试"
+      },
       "0.1.5": {
         "en": "upd devicemanager",
         "de": "gerätemanager und -manager",
@@ -67,32 +93,6 @@
         "pl": "dodaj informacje o debugowaniu",
         "uk": "додати інформацію debug",
         "zh-cn": "添加调试信息"
-      },
-      "0.1.0": {
-        "en": "BREAKING CHANGE - dp name is now with underline\nadd deviceManager\nfix dp's with a space\nfix dp's with special chars",
-        "de": "BREAKING CHANGE - dp name ist jetzt mit unterstreichen\nadd-Gerät Manager\ndp's mit einem raum reparieren\nfix dp's with special chars",
-        "ru": "BREAKING CHANGE - название dp теперь с подчеркиванием\nдобавить устройство Менеджер\nустановить dp в пространстве\nобсуждение dp's with special chars",
-        "pt": "MUDANÇA DE INÍCIO - nome dp está agora com sublinhado\nadicionar dispositivo Gestor\ncorrigir dp's com um espaço\ncorrigir dp's com caracteres especiais",
-        "nl": "BREAKING VERANDERING - dp naam is nu met benadrukken\napparaat toevoegen Beheerder\nfix dp's met een spatie\nfix dp's met speciale tekens",
-        "fr": "CHANGEMENT DE BREAKING - DP nom est maintenant avec le soulignement\najouter un périphérique Gestionnaire\nréparer dp's avec un espace\nfixer dp's avec des caractères spéciaux",
-        "it": "BREAKING CHANGE - il nome dp è ora in linea\naggiungere dispositivo Manager\nfix dp's con uno spazio\nsistemare dp's con beneficenza speciali",
-        "es": "CAMBIO DE BREAKING - nombre dp ahora es con subrayado\nañadir dispositivo Manager\narreglar dp con un espacio\narreglar dp con chars especiales",
-        "pl": "ZMIANA BREAKING - nazwa dp jest teraz z podkreśleniem\ndodaj urządzenie Kierownik\nfix dp 's z przestrzenią\nfix dp 's ze specjalnymi znakami",
-        "uk": "BREAKING CHANGE - ім'я dp тепер з онлайн\nдодати пристрій Менеджер\nзакріпити dp's з космосом\nфіксувати dp з особливими chars",
-        "zh-cn": "断裂变换 - dp 名称现在是下划线\n添加设备 经理\n修补 dp 的空格\n修复 dp 与特殊字符"
-      },
-      "0.0.18": {
-        "en": "add info.sendMessageAllowed object to allow sending the message to zwave-ui-js\nadd new checkbox to set info.sendMessageAllowed immediately after starting the adapter",
-        "de": "add info.sendMessageAllowed object to let send the message to zwave-ui-js\nneue Checkbox hinzufügen, um info.sendMessage einzustellen Sofort nach dem Start des Adapters zugelassen",
-        "ru": "добавить info.sendMessageРазрешенный объект для отправки сообщения на zwave-ui-js\nдобавить новый флажок для установки info.sendMessage Допускается сразу после запуска адаптера",
-        "pt": "add info.sendMessagePermitido objeto para permitir o envio da mensagem para zwave-ui-js\nadicionar nova caixa de seleção para definir info.sendMessage Permitido imediatamente após iniciar o adaptador",
-        "nl": "info.sendMessageToegewezen object om het bericht naar zwave-ui-js te versturen\nnieuwe selectievakje toevoegen om info.sendMessage in te stellen Onmiddellijk na het starten van de adapter toegestaan",
-        "fr": "ajouter info.sendMessageObjet autorisé pour permettre l'envoi du message à zwave-ui-js\najouter une nouvelle case à cocher pour définir info.sendMessage Autorisé immédiatement après le démarrage de l'adaptateur",
-        "it": "aggiungere info.sendMessageAllowed oggetto per consentire l'invio del messaggio a zwave-ui-js\naggiungere nuova casella di controllo per impostare info.sendMessage Consentito subito dopo l'avvio dell'adattatore",
-        "es": "añadir info.sendMessagePropósito permitido enviar el mensaje a zwave-ui-js\nañadir nueva casilla para configurar información.sendMessage Permitido inmediatamente después de iniciar el adaptador",
-        "pl": "dodaj info.sendMessageDopuszczalny obiekt, aby umożliwić wysyłanie wiadomości do zwave- ui- js\ndodaj nową opcję do ustawienia info.sendMessage Dozwolone bezpośrednio po uruchomieniu adaptera",
-        "uk": "додайте інформацію.sendMessageВсього об'єкту, щоб дозволити надсилати повідомлення на zwave-ui-js\nдодати нову прапорець, щоб встановити інформацію.sendMessage Допускається відразу після запуску адаптера",
-        "zh-cn": "添加信息. sendMessage Allowed 对象允许将消息发送到 zwave- ui- js\n添加新复选框以设置信息. sendMessage 启动适配器后立即允许"
       }
     },
     "titleLang": {

package/lib/helper.js

@@ -316,8 +316,8 @@ return "boolean";
 
       if (isObj) {
         if (Object.keys(valDP).length > 0) {
-          options.write = false;
-          await this.parse(fullPath, valDP, options);
+          // FIX: options-Objekt nicht mutieren – Spread-Kopie verwenden
+          await this.parse(fullPath, valDP, { ...options, write: false });
         }
         continue;
       }
@@ -612,7 +612,7 @@ return;
    */
   async changeState(path, value, change = false) {
     if (change) {
-      await this.adapter.setStateAsync(path, value, true);
+      this.adapter.setState(path, value, true);
     } else {
       await this.adapter.setStateChangedAsync(path, value, true);
     }

package/lib/mqttServerController.js

@@ -33,7 +33,7 @@ class MqttServerController {
         this.adapter.config.mqttServerIPBind,
         () => {
           this.adapter.log.info(
-            `Statring MQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`,
+            `Starting MQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`,
           );
         },
       );
@@ -54,7 +54,7 @@ class MqttServerController {
         this.adapter.config.mqttServerIPBind,
         () => {
           this.adapter.log.info(
-            `Statring DummyMQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`,
+            `Starting DummyMQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`,
           );
         },
       );

package/lib/statesController.js

@@ -21,7 +21,7 @@ class StatesController {
     if (value === undefined || value === null) {
       return;
     }
-    await this.adapter.setStateAsync(stateName, value, true);
+    this.adapter.setState(stateName, value, true);
   }
 
   /**

package/lib/websocketController.js

@@ -1,10 +1,9 @@
+'use strict';
+
 const WebSocket = require('ws');
-let wsClient;
-const wsHeartbeatIntervall = 5000;
-const restartTimeout = 1000;
-let ping;
-let pingTimeout;
-let autoRestartTimeout;
+
+const WS_HEARTBEAT_INTERVAL = 5000;
+const WS_RESTART_TIMEOUT = 1000;
 
 /**
  * Manages the WebSocket connection to the zwave-js-ui server.
@@ -17,12 +16,18 @@ class WebsocketController {
      */
     constructor(adapter) {
         this.adapter = adapter;
+
+        // FIX: Instanz-Properties statt Modul-globaler Variablen
+        this.wsClient = null;
+        this.ping = null;
+        this.pingTimeout = null;
+        this.autoRestartTimeout = null;
     }
 
     /**
      * Initialises and connects the WebSocket client to the zwave-js-ui server.
      *
-     * @returns {WebSocket} The created WebSocket client instance.
+     * @returns {WebSocket|null} The created WebSocket client instance, or null on error.
      */
     initWsClient() {
         try {
@@ -32,37 +37,35 @@ class WebsocketController {
                 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.sendPingToServer();
-                // Start Heartbeat
                 this.wsHeartbeat();
             });
 
-            wsClient.on('pong', () => {
+            this.wsClient.on('pong', () => {
                 this.wsHeartbeat();
             });
 
-            wsClient.on('close', async () => {
-                clearTimeout(pingTimeout);
-                clearTimeout(ping);
+            this.wsClient.on('close', () => {
+                clearTimeout(this.pingTimeout);
+                clearTimeout(this.ping);
 
-                if (wsClient.readyState === WebSocket.CLOSED) {
+                if (this.wsClient.readyState === WebSocket.CLOSED) {
                     this.autoRestart();
                 }
             });
 
-            wsClient.on('message', () => {});
-
-            wsClient.on('error', (err) => {
-                this.adapter.log.debug(err);
+            this.wsClient.on('error', (err) => {
+                // FIX: err.message statt komplettes Objekt loggen
+                this.adapter.log.warn(`<zwavews> WebSocket error: ${err.message}`);
             });
 
-            return wsClient;
+            return this.wsClient;
         } catch (err) {
-            this.adapter.log.error(err);
+            this.adapter.log.error(`<zwavews> initWsClient failed: ${err.message}`);
+            return null;
         }
     }
 
@@ -72,51 +75,56 @@ class WebsocketController {
      * @param {string} message - The message payload to send.
      */
     send(message) {
-        if (wsClient.readyState !== WebSocket.OPEN) {
-            this.adapter.log.warn('Cannot set State, no websocket connection to zwave-js-ui');
+        // FIX: Null-Check für wsClient
+        if (!this.wsClient || this.wsClient.readyState !== WebSocket.OPEN) {
+            this.adapter.log.warn('<zwavews> Cannot send message, no open websocket connection to zwave-js-ui.');
             return;
         }
-        wsClient.send(message);
+        this.wsClient.send(message);
     }
 
     /**
      * Sends a WebSocket ping to the server and schedules the next ping.
      */
     sendPingToServer() {
-        //this.logDebug('Send ping to server');
-        wsClient.ping();
-        ping = setTimeout(() => {
+        if (!this.wsClient || this.wsClient.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        this.wsClient.ping();
+        this.ping = setTimeout(() => {
             this.sendPingToServer();
-        }, wsHeartbeatIntervall);
+        }, WS_HEARTBEAT_INTERVAL);
     }
 
     /**
      * Resets the heartbeat timeout; terminates the connection if no pong is received in time.
      */
     wsHeartbeat() {
-        clearTimeout(pingTimeout);
-        pingTimeout = setTimeout(() => {
-            this.adapter.log.warn('Websocked connection timed out');
-            wsClient.terminate();
-        }, wsHeartbeatIntervall + 3000);
+        clearTimeout(this.pingTimeout);
+        this.pingTimeout = setTimeout(() => {
+            this.adapter.log.warn('<zwavews> WebSocket connection timed out, terminating.');
+            if (this.wsClient) {
+                this.wsClient.terminate();
+            }
+        }, WS_HEARTBEAT_INTERVAL + 3000);
     }
 
     /**
      * Schedules an automatic reconnect attempt after the configured restart timeout.
      */
     autoRestart() {
-        this.adapter.log.warn(`Start try again in ${restartTimeout / 1000} seconds...`);
-        autoRestartTimeout = setTimeout(() => {
+        this.adapter.log.warn(`<zwavews> WebSocket closed, reconnecting in ${WS_RESTART_TIMEOUT / 1000}s...`);
+        this.autoRestartTimeout = setTimeout(() => {
             this.adapter.startWebsocket();
-        }, restartTimeout);
+        }, WS_RESTART_TIMEOUT);
     }
 
     /**
      * Closes the WebSocket connection if it is currently open.
      */
     closeConnection() {
-        if (wsClient && wsClient.readyState !== WebSocket.CLOSED) {
-            wsClient.close();
+        if (this.wsClient && this.wsClient.readyState !== WebSocket.CLOSED) {
+            this.wsClient.close();
         }
     }
 
@@ -124,9 +132,9 @@ class WebsocketController {
      * Clears all active timers (ping, pingTimeout, autoRestartTimeout).
      */
     allTimerClear() {
-        clearTimeout(pingTimeout);
-        clearTimeout(ping);
-        clearTimeout(autoRestartTimeout);
+        clearTimeout(this.pingTimeout);
+        clearTimeout(this.ping);
+        clearTimeout(this.autoRestartTimeout);
     }
 }
 

package/main.js

@@ -1,509 +1,492 @@
 'use strict';
 
-const core = require("@iobroker/adapter-core");
-const mqtt = require("mqtt");
-const utils = require("./lib/utils");
-const constant = require("./lib/constants");
-const dmZwave  = require('./lib/devicemgmt.js');
-
-const adapterInfo = require("./lib/messages").adapterInfo;
-const StatesController = require("./lib/statesController").StatesController;
-const WebsocketController = require('./lib/websocketController').WebsocketController;
-const Helper = require("./lib/helper").Helper;
-
-const MqttServerController = require("./lib/mqttServerController").MqttServerController;
-
-let mqttClient;
-let deviceCache = {};
-let websocketController;
-let mqttServerController;
-let statesController;
-let helper;
-let messageParseMutex = Promise.resolve();
-let options = {};
-let startListening = false;
-let allNodesCreated = false;
-
-let driver;
-let controller;
-let allNodes;
-let eventTyp;
-
+const core = require('@iobroker/adapter-core');
+const mqtt = require('mqtt');
+const utils = require('./lib/utils');
+const constant = require('./lib/constants');
+const dmZwave = require('./lib/devicemgmt.js');
+
+const { adapterInfo } = require('./lib/messages');
+const { StatesController } = require('./lib/statesController');
+const { WebsocketController } = require('./lib/websocketController');
+const { Helper } = require('./lib/helper');
+const { MqttServerController } = require('./lib/mqttServerController');
 
 class zwavews extends core.Adapter {
-  constructor(options) {
-    super({
-      ...options,
-      name: "zwavews",
-    });
-    this.on("ready", this.onReady.bind(this));
-    this.on("stateChange", this.onStateChange.bind(this));
-    this.on("unload", this.onUnload.bind(this));
-  }
+    constructor(options) {
+        super({
+            ...options,
+            name: 'zwavews',
+        });
 
-  async onReady() {
-    statesController = new StatesController(this);
+        // Instanz-State statt Modul-globale Variablen
+        this.mqttClient = null;
+        this.deviceCache = {};
+        this.websocketController = null;
+        this.mqttServerController = null;
+        this.statesController = null;
+        this.helper = null;
+        this.messageParseMutex = Promise.resolve();
+        this.parseOptions = {};
+        this.startListening = false;
+        this.allNodesCreated = false;
+        this.nodeCache = {};
+
+        this.on('ready', this.onReady.bind(this));
+        this.on('stateChange', this.onStateChange.bind(this));
+        this.on('unload', this.onUnload.bind(this));
+    }
 
-    // Initialize your adapter here
-    adapterInfo(this.config, this.log);
+    async onReady() {
+        this.statesController = new StatesController(this);
 
-    this.setStateChanged("info.connection", false, true);
-    await statesController.setAllAvailableToFalse();
+        adapterInfo(this.config, this.log);
 
-    helper = new Helper(this, deviceCache);
+        this.setStateChanged('info.connection', false, true);
+        await this.statesController.setAllAvailableToFalse();
 
-    this.deviceManagement = new dmZwave(this);
+        this.helper = new Helper(this, this.deviceCache);
+        this.deviceManagement = new dmZwave(this);
 
-    if (this.config.wsOnStart) {
-        this.setStateChanged("info.sendMessageAllowed", true, true);
-    }
+        if (this.config.wsOnStart) {
+            this.setStateChanged('info.sendMessageAllowed', true, true);
+        }
 
-    this.nodeCache = {};
-    this.setStateChanged("info.debugmessages", "", true);
+        this.setStateChanged('info.debugmessages', '', true);
 
+        // MQTT-Verbindungstypen
+        if (['exmqtt', 'intmqtt'].includes(this.config.connectionType)) {
+            if (this.config.connectionType === 'exmqtt') {
+                if (!this.config.externalMqttServerIP) {
+                    this.log.warn('Please configure the External MQTT-Server connection!');
+                    return;
+                }
 
-    // MQTT
-    if (["exmqtt", "intmqtt"].includes(this.config.connectionType)) {
-      // External MQTT-Server
-      if (this.config.connectionType === "exmqtt") {
-        if (this.config.externalMqttServerIP === "") {
-          this.log.warn(
-            "Please configure the External MQTT-Server connection!",
-          );
-          return;
-        }
+                const mqttClientOptions = {
+                    clientId: `ioBroker.zwavews_${Math.random().toString(16).slice(2, 8)}`,
+                    clean: false,
+                    protocolVersion: 4,
+                    reconnectPeriod: 5000,
+                    connectTimeout: 30000,
+                    keepalive: 30,
+                    resubscribe: true,
+                };
+
+                if (this.config.externalMqttServerCredentials === true) {
+                    mqttClientOptions.username = this.config.externalMqttServerUsername;
+                    mqttClientOptions.password = this.config.externalMqttServerPassword;
+                }
 
-        // MQTT connection settings
-        const mqttClientOptions = {
-          clientId: `ioBroker.zwavews_${Math.random().toString(16).slice(2, 8)}`,
-          clean: false,
-          protocolVersion: 4,
-          reconnectPeriod: 5000,
-          connectTimeout: 30000,  // 30s
-          keepalive: 30,
-          resubscribe: true,
-        };
-
-        // Set external mqtt credentials
-        if (this.config.externalMqttServerCredentials === true) {
-          mqttClientOptions.username = this.config.externalMqttServerUsername;
-          mqttClientOptions.password = this.config.externalMqttServerPassword;
-        }
+                this.mqttClient = mqtt.connect(
+                    `mqtt://${this.config.externalMqttServerIP}:${this.config.externalMqttServerPort}`,
+                    mqttClientOptions,
+                );
+            } else {
+                // Interner MQTT-Server
+                this.mqttServerController = new MqttServerController(this);
+                await this.mqttServerController.createMQTTServer();
+                await this.delay(1500);
+                this.mqttClient = mqtt.connect(
+                    `mqtt://${this.config.mqttServerIPBind}:${this.config.mqttServerPort}`,
+                    {
+                        clientId: `ioBroker.zwavews_${Math.random().toString(16).slice(2, 8)}`,
+                        clean: true,
+                        reconnectPeriod: 500,
+                    },
+                );
+            }
 
-        // Init connection
-        mqttClient = mqtt.connect(
-          `mqtt://${this.config.externalMqttServerIP}:${this.config.externalMqttServerPort}`,
-          mqttClientOptions,
-        );
-      } else {
-        // Internal MQTT-Server
-        mqttServerController = new MqttServerController(this);
-        await mqttServerController.createMQTTServer();
-        await this.delay(1500);
-        mqttClient = mqtt.connect(
-          `mqtt://${this.config.mqttServerIPBind}:${this.config.mqttServerPort}`,
-          {
-            clientId: `ioBroker.zwavews_${Math.random().toString(16).slice(2, 8)}`,
-            clean: true,
-            reconnectPeriod: 500,
-          },
-        );
-      }
-
-      // MQTT Client
-      mqttClient.on("connect", () => {
-        this.log.info(`Connect to zwavews over ${this.config.connectionType === "exmqtt" ? "external mqtt" : "internal mqtt"} connection.`);
-        this.setStateChanged("info.connection", true, true);
-      });
-
-      mqttClient.subscribe(`${this.config.baseTopic}/#`, (err) => {
-        if (err) {
-this.log.error(`<zwavews> MQTT subscribe error: ${err.message}`);
-}
-      });
+            // FIX: subscribe innerhalb des connect-Events, nicht außerhalb
+            this.mqttClient.on('connect', () => {
+                const connType = this.config.connectionType === 'exmqtt' ? 'external mqtt' : 'internal mqtt';
+                this.log.info(`Connect to zwavews over ${connType} connection.`);
+                this.setStateChanged('info.connection', true, true);
 
-      mqttClient.on("message", (topic, payload) => {
-        const rawPayload = payload.toString();
-        let parsedPayload;
-        try {
-          parsedPayload = rawPayload === "" ? null : JSON.parse(rawPayload);
-        } catch {
-          parsedPayload = rawPayload;
-        }
-        const newMessage = JSON.stringify({
-          payload: parsedPayload,
-          topic: topic.slice(topic.indexOf("/") + 1),
-        });
-        this.messageParse(newMessage);
-      });
-    } else if (this.config.connectionType === 'ws') {
-    // Websocket
-            if (this.config.wsServerIP === '') {
-                this.log.warn('Please configure the Websoket connection!');
+                this.mqttClient.subscribe(`${this.config.baseTopic}/#`, (err) => {
+                    if (err) {
+                        this.log.error(`<zwavews> MQTT subscribe error: ${err.message}`);
+                    }
+                });
+            });
+
+            this.mqttClient.on('error', (err) => {
+                this.log.error(`<zwavews> MQTT client error: ${err.message}`);
+            });
+
+            this.mqttClient.on('offline', () => {
+                this.log.warn('<zwavews> MQTT client offline.');
+                this.setStateChanged('info.connection', false, true);
+            });
+
+            this.mqttClient.on('message', (topic, payload) => {
+                const rawPayload = payload.toString();
+                let parsedPayload;
+                try {
+                    parsedPayload = rawPayload === '' ? null : JSON.parse(rawPayload);
+                } catch {
+                    parsedPayload = rawPayload;
+                }
+                const newMessage = JSON.stringify({
+                    payload: parsedPayload,
+                    topic: topic.slice(topic.indexOf('/') + 1),
+                });
+                this.messageParse(newMessage);
+            });
+        } else if (this.config.connectionType === 'ws') {
+            if (!this.config.wsServerIP) {
+                this.log.warn('Please configure the Websocket connection!');
                 return;
             }
 
-            // Dummy MQTT-Server
             if (this.config.dummyMqtt === true) {
-                mqttServerController = new MqttServerController(this);
-                await mqttServerController.createDummyMQTTServer();
-                this.setStateChanged("info.connection", true, true);
+                this.mqttServerController = new MqttServerController(this);
+                await this.mqttServerController.createDummyMQTTServer();
+                this.setStateChanged('info.connection', true, true);
                 await this.delay(1500);
             }
 
             this.startWebsocket();
         }
-  }
-  
-  startWebsocket() {
-      websocketController = new WebsocketController(this);
-      const wsClient = websocketController.initWsClient();
-
-      if (!wsClient) {
-          this.log.error('<zwavews> initWsClient returned null — websocket not started.');
-          return;
-      }
-
-      wsClient.on('open', () => {
-          this.log.info('Connect to zwave-js-ui over websocket connection.');
-          startListening = true;
-          websocketController.send(JSON.stringify({command: "start_listening"}));
-      });
-
-      wsClient.on('message', (message) => {
-          this.messageParse(message);
-      });
-
-      wsClient.on('close', async () => {
-          this.setStateChanged('info.connection', false, true);
-          await statesController.setAllAvailableToFalse();
-          startListening = false;
-          allNodesCreated = false;
-          deviceCache = {};
-          this.nodeCache = {};
-          this.log.info('Websocket connection closed. Attempting to reconnect...');
-      });
-  }
-  
-  async messageParse(message) {
-    // Mutex lock: queue up calls to messageParse
-    let release;
-    const lock = new Promise((resolve) => (release = resolve));
-    const prev = messageParseMutex;
-    messageParseMutex = lock;
-    await prev;
-
-    try {
-      const messageObj = JSON.parse(message);
-
-      const debugDevicesState = await this.getStateAsync("info.debugId");
-
-      this.log.debug(`--->>> fromZ2W_RAW1 -> ${JSON.stringify(messageObj)}`);
-
-      const type       = messageObj?.type;
-
-      if (this.config.connectionType === 'ws') {
-        switch (type) {
-            case 'version': {      // say hello
-                this.setStateChanged('info.connection', true, true);
-                this.setStateChanged('info.zwave_gateway_version', messageObj.driverVersion, true);
-                this.setStateChanged('info.zwave_gateway_status', 'online', true);
-                break;
-            }
-            case 'result': {
-                if (messageObj.result?.success === true) {
-                    this.setStateChanged('info.debugmessages', JSON.stringify(messageObj), true);
-                    break;
-                }
+    }
 
-                if (allNodesCreated) {  // wird manchmal doppelt geschickt
-                    break;
-                }
+    startWebsocket() {
+        this.websocketController = new WebsocketController(this);
+        const wsClient = this.websocketController.initWsClient();
 
-                if (!messageObj.result?.state || !Array.isArray(messageObj.result.state.nodes)) {
-                    this.log.warn('<zwavews> Invalid result.state structure received, skipping.');
-                    break;
-                }
+        if (!wsClient) {
+            this.log.error('<zwavews> initWsClient returned null — websocket not started.');
+            return;
+        }
 
-                driver     = messageObj.result.state.driver;
-                controller = messageObj.result.state.controller;
-                allNodes   = messageObj.result.state.nodes;
+        wsClient.on('open', () => {
+            this.log.info('Connect to zwave-js-ui over websocket connection.');
+            this.startListening = true;
+            this.websocketController.send(JSON.stringify({ command: 'start_listening' }));
+        });
 
-                for (const nodeData of allNodes) {
-                    const nodeId = utils.formatNodeId(nodeData.nodeId);
+        wsClient.on('message', (message) => {
+            this.messageParse(message);
+        });
 
-                    if (debugDevicesState && debugDevicesState.val && String(debugDevicesState.val).includes(nodeId)) {
-                        this.log.warn(`--->>> fromZ2W_RAW2-> ${JSON.stringify(nodeData)}` );
+        wsClient.on('close', async () => {
+            this.setStateChanged('info.connection', false, true);
+            await this.statesController.setAllAvailableToFalse();
+            this.startListening = false;
+            this.allNodesCreated = false;
+            this.deviceCache = {};
+            this.nodeCache = {};
+            this.log.info('Websocket connection closed. Attempting to reconnect...');
+        });
+    }
+
+    async messageParse(message) {
+        // FIX: release mit let deklarieren (war implizite globale Variable)
+        let release;
+        const lock = new Promise((resolve) => (release = resolve));
+        const prev = this.messageParseMutex;
+        this.messageParseMutex = lock;
+        await prev;
+
+        try {
+            const messageObj = JSON.parse(message);
+            const debugDevicesState = await this.getStateAsync('info.debugId');
+
+            this.log.debug(`--->>> fromZ2W_RAW1 -> ${JSON.stringify(messageObj)}`);
+
+            const type = messageObj?.type;
+
+            if (this.config.connectionType === 'ws') {
+                switch (type) {
+                    case 'version': {
+                        this.setStateChanged('info.connection', true, true);
+                        this.setStateChanged('info.zwave_gateway_version', messageObj.driverVersion, true);
+                        this.setStateChanged('info.zwave_gateway_status', 'online', true);
+                        break;
                     }
+                    case 'result': {
+                        if (messageObj.result?.success === true) {
+                            this.setStateChanged('info.debugmessages', JSON.stringify(messageObj), true);
+                            break;
+                        }
+
+                        if (this.allNodesCreated) {
+                            break;
+                        }
+
+                        if (!messageObj.result?.state || !Array.isArray(messageObj.result.state.nodes)) {
+                            this.log.warn('<zwavews> Invalid result.state structure received, skipping.');
+                            break;
+                        }
+
+                        const { nodes: allNodes } = messageObj.result.state;
+
+                        for (const nodeData of allNodes) {
+                            const nodeId = utils.formatNodeId(nodeData.nodeId);
+
+                            if (debugDevicesState?.val && String(debugDevicesState.val).includes(nodeId)) {
+                                this.log.warn(`--->>> fromZ2W_RAW2-> ${JSON.stringify(nodeData)}`);
+                            }
+
+                            if (!this.nodeCache[nodeId]) {
+                                if (this.config.showNodeInfoMessage) {
+                                    this.log.info(`Node Info Update for ${nodeId}`);
+                                }
+                                this.nodeCache[nodeId] = { nodeData };
+                            }
+                            await this.helper.createNode(nodeId, nodeData, this.parseOptions);
+                        }
+
+                        this.allNodesCreated = true;
 
-                    if (!this.nodeCache[nodeId]) {
                         if (this.config.showNodeInfoMessage) {
-                            this.log.info(`Node Info Update for ${nodeId}`);
+                            this.log.info('all Nodes are ready');
+                        }
+                        if (this.startListening) {
+                            this.websocketController.send(JSON.stringify({ command: 'start_listening' }));
+                            this.startListening = false;
                         }
-                        this.nodeCache[nodeId] = {nodeData};
+                        break;
                     }
-                    await helper.createNode(nodeId, nodeData, options);
+                    case 'event': {
+                        const eventTyp = messageObj.event;
+
+                        switch (eventTyp.event) {
+                            case 'value updated':
+                            case 'value added':
+                            case 'value notification': {
+                                const nodeArg = eventTyp.args;
+                                const nodeId = utils.formatNodeId(eventTyp.nodeId);
+
+                                if (debugDevicesState?.val && String(debugDevicesState.val).includes(nodeId)) {
+                                    this.log.warn(`--->>> fromZ2W_RAW2-> ${JSON.stringify(eventTyp)}`);
+                                }
+
+                                let parsePath = `${nodeId}.${nodeArg.commandClassName}.${nodeArg.propertyName
+                                    .replace(/[^\p{L}\p{N}\s]/gu, '')
+                                    .replace(/\s+/g, ' ')
+                                    .trim()}`;
+
+                                if (nodeArg?.propertyKeyName) {
+                                    parsePath = `${parsePath}.${nodeArg.propertyKeyName
+                                        .replace(/[^\p{L}\p{N}\s]/gu, '')
+                                        .replace(/\s+/g, ' ')
+                                        .trim()}`;
+
+                                    if (constant.RGB.includes(nodeArg.propertyKeyName)) {
+                                        parsePath = utils.replaceLastDot(parsePath);
+                                    }
+                                }
+
+                                parsePath = utils.deleteLastDot(utils.formatObject(parsePath));
+
+                                if (nodeArg.commandClass === 119) {
+                                    switch (nodeArg.property) {
+                                        case 'name':
+                                            await this.helper.updateDevice(nodeId, nodeArg);
+                                            parsePath = `${nodeId}.info.${nodeArg.property}`;
+                                            break;
+                                        case 'location':
+                                            break;
+                                        default:
+                                            parsePath = `${nodeId}.info.${nodeArg.property}`;
+                                            break;
+                                    }
+                                }
+
+                                this.log.debug(`${parsePath} ->> ${nodeArg.newValue}`);
+
+                                if (parsePath.includes('firmwareVersions')) {
+                                    parsePath = `${parsePath}_value`;
+                                }
+
+                                if (nodeArg.endpoint != null && nodeArg.endpoint > 0) {
+                                    parsePath = `${parsePath}_${nodeArg.endpoint}`;
+                                }
+
+                                parsePath = utils.deleteLastDot(parsePath);
+
+                                if (eventTyp.event === 'value notification') {
+                                    await this.helper.parse(parsePath, nodeArg.newValue, this.parseOptions, true);
+                                } else {
+                                    await this.helper.parse(parsePath, nodeArg.newValue, this.parseOptions, false);
+                                }
+                                break;
+                            }
+
+                            case 'firmware update progress': {
+                                const total = Number(eventTyp.totalFragments) || 0;
+                                const sent = Number(eventTyp.sentFragments) || 0;
+                                const progress = total > 0 ? Math.min(100, Math.max(0, (sent / total) * 100)) : 0;
+                                this.log.info(
+                                    `Firmware update progress for ${utils.formatNodeId(eventTyp.nodeId)} ->> ` +
+                                    `send Fragments ${sent} -- total ${total} (${progress.toFixed(1)}%)`,
+                                );
+                                break;
+                            }
+
+                            case 'firmware update finished': {
+                                this.log.info(`${utils.formatNodeId(eventTyp.nodeId)} --> ${eventTyp.event}`);
+                                break;
+                            }
+
+                            case 'ready':
+                            case 'sleep':
+                            case 'wake up':
+                            case 'alive':
+                            case 'dead': {
+                                const nodeId = utils.formatNodeId(eventTyp.nodeId);
+                                await this.helper.parse(`${nodeId}.status`, eventTyp.event.toLowerCase(), this.parseOptions);
+
+                                if (eventTyp.event === 'dead') {
+                                    await this.helper.parse(`${nodeId}.ready`, false, this.parseOptions);
+                                } else {
+                                    await this.helper.parse(`${nodeId}.ready`, true, this.parseOptions);
+                                }
+
+                                if (this.config.wakeUpInfo) {
+                                    this.log.info(`${utils.formatNodeId(eventTyp.nodeId)} --> ${eventTyp.event}`);
+                                }
+                                break;
+                            }
+
+                            case 'node removed': {
+                                const nodeId = utils.formatNodeId(eventTyp.nodeId);
+                                if (this.config.useEventInDesc) {
+                                    await this.helper.updateDevice(nodeId, { desc: 'Node is Deleted' }, false);
+                                } else {
+                                    await this.helper.updateDevice(nodeId, { name: 'Node is Deleted' }, true);
+                                }
+                                this.log.error(`Delete ${utils.formatNodeId(eventTyp.nodeId)}`);
+                                break;
+                            }
+
+                            case 'interview started':
+                            case 'interview stage completed':
+                            case 'interview failed':
+                            case 'interview completed':
+                                this.log.info(`${utils.formatNodeId(eventTyp.nodeId)} --> ${eventTyp.event}`);
+                                break;
+
+                            case 'statistics updated':
+                            case 'metadata updated':
+                            case 'node info received':
+                                break;
+
+                            default:
+                                if (this.config.newTypeEvent) {
+                                    this.log.warn(`New type event ->> ${eventTyp.event}`);
+                                    this.log.warn(JSON.stringify(messageObj));
+                                }
+                                break;
+                        }
+                        break;
+                    }
+                    default:
+                        break;
                 }
-                
-                allNodesCreated = true;
+            }
+        } catch (err) {
+            this.log.error(err);
+            this.log.error(`<zwavews> error message -->> ${message}`);
+        } finally {
+            release();
+        }
+    }
 
-                if (this.config.showNodeInfoMessage) {
-                    this.log.info(`all Nodes are ready`);
-                }
-                if (startListening) {
-                    websocketController.send(JSON.stringify({command: "start_listening"}));
-                    startListening = false;
+    async onUnload(callback) {
+        try {
+            if (['exmqtt', 'intmqtt'].includes(this.config.connectionType)) {
+                if (this.mqttClient && !this.mqttClient.closed) {
+                    try {
+                        this.mqttClient.end();
+                    } catch (e) {
+                        this.log.error(e);
+                    }
                 }
-                break;
             }
-            case 'event':
-                eventTyp = messageObj.event;
-
-                switch (eventTyp.event) {
-                  case 'value updated':
-                  case 'value added': 
-                  case 'value notification': { 
-                      const nodeArg = eventTyp.args;
-                      const nodeId = utils.formatNodeId(eventTyp.nodeId);
-
-                      if (debugDevicesState && debugDevicesState.val && String(debugDevicesState.val).includes(nodeId)) {
-                        this.log.warn(`--->>> fromZ2W_RAW2-> ${JSON.stringify(eventTyp)}` );
-                      }
-
-                      let parsePath = `${nodeId}.${nodeArg.commandClassName}.${nodeArg.propertyName
-                          .replace(/[^\p{L}\p{N}\s]/gu, "")
-                          .replace(/\s+/g, " ")
-                          .trim()}`;
-
-                      if (nodeArg?.propertyKeyName) {
-                          parsePath = `${parsePath}.${nodeArg.propertyKeyName
-                              .replace(/[^\p{L}\p{N}\s]/gu, "")
-                              .replace(/\s+/g, " ")
-                              .trim()}`;
-
-                          if (constant.RGB.includes(nodeArg.propertyKeyName)) {
-                              parsePath = utils.replaceLastDot(parsePath);
-                          }
-                      }
-
-                      parsePath = utils.deleteLastDot(utils.formatObject(parsePath));
-
-                      if (nodeArg.commandClass === 119) {    // sonderlocke für node naming
-                          switch (nodeArg.property) {
-                              case 'name':
-                                  await helper.updateDevice(nodeId, nodeArg);
-                                  parsePath = `${nodeId}.info.${nodeArg.property}`;
-                                  break;
-                              case 'location':
-                                  // intentionally ignored
-                                  break;
-                              default:
-                                  parsePath = `${nodeId}.info.${nodeArg.property}`;
-                                  break;
-                          }
-                      }
-
-                      this.log.debug(`${parsePath} ->> ${nodeArg.newValue}`);
-
-                      if (parsePath.includes('firmwareVersions')) { // damit array werte gespeichert werden
-                          parsePath = `${parsePath}_value`;
-                      }
-
-                       // mehr als 1 endpoint behandeln
-                      if (nodeArg.endpoint != null && nodeArg.endpoint > 0) {
-                        parsePath = `${parsePath}_${nodeArg.endpoint}`;
-                      }
-
-                      parsePath = utils.deleteLastDot(parsePath); // check again
-
-                      if (eventTyp.event === 'value notification') {
-                        await helper.parse(`${parsePath}`, nodeArg.newValue, options, true);
-                      } else {
-                        await helper.parse(`${parsePath}`, nodeArg.newValue, options, false);
-                      }
-                      break;
-                  }
-
-                  case 'firmware update progress': {
-                    const total = Number(eventTyp.totalFragments) || 0;
-                    const sent = Number(eventTyp.sentFragments) || 0;
-
-                    const progress = total > 0 ? Math.min(100, Math.max(0, (sent / total) * 100)) : 0;
-
-                    this.log.info(
-                      `Firmware update progress for ${utils.formatNodeId(eventTyp.nodeId)} ->> ` + `send Fragments ${sent} -- total ${total} 
-                        (${progress.toFixed(1)}%)`);
-                    break;
-                  }
-                  case 'firmware update finished': {
-                      this.log.info(`${utils.formatNodeId(eventTyp.nodeId)} --> ${eventTyp.event}`);
-                    break;
-                  }
-                  case 'ready':
-                  case 'sleep':
-                  case 'wake up':
-                  case 'alive':
-                  case 'dead': {
-                      const nodeId = utils.formatNodeId(eventTyp.nodeId);
-                      await helper.parse(`${nodeId}.status`, eventTyp.event.toLowerCase(), options);
-                      
-                      if (eventTyp.event === 'dead') {
-                        await helper.parse(`${nodeId}.ready`, false, options);
-                      } else {
-                        await helper.parse(`${nodeId}.ready`, true, options);
-                      }
-                      
-                      if (this.config.wakeUpInfo) {
-                          this.log.info(`${utils.formatNodeId(eventTyp.nodeId)} --> ${eventTyp.event}`);
-                      }
-                      break;
-                  }
-
-                  case 'node removed': {
-                        const nodeId = utils.formatNodeId(eventTyp.nodeId);
-
-                        if (this.config.useEventInDesc) {
-                           const nodeArg = {desc: "Node is Deleted"};
-                           await helper.updateDevice(nodeId, nodeArg, false);
-                        } else {
-                          const nodeArg = {name : 'Node is Deleted'};
-                          await helper.updateDevice(nodeId, nodeArg, true);
-                        }
-                        this.log.error(`Delete ${utils.formatNodeId(eventTyp.nodeId)}`);
-                        break;
-                  }
-                  case 'interview started':
-                  case 'interview stage completed':
-                  case 'interview failed':
-                  case 'interview completed':
-                    this.log.info(`${utils.formatNodeId(eventTyp.nodeId)} --> ${eventTyp.event}`);
-                    break;
-                  
-                  case 'statistics updated':
-                  case 'metadata updated':
-                  case 'node info received':
-                    break;
-                default:
-                    if (this.config.newTypeEvent) {
-                        this.log.warn(`New type event ->> ${eventTyp.event}`);
-                        this.log.warn(JSON.stringify(messageObj));
+
+            if (this.config.connectionType === 'intmqtt' || this.config.dummyMqtt === true) {
+                try {
+                    if (this.mqttServerController) {
+                        this.mqttServerController.closeServer();
                     }
-                    break;
+                } catch (e) {
+                    this.log.error(e);
+                }
             }
 
-            break;
-          default:
-            break;
+            if (this.websocketController) {
+                try {
+                    await this.websocketController.allTimerClear();
+                    this.websocketController.closeConnection();
+                } catch (e) {
+                    this.log.error(e);
+                }
+            }
+
+            try {
+                if (this.statesController) {
+                    await this.statesController.setAllAvailableToFalse();
+                }
+            } catch (e) {
+                this.log.error(e);
+            }
+
+            this.setStateChanged('info.connection', false, true);
+        } finally {
+            callback();
         }
-      }
-    } catch (err) {
-      this.log.error(err);
-      this.log.error(`<zwavews> error message -->> ${message}`);
-    } finally {
-      release();
     }
-  }
-
-  async onUnload(callback) {
-    try {
-      // Close MQTT connections
-      if (["exmqtt", "intmqtt"].includes(this.config.connectionType)) {
-        if (mqttClient && !mqttClient.closed) {
-          try {
-              mqttClient.end();
-          } catch (e) {
-              this.log.error(e);
-          }
-        }
-      }
-      // Internal or Dummy MQTT-Server
-      if (this.config.connectionType === "intmqtt" || this.config.dummyMqtt === true) {
-        try {
-          if (mqttServerController) {
-            mqttServerController.closeServer();
-          }
-        } catch (e) {
-          this.log.error(e);
-        }
-      }
-      // WebSocket cleanup
-      if (websocketController) {
-        try {
-          await websocketController.allTimerClear();
-          websocketController.closeConnection();
-        } catch (e) {
-          this.log.error(e);
-        }
-      }
-      // Set all device available states to false
-      try {
-        if (statesController) {
-          await statesController.setAllAvailableToFalse();
+
+    async onStateChange(id, state) {
+        if (!this.allNodesCreated) {
+            return;
         }
-      } catch (e) {
-        this.log.error(e);
-      }
 
-      this.setStateChanged("info.connection", false, true);
-    } finally {
-      callback();
-    }
-  }
+        if (state && state.ack === false) {
+            if (id.endsWith('info.debugId')) {
+                this.setStateChanged(id, state.val, true);
+                return;
+            }
 
-  async onStateChange(id, state) {
-    if (!allNodesCreated) {  // wenn alle nodes angelegt sind, erst dann horchen auf target
-        return;
-    }
+            const obj = await this.getObjectAsync(id);
+            if (obj) {
+                const nativeObj = obj.native || {};
+
+                const m = id.match(/nodeID_0*(\d+)/i);
+                if (!m) {
+                    this.log.warn(`<zwavews> Could not extract nodeId from state id: ${id}`);
+                    return;
+                }
+                const nodeId = Number(m[1]);
+
+                const message = {
+                    messageId: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+                    command: 'node.set_value',
+                    nodeId,
+                    valueId: nativeObj.valueId,
+                    value: state.val,
+                };
+
+                const sendMessageAllowed = await this.getStateAsync('info.sendMessageAllowed');
+
+                if (sendMessageAllowed && sendMessageAllowed.val === true) {
+                    if (this.websocketController) {
+                        this.websocketController.send(JSON.stringify(message));
+                    } else {
+                        this.log.warn('<zwavews> websocketController not initialised, cannot send message.');
+                    }
+                }
 
-    if (state && state.ack === false) {
-      if (id.endsWith("info.debugId")) {
-        this.setStateChanged(id, state.val, true);
-        return;
-      }
-
-      const obj = await this.getObjectAsync(id);
-      if (obj) {
-          const nativeObj = obj.native || {};
-
-          const m = id.match(/nodeID_0*(\d+)/i);
-          if (!m) {
-              this.log.warn(`<zwavews> Could not extract nodeId from state id: ${id}`);
-              return;
-          }
-          const nodeId = Number(m[1]);
-
-          const message = {
-              messageId: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
-              command: "node.set_value",
-              nodeId: nodeId,
-              valueId: nativeObj.valueId,
-              value: state.val
-          };
-
-          const sendMessageAllowed = await this.getStateAsync("info.sendMessageAllowed");
-
-          if (sendMessageAllowed && sendMessageAllowed.val === true) {
-              if (websocketController) {
-                  websocketController.send(JSON.stringify(message));
-              } else {
-                  this.log.warn('<zwavews> websocketController not initialised, cannot send message.');
-              }
-          }
-
-          this.setStateChanged('info.debugmessages', JSON.stringify(message), true);
-          this.log.debug(`<zwavews> message onStateChange ${JSON.stringify(message)}`);
-      }
+                this.setStateChanged('info.debugmessages', JSON.stringify(message), true);
+                this.log.debug(`<zwavews> message onStateChange ${JSON.stringify(message)}`);
+            }
+        }
     }
-  }
 }
 
 if (require.main !== module) {
-  // Export the constructor in compact mode
-  /**
-   * @param {Partial<core.AdapterOptions>} [options]
-   */
-  module.exports = (options) => new zwavews(options);
+    module.exports = (options) => new zwavews(options);
 } else {
-  // otherwise start the instance directly
-  new zwavews();
+    new zwavews();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.zwavews",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "zwavews adapter for ioBroker",
   "author": {
     "name": "Arthur Rupp",
@@ -26,7 +26,7 @@
   },
   "dependencies": {
     "@iobroker/adapter-core": "^3.3.2",
-    "@iobroker/dm-utils": "^3.0.3",
+    "@iobroker/dm-utils": "^3.0.19",
     "humanize-duration": "^3.33.2",
     "aedes": "^0.51.3",
     "aedes-persistence-nedb": "^2.0.3",
@@ -45,7 +45,7 @@
     "@iobroker/testing": "^5.2.2",
     "@iobroker/eslint-config": "^2.2.0",
     "@tsconfig/node14": "^14.1.8",
-    "@types/node": "^25.5.0",
+    "@types/node": "^25.6.0",
     "@types/node-schedule": "^2.1.8",
     "typescript": "~6.0.2"
   },