matterbridge 1.5.10 → 1.6.1

package/dist/matterbridge.js

@@ -36,7 +36,7 @@ import { NodeStorageManager } from 'node-persist-manager';
 import { AnsiLogger, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, stringify, BRIGHT, RESET, er, nf, rs, wr, RED, GREEN, zb, hk, or, idn, BLUE, CYAN, nt } from 'node-ansi-logger';
 // Matterbridge
 import { MatterbridgeDevice } from './matterbridgeDevice.js';
-import { logInterfaces, wait, waiter, createZip } from './utils/utils.js';
+import { logInterfaces, wait, waiter, createZip, copyDirectory } from './utils/utils.js';
 import { PluginManager } from './pluginManager.js';
 import { DeviceManager } from './deviceManager.js';
 // @project-chip/matter-node.js
@@ -50,6 +50,7 @@ import { StorageBackendDisk, StorageBackendJsonFile, StorageManager } from '@pro
 import { getParameter, getIntParameter, hasParameter } from '@project-chip/matter-node.js/util';
 import { CryptoNode } from '@project-chip/matter-node.js/crypto';
 import { Specification } from '@project-chip/matter-node.js/model';
+import { WS_ID_LOG, WS_ID_REFRESH_NEEDED, WS_ID_RESTART_NEEDED, wsMessageHandler } from './matterbridgeWebsocket.js';
 // Default colors
 const plg = '\u001B[38;5;33m';
 const dev = '\u001B[38;5;79m';
@@ -130,13 +131,13 @@ export class Matterbridge extends EventEmitter {
     initialized = false;
     execRunningCount = 0;
     startMatterInterval;
-    cleanupTimeout1;
-    cleanupTimeout2;
     checkUpdateInterval;
     configureTimeout;
     reachabilityTimeout;
     sigintHandler;
     sigtermHandler;
+    exceptionHandler;
+    rejectionHandler;
     // Frontend
     expressApp;
     httpServer;
@@ -156,11 +157,16 @@ export class Matterbridge extends EventEmitter {
     matterAggregator;
     commissioningServer;
     commissioningController;
+    aggregatorVendorId = VendorId(0xfff1);
+    aggregatorProductId = 0x8000;
     static instance;
     // We load asyncronously so is private
     constructor() {
         super();
+        // Bind the handler to the instance
+        this.matterbridgeMessageHandler = wsMessageHandler.bind(this);
     }
+    matterbridgeMessageHandler;
     /** ***********************************************************************************************************************************/
     /**                                              loadInstance() and cleanup() methods                                                 */
     /** ***********************************************************************************************************************************/
@@ -219,19 +225,54 @@ export class Matterbridge extends EventEmitter {
         // Set the matterbridge directory
         this.homeDirectory = getParameter('homedir') ?? os.homedir();
         this.matterbridgeDirectory = path.join(this.homeDirectory, '.matterbridge');
-        // Initialize nodeStorage and nodeContext
-        // this.log.debug(`Creating node storage manager: ${CYAN}${this.nodeStorageName}${db}`);
-        this.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridgeDirectory, this.nodeStorageName), writeQueue: false, expiredInterval: undefined, logging: false });
-        // this.log.debug('Creating node storage context for matterbridge');
-        this.nodeContext = await this.nodeStorage.createStorage('matterbridge');
-        // Check if the storage is corrupted and remove it
-        // TODO: Check if the storage is corrupted and remove it
         // Create matterbridge logger
-        this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: "info" /* LogLevel.INFO */ });
-        // Create the file logger for matterbridge (context: matterbridgeFileLog)
-        if (hasParameter('filelogger') || (await this.nodeContext.get('matterbridgeFileLog', false))) {
-            AnsiLogger.setGlobalLogfile(path.join(this.matterbridgeDirectory, this.matterbrideLoggerFile), "debug" /* LogLevel.DEBUG */, true);
-            this.matterbridgeInformation.fileLogger = true;
+        this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: hasParameter('debug') ? "debug" /* LogLevel.DEBUG */ : "info" /* LogLevel.INFO */ });
+        // Initialize nodeStorage and nodeContext
+        try {
+            this.log.debug(`Creating node storage manager: ${CYAN}${this.nodeStorageName}${db}`);
+            this.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridgeDirectory, this.nodeStorageName), writeQueue: false, expiredInterval: undefined, logging: false });
+            this.log.debug('Creating node storage context for matterbridge');
+            this.nodeContext = await this.nodeStorage.createStorage('matterbridge');
+            // TODO: Remove this code when node-persist-manager is updated
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const keys = (await this.nodeStorage?.storage.keys());
+            for (const key of keys) {
+                this.log.debug(`Checking node storage manager key: ${CYAN}${key}${db}`);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                await this.nodeStorage?.storage.get(key);
+            }
+            const storages = await this.nodeStorage.getStorageNames();
+            for (const storage of storages) {
+                this.log.debug(`Checking storage: ${CYAN}${storage}${db}`);
+                const nodeContext = await this.nodeStorage?.createStorage(storage);
+                // TODO: Remove this code when node-persist-manager is updated
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const keys = (await nodeContext?.storage.keys());
+                keys.forEach(async (key) => {
+                    this.log.debug(`Checking key: ${CYAN}${storage}:${key}${db}`);
+                    await nodeContext?.get(key);
+                });
+            }
+            // Creating a backup of the node storage since it is not corrupted
+            this.log.debug('Creating node storage backup...');
+            await copyDirectory(path.join(this.matterbridgeDirectory, this.nodeStorageName), path.join(this.matterbridgeDirectory, this.nodeStorageName + '.backup'));
+            this.log.debug('Created node storage backup');
+        }
+        catch (error) {
+            // Restoring the backup of the node storage since it is corrupted
+            this.log.error(`Error creating node storage manager and context: ${error instanceof Error ? error.message : error}`);
+            if (hasParameter('norestore')) {
+                this.log.fatal(`The matterbridge node storage is corrupted. Parameter -norestore found: exiting...`);
+                await this.cleanup('Fatal error creating node storage manager and context for matterbridge');
+                return;
+            }
+            this.log.notice(`The matterbridge storage is corrupted. Restoring it with backup...`);
+            await copyDirectory(path.join(this.matterbridgeDirectory, this.nodeStorageName + '.backup'), path.join(this.matterbridgeDirectory, this.nodeStorageName));
+            this.log.notice(`The matterbridge storage has been restored with backup`);
+        }
+        if (!this.nodeStorage || !this.nodeContext) {
+            this.log.fatal('Fatal error creating node storage manager and context for matterbridge');
+            throw new Error('Fatal error creating node storage manager and context for matterbridge');
         }
         // Set matterbridge logger level (context: matterbridgeLogLevel)
         if (hasParameter('logger')) {
@@ -263,6 +304,11 @@ export class Matterbridge extends EventEmitter {
             this.log.logLevel = await this.nodeContext.get('matterbridgeLogLevel', "info" /* LogLevel.INFO */);
         }
         MatterbridgeDevice.logLevel = this.log.logLevel;
+        // Create the file logger for matterbridge (context: matterbridgeFileLog)
+        if (hasParameter('filelogger') || (await this.nodeContext.get('matterbridgeFileLog', false))) {
+            AnsiLogger.setGlobalLogfile(path.join(this.matterbridgeDirectory, this.matterbrideLoggerFile), this.log.logLevel, true);
+            this.matterbridgeInformation.fileLogger = true;
+        }
         this.log.notice('Matterbridge is starting...');
         this.log.debug(`Matterbridge logLevel: ${this.log.logLevel} fileLoger: ${this.matterbridgeInformation.fileLogger}.`);
         // Set matter.js logger level, format and logger (context: matterLogLevel)
@@ -300,7 +346,7 @@ export class Matterbridge extends EventEmitter {
         if (hasParameter('matterfilelogger') || (await this.nodeContext.get('matterFileLog', false))) {
             this.matterbridgeInformation.matterFileLogger = true;
             Logger.addLogger('matterfilelogger', await this.createMatterFileLogger(path.join(this.matterbridgeDirectory, this.matterLoggerFile), true), {
-                defaultLogLevel: Level.DEBUG,
+                defaultLogLevel: Logger.defaultLogLevel,
                 logFormat: Format.PLAIN,
             });
         }
@@ -345,7 +391,7 @@ export class Matterbridge extends EventEmitter {
                 // We don't do this when the add parameter is set because we shut down the process after adding the plugin
                 this.log.info(`Error parsing plugin ${plg}${plugin.name}${nf}. Trying to reinstall it from npm.`);
                 try {
-                    await this.spawnCommand('npm', ['install', '-g', '--omit=dev', plugin.name]);
+                    await this.spawnCommand('npm', ['install', '-g', plugin.name, '--omit=dev', '--verbose']);
                     this.log.info(`Plugin ${plg}${plugin.name}${nf} reinstalled.`);
                     plugin.error = false;
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -381,8 +427,8 @@ export class Matterbridge extends EventEmitter {
             this.log.error(`Node version ${versionMajor} is not supported. Please upgrade to ${minNodeVersion} or above.`);
             throw new Error(`Node version ${versionMajor} is not supported. Please upgrade to ${minNodeVersion} or above.`);
         }
-        // Register SIGINT SIGTERM signal handlers
-        this.registerSignalHandlers();
+        // Register process handlers
+        this.registerProcessHandlers();
         // Parse command line
         await this.parseCommandLine();
         this.initialized = true;
@@ -413,6 +459,7 @@ export class Matterbridge extends EventEmitter {
       - logstorage:            log the node storage
       - sudo:                  force the use of sudo to install or update packages if the internal logic fails
       - nosudo:                force not to use sudo to install or update packages if the internal logic fails
+      - norestore:             force not to automatically restore the matterbridge node storage and the matter storage from backup if it is corrupted
       - ssl:                   enable SSL for the frontend and WebSockerServer (certificates in .matterbridge/certs directory cert.pem, key.pem and ca.pem (optional))
       - add [plugin path]:     register the plugin from the given absolute or relative path
       - add [plugin name]:     register the globally installed plugin with the given name
@@ -520,9 +567,13 @@ export class Matterbridge extends EventEmitter {
             return;
         }
         // Start the matter storage and create the matterbridge context
-        await this.startMatterStorage('json', path.join(this.matterbridgeDirectory, this.matterStorageName));
-        this.log.debug(`Creating commissioning server context for ${plg}Matterbridge${db}`);
-        this.matterbridgeContext = await this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggregator');
+        try {
+            await this.startMatterStorage('json', path.join(this.matterbridgeDirectory, this.matterStorageName));
+        }
+        catch (error) {
+            this.log.fatal(`Fatal error creating matter storage: ${error instanceof Error ? error.message : error}`);
+            throw new Error(`Fatal error creating matter storage: ${error instanceof Error ? error.message : error}`);
+        }
         if (hasParameter('reset') && getParameter('reset') === undefined) {
             this.log.info('Resetting Matterbridge commissioning information...');
             await this.matterbridgeContext?.clearAll();
@@ -560,12 +611,13 @@ export class Matterbridge extends EventEmitter {
                 this.getPluginLatestVersion(plugin);
             }
         }, 60 * 60 * 1000);
+        // Start the matterbridge in mode test
         if (hasParameter('test')) {
             this.bridgeMode = 'bridge';
             MatterbridgeDevice.bridgeMode = 'bridge';
-            await this.startTest();
             return;
         }
+        // Start the matterbridge in mode controller
         if (hasParameter('controller')) {
             this.bridgeMode = 'controller';
             await this.startController();
@@ -576,96 +628,81 @@ export class Matterbridge extends EventEmitter {
             this.log.info('Setting default matterbridge start mode to bridge');
             await this.nodeContext?.set('bridgeMode', 'bridge');
         }
+        // Start matterbridge in bridge mode
         if (hasParameter('bridge') || (!hasParameter('childbridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'bridge')) {
             this.bridgeMode = 'bridge';
             MatterbridgeDevice.bridgeMode = 'bridge';
-            if (!this.storageManager)
-                throw new Error('No storage manager initialized');
-            this.log.debug('Starting matterbridge in mode', this.bridgeMode);
-            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}`);
-            this.matterAggregator = await this.createMatterAggregator(this.matterbridgeContext, 'Matterbridge');
-            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' });
-            for (const plugin of this.plugins) {
-                plugin.configJson = await this.plugins.loadConfig(plugin);
-                plugin.schemaJson = await this.plugins.loadSchema(plugin);
-                // Check if the plugin is available
-                if (!(await this.plugins.resolve(plugin.path))) {
-                    this.log.error(`Plugin ${plg}${plugin.name}${er} not found or not validated. Disabling it.`);
-                    plugin.enabled = false;
-                    plugin.error = true;
-                    continue;
-                }
-                // Check if the plugin has a new version
-                this.getPluginLatestVersion(plugin); // No await do it asyncronously
-                if (!plugin.enabled) {
-                    this.log.info(`Plugin ${plg}${plugin.name}${nf} not enabled`);
-                    continue;
-                }
-                plugin.error = false;
-                plugin.locked = false;
-                plugin.loaded = false;
-                plugin.started = false;
-                plugin.configured = false;
-                plugin.connected = undefined;
-                plugin.registeredDevices = undefined;
-                plugin.addedDevices = undefined;
-                plugin.qrPairingCode = undefined;
-                plugin.manualPairingCode = undefined;
-                this.plugins.load(plugin, true, 'Matterbridge is starting'); // No await do it asyncronously
-            }
+            this.log.debug(`Starting matterbridge in mode ${this.bridgeMode}`);
             await this.startBridge();
             return;
         }
+        // Start matterbridge in childbridge mode
         if (hasParameter('childbridge') || (!hasParameter('bridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'childbridge')) {
             this.bridgeMode = 'childbridge';
             MatterbridgeDevice.bridgeMode = 'childbridge';
-            if (!this.storageManager)
-                throw new Error('No storage manager initialized');
-            this.log.debug('Starting matterbridge in mode', this.bridgeMode);
-            this.matterServer = this.createMatterServer(this.storageManager);
-            for (const plugin of this.plugins) {
-                plugin.configJson = await this.plugins.loadConfig(plugin);
-                plugin.schemaJson = await this.plugins.loadSchema(plugin);
-                // Check if the plugin is available
-                if (!(await this.plugins.resolve(plugin.path))) {
-                    this.log.error(`Plugin ${plg}${plugin.name}${er} not found or not validated. Disabling it.`);
-                    plugin.enabled = false;
-                    plugin.error = true;
-                    continue;
-                }
-                // Check if the plugin has a new version
-                this.getPluginLatestVersion(plugin); // No await do it asyncronously
-                if (!plugin.enabled) {
-                    this.log.info(`Plugin ${plg}${plugin.name}${nf} not enabled`);
-                    continue;
-                }
-                plugin.error = false;
-                plugin.locked = false;
-                plugin.loaded = false;
-                plugin.started = false;
-                plugin.configured = false;
-                plugin.connected = false;
-                plugin.registeredDevices = undefined;
-                plugin.addedDevices = undefined;
-                plugin.qrPairingCode = undefined;
-                plugin.manualPairingCode = undefined;
-                this.plugins.load(plugin, true, 'Matterbridge is starting'); // No await do it asyncronously
-            }
+            this.log.debug(`Starting matterbridge in mode ${this.bridgeMode}`);
             await this.startChildbridge();
             return;
         }
     }
     /**
-     * Registers the signal handlers for SIGINT and SIGTERM.
+     * Asynchronously loads and starts the registered plugins.
+     *
+     * This method is responsible for initializing and staarting all enabled plugins.
+     * It ensures that each plugin is properly loaded and started before the ridge starts.
+     *
+     * @returns {Promise<void>} A promise that resolves when all plugins have been loaded and started.
+     */
+    async startPlugins() {
+        // Check, load and start the plugins
+        for (const plugin of this.plugins) {
+            plugin.configJson = await this.plugins.loadConfig(plugin);
+            plugin.schemaJson = await this.plugins.loadSchema(plugin);
+            // Check if the plugin is available
+            if (!(await this.plugins.resolve(plugin.path))) {
+                this.log.error(`Plugin ${plg}${plugin.name}${er} not found or not validated. Disabling it.`);
+                plugin.enabled = false;
+                plugin.error = true;
+                continue;
+            }
+            // Check if the plugin has a new version
+            this.getPluginLatestVersion(plugin); // No await do it asyncronously
+            if (!plugin.enabled) {
+                this.log.info(`Plugin ${plg}${plugin.name}${nf} not enabled`);
+                continue;
+            }
+            plugin.error = false;
+            plugin.locked = false;
+            plugin.loaded = false;
+            plugin.started = false;
+            plugin.configured = false;
+            plugin.connected = undefined;
+            plugin.registeredDevices = undefined;
+            plugin.addedDevices = undefined;
+            plugin.qrPairingCode = undefined;
+            plugin.manualPairingCode = undefined;
+            this.plugins.load(plugin, true, 'Matterbridge is starting'); // No await do it asyncronously
+        }
+        this.wssSendRefreshRequired();
+    }
+    /**
+     * Registers the process handlers for uncaughtException, unhandledRejection, SIGINT and SIGTERM.
      * When either of these signals are received, the cleanup method is called with an appropriate message.
      */
-    registerSignalHandlers() {
+    registerProcessHandlers() {
+        this.log.debug(`Registering uncaughtException and unhandledRejection handlers...`);
+        process.removeAllListeners('uncaughtException');
+        process.removeAllListeners('unhandledRejection');
+        this.exceptionHandler = async (error) => {
+            this.log.fatal('Unhandled Exception detected at:', error.stack || error, rs);
+            await this.cleanup('Unhandled Exception detected, cleaning up...');
+        };
+        process.on('uncaughtException', this.exceptionHandler);
+        this.rejectionHandler = async (reason, promise) => {
+            this.log.fatal('Unhandled Rejection detected at:', promise, 'reason:', reason instanceof Error ? reason.stack : reason, rs);
+            await this.cleanup('Unhandled Rejection detected, cleaning up...');
+        };
+        process.on('unhandledRejection', this.rejectionHandler);
         this.log.debug(`Registering SIGINT and SIGTERM signal handlers...`);
         this.sigintHandler = async () => {
             await this.cleanup('SIGINT received, cleaning up...');
@@ -677,9 +714,16 @@ export class Matterbridge extends EventEmitter {
         process.on('SIGTERM', this.sigtermHandler);
     }
     /**
-     * Deregisters the SIGINT and SIGTERM signal handlers.
+     * Deregisters the process uncaughtException, unhandledRejection, SIGINT and SIGTERM signal handlers.
      */
-    deregisterSignalHandlers() {
+    deregisterProcesslHandlers() {
+        this.log.debug(`Deregistering uncaughtException and unhandledRejection handlers...`);
+        if (this.exceptionHandler)
+            process.off('uncaughtException', this.exceptionHandler);
+        this.exceptionHandler = undefined;
+        if (this.rejectionHandler)
+            process.off('unhandledRejection', this.rejectionHandler);
+        this.rejectionHandler = undefined;
         this.log.debug(`Deregistering SIGINT and SIGTERM signal handlers...`);
         if (this.sigintHandler)
             process.off('SIGINT', this.sigintHandler);
@@ -1080,8 +1124,8 @@ export class Matterbridge extends EventEmitter {
         if (this.initialized && !this.hasCleanupStarted) {
             this.hasCleanupStarted = true;
             this.log.info(message);
-            // Deregisters the SIGINT and SIGTERM signal handlers
-            this.deregisterSignalHandlers();
+            // Deregisters the process handlers
+            this.deregisterProcesslHandlers();
             // Clear the start matter interval
             if (this.startMatterInterval) {
                 clearInterval(this.startMatterInterval);
@@ -1155,7 +1199,6 @@ export class Matterbridge extends EventEmitter {
                 });
                 this.webSocketServer = undefined;
             }
-            // this.cleanupTimeout1 = setTimeout(async () => {
             // Closing matter
             await this.stopMatterServer();
             // Closing matter storage
@@ -1201,9 +1244,6 @@ export class Matterbridge extends EventEmitter {
             }
             this.plugins.clear();
             this.devices.clear();
-            // this.registeredDevices = [];
-            // this.log.info('Waiting for matter to deliver last messages...');
-            // this.cleanupTimeout2 = setTimeout(async () => {
             if (restart) {
                 if (message === 'updating...') {
                     this.log.info('Cleanup completed. Updating...');
@@ -1238,8 +1278,6 @@ export class Matterbridge extends EventEmitter {
             }
             this.hasCleanupStarted = false;
             this.initialized = false;
-            // }, 2 * 1000);
-            // }, 3 * 1000);
         }
     }
     /**
@@ -1249,17 +1287,17 @@ export class Matterbridge extends EventEmitter {
      * @returns {Promise<void>} - A promise that resolves when the device is added.
      */
     async addBridgedDevice(pluginName, device) {
-        this.log.debug(`Adding bridged device ${dev}${device.deviceName}${db} (${dev}${device.name}${db}) for plugin ${plg}${pluginName}${db}`);
+        this.log.debug(`Adding bridged device ${dev}${device.deviceName}${db} (${zb}${device.name}${db}) for plugin ${plg}${pluginName}${db}`);
         // Check if the plugin is registered
         const plugin = this.plugins.get(pluginName);
         if (!plugin) {
-            this.log.error(`Error adding bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) plugin ${plg}${pluginName}${er} not found`);
+            this.log.error(`Error adding bridged device ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) plugin ${plg}${pluginName}${er} not found`);
             return;
         }
         // Register and add the device to matterbridge aggregator in bridge mode
         if (this.bridgeMode === 'bridge') {
             if (!this.matterAggregator) {
-                this.log.error(`Adding bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
+                this.log.error(`Adding bridged device ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
                 return;
             }
             this.matterAggregator.addBridgedDevice(device);
@@ -1314,17 +1352,17 @@ export class Matterbridge extends EventEmitter {
      * @returns A Promise that resolves when the device is successfully removed.
      */
     async removeBridgedDevice(pluginName, device) {
-        this.log.debug(`Removing bridged device ${dev}${device.deviceName}${db} (${dev}${device.name}${db}) for plugin ${plg}${pluginName}${db}`);
+        this.log.debug(`Removing bridged device ${dev}${device.deviceName}${db} (${zb}${device.name}${db}) for plugin ${plg}${pluginName}${db}`);
         // Check if the plugin is registered
         const plugin = this.plugins.get(pluginName);
         if (!plugin) {
-            this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) for plugin ${plg}${pluginName}${er}: plugin not found`);
+            this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) for plugin ${plg}${pluginName}${er}: plugin not found`);
             return;
         }
         // Remove the device from matterbridge aggregator in bridge mode
         if (this.bridgeMode === 'bridge') {
             if (!this.matterAggregator) {
-                this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) for plugin ${plg}${pluginName}${er}: matterAggregator not found`);
+                this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) for plugin ${plg}${pluginName}${er}: matterAggregator not found`);
                 return;
             }
             if (device.number !== undefined) {
@@ -1334,7 +1372,7 @@ export class Matterbridge extends EventEmitter {
             // device.getClusterServerById(BridgedDeviceBasicInformation.Cluster.id)?.triggerShutDownEvent({});
             // device.getClusterServerById(BridgedDeviceBasicInformation.Cluster.id)?.triggerLeaveEvent({});
             this.matterAggregator?.removeBridgedDevice(device);
-            this.log.info(`Removed bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${dev}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
+            this.log.info(`Removed bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${zb}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
             if (plugin.registeredDevices !== undefined)
                 plugin.registeredDevices--;
             if (plugin.addedDevices !== undefined)
@@ -1344,13 +1382,13 @@ export class Matterbridge extends EventEmitter {
         if (this.bridgeMode === 'childbridge') {
             if (plugin.type === 'AccessoryPlatform') {
                 if (!plugin.commissioningServer) {
-                    this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) for plugin ${plg}${pluginName}${er}: commissioning server not found`);
+                    this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) for plugin ${plg}${pluginName}${er}: commissioning server not found`);
                     return;
                 }
             }
             else if (plugin.type === 'DynamicPlatform') {
                 if (!plugin.aggregator) {
-                    this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) for plugin ${plg}${pluginName}${er}: aggregator not found`);
+                    this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) for plugin ${plg}${pluginName}${er}: aggregator not found`);
                     return;
                 }
                 if (device.number !== undefined) {
@@ -1359,7 +1397,7 @@ export class Matterbridge extends EventEmitter {
                 }
                 plugin.aggregator.removeBridgedDevice(device);
             }
-            this.log.info(`Removed bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${dev}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
+            this.log.info(`Removed bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${zb}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
             if (plugin.registeredDevices !== undefined)
                 plugin.registeredDevices--;
             if (plugin.addedDevices !== undefined)
@@ -1388,18 +1426,28 @@ export class Matterbridge extends EventEmitter {
             }
         });
     }
-    async startTest() {
-        // Start the Matterbridge test
-    }
     /**
      * Starts the Matterbridge in bridge mode.
      * @private
      * @returns {Promise<void>} A promise that resolves when the Matterbridge is started.
      */
     async startBridge() {
-        // Plugins are loaded and started by loadPlugin on startup and plugin.loaded and plugin.started are set to true
         // Plugins are configured by a timer when matter server is started and plugin.configured is set to true
-        this.log.debug('Starting startMatterInterval in bridge mode');
+        if (!this.storageManager)
+            throw new Error('No storage manager initialized');
+        if (!this.matterbridgeContext)
+            throw new Error('No storage context initialized');
+        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}`);
+        this.matterAggregator = await this.createMatterAggregator(this.matterbridgeContext, 'Matterbridge');
+        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' });
+        await this.startPlugins();
+        this.log.debug('Starting start matter interval in bridge mode');
         let failCount = 0;
         this.startMatterInterval = setInterval(async () => {
             for (const plugin of this.plugins) {
@@ -1428,8 +1476,11 @@ export class Matterbridge extends EventEmitter {
             clearInterval(this.startMatterInterval);
             this.startMatterInterval = undefined;
             this.log.debug('Cleared startMatterInterval interval for Matterbridge');
+            // Start the Matter server
             await this.startMatterServer();
             this.log.notice('Matter server started');
+            // Show the QR code for commissioning or log the already commissioned message
+            await this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, this.nodeContext, 'Matterbridge');
             // Configure the plugins
             this.configureTimeout = setTimeout(async () => {
                 for (const plugin of this.plugins) {
@@ -1443,9 +1494,8 @@ export class Matterbridge extends EventEmitter {
                         this.log.error(`Error configuring plugin ${plg}${plugin.name}${er}`, error);
                     }
                 }
+                this.wssSendRefreshRequired();
             }, 30 * 1000);
-            // Show the QR code for commissioning or log the already commissioned message
-            await this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, this.nodeContext, 'Matterbridge');
             // Setting reachability to true
             this.reachabilityTimeout = setTimeout(() => {
                 this.log.info(`Setting reachability to true for ${plg}Matterbridge${db}`);
@@ -1462,9 +1512,12 @@ export class Matterbridge extends EventEmitter {
      * @returns {Promise<void>} A promise that resolves when the Matterbridge is started.
      */
     async startChildbridge() {
-        // Plugins are loaded and started by loadPlugin on startup and plugin.loaded and plugin.started are set to true
-        // addDevice and addBridgedDeevice create the commissionig servers and add the devices to the the commissioning server or to the aggregator
+        // Matterbridge.addBridgedDevice creates the commissionig servers and add the devices to the the commissioning server or to the aggregator
         // Plugins are configured by a timer when matter server is started and plugin.configured is set to true
+        if (!this.storageManager)
+            throw new Error('No storage manager initialized');
+        this.matterServer = this.createMatterServer(this.storageManager);
+        await this.startPlugins();
         this.log.debug('Starting start matter interval in childbridge mode...');
         let failCount = 0;
         this.startMatterInterval = setInterval(async () => {
@@ -1476,7 +1529,7 @@ export class Matterbridge extends EventEmitter {
                 if (plugin.error) {
                     clearInterval(this.startMatterInterval);
                     this.startMatterInterval = undefined;
-                    this.log.debug('Cleared startMatterInterval interval for Matterbridge for plugin in error state');
+                    this.log.debug('Cleared startMatterInterval interval for a plugin in error state');
                     this.log.error(`The plugin ${plg}${plugin.name}${er} is in error state.`);
                     this.log.error('The bridge will not start until the problem is solved to prevent the controllers from deleting all registered devices.');
                     this.log.error('If you want to start the bridge disable the plugin in error state and restart.');
@@ -1498,6 +1551,7 @@ export class Matterbridge extends EventEmitter {
             clearInterval(this.startMatterInterval);
             this.startMatterInterval = undefined;
             this.log.debug('Cleared startMatterInterval interval in childbridge mode');
+            // Start the Matter server
             await this.startMatterServer();
             this.log.notice('Matter server started');
             // Configure the plugins
@@ -1513,6 +1567,7 @@ export class Matterbridge extends EventEmitter {
                         this.log.error(`Error configuring plugin ${plg}${plugin.name}${er}`, error);
                     }
                 }
+                this.wssSendRefreshRequired();
             }, 30 * 1000);
             for (const plugin of this.plugins) {
                 if (!plugin.enabled || plugin.error)
@@ -1733,7 +1788,7 @@ export class Matterbridge extends EventEmitter {
      * @returns {Promise<void>} - A promise that resolves when the storage process is started.
      */
     async startMatterStorage(storageType, storageName) {
-        this.log.debug(`Starting ${storageType} storage ${CYAN}${storageName}${db}`);
+        this.log.debug(`Starting matter ${storageType} storage ${CYAN}${storageName}${db}`);
         if (storageType === 'disk') {
             const storageDisk = new StorageBackendDisk(storageName);
             this.storageManager = new StorageManager(storageDisk);
@@ -1745,23 +1800,37 @@ export class Matterbridge extends EventEmitter {
             this.storageManager = new StorageManager(storageJson);
         }
         else {
-            this.log.error(`Unsupported storage type ${storageType}`);
-            await this.cleanup('Unsupported storage type');
+            this.log.error(`Unsupported matter storage type ${storageType}`);
+            await this.cleanup('Unsupported matter storage type');
             return;
         }
         try {
             await this.storageManager.initialize();
-            this.log.debug('Storage initialized');
+            this.log.debug('Matter storage initialized');
             if (storageType === 'json') {
-                await this.backupJsonMatterStorage(storageName, storageName.replace('.json', '') + '.backup.json');
+                await this.backupMatterStorage(storageName, storageName.replace('.json', '') + '.backup.json');
             }
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
         }
         catch (error) {
-            this.log.error(`Storage initialize() error! The file .matterbridge/${storageName} may be corrupted.`);
-            this.log.error(`Please delete it and rename ${storageName.replace('.json', '.backup.json')} to ${storageName} and try to restart Matterbridge.`);
-            await this.cleanup('Storage initialize() error!');
+            this.log.error(`Matter storage initialize error! The file .matterbridge/${storageName} may be corrupted: ${error instanceof Error ? error.message : error}`);
+            if (hasParameter('norestore')) {
+                this.log.fatal(`Please delete it and rename ${storageName.replace('.json', '.backup.json')} to ${storageName} and try to restart Matterbridge.`);
+                await this.cleanup('Matter storage initialize error and -norestore parameter found!');
+                return;
+            }
+            await this.restoreMatterStorage(storageName.replace('.json', '') + '.backup.json', storageName);
+            try {
+                await this.storageManager.initialize();
+                this.log.notice('Matter storage initialized from the backup file');
+            }
+            catch (error) {
+                this.log.error(`Matter storage initialize error! The backup file for .matterbridge/${storageName} may be corrupted too:`, error instanceof Error ? error.message : error);
+                await this.cleanup('Matter storage initialize error from backup!');
+                return;
+            }
         }
+        this.log.debug(`Creating commissioning server context for ${plg}Matterbridge${db}`);
+        this.matterbridgeContext = await this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggregator');
     }
     /**
      * Makes a backup copy of the specified matter JSON storage file.
@@ -1769,7 +1838,7 @@ export class Matterbridge extends EventEmitter {
      * @param storageName - The name of the JSON storage file to be backed up.
      * @param backupName - The name of the backup file to be created.
      */
-    async backupJsonMatterStorage(storageName, backupName) {
+    async backupMatterStorage(storageName, backupName) {
         try {
             this.log.debug(`Making backup copy of ${storageName}`);
             await fs.copyFile(storageName, backupName);
@@ -1778,7 +1847,7 @@ export class Matterbridge extends EventEmitter {
         catch (err) {
             if (err instanceof Error && 'code' in err) {
                 if (err.code === 'ENOENT') {
-                    this.log.info(`No existing file to back up for ${storageName}. This is expected on the first run.`);
+                    this.log.debug(`No existing file to back up for ${storageName}. This is expected on the first run.`);
                 }
                 else {
                     this.log.error(`Error making backup copy of ${storageName}: ${err.message}`);
@@ -1789,6 +1858,32 @@ export class Matterbridge extends EventEmitter {
             }
         }
     }
+    /**
+     * Restore the specified matter JSON storage file.
+     *
+     * @param backupName - The name of the backup file to restore from.
+     * @param storageName - The name of the JSON storage file to restored.
+     */
+    async restoreMatterStorage(backupName, storageName) {
+        try {
+            this.log.notice(`Restoring the backup copy of ${storageName}`);
+            await fs.copyFile(backupName, storageName);
+            this.log.notice(`Successfully restored ${backupName} to ${storageName}`);
+        }
+        catch (err) {
+            if (err instanceof Error && 'code' in err) {
+                if (err.code === 'ENOENT') {
+                    this.log.info(`No existing file to restore: ${backupName}.`);
+                }
+                else {
+                    this.log.error(`Error restoring ${backupName}: ${err.message}`);
+                }
+            }
+            else {
+                this.log.error(`An unexpected error occurred during the restore of ${backupName}: ${String(err)}`);
+            }
+        }
+    }
     /**
      * Stops the matter storage.
      * @returns {Promise<void>} A promise that resolves when the storage is stopped.
@@ -2010,6 +2105,7 @@ export class Matterbridge extends EventEmitter {
                         }
                     }
                 }
+                this.wssSendRefreshRequired();
             },
             commissioningChangedCallback: async (fabricIndex) => {
                 const fabricInfo = commissioningServer.getCommissionedFabricInformation(fabricIndex);
@@ -2052,6 +2148,7 @@ export class Matterbridge extends EventEmitter {
                         }
                     }
                 }
+                this.wssSendRefreshRequired();
             },
         });
         if (this.passcode !== undefined)
@@ -2211,6 +2308,7 @@ export class Matterbridge extends EventEmitter {
                 }
             }
         }
+        this.wssSendRefreshRequired();
     }
     /**
      * Sanitizes the fabric information by converting bigint properties to string cause res.json doesn't know bigint.
@@ -2333,6 +2431,9 @@ export class Matterbridge extends EventEmitter {
             case 4701:
                 vendorName = '(Tuya)';
                 break;
+            case 4718:
+                vendorName = '(Xiaomi)';
+                break;
             case 4742:
                 vendorName = '(eWeLink)';
                 break;
@@ -2384,7 +2485,7 @@ export class Matterbridge extends EventEmitter {
      * Spawns a child process with the given command and arguments.
      * @param {string} command - The command to execute.
      * @param {string[]} args - The arguments to pass to the command (default: []).
-     * @returns {Promise<void>} A promise that resolves when the child process exits successfully, or rejects if there is an error.
+     * @returns {Promise<boolean>} A promise that resolves when the child process exits successfully, or rejects if there is an error.
      */
     async spawnCommand(command, args = []) {
         /*
@@ -2429,7 +2530,7 @@ export class Matterbridge extends EventEmitter {
                     if (cmdLine.startsWith('npm install -g'))
                         this.log.notice(`Package ${cmdLine.replace('npm install -g ', '').replace('--verbose', '').replace('--omit=dev', '')} installed correctly`);
                     this.log.debug(`Child process "${cmdLine}" closed with code ${code} and signal ${signal}`);
-                    resolve();
+                    resolve(true);
                 }
                 else {
                     this.log.error(`Child process "${cmdLine}" closed with code ${code} and signal ${signal}`);
@@ -2440,7 +2541,7 @@ export class Matterbridge extends EventEmitter {
                 this.wssSendMessage('spawn', this.log.now(), 'Matterbridge:spawn', `child process exited with code ${code} and signal ${signal}`);
                 if (code === 0) {
                     this.log.debug(`Child process "${cmdLine}" exited with code ${code} and signal ${signal}`);
-                    resolve();
+                    resolve(true);
                 }
                 else {
                     this.log.error(`Child process "${cmdLine}" exited with code ${code} and signal ${signal}`);
@@ -2449,7 +2550,7 @@ export class Matterbridge extends EventEmitter {
             });
             childProcess.on('disconnect', () => {
                 this.log.debug(`Child process "${cmdLine}" has been disconnected from the parent`);
-                resolve();
+                resolve(true);
             });
             if (childProcess.stdout) {
                 childProcess.stdout.on('data', (data) => {
@@ -2508,7 +2609,33 @@ export class Matterbridge extends EventEmitter {
         // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ level, time, name, message }));
+                client.send(JSON.stringify({ id: WS_ID_LOG, src: 'Matterbridge', level, time, name, message }));
+            }
+        });
+    }
+    /**
+     * Sends a need to refresh WebSocket message to all connected clients.
+     *
+     */
+    wssSendRefreshRequired() {
+        this.matterbridgeInformation.refreshRequired = true;
+        // Send the message to all connected clients
+        this.webSocketServer?.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(JSON.stringify({ id: WS_ID_REFRESH_NEEDED, src: 'Matterbridge', dst: 'Matterbridge', method: 'refresh_required', params: {} }));
+            }
+        });
+    }
+    /**
+     * Sends a need to restart WebSocket message to all connected clients.
+     *
+     */
+    wssSendRestartRequired() {
+        this.matterbridgeInformation.restartRequired = true;
+        // Send the message to all connected clients
+        this.webSocketServer?.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(JSON.stringify({ id: WS_ID_RESTART_NEEDED, src: 'Matterbridge', dst: 'Matterbridge', method: 'restart_required', params: {} }));
             }
         });
     }
@@ -2627,7 +2754,7 @@ export class Matterbridge extends EventEmitter {
         }
         if (initializeError)
             return;
-        // Createe a WebSocket server and attach it to the http server
+        // Createe a WebSocket server and attach it to the http or https server
         const wssPort = port;
         const wssHost = hasParameter('ssl') ? `wss://${this.systemInformation.ipv4Address}:${wssPort}` : `ws://${this.systemInformation.ipv4Address}:${wssPort}`;
         this.webSocketServer = new WebSocketServer(hasParameter('ssl') ? { server: this.httpsServer } : { server: this.httpServer });
@@ -2637,6 +2764,14 @@ export class Matterbridge extends EventEmitter {
             this.log.info(`WebSocketServer client "${clientIp}" connected to Matterbridge`);
             ws.on('message', (message) => {
                 this.log.debug(`WebSocket client message: ${message}`);
+                this.matterbridgeMessageHandler(ws, message);
+            });
+            ws.on('ping', () => {
+                this.log.debug('WebSocket client ping');
+                ws.pong();
+            });
+            ws.on('pong', () => {
+                this.log.debug('WebSocket client pong');
             });
             ws.on('close', () => {
                 this.log.info('WebSocket client disconnected');
@@ -2699,12 +2834,8 @@ export class Matterbridge extends EventEmitter {
             this.matterbridgeInformation.matterbridgeQrPairingCode = this.matterbridgeQrPairingCode;
             this.matterbridgeInformation.matterbridgeManualPairingCode = this.matterbridgeManualPairingCode;
             this.matterbridgeInformation.matterbridgeFabricInformations = this.matterbridgeFabricInformations;
-            // this.matterbridgeInformation.matterbridgeSessionInformations = this.matterbridgeSessionInformations;
             this.matterbridgeInformation.matterbridgeSessionInformations = Array.from(this.matterbridgeSessionInformations.values());
-            // console.log('this.matterbridgeSessionInformations:', this.matterbridgeSessionInformations);
-            if (this.profile)
-                this.matterbridgeInformation.profile = this.profile;
-            // const response = { wssHost, ssl: hasParameter('ssl'), qrPairingCode, manualPairingCode, systemInformation: this.systemInformation, matterbridgeInformation: this.matterbridgeInformation };
+            this.matterbridgeInformation.profile = this.profile;
             const response = { wssHost, ssl: hasParameter('ssl'), systemInformation: this.systemInformation, matterbridgeInformation: this.matterbridgeInformation };
             // this.log.debug('Response:', debugStringify(response));
             res.json(response);
@@ -2785,7 +2916,7 @@ export class Matterbridge extends EventEmitter {
                         });
                     });
                     device.getChildEndpoints().forEach((childEndpoint) => {
-                        const name = device.getChildEndpointName(childEndpoint);
+                        const name = childEndpoint.uniqueStorageKey;
                         const clusterServers = childEndpoint.getAllClusterServers();
                         clusterServers.forEach((clusterServer) => {
                             Object.entries(clusterServer.attributes).forEach(([key, value]) => {
@@ -2819,7 +2950,7 @@ export class Matterbridge extends EventEmitter {
             });
             res.json(data);
         });
-        // Endpoint to send the log
+        // Endpoint to view the log
         this.expressApp.get('/api/view-log', async (req, res) => {
             this.log.debug('The frontend sent /api/log');
             try {
@@ -2941,7 +3072,7 @@ export class Matterbridge extends EventEmitter {
             // Handle the command setbridgemode from Settings
             if (command === 'setbridgemode') {
                 this.log.debug(`setbridgemode: ${param}`);
-                this.matterbridgeInformation.restartRequired = true;
+                this.wssSendRestartRequired();
                 await this.nodeContext?.set('bridgeMode', param);
                 res.json({ message: 'Command received' });
                 return;
@@ -3121,7 +3252,7 @@ export class Matterbridge extends EventEmitter {
                     this.log.error('Error updating matterbridge');
                 }
                 await this.updateProcess();
-                this.matterbridgeInformation.restartRequired = true;
+                this.wssSendRestartRequired();
                 res.json({ message: 'Command received' });
                 return;
             }
@@ -3139,7 +3270,7 @@ export class Matterbridge extends EventEmitter {
                         return;
                     this.plugins.saveConfigFromJson(plugin, req.body);
                 }
-                this.matterbridgeInformation.restartRequired = true;
+                this.wssSendRestartRequired();
                 res.json({ message: 'Command received' });
                 return;
             }
@@ -3155,7 +3286,7 @@ export class Matterbridge extends EventEmitter {
                 catch (error) {
                     this.log.error(`Error installing plugin ${plg}${param}${er}`);
                 }
-                this.matterbridgeInformation.restartRequired = true;
+                this.wssSendRestartRequired();
                 // Also add the plugin to matterbridge so no return!
                 // res.json({ message: 'Command received' });
                 // return;
@@ -3168,6 +3299,7 @@ export class Matterbridge extends EventEmitter {
                     this.plugins.load(plugin, true, 'The plugin has been added', true); // No await do it in the background
                 }
                 res.json({ message: 'Command received' });
+                this.wssSendRefreshRequired();
                 return;
             }
             // Handle the command removeplugin from Home
@@ -3181,6 +3313,7 @@ export class Matterbridge extends EventEmitter {
                     await this.plugins.remove(param);
                 }
                 res.json({ message: 'Command received' });
+                this.wssSendRefreshRequired();
                 return;
             }
             // Handle the command enableplugin from Home
@@ -3205,6 +3338,7 @@ export class Matterbridge extends EventEmitter {
                     }
                 }
                 res.json({ message: 'Command received' });
+                this.wssSendRefreshRequired();
                 return;
             }
             // Handle the command disableplugin from Home
@@ -3220,6 +3354,7 @@ export class Matterbridge extends EventEmitter {
                     }
                 }
                 res.json({ message: 'Command received' });
+                this.wssSendRefreshRequired();
                 return;
             }
         });