matterbridge 1.2.7 → 1.2.9

package/dist/matterbridge.js

@@ -26,10 +26,12 @@ 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';
 import path from 'path';
+import WebSocket, { WebSocketServer } from 'ws';
 import { CommissioningController, CommissioningServer, MatterServer } from '@project-chip/matter-node.js';
 import { BasicInformationCluster, BooleanStateCluster, 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -90,6 +92,7 @@ export class Matterbridge extends EventEmitter {
     nodeContext;
     expressApp;
     expressServer;
+    webSocketServer;
     storageManager;
     matterbridgeContext;
     mattercontrollerContext;
@@ -112,13 +115,96 @@ export class Matterbridge extends EventEmitter {
     static async loadInstance(initialize = false) {
         if (!Matterbridge.instance) {
             // eslint-disable-next-line no-console
-            console.log(wr + 'Matterbridge instance does not exists!', initialize ? 'Initializing...' : 'Not initializing...', rs);
+            if (hasParameter('debug'))
+                console.log(wr + 'Creating a new instance of Matterbridge.', initialize ? 'Initializing...' : 'Not initializing...', rs);
             Matterbridge.instance = new Matterbridge();
             if (initialize)
                 await Matterbridge.instance.initialize();
         }
         return Matterbridge.instance;
     }
+    /**
+     * Initializes the Matterbridge instance as extension for zigbee2mqtt.
+     *
+     * @returns A Promise that resolves when the initialization is complete.
+     */
+    async initializeAsExtension(dataPath, debugEnabled) {
+        // Set the bridge mode
+        this.bridgeMode = 'bridge';
+        // Set the first port to use
+        this.port = 5560;
+        // Set Matterbridge logger
+        this.debugEnabled = debugEnabled;
+        this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: this.debugEnabled });
+        this.log.debug('Matterbridge extension is starting...');
+        // Initialize NodeStorage
+        this.matterbridgeDirectory = dataPath;
+        this.log.debug('Creating node storage manager dir: ' + path.join(this.matterbridgeDirectory, 'node_storage'));
+        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;
+        // Set matter.js logger level and format
+        Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
+        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;
+        await this.matterbridgeContext.set('softwareVersion', 1);
+        await this.matterbridgeContext.set('softwareVersionString', this.matterbridgeVersion);
+        await this.matterbridgeContext.set('hardwareVersion', 0);
+        await this.matterbridgeContext.set('hardwareVersionString', '1.0.0'); // Update with the extension version
+        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}`);
+        this.matterAggregator = await this.createMatterAggregator(this.matterbridgeContext);
+        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);
+        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);
+    }
+    /**
+     * Close the Matterbridge instance as extension for zigbee2mqtt.
+     *
+     * @returns A Promise that resolves when the initialization is complete.
+     */
+    async closeAsExtension() {
+        // Closing matter
+        await this.stopMatter();
+        // Closing storage
+        await this.stopStorage();
+    }
     /**
      * Initializes the Matterbridge application.
      *
@@ -202,66 +288,6 @@ export class Matterbridge extends EventEmitter {
         // Parse command line
         this.parseCommandLine();
     }
-    /**
-     * Spawns a child process with the given command and arguments.
-     * @param command - The command to execute.
-     * @param args - The arguments to pass to the command (default: []).
-     * @returns A promise that resolves when the child process exits successfully, or rejects if there is an error.
-     */
-    async spawnCommand(command, args = []) {
-        /*
-        npm > npm.cmd on windows
-        */
-        if (process.platform === 'win32' && command === 'npm') {
-            command = command + '.cmd';
-        }
-        if (process.platform === 'linux' && command === 'npm' && !hasParameter('docker')) {
-            args.unshift(command);
-            command = 'sudo';
-        }
-        return new Promise((resolve, reject) => {
-            const childProcess = spawn(command, args, {
-                stdio: ['inherit', 'pipe', 'pipe'],
-            });
-            childProcess.on('error', (err) => {
-                this.log.error(`Failed to start child process: ${err.message}`);
-                reject(err); // Reject the promise on error
-            });
-            childProcess.on('close', (code) => {
-                if (code === 0) {
-                    this.log.info(`Child process stdio streams have closed with code ${code}`);
-                    resolve();
-                }
-                else {
-                    this.log.error(`Child process stdio streams have closed with code ${code}`);
-                    reject(new Error(`Process exited with code ${code}`));
-                }
-            });
-            // The 'exit' event might be redundant here since 'close' is also being handled
-            childProcess.on('exit', (code, signal) => {
-                this.log.info(`Child process exited with code ${code} and signal ${signal}`);
-            });
-            childProcess.on('disconnect', () => {
-                this.log.info('Child process has been disconnected from the parent');
-            });
-            if (childProcess.stdout) {
-                childProcess.stdout.on('data', (data) => {
-                    // Convert the Buffer data to a string.
-                    const message = data.toString();
-                    this.log.info(message);
-                    // TODO: Send this message to the frontend.
-                });
-            }
-            if (childProcess.stderr) {
-                childProcess.stderr.on('data', (data) => {
-                    // Convert the Buffer data to a string.
-                    const message = data.toString();
-                    this.log.error(message);
-                    // TODO: Handle the error message.
-                });
-            }
-        });
-    }
     /**
      * Parses the command line arguments and performs the corresponding actions.
      * @private
@@ -579,6 +605,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)
@@ -634,11 +661,31 @@ 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) {
+                // Close all active connections
+                this.webSocketServer.clients.forEach((client) => {
+                    if (client.readyState === WebSocket.OPEN) {
+                        client.close();
+                    }
+                });
+                this.webSocketServer.close((error) => {
+                    if (error) {
+                        this.log.error(`Error closing WebSocket server: ${error}`);
+                    }
+                    else {
+                        this.log.debug('WebSocket server closed successfully');
+                    }
+                });
+                this.webSocketServer = undefined;
             }
             /*const cleanupTimeout1 =*/ setTimeout(async () => {
                 // Closing matter
@@ -688,26 +735,12 @@ export class Matterbridge extends EventEmitter {
                         Matterbridge.instance = undefined;
                         this.emit('shutdown');
                     }
-                }, 1 * 1000);
+                }, 2 * 1000);
                 //cleanupTimeout2.unref();
             }, 3 * 1000);
             //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.
@@ -803,7 +836,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
@@ -1220,7 +1253,9 @@ export class Matterbridge extends EventEmitter {
             // Call the default export function of the plugin, passing this MatterBridge instance
             if (pluginInstance.default) {
                 const config = await this.loadPluginConfig(plugin);
-                const platform = pluginInstance.default(this, new AnsiLogger({ logName: plugin.description, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: this.debugEnabled }), config);
+                const log = new AnsiLogger({ logName: plugin.description, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: this.debugEnabled });
+                //log.setCallback(this.wssSendMessage.bind(this));
+                const platform = pluginInstance.default(this, log, config);
                 platform.name = packageJson.name;
                 platform.config = config;
                 plugin.name = packageJson.name;
@@ -1482,20 +1517,17 @@ export class Matterbridge extends EventEmitter {
                 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') {
@@ -1532,6 +1564,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 });
@@ -1572,21 +1606,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) {
@@ -1605,6 +1624,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);
@@ -1621,7 +1648,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');
     }
@@ -1741,6 +1768,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.
      *
@@ -1793,7 +1863,14 @@ export class Matterbridge extends EventEmitter {
                 info.forEach((session) => {
                     this.log.debug(`***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}`);
                         connected = true;
                     }
                 });
@@ -2028,11 +2105,6 @@ export class Matterbridge extends EventEmitter {
         this.matterbridgeInformation.rootDirectory = this.rootDirectory;
         this.log.debug(`Root Directory: ${this.rootDirectory}`);
         // Global node_modules directory
-        /*
-        this.globalModulesDirectory = await this.getGlobalNodeModules();
-        this.matterbridgeInformation.globalModulesDirectory = this.globalModulesDirectory;
-        this.log.debug(`Global node_modules Directory: ${this.globalModulesDirectory}`);
-        */
         if (this.nodeContext)
             this.globalModulesDirectory = await this.nodeContext.get('globalModulesDirectory', '');
         this.log.debug(`Global node_modules Directory: ${this.globalModulesDirectory}`);
@@ -2100,11 +2172,6 @@ export class Matterbridge extends EventEmitter {
         this.matterbridgeInformation.matterbridgeVersion = this.matterbridgeVersion;
         this.log.debug(`Matterbridge Version: ${this.matterbridgeVersion}`);
         // Matterbridge latest version
-        /*
-        this.matterbridgeLatestVersion = await this.getLatestVersion('matterbridge');
-        this.matterbridgeInformation.matterbridgeLatestVersion = this.matterbridgeLatestVersion;
-        this.log.debug(`Matterbridge Latest Version: ${this.matterbridgeLatestVersion}`);
-        */
         if (this.nodeContext)
             this.matterbridgeLatestVersion = await this.nodeContext.get('matterbridgeLatestVersion', '');
         this.log.debug(`Matterbridge Latest Version: ${this.matterbridgeLatestVersion}`);
@@ -2174,6 +2241,99 @@ export class Matterbridge extends EventEmitter {
         }));
         return baseRegisteredPlugins;
     }
+    /**
+     * Spawns a child process with the given command and arguments.
+     * @param command - The command to execute.
+     * @param args - The arguments to pass to the command (default: []).
+     * @returns A promise that resolves when the child process exits successfully, or rejects if there is an error.
+     */
+    async spawnCommand(command, args = []) {
+        /*
+        npm > npm.cmd on windows
+        cmd.exe ['dir'] on windows
+        await this.spawnCommand('npm', ['install', '-g', 'matterbridge']);
+        process.on('unhandledRejection', (reason, promise) => {
+          this.log.error('Unhandled Rejection at:', promise, 'reason:', reason);
+        });
+        */
+        if (process.platform === 'win32' && command === 'npm') {
+            // Must be spawn('cmd.exe', ['/c', 'npm -g install <package>']);
+            const argstring = 'npm ' + args.join(' ');
+            args.splice(0, args.length, '/c', argstring);
+            command = 'cmd.exe';
+        }
+        if (process.platform === 'linux' && command === 'npm' && !hasParameter('docker')) {
+            args.unshift(command);
+            command = 'sudo';
+        }
+        this.log.debug(`Spawning command ${command} with ${debugStringify(args)}`);
+        return new Promise((resolve, reject) => {
+            const childProcess = spawn(command, args, {
+                stdio: ['inherit', 'pipe', 'pipe'],
+            });
+            childProcess.on('error', (err) => {
+                this.log.error(`Failed to start child process: ${err.message}`);
+                reject(err); // Reject the promise on error
+            });
+            childProcess.on('close', (code) => {
+                if (code === 0) {
+                    this.log.debug(`Child process stdio streams have closed with code ${code}`);
+                    resolve();
+                }
+                else {
+                    this.log.error(`Child process stdio streams have closed with code ${code}`);
+                    reject(new Error(`Child process stdio streams have closed with code  ${code}`));
+                }
+            });
+            childProcess.on('exit', (code, signal) => {
+                if (code === 0) {
+                    this.log.debug(`Child process exited with code ${code} and signal ${signal}`);
+                    resolve();
+                }
+                else {
+                    this.log.error(`Child process exited with code ${code} and signal ${signal}`);
+                    reject(new Error(`Child process exited with code ${code} and signal ${signal}`));
+                }
+            });
+            childProcess.on('disconnect', () => {
+                this.log.debug('Child process has been disconnected from the parent');
+                resolve();
+            });
+            if (childProcess.stdout) {
+                childProcess.stdout.on('data', (data) => {
+                    const message = data.toString().trim();
+                    //this.log.info('\n' + 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('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
+        const cleanMessage = message.replace(/\x1B\[[0-9;]*[m|s|u|K]/g, '');
+        // Remove leading asterisks from the message
+        const finalMessage = cleanMessage.replace(/^\*+/, '');
+        this.webSocketServer?.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(JSON.stringify({ type, subType, message: finalMessage }));
+            }
+        });
+    }
     /**
      * Initializes the frontend of Matterbridge.
      *
@@ -2181,10 +2341,57 @@ 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}`);
-        this.expressApp = express();
+        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.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.info(`WebSocketServer received message => ${message}`);
+            });
+            ws.on('close', () => {
+                this.log.info('WebSocketServer client disconnected');
+                if (this.webSocketServer?.clients.size === 0) {
+                    this.log.setGlobalCallback(undefined);
+                    this.log.debug('WebSocketServer deactivated logger callback');
+                }
+            });
+            ws.on('error', (error) => {
+                this.log.error(`WebSocketServer error: ${error}`);
+            });
+        });
         // 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);
@@ -2204,53 +2411,30 @@ export class Matterbridge extends EventEmitter {
                 res.json({ valid: false });
             }
         });
-        // 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) => {
@@ -2336,11 +2520,11 @@ export class Matterbridge extends EventEmitter {
                 res.status(400).json({ error: 'No command provided' });
                 return;
             }
-            this.log.info(`Received frontend command: ${command}:${param}`);
+            this.log.debug(`Received frontend command: ${command}:${param}`);
             // 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
@@ -2374,9 +2558,9 @@ export class Matterbridge extends EventEmitter {
             }
             // Handle the command update from Header
             if (command === 'update') {
-                this.log.warn(`***Updating matterbridge ${plg}${param}${db}`);
+                this.log.info('Updating matterbridge...');
                 try {
-                    await this.spawnCommand('npm', ['install', '-g', 'matterbridge']);
+                    await this.spawnCommand('npm', ['install', '-g', 'matterbridge', '--loglevel=verbose']);
                     this.log.info('Matterbridge has been updated. Full restart required.');
                 }
                 catch (error) {
@@ -2389,10 +2573,10 @@ export class Matterbridge extends EventEmitter {
             // Handle the command installplugin from Home
             if (command === 'installplugin') {
                 param = param.replace(/\*/g, '\\');
-                this.log.warn(`***Installing plugin ${plg}${param}${db}`);
+                this.log.info(`Installing plugin ${plg}${param}${db}...`);
                 try {
-                    await this.spawnCommand('npm', ['install', '-g', param]);
-                    this.log.info(`Plugin ${plg}${param}${nf} installed. Restart required.`);
+                    await this.spawnCommand('npm', ['install', '-g', param, '--loglevel=verbose']);
+                    this.log.info(`Plugin ${plg}${param}${nf} installed. Full restart required.`);
                 }
                 catch (error) {
                     this.log.error(`Error installing plugin ${plg}${param}${er}`);
@@ -2518,9 +2702,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}`);
     }
     /**
@@ -2588,7 +2789,6 @@ function restartProcess() {
 }
 
 import * as WebSocket from 'ws';
-const globalModulesDir = require('global-modules');
 
 const wss = new WebSocket.Server({ port: 8080 });
 
@@ -2607,13 +2807,6 @@ ws.onmessage = (event) => {
   console.log(`Received message => ${event.data}`);
 };
 
-*/
-/*
-// In Matterbridge
-global.matterbridgeInstance = Matterbridge.loadInstance();
-
-// In plugins
-const matterbridge = global.matterbridgeInstance;
 */
 /*
 npx create-react-app matterbridge-frontend