matterbridge 1.2.8 → 1.2.10

package/dist/matterbridge.js

@@ -26,6 +26,7 @@ import { AnsiLogger, BRIGHT, RESET, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugSt
 import { fileURLToPath, pathToFileURL } from 'url';
 import { promises as fs } from 'fs';
 import { exec, spawn } from 'child_process';
+import https from 'https';
 import EventEmitter from 'events';
 import express from 'express';
 import os from 'os';
@@ -81,6 +82,7 @@ export class Matterbridge extends EventEmitter {
     matterbridgeVersion = '';
     matterbridgeLatestVersion = '';
     bridgeMode = '';
+    restartMode = '';
     debugEnabled = false;
     port = 5540;
     log;
@@ -127,9 +129,11 @@ export class Matterbridge extends EventEmitter {
      *
      * @returns A Promise that resolves when the initialization is complete.
      */
-    async initializeAsExtension(dataPath, debugEnabled) {
+    async startExtension(dataPath, debugEnabled, extensionVersion, port = 5560) {
+        // Set the bridge mode
+        this.bridgeMode = 'bridge';
         // Set the first port to use
-        this.port = 5560;
+        this.port = port;
         // Set Matterbridge logger
         this.debugEnabled = debugEnabled;
         this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: this.debugEnabled });
@@ -140,6 +144,19 @@ export class Matterbridge extends EventEmitter {
         this.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridgeDirectory, 'node_storage'), logging: false });
         this.log.debug('Creating node storage context for matterbridge: matterbridge');
         this.nodeContext = await this.nodeStorage.createStorage('matterbridge');
+        const plugin = {
+            path: '',
+            type: 'DynamicPlatform',
+            name: 'MatterbridgeExtension',
+            version: '1.0.0',
+            description: 'Matterbridge extension',
+            author: 'https://github.com/Luligu',
+            enabled: false,
+            registeredDevices: 0,
+            addedDevices: 0,
+        };
+        this.registeredPlugins.push(plugin);
+        await this.nodeContext?.set('plugins', this.getBaseRegisteredPlugins());
         // Log system info and create .matterbridge directory
         await this.logNodeAndSystemInfo();
         this.matterbridgeDirectory = dataPath;
@@ -148,14 +165,16 @@ export class Matterbridge extends EventEmitter {
         Logger.format = Format.ANSI;
         // Start the storage and create matterbridgeContext
         await this.startStorage('json', path.join(this.matterbridgeDirectory, 'matterbridge.json'));
-        this.matterbridgeContext = await this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggregator');
-        if (!this.storageManager || !this.matterbridgeContext)
-            return;
+        if (!this.storageManager)
+            return false;
+        this.matterbridgeContext = await this.createCommissioningServerContext('Matterbridge', 'Matterbridge zigbee2MQTT', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'zigbee2MQTT Matter extension');
+        if (!this.matterbridgeContext)
+            return false;
         await this.matterbridgeContext.set('softwareVersion', 1);
         await this.matterbridgeContext.set('softwareVersionString', this.matterbridgeVersion);
-        await this.matterbridgeContext.set('hardwareVersion', 0);
-        await this.matterbridgeContext.set('hardwareVersionString', '0.0.1');
-        this.createMatterServer(this.storageManager);
+        await this.matterbridgeContext.set('hardwareVersion', 1);
+        await this.matterbridgeContext.set('hardwareVersionString', extensionVersion); // Update with the extension version
+        this.matterServer = this.createMatterServer(this.storageManager);
         this.log.debug(`Creating commissioning server for ${plg}Matterbridge${db}`);
         this.commissioningServer = await this.createCommisioningServer(this.matterbridgeContext, 'Matterbridge');
         this.log.debug(`Creating matter aggregator for ${plg}Matterbridge${db}`);
@@ -163,24 +182,38 @@ export class Matterbridge extends EventEmitter {
         this.log.debug('Adding matterbridge aggregator to commissioning server');
         this.commissioningServer.addDevice(this.matterAggregator);
         this.log.debug('Adding matterbridge commissioning server to matter server');
-        await this.matterServer?.addCommissioningServer(this.commissioningServer, { uniqueStorageKey: 'Matterbridge' });
-        this.log.debug(`Setting reachability to true for ${plg}Matterbridge${db}`);
-        this.commissioningServer.setReachability(true);
-        this.log.debug('Starting matter server...');
+        await this.matterServer.addCommissioningServer(this.commissioningServer, { uniqueStorageKey: 'Matterbridge' });
         await this.startMatterServer();
         this.log.info('Matter server started');
         await this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, this.nodeContext, 'Matterbridge');
+        // Set reachability to true and trigger event after 60 seconds
+        setTimeout(() => {
+            this.log.info(`*Setting reachability to true for ${plg}Matterbridge${db}`);
+            if (this.commissioningServer)
+                this.setCommissioningServerReachability(this.commissioningServer, true);
+            if (this.matterAggregator)
+                this.setAggregatorReachability(this.matterAggregator, true);
+        }, 60 * 1000);
+        return this.commissioningServer.isCommissioned();
     }
     /**
      * Close the Matterbridge instance as extension for zigbee2mqtt.
      *
      * @returns A Promise that resolves when the initialization is complete.
      */
-    async closeAsExtension() {
+    async stopExtension() {
         // Closing matter
         await this.stopMatter();
+        // Clearing the session manager
+        // this.matterbridgeContext?.createContext('SessionManager').clear();
         // Closing storage
         await this.stopStorage();
+        this.log.info('Matter server stopped');
+    }
+    isExtensionCommissioned() {
+        if (!this.commissioningServer)
+            return false;
+        return this.commissioningServer.isCommissioned();
     }
     /**
      * Initializes the Matterbridge application.
@@ -220,6 +253,11 @@ export class Matterbridge extends EventEmitter {
         }
         // Set the first port to use
         this.port = getIntParameter('port') ?? 5540;
+        // Set the restart mode
+        if (hasParameter('service'))
+            this.restartMode = 'service';
+        if (hasParameter('docker'))
+            this.restartMode = 'docker';
         // Set Matterbridge logger
         if (hasParameter('debug'))
             this.debugEnabled = true;
@@ -254,7 +292,8 @@ export class Matterbridge extends EventEmitter {
         await this.logNodeAndSystemInfo();
         this.log.info(
         // eslint-disable-next-line max-len
-        `Matterbridge version ${this.matterbridgeVersion} mode ${hasParameter('bridge') ? 'bridge' : ''}${hasParameter('childbridge') ? 'childbridge' : ''}${hasParameter('controller') ? 'controller' : ''} running on ${this.systemInformation.osType} ${this.systemInformation.osRelease} ${this.systemInformation.osPlatform} ${this.systemInformation.osArch}`);
+        `Matterbridge version ${this.matterbridgeVersion} mode ${hasParameter('bridge') ? 'bridge' : ''}${hasParameter('childbridge') ? 'childbridge' : ''}${hasParameter('controller') ? 'controller' : ''} ` +
+            `${this.restartMode !== '' ? 'restart mode ' + this.restartMode + ' ' : ''}running on ${this.systemInformation.osType} ${this.systemInformation.osRelease} ${this.systemInformation.osPlatform} ${this.systemInformation.osArch}`);
         // Check node version and throw error
         requireMinNodeVersion(18);
         // Register SIGINT SIGTERM signal handlers
@@ -582,6 +621,7 @@ export class Matterbridge extends EventEmitter {
             this.log.info(message);
             process.removeAllListeners('SIGINT');
             process.removeAllListeners('SIGTERM');
+            this.log.debug('All listeners removed');
             // Calling the shutdown functions with a reason
             for (const plugin of this.registeredPlugins) {
                 if (!plugin.enabled)
@@ -637,11 +677,13 @@ export class Matterbridge extends EventEmitter {
             if (this.expressServer) {
                 this.expressServer.close();
                 this.expressServer = undefined;
+                this.log.debug('Express server closed successfully');
             }
             // Remove listeners
             if (this.expressApp) {
                 this.expressApp.removeAllListeners();
                 this.expressApp = undefined;
+                this.log.debug('Frontend closed successfully');
             }
             // Close the WebSocket server
             if (this.webSocketServer) {
@@ -715,20 +757,6 @@ export class Matterbridge extends EventEmitter {
             //cleanupTimeout1.unref();
         }
     }
-    /**
-     * Sets the reachable attribute of a device.
-     *
-     * @param device - The device for which to set the reachable attribute.
-     * @param reachable - The value to set for the reachable attribute.
-     */
-    setReachableAttribute(device, reachable) {
-        const basicInformationCluster = device.getClusterServer(BasicInformationCluster);
-        if (!basicInformationCluster) {
-            this.log.error('setReachableAttribute BasicInformationCluster needs to be set!');
-            return;
-        }
-        basicInformationCluster.setReachableAttribute(reachable);
-    }
     /**
      * Adds a device to the Matterbridge.
      * @param pluginName - The name of the plugin.
@@ -824,7 +852,7 @@ export class Matterbridge extends EventEmitter {
             return;
         }
         if (this.bridgeMode === 'childbridge' && !plugin.connected) {
-            this.log.warn(`Removing bridged device ${dev}${device.deviceName}${wr} (${dev}${device.name}${wr}) plugin ${plg}${pluginName}${wr} not connected`);
+            this.log.info(`Removing bridged device ${dev}${device.deviceName}${wr} (${dev}${device.name}${wr}) plugin ${plg}${pluginName}${wr} not connected`);
             return;
         }
         // Remove the device from matterbridge aggregator in bridge mode
@@ -971,12 +999,7 @@ export class Matterbridge extends EventEmitter {
             return;
         }
         this.log.debug('Starting matterbridge in mode', this.bridgeMode);
-        this.createMatterServer(this.storageManager);
-        if (!this.matterServer) {
-            this.log.error('No matter server initialized');
-            await this.cleanup('No matter server initialized');
-            return;
-        }
+        this.matterServer = this.createMatterServer(this.storageManager);
         this.log.debug('***Starting startMatterbridge interval for Matterbridge');
         let failCount = 0;
         const startInterval = setInterval(async () => {
@@ -1152,7 +1175,7 @@ export class Matterbridge extends EventEmitter {
             return Promise.reject(new Error(`Plugin ${plg}${plugin.name}${er} not loaded or no platform`));
         }
         if (plugin.started) {
-            this.log.warn(`Plugin ${plg}${plugin.name}${wr} already started`);
+            this.log.debug(`Plugin ${plg}${plugin.name}${db} already started`);
             return Promise.resolve();
         }
         this.log.info(`Starting plugin ${plg}${plugin.name}${db} type ${typ}${plugin.type}${db}`);
@@ -1292,12 +1315,7 @@ export class Matterbridge extends EventEmitter {
             return;
         }
         this.log.debug('Starting matterbridge in mode', this.bridgeMode);
-        this.createMatterServer(this.storageManager);
-        if (!this.matterServer) {
-            this.log.error('No matter server initialized');
-            await this.cleanup('No matter server initialized');
-            return;
-        }
+        this.matterServer = this.createMatterServer(this.storageManager);
         this.log.info('Creating matter commissioning controller');
         this.commissioningController = new CommissioningController({
             autoConnect: false,
@@ -1454,12 +1472,7 @@ export class Matterbridge extends EventEmitter {
             return;
         }
         this.log.debug('Starting matterbridge in mode', this.bridgeMode);
-        this.createMatterServer(this.storageManager);
-        if (!this.matterServer) {
-            this.log.error('No matter server initialized');
-            await this.cleanup('No matter server initialized');
-            return;
-        }
+        this.matterServer = this.createMatterServer(this.storageManager);
         if (this.bridgeMode === 'bridge') {
             // Plugins are loaded by loadPlugin on startup and plugin.loaded is set to true
             // Plugins are started and configured by callback when Matterbridge is commissioned
@@ -1503,22 +1516,17 @@ export class Matterbridge extends EventEmitter {
                 this.commissioningServer.addDevice(this.matterAggregator);
                 this.log.debug('Adding matterbridge commissioning server to matter server');
                 await this.matterServer?.addCommissioningServer(this.commissioningServer, { uniqueStorageKey: 'Matterbridge' });
-                this.log.debug(`Setting reachability to true for ${plg}Matterbridge${db}`);
-                this.commissioningServer.setReachability(true);
-                this.log.debug('Starting matter server...');
                 await this.startMatterServer();
                 this.log.info('Matter server started');
                 await this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, this.nodeContext, 'Matterbridge');
                 //if (hasParameter('advertise')) await this.commissioningServer.advertise();
-                /*
-                setInterval(() => {
-                  this.matterAggregator?.getBridgedDevices().forEach((device) => {
-                    this.log.info(`Bridged device: ${dev}${device.name}${nf}`);
-                    device.getClusterServer(BridgedDeviceBasicInformationCluster)?.setReachableAttribute(true);
-                    device.getClusterServer(BridgedDeviceBasicInformationCluster)?.triggerReachableChangedEvent({ reachableNewValue: true });
-                  });
-                }, 30 * 1000);
-                */
+                setTimeout(() => {
+                    this.log.info(`*Setting reachability to true for ${plg}Matterbridge${db}`);
+                    if (this.commissioningServer)
+                        this.setCommissioningServerReachability(this.commissioningServer, true);
+                    if (this.matterAggregator)
+                        this.setAggregatorReachability(this.matterAggregator, true);
+                }, 60 * 1000);
             }, 1000);
         }
         if (this.bridgeMode === 'childbridge') {
@@ -1555,6 +1563,8 @@ export class Matterbridge extends EventEmitter {
                                 plugin.commissioningServer = await this.createCommisioningServer(plugin.storageContext, plugin.name);
                             this.log.debug(`Adding device ${dev}${registeredDevice.device.name}${db} to commissioning server for plugin ${plg}${plugin.name}${db}`);
                             plugin.commissioningServer.addDevice(registeredDevice.device);
+                            if (!plugin.device)
+                                plugin.device = registeredDevice.device;
                         }
                         this.log.debug(`Adding commissioning server to matter server for plugin ${plg}${plugin.name}${db}`);
                         await this.matterServer?.addCommissioningServer(plugin.commissioningServer, { uniqueStorageKey: plugin.name });
@@ -1595,21 +1605,6 @@ export class Matterbridge extends EventEmitter {
                     return;
                 clearInterval(startMatterInterval);
                 this.log.info('Starting matter server...');
-                // Setting reachability to true
-                this.registeredPlugins.forEach((plugin) => {
-                    if (!plugin.enabled)
-                        return;
-                    this.log.debug(`Setting reachability to true for ${plg}${plugin.name}${db}`);
-                    plugin.commissioningServer?.setReachability(true);
-                    this.registeredDevices.forEach((registeredDevice) => {
-                        if (registeredDevice.plugin === plugin.name) {
-                            if (plugin.type === 'AccessoryPlatform')
-                                this.setReachableAttribute(registeredDevice.device, true);
-                            if (plugin.type === 'DynamicPlatform')
-                                registeredDevice.device.setBridgedDeviceReachability(true);
-                        }
-                    });
-                });
                 await this.startMatterServer();
                 this.log.info('Matter server started');
                 for (const plugin of this.registeredPlugins) {
@@ -1628,6 +1623,14 @@ export class Matterbridge extends EventEmitter {
                         continue;
                     }
                     await this.showCommissioningQRCode(plugin.commissioningServer, plugin.storageContext, plugin.nodeContext, plugin.name);
+                    // Setting reachability to true
+                    this.log.info(`*Setting reachability to true for ${plg}${plugin.name}${db}`);
+                    if (plugin.commissioningServer)
+                        this.setCommissioningServerReachability(plugin.commissioningServer, true);
+                    if (plugin.type === 'AccessoryPlatform' && plugin.device)
+                        this.setDeviceReachability(plugin.device, true);
+                    if (plugin.type === 'DynamicPlatform' && plugin.aggregator)
+                        this.setAggregatorReachability(plugin.aggregator, true);
                 }
                 Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
                 //clearInterval(startMatterInterval);
@@ -1644,7 +1647,7 @@ export class Matterbridge extends EventEmitter {
             await this.cleanup('No matter server initialized');
             return;
         }
-        this.log.debug('Starting matter server');
+        this.log.debug('Starting matter server...');
         await this.matterServer.start();
         this.log.debug('Started matter server');
     }
@@ -1723,8 +1726,8 @@ export class Matterbridge extends EventEmitter {
         if (!commissioningServer.isCommissioned()) {
             this.log.info(`***The commissioning server on port ${commissioningServer.getPort()} for ${plg}${pluginName}${nf} is not commissioned. Pair it scanning the QR code ...`);
             const { qrPairingCode, manualPairingCode } = commissioningServer.getPairingCode();
-            storageContext.set('qrPairingCode', qrPairingCode);
-            storageContext.set('manualPairingCode', manualPairingCode);
+            await storageContext.set('qrPairingCode', qrPairingCode);
+            await storageContext.set('manualPairingCode', manualPairingCode);
             await nodeContext.set('qrPairingCode', qrPairingCode);
             await nodeContext.set('manualPairingCode', manualPairingCode);
             const QrCode = new QrCodeSchema();
@@ -1764,6 +1767,49 @@ export class Matterbridge extends EventEmitter {
         }
         return plugin;
     }
+    /**
+     * Sets the reachability of a commissioning server and trigger.
+     *
+     * @param {CommissioningServer} commissioningServer - The commissioning server to set the reachability for.
+     * @param {boolean} reachable - The new reachability status.
+     */
+    setCommissioningServerReachability(commissioningServer, reachable) {
+        const basicInformationCluster = commissioningServer?.getRootClusterServer(BasicInformationCluster);
+        if (basicInformationCluster && basicInformationCluster.attributes.reachable !== undefined)
+            basicInformationCluster.setReachableAttribute(reachable);
+        if (basicInformationCluster && basicInformationCluster.triggerReachableChangedEvent)
+            basicInformationCluster.triggerReachableChangedEvent({ reachableNewValue: reachable });
+    }
+    /**
+     * Sets the reachability of the specified matter aggregator and its bridged devices and trigger.
+     * @param {Aggregator} matterAggregator - The matter aggregator to set the reachability for.
+     * @param {boolean} reachable - A boolean indicating the reachability status to set.
+     */
+    setAggregatorReachability(matterAggregator, reachable) {
+        const basicInformationCluster = matterAggregator.getClusterServer(BasicInformationCluster);
+        if (basicInformationCluster && basicInformationCluster.attributes.reachable !== undefined)
+            basicInformationCluster.setReachableAttribute(reachable);
+        if (basicInformationCluster && basicInformationCluster.triggerReachableChangedEvent)
+            basicInformationCluster.triggerReachableChangedEvent({ reachableNewValue: reachable });
+        matterAggregator.getBridgedDevices().forEach((device) => {
+            this.log.debug(`*Setting reachability to true for bridged device: ${dev}${device.name}${nf}`);
+            device.getClusterServer(BridgedDeviceBasicInformationCluster)?.setReachableAttribute(reachable);
+            device.getClusterServer(BridgedDeviceBasicInformationCluster)?.triggerReachableChangedEvent({ reachableNewValue: reachable });
+        });
+    }
+    /**
+     * Sets the reachability of a device and trigger.
+     *
+     * @param {MatterbridgeDevice} device - The device to set the reachability for.
+     * @param {boolean} reachable - The new reachability status of the device.
+     */
+    setDeviceReachability(device, reachable) {
+        const basicInformationCluster = device.getClusterServer(BasicInformationCluster);
+        if (basicInformationCluster && basicInformationCluster.attributes.reachable !== undefined)
+            basicInformationCluster.setReachableAttribute(reachable);
+        if (basicInformationCluster && basicInformationCluster.triggerReachableChangedEvent)
+            basicInformationCluster.triggerReachableChangedEvent({ reachableNewValue: reachable });
+    }
     /**
      * Creates a matter commissioning server.
      *
@@ -1814,9 +1860,16 @@ export class Matterbridge extends EventEmitter {
                 const info = commissioningServer.getActiveSessionInformation(fabricIndex);
                 let connected = false;
                 info.forEach((session) => {
-                    this.log.debug(`***Active session changed on fabric ${fabricIndex} ${session.fabric?.rootVendorId}/${session.fabric?.label} for ${plg}${pluginName}${nf}`, debugStringify(session));
+                    this.log.info(`***Active session changed on fabric ${fabricIndex} ${session.fabric?.rootVendorId}/${session.fabric?.label} for ${plg}${pluginName}${nf}`, debugStringify(session));
                     if (session.isPeerActive === true && session.secure === true && session.numberOfActiveSubscriptions >= 1) {
-                        this.log.info(`***Controller ${session.fabric?.rootVendorId}/${session.fabric?.label} connected to ${plg}${pluginName}${nf}`);
+                        let controllerName = '';
+                        if (session.fabric?.rootVendorId === 4937)
+                            controllerName = 'AppleHome';
+                        if (session.fabric?.rootVendorId === 4362)
+                            controllerName = 'SmartThings';
+                        if (session.fabric?.rootVendorId === 4939)
+                            controllerName = 'HomeAssistant';
+                        this.log.info(`***Controller ${session.fabric?.rootVendorId}${controllerName !== '' ? '(' + controllerName + ')' : ''}/${session.fabric?.label} connected to ${plg}${pluginName}${nf} on session ${session.name}`);
                         connected = true;
                     }
                 });
@@ -1874,7 +1927,7 @@ export class Matterbridge extends EventEmitter {
                 const info = commissioningServer.getCommissionedFabricInformation(fabricIndex);
                 this.log.debug(`***Commissioning changed on fabric ${fabricIndex} for ${plg}${pluginName}${nf}`, debugStringify(info));
                 if (info.length === 0) {
-                    this.log.warn(`***Commissioning removed from fabric ${fabricIndex} for ${plg}${pluginName}${nf}. Resetting the commissioning server ...`);
+                    this.log.warn(`***Commissioning removed from fabric ${fabricIndex} for ${plg}${pluginName}${wr}. Resetting the commissioning server ...`);
                     await commissioningServer.factoryReset();
                     if (pluginName === 'Matterbridge') {
                         await this.matterbridgeContext?.clearAll();
@@ -1889,6 +1942,7 @@ export class Matterbridge extends EventEmitter {
                             }
                         }
                     }
+                    this.log.warn(`***Restart to activate the pairing for ${plg}${pluginName}${wr}`);
                 }
             },
         });
@@ -1902,8 +1956,9 @@ export class Matterbridge extends EventEmitter {
      */
     createMatterServer(storageManager) {
         this.log.debug('Creating matter server');
-        this.matterServer = new MatterServer(storageManager, { mdnsAnnounceInterface: undefined });
+        const matterServer = new MatterServer(storageManager, { mdnsAnnounceInterface: undefined });
         this.log.debug('Created matter server');
+        return matterServer;
     }
     /**
      * Creates a Matter Aggregator.
@@ -2249,18 +2304,25 @@ export class Matterbridge extends EventEmitter {
                 childProcess.stdout.on('data', (data) => {
                     const message = data.toString().trim();
                     //this.log.info('\n' + message);
-                    this.wssSendMessage('spawn', 'stdout', message);
+                    this.wssSendMessage('Matterbridge:spawn', 'spawn', message);
                 });
             }
             if (childProcess.stderr) {
                 childProcess.stderr.on('data', (data) => {
                     const message = data.toString().trim();
                     //this.log.debug('\n' + message);
-                    this.wssSendMessage('spawn', 'stderr', message);
+                    this.wssSendMessage('Matterbridge:spawn', 'spawn', message);
                 });
             }
         });
     }
+    /**
+     * Sends a WebSocket message to all connected clients.
+     *
+     * @param {string} type - The type of the message: Matterbridge, Plugin, Device, ...
+     * @param {string} subType - The subtype of the message: debug info warn error ....
+     * @param {string} message - The content of the message.
+     */
     wssSendMessage(type, subType, message) {
         // Remove ANSI escape codes from the message
         // eslint-disable-next-line no-control-regex
@@ -2280,17 +2342,44 @@ export class Matterbridge extends EventEmitter {
      */
     async initializeFrontend(port = 8283) {
         this.log.debug(`Initializing the frontend on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
-        // Create a WebSocket server
-        this.webSocketServer = new WebSocketServer({ port: 8284 });
+        const wssPort = 8284;
+        const useHttps = false;
+        //const wssHost = (useHttps ? 'wss://' : 'ws://') + `${os.hostname().toLowerCase()}:${wssPort}`;
+        const wssHost = (useHttps ? 'wss://' : 'ws://') + `${this.systemInformation.ipv4Address}:${wssPort}`;
+        if (!useHttps) {
+            // Create a WebSocket server no certificate required
+            this.webSocketServer = new WebSocketServer({ port: wssPort });
+            this.log.info(`WebSocket server listening on ${UNDERLINE}${wssHost}${UNDERLINEOFF}${rs}`);
+        }
+        else {
+            // Define the options for HTTPS server
+            // openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout mykey.key -out mycert.pem -config openssl.cnf
+            // For wss connect the browser to https://laptop5_luca:8284/ https://192.168.1.189/log and accept the certificate
+            const serverOptions = {
+                cert: await fs.readFile(path.join(this.rootDirectory, 'frontend/certificates/mycert.pem')), // Ensure the path is correct
+                key: await fs.readFile(path.join(this.rootDirectory, 'frontend/certificates/mykey.key')), // Ensure the path is correct
+                // cert: await fs.readFile(path.join(this.rootDirectory, 'frontend/certificates/laptop5_luca.pem')), // Ensure the path is correct
+                // key: await fs.readFile(path.join(this.rootDirectory, 'frontend/certificates/laptop5_luca.key')), // Ensure the path is correct
+            };
+            // Create an HTTPS server
+            const httpsServer = https.createServer(serverOptions);
+            // Attach WebSocket server to HTTPS server
+            this.webSocketServer = new WebSocketServer({ server: httpsServer });
+            // Listen on a specific port
+            httpsServer.listen(wssPort, () => {
+                this.log.info(`WebSocket server listening on ${UNDERLINE}${wssHost}${UNDERLINEOFF}${rs}`);
+            });
+        }
         this.webSocketServer.on('connection', (ws) => {
-            this.log.debug('WebSocketServer client connected');
+            this.log.info('WebSocketServer client connected');
             this.log.setGlobalCallback(this.wssSendMessage.bind(this));
             this.log.debug('WebSocketServer activated logger callback');
+            this.wssSendMessage('Matterbridge', 'info', 'WebSocketServer client connected to Matterbridge');
             ws.on('message', (message) => {
-                this.log.debug(`WebSocketServer received message => ${message}`);
+                this.log.info(`WebSocketServer received message => ${message}`);
             });
             ws.on('close', () => {
-                this.log.debug('WebSocketServer client disconnected');
+                this.log.info('WebSocketServer client disconnected');
                 if (this.webSocketServer?.clients.size === 0) {
                     this.log.setGlobalCallback(undefined);
                     this.log.debug('WebSocketServer deactivated logger callback');
@@ -2303,7 +2392,7 @@ export class Matterbridge extends EventEmitter {
         // Serve React build directory
         this.expressApp = express();
         this.expressApp.use(express.static(path.join(this.rootDirectory, 'frontend/build')));
-        // Endpoint to provide login code
+        // Endpoint to validate login code
         this.expressApp.post('/api/login', express.json(), async (req, res) => {
             const { password } = req.body;
             this.log.debug('The frontend sent /api/login', password);
@@ -2323,63 +2412,30 @@ export class Matterbridge extends EventEmitter {
                 res.json({ valid: false });
             }
         });
-        // Endpoint to provide host
-        this.expressApp.get('/api/wsshost', express.json(), async (req, res) => {
-            this.log.debug('The frontend sent /api/wsshost');
-            res.json({ host: os.hostname() });
-        });
-        // Endpoint to provide port
-        this.expressApp.get('/api/wssport', express.json(), async (req, res) => {
-            this.log.debug('The frontend sent /api/wssport');
-            res.json({ port: 8284 });
-        });
-        // Endpoint to provide manual pairing code
-        this.expressApp.get('/api/pairing-code', (req, res) => {
-            this.log.debug('The frontend sent /api/pairing-code');
+        // Endpoint to provide settings
+        this.expressApp.get('/api/settings', express.json(), async (req, res) => {
             if (!this.matterbridgeContext) {
-                this.log.error('/api/pairing-code matterbridgeContext not found');
-                res.json([]);
-                return;
-            }
-            try {
-                const qrData = { qrPairingCode: this.matterbridgeContext.get('qrPairingCode'), manualPairingCode: this.matterbridgeContext.get('manualPairingCode') };
-                res.json(qrData);
-            }
-            catch (error) {
-                if (this.bridgeMode === 'bridge')
-                    this.log.error('qrPairingCode for /api/qr-code not found');
+                this.log.error('/api/settings matterbridgeContext not found');
                 res.json({});
-            }
-        });
-        // Endpoint to provide QR pairing code
-        this.expressApp.get('/api/qr-code', (req, res) => {
-            this.log.debug('The frontend sent /api/qr-code');
-            if (!this.matterbridgeContext) {
-                this.log.error('/api/qr-code matterbridgeContext not found');
-                res.json([]);
                 return;
             }
+            let qrPairingCode = '';
+            let manualPairingCode = '';
             try {
-                const qrData = { qrPairingCode: this.matterbridgeContext.get('qrPairingCode'), manualPairingCode: this.matterbridgeContext.get('manualPairingCode') };
-                res.json(qrData);
+                qrPairingCode = await this.matterbridgeContext.get('qrPairingCode');
+                manualPairingCode = await this.matterbridgeContext.get('manualPairingCode');
             }
             catch (error) {
                 if (this.bridgeMode === 'bridge')
-                    this.log.error('qrPairingCode for /api/qr-code not found');
+                    this.log.error('pairingCode for /api/settings not found');
                 res.json({});
             }
-        });
-        // Endpoint to provide system information
-        this.expressApp.get('/api/system-info', (req, res) => {
-            this.log.debug('The frontend sent /api/system-info');
-            res.json(this.systemInformation);
-        });
-        // Endpoint to provide matterbridge information
-        this.expressApp.get('/api/matterbridge-info', (req, res) => {
-            this.log.debug('The frontend sent /api/matterbridge-info');
             this.matterbridgeInformation.bridgeMode = this.bridgeMode;
             this.matterbridgeInformation.debugEnabled = this.debugEnabled;
-            res.json(this.matterbridgeInformation);
+            const response = { wssHost, qrPairingCode, manualPairingCode, systemInformation: this.systemInformation, matterbridgeInformation: this.matterbridgeInformation };
+            this.log.debug('The frontend sent /api/settings');
+            this.log.debug('Response:', debugStringify(response));
+            res.json(response);
         });
         // Endpoint to provide plugins
         this.expressApp.get('/api/plugins', (req, res) => {
@@ -2440,7 +2496,7 @@ export class Matterbridge extends EventEmitter {
                             }
                             catch (error) {
                                 attributeValue = 'Unavailable';
-                                this.log.debug(`****${error} in clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute: ${key}(${value.id})`);
+                                this.log.debug(`GetLocal value ${error} in clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute: ${key}(${value.id})`);
                                 //console.log(error);
                             }
                             data.push({
@@ -2469,7 +2525,7 @@ export class Matterbridge extends EventEmitter {
             // Handle the command setpassword from Settings
             if (command === 'setpassword') {
                 const password = param.slice(1, -1); // Remove the first and last characters
-                this.log.info('setpassword', param, password);
+                this.log.debug('setpassword', param, password);
                 await this.nodeContext?.set('password', password);
             }
             // Handle the command debugLevel from Settings
@@ -2504,15 +2560,12 @@ export class Matterbridge extends EventEmitter {
             // Handle the command update from Header
             if (command === 'update') {
                 this.log.info('Updating matterbridge...');
-                //this.wssSendMessage('cmd', 'update', 'Updating matterbridge');
                 try {
                     await this.spawnCommand('npm', ['install', '-g', 'matterbridge', '--loglevel=verbose']);
                     this.log.info('Matterbridge has been updated. Full restart required.');
-                    //this.wssSendMessage('cmd', 'update', 'Matterbridge has been updated. Full restart required.');
                 }
                 catch (error) {
                     this.log.error('Error updating matterbridge');
-                    //this.wssSendMessage('cmd', 'update', 'Error updating matterbridge');
                     res.json({ message: 'Command received' });
                     return;
                 }
@@ -2522,15 +2575,12 @@ export class Matterbridge extends EventEmitter {
             if (command === 'installplugin') {
                 param = param.replace(/\*/g, '\\');
                 this.log.info(`Installing plugin ${plg}${param}${db}...`);
-                //this.wssSendMessage('cmd', 'installplugin', `Installing plugin ${param}`);
                 try {
                     await this.spawnCommand('npm', ['install', '-g', param, '--loglevel=verbose']);
                     this.log.info(`Plugin ${plg}${param}${nf} installed. Full restart required.`);
-                    //this.wssSendMessage('cmd', 'installplugin', `Plugin ${param} installed. Full restart required.`);
                 }
                 catch (error) {
                     this.log.error(`Error installing plugin ${plg}${param}${er}`);
-                    //this.wssSendMessage('cmd', 'installplugin', `Error installing plugin${param}`);
                     res.json({ message: 'Command received' });
                     return;
                 }
@@ -2653,9 +2703,26 @@ export class Matterbridge extends EventEmitter {
             this.log.debug('The frontend sent *', req.url);
             res.sendFile(path.join(this.rootDirectory, 'frontend/build/index.html'));
         });
-        this.expressServer = this.expressApp.listen(port, () => {
-            this.log.info(`The frontend is running on ${UNDERLINE}http://localhost:${port}${UNDERLINEOFF}${rs}`);
-        });
+        if (!useHttps) {
+            // Listen on HTTP
+            this.expressServer = this.expressApp.listen(port, () => {
+                this.log.info(`The frontend is running on ${UNDERLINE}http://localhost:${port}${UNDERLINEOFF}${rs}`);
+            });
+        }
+        else {
+            // SSL certificate and private key paths
+            const options = {
+                cert: await fs.readFile(path.join(this.rootDirectory, 'frontend/certificates/laptop5_luca.pem')), // Ensure the path is correct
+                key: await fs.readFile(path.join(this.rootDirectory, 'frontend/certificates/laptop5_luca.key')), // Ensure the path is correct
+            };
+            // Create HTTPS server
+            const httpsServer = https.createServer(options, this.expressApp);
+            // Specify the port to listen on, for example 443 for default HTTPS
+            const PORT = 443;
+            httpsServer.listen(PORT, () => {
+                this.log.info(`The frontend is running on ${UNDERLINE}https://localhost:${PORT}${UNDERLINEOFF}${rs}`);
+            });
+        }
         this.log.debug(`Frontend initialized on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
     }
     /**
@@ -2699,6 +2766,8 @@ export class Matterbridge extends EventEmitter {
                 attributes += `Humidity: ${clusterServer.getMeasuredValueAttribute() / 100}% `;
             if (clusterServer.name === 'PressureMeasurement')
                 attributes += `Pressure: ${clusterServer.getMeasuredValueAttribute()} `;
+            if (clusterServer.name === 'FlowMeasurement')
+                attributes += `Pressure: ${clusterServer.getMeasuredValueAttribute()} `;
         });
         return attributes;
     }
@@ -2715,34 +2784,22 @@ function restartProcess() {
     stdio: 'inherit',
   });
 
+  // Handle errors
+  newProcess.on('error', (err) => {
+    console.error('Failed to start new process:', err);
+  });
+
   // Unreference the new process so that the current process can exit
   newProcess.unref();
 
   // Exit the current process
+  cleanup();
   process.exit();
 }
 
-import * as WebSocket from 'ws';
-
-const wss = new WebSocket.Server({ port: 8080 });
 
-wss.on('connection', ws => {
-  ws.on('message', message => {
-    console.log(`Received message => ${message}`)
-  });
-
-  // Send a message to the frontend
-  ws.send('Hello from backend!');
-});
-
-const ws = new WebSocket('ws://localhost:8080');
-
-ws.onmessage = (event) => {
-  console.log(`Received message => ${event.data}`);
-};
-
-*/
 /*
+How frontend was created
 npx create-react-app matterbridge-frontend
 cd matterbridge-frontend
 npm install react-router-dom