matterbridge 1.5.9 → 1.6.0

package/dist/matterbridge.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';
@@ -121,7 +122,6 @@ export class Matterbridge extends EventEmitter {
     matterLoggerFile = 'matter' + (getParameter('profile') ? '.' + getParameter('profile') : '') + '.log';
     plugins;
     devices;
-    registeredDevices = [];
     nodeStorage;
     nodeContext;
     matterStorageName = 'matterbridge' + (getParameter('profile') ? '.' + getParameter('profile') : '') + '.json';
@@ -131,8 +131,6 @@ export class Matterbridge extends EventEmitter {
     initialized = false;
     execRunningCount = 0;
     startMatterInterval;
-    cleanupTimeout1;
-    cleanupTimeout2;
     checkUpdateInterval;
     configureTimeout;
     reachabilityTimeout;
@@ -161,7 +159,10 @@ export class Matterbridge extends EventEmitter {
     // We load asyncronously so is private
     constructor() {
         super();
+        // Bind the handler to the instance
+        this.matterbridgeMessageHandler = wsMessageHandler.bind(this);
     }
+    matterbridgeMessageHandler;
     /** ***********************************************************************************************************************************/
     /**                                              loadInstance() and cleanup() methods                                                 */
     /** ***********************************************************************************************************************************/
@@ -225,6 +226,8 @@ export class Matterbridge extends EventEmitter {
         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)
@@ -344,7 +347,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', plugin.name]);
+                    await this.spawnCommand('npm', ['install', '-g', '--omit=dev', plugin.name]);
                     this.log.info(`Plugin ${plg}${plugin.name}${nf} reinstalled.`);
                     plugin.error = false;
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -473,28 +476,24 @@ export class Matterbridge extends EventEmitter {
         }
         if (getParameter('add')) {
             this.log.debug(`Adding plugin ${getParameter('add')}`);
-            // await this.executeCommandLine(getParameter('add') as string, 'add');
             await this.plugins.add(getParameter('add'));
             this.emit('shutdown');
             return;
         }
         if (getParameter('remove')) {
             this.log.debug(`Removing plugin ${getParameter('remove')}`);
-            // await this.executeCommandLine(getParameter('remove') as string, 'remove');
             await this.plugins.remove(getParameter('remove'));
             this.emit('shutdown');
             return;
         }
         if (getParameter('enable')) {
             this.log.debug(`Enabling plugin ${getParameter('enable')}`);
-            // await this.executeCommandLine(getParameter('enable') as string, 'enable');
             await this.plugins.enable(getParameter('enable'));
             this.emit('shutdown');
             return;
         }
         if (getParameter('disable')) {
             this.log.debug(`Disabling plugin ${getParameter('disable')}`);
-            // await this.executeCommandLine(getParameter('disable') as string, 'disable');
             await this.plugins.disable(getParameter('disable'));
             this.emit('shutdown');
             return;
@@ -518,14 +517,12 @@ export class Matterbridge extends EventEmitter {
             this.nodeContext = undefined;
             this.nodeStorage = undefined;
             this.plugins.clear();
-            this.registeredDevices = [];
+            this.devices.clear();
             this.emit('shutdown');
             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');
         if (hasParameter('reset') && getParameter('reset') === undefined) {
             this.log.info('Resetting Matterbridge commissioning information...');
             await this.matterbridgeContext?.clearAll();
@@ -563,12 +560,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();
@@ -579,91 +577,63 @@ 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;
         }
     }
+    /**
+     * 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 signal handlers for SIGINT and SIGTERM.
      * When either of these signals are received, the cleanup method is called with an appropriate message.
@@ -1158,7 +1128,6 @@ export class Matterbridge extends EventEmitter {
                 });
                 this.webSocketServer = undefined;
             }
-            // this.cleanupTimeout1 = setTimeout(async () => {
             // Closing matter
             await this.stopMatterServer();
             // Closing matter storage
@@ -1175,8 +1144,8 @@ export class Matterbridge extends EventEmitter {
             if (this.nodeStorage && this.nodeContext) {
                 this.log.info('Saving registered devices...');
                 const serializedRegisteredDevices = [];
-                this.registeredDevices.forEach((registeredDevice) => {
-                    const serializedMatterbridgeDevice = registeredDevice.device.serialize(registeredDevice.plugin);
+                this.devices.forEach(async (device) => {
+                    const serializedMatterbridgeDevice = device.serialize();
                     // this.log.info(`- ${serializedMatterbridgeDevice.deviceName}${rs}\n`, serializedMatterbridgeDevice);
                     if (serializedMatterbridgeDevice)
                         serializedRegisteredDevices.push(serializedMatterbridgeDevice);
@@ -1203,9 +1172,7 @@ export class Matterbridge extends EventEmitter {
                 this.log.error('Error saving registered devices: nodeContext not found!');
             }
             this.plugins.clear();
-            this.registeredDevices = [];
-            // this.log.info('Waiting for matter to deliver last messages...');
-            // this.cleanupTimeout2 = setTimeout(async () => {
+            this.devices.clear();
             if (restart) {
                 if (message === 'updating...') {
                     this.log.info('Cleanup completed. Updating...');
@@ -1240,8 +1207,6 @@ export class Matterbridge extends EventEmitter {
             }
             this.hasCleanupStarted = false;
             this.initialized = false;
-            // }, 2 * 1000);
-            // }, 3 * 1000);
         }
     }
     /**
@@ -1251,17 +1216,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);
@@ -1301,7 +1266,6 @@ export class Matterbridge extends EventEmitter {
                 plugin.aggregator?.addBridgedDevice(device);
             }
         }
-        this.registeredDevices.push({ plugin: pluginName, device });
         if (plugin.registeredDevices !== undefined)
             plugin.registeredDevices++;
         if (plugin.addedDevices !== undefined)
@@ -1317,17 +1281,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) {
@@ -1337,13 +1301,7 @@ export class Matterbridge extends EventEmitter {
             // device.getClusterServerById(BridgedDeviceBasicInformation.Cluster.id)?.triggerShutDownEvent({});
             // device.getClusterServerById(BridgedDeviceBasicInformation.Cluster.id)?.triggerLeaveEvent({});
             this.matterAggregator?.removeBridgedDevice(device);
-            this.registeredDevices.forEach((registeredDevice, index) => {
-                if (registeredDevice.device === device) {
-                    this.registeredDevices.splice(index, 1);
-                    return;
-                }
-            });
-            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)
@@ -1353,34 +1311,22 @@ 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;
                 }
-                this.registeredDevices.forEach((registeredDevice, index) => {
-                    if (registeredDevice.device === device) {
-                        this.registeredDevices.splice(index, 1);
-                        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;
                 }
-                this.registeredDevices.forEach((registeredDevice, index) => {
-                    if (registeredDevice.device === device) {
-                        this.registeredDevices.splice(index, 1);
-                        return;
-                    }
-                });
                 if (device.number !== undefined) {
                     device.setBridgedDeviceReachability(false);
                     device.getClusterServerById(BridgedDeviceBasicInformation.Cluster.id)?.triggerReachableChangedEvent({ reachableNewValue: false });
                 }
                 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)
@@ -1403,18 +1349,11 @@ export class Matterbridge extends EventEmitter {
      */
     async removeAllBridgedDevices(pluginName) {
         this.log.debug(`Removing all bridged devices for plugin ${plg}${pluginName}${db}`);
-        const devicesToRemove = [];
-        for (const registeredDevice of this.registeredDevices) {
-            if (registeredDevice.plugin === pluginName) {
-                devicesToRemove.push(registeredDevice);
+        this.devices.forEach(async (device) => {
+            if (device.plugin === pluginName) {
+                await this.removeBridgedDevice(pluginName, device);
             }
-        }
-        for (const registeredDevice of devicesToRemove) {
-            this.removeBridgedDevice(pluginName, registeredDevice.device);
-        }
-    }
-    async startTest() {
-        // Start the Matterbridge
+        });
     }
     /**
      * Starts the Matterbridge in bridge mode.
@@ -1422,9 +1361,22 @@ export class Matterbridge extends EventEmitter {
      * @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) {
@@ -1453,8 +1405,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) {
@@ -1468,9 +1423,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}`);
@@ -1487,9 +1441,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 () => {
@@ -1501,7 +1458,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.');
@@ -1523,6 +1480,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
@@ -1538,6 +1496,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)
@@ -1778,7 +1737,7 @@ export class Matterbridge extends EventEmitter {
             await this.storageManager.initialize();
             this.log.debug('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
         }
@@ -1787,6 +1746,8 @@ export class Matterbridge extends EventEmitter {
             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.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.
@@ -1794,7 +1755,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);
@@ -2035,6 +1996,7 @@ export class Matterbridge extends EventEmitter {
                         }
                     }
                 }
+                this.wssSendRefreshRequired();
             },
             commissioningChangedCallback: async (fabricIndex) => {
                 const fabricInfo = commissioningServer.getCommissionedFabricInformation(fabricIndex);
@@ -2077,6 +2039,7 @@ export class Matterbridge extends EventEmitter {
                         }
                     }
                 }
+                this.wssSendRefreshRequired();
             },
         });
         if (this.passcode !== undefined)
@@ -2236,6 +2199,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.
@@ -2358,6 +2322,9 @@ export class Matterbridge extends EventEmitter {
             case 4701:
                 vendorName = '(Tuya)';
                 break;
+            case 4718:
+                vendorName = '(Xiaomi)';
+                break;
             case 4742:
                 vendorName = '(eWeLink)';
                 break;
@@ -2452,7 +2419,7 @@ export class Matterbridge extends EventEmitter {
                 this.wssSendMessage('spawn', this.log.now(), 'Matterbridge:spawn', `child process closed with code ${code} and signal ${signal}`);
                 if (code === 0) {
                     if (cmdLine.startsWith('npm install -g'))
-                        this.log.notice(`Package ${cmdLine.replace('npm install -g ', '').replace('--verbose', '')} installed correctly`);
+                        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();
                 }
@@ -2533,7 +2500,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: {} }));
             }
         });
     }
@@ -2652,7 +2645,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 });
@@ -2662,6 +2655,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');
@@ -2724,12 +2725,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);
@@ -2745,21 +2742,21 @@ export class Matterbridge extends EventEmitter {
         this.expressApp.get('/api/devices', (req, res) => {
             this.log.debug('The frontend sent /api/devices');
             const data = [];
-            this.registeredDevices.forEach((registeredDevice) => {
-                let name = registeredDevice.device.getClusterServer(BasicInformationCluster)?.attributes.nodeLabel?.getLocal();
+            this.devices.forEach(async (device) => {
+                let name = device.getClusterServer(BasicInformationCluster)?.attributes.nodeLabel?.getLocal();
                 if (!name)
-                    name = registeredDevice.device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.nodeLabel?.getLocal() ?? 'Unknown';
-                let serial = registeredDevice.device.getClusterServer(BasicInformationCluster)?.attributes.serialNumber?.getLocal();
+                    name = device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.nodeLabel?.getLocal() ?? 'Unknown';
+                let serial = device.getClusterServer(BasicInformationCluster)?.attributes.serialNumber?.getLocal();
                 if (!serial)
-                    serial = registeredDevice.device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.serialNumber?.getLocal() ?? 'Unknown';
-                let uniqueId = registeredDevice.device.getClusterServer(BasicInformationCluster)?.attributes.uniqueId?.getLocal();
+                    serial = device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.serialNumber?.getLocal() ?? 'Unknown';
+                let uniqueId = device.getClusterServer(BasicInformationCluster)?.attributes.uniqueId?.getLocal();
                 if (!uniqueId)
-                    uniqueId = registeredDevice.device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.uniqueId?.getLocal() ?? 'Unknown';
-                const cluster = this.getClusterTextFromDevice(registeredDevice.device);
+                    uniqueId = device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.uniqueId?.getLocal() ?? 'Unknown';
+                const cluster = this.getClusterTextFromDevice(device);
                 data.push({
-                    pluginName: registeredDevice.plugin,
-                    type: registeredDevice.device.name + ' (0x' + registeredDevice.device.deviceType.toString(16).padStart(4, '0') + ')',
-                    endpoint: registeredDevice.device.number,
+                    pluginName: device.plugin ?? 'Unknown',
+                    type: device.name + ' (0x' + device.deviceType.toString(16).padStart(4, '0') + ')',
+                    endpoint: device.number,
                     name,
                     serial,
                     uniqueId,
@@ -2779,9 +2776,9 @@ export class Matterbridge extends EventEmitter {
                 return;
             }
             const data = [];
-            this.registeredDevices.forEach((registeredDevice) => {
-                if (registeredDevice.plugin === selectedPluginName && registeredDevice.device.number === selectedDeviceEndpoint) {
-                    const clusterServers = registeredDevice.device.getAllClusterServers();
+            this.devices.forEach(async (device) => {
+                if (device.plugin === selectedPluginName && device.number === selectedDeviceEndpoint) {
+                    const clusterServers = device.getAllClusterServers();
                     clusterServers.forEach((clusterServer) => {
                         Object.entries(clusterServer.attributes).forEach(([key, value]) => {
                             if (clusterServer.name === 'EveHistory')
@@ -2800,7 +2797,7 @@ export class Matterbridge extends EventEmitter {
                                 // console.log(error);
                             }
                             data.push({
-                                endpoint: registeredDevice.device.number ? registeredDevice.device.number.toString() : '...',
+                                endpoint: device.number ? device.number.toString() : '...',
                                 clusterName: clusterServer.name,
                                 clusterId: '0x' + clusterServer.id.toString(16).padStart(2, '0'),
                                 attributeName: key,
@@ -2809,8 +2806,8 @@ export class Matterbridge extends EventEmitter {
                             });
                         });
                     });
-                    registeredDevice.device.getChildEndpoints().forEach((childEndpoint) => {
-                        const name = registeredDevice.device.getChildEndpointName(childEndpoint);
+                    device.getChildEndpoints().forEach((childEndpoint) => {
+                        const name = childEndpoint.uniqueStorageKey;
                         const clusterServers = childEndpoint.getAllClusterServers();
                         clusterServers.forEach((clusterServer) => {
                             Object.entries(clusterServer.attributes).forEach(([key, value]) => {
@@ -2844,7 +2841,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 {
@@ -2966,7 +2963,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;
@@ -3138,7 +3135,7 @@ export class Matterbridge extends EventEmitter {
             if (command === 'update') {
                 this.log.info('Updating matterbridge...');
                 try {
-                    await this.spawnCommand('npm', ['install', '-g', 'matterbridge', '--verbose']);
+                    await this.spawnCommand('npm', ['install', '-g', 'matterbridge', '--omit=dev', '--verbose']);
                     this.log.info('Matterbridge has been updated. Full restart required.');
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 }
@@ -3146,7 +3143,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;
             }
@@ -3164,7 +3161,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;
             }
@@ -3173,14 +3170,14 @@ export class Matterbridge extends EventEmitter {
                 param = param.replace(/\*/g, '\\');
                 this.log.info(`Installing plugin ${plg}${param}${nf}...`);
                 try {
-                    await this.spawnCommand('npm', ['install', '-g', param, '--verbose']);
+                    await this.spawnCommand('npm', ['install', '-g', param, '--omit=dev', '--verbose']);
                     this.log.info(`Plugin ${plg}${param}${nf} installed. Full restart required.`);
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 }
                 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;
@@ -3193,6 +3190,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
@@ -3206,6 +3204,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
@@ -3230,6 +3229,7 @@ export class Matterbridge extends EventEmitter {
                     }
                 }
                 res.json({ message: 'Command received' });
+                this.wssSendRefreshRequired();
                 return;
             }
             // Handle the command disableplugin from Home
@@ -3245,6 +3245,7 @@ export class Matterbridge extends EventEmitter {
                     }
                 }
                 res.json({ message: 'Command received' });
+                this.wssSendRefreshRequired();
                 return;
             }
         });