matterbridge 1.1.10 → 1.1.12

package/dist/matterbridge.js

@@ -30,7 +30,7 @@ import EventEmitter from 'events';
 import express from 'express';
 import os from 'os';
 import path from 'path';
-import { CommissioningServer, MatterServer } from '@project-chip/matter-node.js';
+import { CommissioningController, CommissioningServer, MatterServer } from '@project-chip/matter-node.js';
 import { BasicInformationCluster, BridgedDeviceBasicInformationCluster, ClusterServer } from '@project-chip/matter-node.js/cluster';
 import { DeviceTypeId, VendorId } from '@project-chip/matter-node.js/datatype';
 import { Aggregator, DeviceTypes } from '@project-chip/matter-node.js/device';
@@ -59,13 +59,24 @@ export class Matterbridge extends EventEmitter {
         freeMemory: '',
         systemUptime: '',
     };
+    matterbridgeInformation = {
+        homeDirectory: '',
+        rootDirectory: '',
+        matterbridgeDirectory: '',
+        matterbridgePluginDirectory: '',
+        globalModulesDirectory: '',
+        matterbridgeVersion: '',
+        matterbridgeLatestVersion: '',
+        bridgeMode: '',
+        debugEnabled: false,
+    };
     homeDirectory = '';
     rootDirectory = '';
     matterbridgeDirectory = '';
     matterbridgePluginDirectory = '';
+    globalModulesDirectory = '';
     matterbridgeVersion = '';
     matterbridgeLatestVersion = '';
-    globalModulesDir = '';
     bridgeMode = '';
     debugEnabled = false;
     log;
@@ -272,6 +283,12 @@ export class Matterbridge extends EventEmitter {
             MatterbridgeDevice.bridgeMode = 'childbridge';
             await this.testStartMatterBridge(); // No await do it asyncronously
         }
+        if (hasParameter('controller')) {
+            this.bridgeMode = 'controller';
+            this.log.info('Creating mattercontrollerContext: mattercontrollerContext');
+            this.mattercontrollerContext = this.storageManager?.createContext('mattercontrollerContext');
+            await this.startMatterBridge();
+        }
         if (hasParameter('bridge')) {
             this.bridgeMode = 'bridge';
             MatterbridgeDevice.bridgeMode = 'bridge';
@@ -326,8 +343,8 @@ export class Matterbridge extends EventEmitter {
         }
         if (!packageJsonExists) {
             this.log.debug(`Package.json not found at ${packageJsonPath}`);
-            this.log.debug(`Trying at ${this.globalModulesDir}`);
-            packageJsonPath = path.join(this.globalModulesDir, pluginPath);
+            this.log.debug(`Trying at ${this.globalModulesDirectory}`);
+            packageJsonPath = path.join(this.globalModulesDirectory, pluginPath);
             //this.log.debug(`Got ${packageJsonPath}`);
         }
         try {
@@ -449,10 +466,12 @@ export class Matterbridge extends EventEmitter {
             this.log.info(message);
             process.removeAllListeners('SIGINT');
             process.removeAllListeners('SIGTERM');
-            // Callint the shutdown functions with a reason
+            // Calling the shutdown functions with a reason
             for (const plugin of this.registeredPlugins) {
                 if (plugin.platform)
                     await plugin.platform.onShutdown('Matterbridge is closing: ' + message);
+                if (plugin.platform)
+                    await plugin.platform.saveConfig();
             }
             // Set reachability to false
             /*
@@ -487,17 +506,20 @@ export class Matterbridge extends EventEmitter {
                 // Closing storage
                 await this.stopStorage();
                 // Serialize registeredDevices
-                if (this.nodeContext) {
+                if (this.nodeStorage && this.nodeContext) {
                     this.log.info('Saving registered devices...');
                     const serializedRegisteredDevices = [];
                     this.registeredDevices.forEach((registeredDevice) => {
                         serializedRegisteredDevices.push(registeredDevice.device.serialize(registeredDevice.plugin));
                     });
-                    //console.log('serializedRegisteredDevices:', serializedRegisteredDevices);
                     await this.nodeContext.set('devices', serializedRegisteredDevices);
                     this.log.info('Saved registered devices');
                     // Clear nodeContext and nodeStorage (they just need 1000ms to write the data to disk)
+                    this.log.debug('Closing node storage context...');
+                    this.nodeContext.close();
                     this.nodeContext = undefined;
+                    this.log.debug('Closing node storage manager...');
+                    this.nodeStorage.close();
                     this.nodeStorage = undefined;
                 }
                 else {
@@ -505,6 +527,7 @@ export class Matterbridge extends EventEmitter {
                 }
                 this.registeredPlugins = [];
                 this.registeredDevices = [];
+                this.log.info('Waiting for matter to deliver last messages...');
                 const cleanupTimeout2 = setTimeout(async () => {
                     if (restart) {
                         this.log.info('Cleanup completed. Restarting...');
@@ -544,14 +567,14 @@ export class Matterbridge extends EventEmitter {
      */
     async addDevice(pluginName, device) {
         if (this.bridgeMode === 'bridge' && !this.matterAggregator) {
-            this.log.error(`Adding device ${dev}${device.name}-${device.deviceName}${er} for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
+            this.log.error(`Adding device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
             return;
         }
-        this.log.debug(`Adding device ${dev}${device.name}-${device.deviceName}${db} for plugin ${plg}${pluginName}${db}`);
+        this.log.debug(`Adding device ${dev}${device.deviceName}${db} (${dev}${device.name}${db}) for plugin ${plg}${pluginName}${db}`);
         // Check if the plugin is registered
         const plugin = this.registeredPlugins.find((plugin) => plugin.name === pluginName);
         if (!plugin) {
-            this.log.error(`Error adding device ${dev}${device.name}-${device.deviceName}${er} plugin ${plg}${pluginName}${er} not found`);
+            this.log.error(`Error adding device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) plugin ${plg}${pluginName}${er} not found`);
             return;
         }
         // Register and add the device to matterbridge aggregator in bridge mode
@@ -562,14 +585,14 @@ export class Matterbridge extends EventEmitter {
                 plugin.registeredDevices++;
             if (plugin.addedDevices !== undefined)
                 plugin.addedDevices++;
-            this.log.info(`Added and registered device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.name}-${device.deviceName}${nf} for plugin ${plg}${pluginName}${nf}`);
+            this.log.info(`Added and registered device (${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${dev}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
         }
         // Only register the device in childbridge mode
         if (this.bridgeMode === 'childbridge') {
             this.registeredDevices.push({ plugin: pluginName, device, added: false });
             if (plugin.registeredDevices !== undefined)
                 plugin.registeredDevices++;
-            this.log.info(`Registered device ${dev}${device.name}-${device.deviceName}${nf} for plugin ${plg}${pluginName}${nf}`);
+            this.log.info(`Registered device ${dev}${device.deviceName}${nf} (${dev}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
         }
     }
     /**
@@ -580,14 +603,14 @@ export class Matterbridge extends EventEmitter {
      */
     async addBridgedDevice(pluginName, device) {
         if (this.bridgeMode === 'bridge' && !this.matterAggregator) {
-            this.log.error(`Adding bridged device ${dev}${device.name}-${device.deviceName}${er} for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
+            this.log.error(`Adding bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
             return;
         }
-        this.log.debug(`Adding bridged device ${db}${device.name}-${device.deviceName}${nf} for plugin ${plg}${pluginName}${db}`);
+        this.log.debug(`Adding bridged device ${dev}${device.deviceName}${db} (${dev}${device.name}${db}) for plugin ${plg}${pluginName}${db}`);
         // Check if the plugin is registered
         const plugin = this.registeredPlugins.find((plugin) => plugin.name === pluginName);
         if (!plugin) {
-            this.log.error(`Error adding bridged device ${dev}${device.name}-${device.deviceName}${er} plugin ${plg}${pluginName}${er} not found`);
+            this.log.error(`Error adding bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) plugin ${plg}${pluginName}${er} not found`);
             return;
         }
         // Register and add the device to matterbridge aggregator in bridge mode
@@ -598,36 +621,38 @@ export class Matterbridge extends EventEmitter {
                 plugin.registeredDevices++;
             if (plugin.addedDevices !== undefined)
                 plugin.addedDevices++;
-            this.log.info(`Added and registered bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.name}-${device.deviceName}${nf} for plugin ${plg}${pluginName}${nf}`);
+            this.log.info(`Added and registered bridged device (${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${dev}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
         }
         // Only register the device in childbridge mode
         if (this.bridgeMode === 'childbridge') {
             this.registeredDevices.push({ plugin: pluginName, device, added: false });
             if (plugin.registeredDevices !== undefined)
                 plugin.registeredDevices++;
-            this.log.info(`Registered bridged device ${dev}${device.name}-${device.deviceName}${nf} for plugin ${plg}${pluginName}${nf}`);
+            this.log.info(`Registered bridged device ${dev}${device.deviceName}${nf} (${dev}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
         }
     }
     async removeBridgedDevice(pluginName, device) {
         if (this.bridgeMode === 'bridge' && !this.matterAggregator) {
-            this.log.error(`Removing bridged device ${dev}${device.name}-${device.deviceName}${er} for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
+            this.log.error(`Removing bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
             return;
         }
-        this.log.debug(`Removing bridged device ${db}${device.name}-${device.deviceName}${nf} for plugin ${plg}${pluginName}${db}`);
+        this.log.debug(`Removing bridged device ${dev}${device.deviceName}${db} (${dev}${device.name}${db}) for plugin ${plg}${pluginName}${db}`);
         // Check if the plugin is registered
         const plugin = this.findPlugin(pluginName);
         if (!plugin) {
-            this.log.error(`Error removing bridged device ${dev}${device.name}-${device.deviceName}${er} plugin ${plg}${pluginName}${er} not found`);
+            this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) plugin ${plg}${pluginName}${er} not found`);
             return;
         }
         if (this.bridgeMode === 'childbridge' && !plugin.aggregator) {
-            this.log.error(`Error removing bridged device ${dev}${device.name}-${device.deviceName}${er} plugin ${plg}${pluginName}${er} aggregator not found`);
+            this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) plugin ${plg}${pluginName}${er} aggregator not found`);
             return;
         }
+        /*
         if (this.bridgeMode === 'childbridge' && !plugin.connected) {
-            this.log.error(`Error removing bridged device ${dev}${device.name}-${device.deviceName}${er} plugin ${plg}${pluginName}${er} not connected`);
-            return;
+          this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${dev}${device.name}${er}) plugin ${plg}${pluginName}${er} not connected`);
+          return;
         }
+        */
         // Register and add the device to matterbridge aggregator in bridge mode
         if (this.bridgeMode === 'bridge') {
             this.matterAggregator.removeBridgedDevice(device);
@@ -641,12 +666,12 @@ export class Matterbridge extends EventEmitter {
                 plugin.registeredDevices--;
             if (plugin.addedDevices !== undefined)
                 plugin.addedDevices--;
-            this.log.info(`Rmoved bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.name}-${device.deviceName}${nf} for plugin ${plg}${pluginName}${nf}`);
+            this.log.info(`Removed bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${dev}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
         }
         // Only register the device in childbridge mode
         if (this.bridgeMode === 'childbridge') {
             if (plugin.type === 'AccessoryPlatform') {
-                this.log.warn(`Removing bridged device ${dev}${device.name}-${device.deviceName}${wr} for plugin ${plg}${pluginName}${wr} error: AccessoryPlatform not supported in childbridge mode`);
+                this.log.warn(`Removing bridged device ${dev}${device.deviceName}${wr} (${dev}${device.name}${wr}) for plugin ${plg}${pluginName}${wr} error: AccessoryPlatform not supported in childbridge mode`);
             }
             else if (plugin.type === 'DynamicPlatform') {
                 this.registeredDevices.forEach((registeredDevice, index) => {
@@ -657,11 +682,11 @@ 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}`);
             if (plugin.registeredDevices !== undefined)
                 plugin.registeredDevices--;
             if (plugin.addedDevices !== undefined)
                 plugin.addedDevices--;
-            this.log.info(`Removed bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.name}-${device.deviceName}${nf} for plugin ${plg}${pluginName}${nf}`);
         }
     }
     /**
@@ -897,6 +922,7 @@ export class Matterbridge extends EventEmitter {
                 plugin.registeredDevices = 0;
                 plugin.addedDevices = 0;
                 await this.nodeContext?.set('plugins', this.getBaseRegisteredPlugins());
+                await platform.loadConfig();
                 this.log.info(`Loaded plugin ${plg}${plugin.name}${db} type ${typ}${platform.type}${db} (entrypoint ${UNDERLINE}${pluginEntry}${UNDERLINEOFF})`);
                 if (start)
                     this.startPlugin(plugin, message); // No await do it asyncronously
@@ -934,15 +960,41 @@ export class Matterbridge extends EventEmitter {
             await this.cleanup('No matter server initialized');
             return;
         }
+        if (this.bridgeMode === 'controller') {
+            this.log.info('Creating matter commissioning controller');
+            this.commissioningController = new CommissioningController({
+                autoConnect: false,
+            });
+            this.log.info('Adding matter commissioning controller to matter server');
+            await this.matterServer.addCommissioningController(this.commissioningController);
+            this.log.info('Starting matter server');
+            await this.matterServer.start();
+            this.log.info('Matter server started');
+            if (hasParameter('discover')) {
+                //const discover = await this.commissioningController.discoverCommissionableDevices({ productId: 0x8000, deviceType: 0xfff1 });
+                //console.log(discover);
+            }
+            this.log.info(`Commissioning controller is already commisioned: ${this.commissioningController.isCommissioned()}`);
+            const nodes = this.commissioningController.getCommissionedNodes();
+            nodes.forEach(async (nodeId) => {
+                this.log.warn(`Connecting to commissioned node: ${nodeId}`);
+            });
+        }
         if (this.bridgeMode === 'bridge') {
             // Plugins are loaded by loadPlugin on startup and plugin.loaded is set to true
             // Plugins are started and configured by callback when Matterbridge is commissioned
             this.log.debug(`Creating commissioning server context for ${plg}Matterbridge${db}`);
-            this.matterbridgeContext = this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggregator');
+            this.matterbridgeContext = this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Aggregator');
             if (!this.matterbridgeContext) {
-                this.log.error(`Error creating storage context${er}`);
+                this.log.error(`Error creating storage context for ${plg}Matterbridge${er}`);
+                return;
+            }
+            if (!this.nodeContext) {
+                this.log.error(`Node storage context undefined for ${plg}Matterbridge${er}`);
                 return;
             }
+            this.matterbridgeContext.set('softwareVersion', 1);
+            this.matterbridgeContext.set('softwareVersionString', this.matterbridgeVersion);
             this.log.debug(`Creating commissioning server for ${plg}Matterbridge${db}`);
             this.commissioningServer = this.createCommisioningServer(this.matterbridgeContext, 'Matterbridge');
             this.log.debug(`Creating matter aggregator for ${plg}Matterbridge${db}`);
@@ -951,9 +1003,10 @@ export class Matterbridge extends EventEmitter {
             this.commissioningServer.addDevice(this.matterAggregator);
             this.log.debug('Adding matterbridge commissioning server to matter server');
             await this.matterServer.addCommissioningServer(this.commissioningServer, { uniqueStorageKey: 'Matterbridge' });
-            this.log.debug('Starting matter server');
+            this.log.debug('Starting matter server...');
             await this.startMatterServer();
-            this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, 'Matterbridge');
+            this.log.info('Matter server started');
+            await this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, this.nodeContext, 'Matterbridge');
         }
         if (this.bridgeMode === 'childbridge') {
             // Plugins are loaded and started by loadPlugin on startup
@@ -991,7 +1044,9 @@ export class Matterbridge extends EventEmitter {
                         await this.matterServer.addCommissioningServer(plugin.commissioningServer, { uniqueStorageKey: plugin.name });
                     }
                     if (plugin.type === 'DynamicPlatform') {
-                        plugin.storageContext = this.createCommissioningServerContext(plugin.name, 'Matterbridge Dynamic Platform', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Dynamic Platform');
+                        plugin.storageContext = this.createCommissioningServerContext(plugin.name, 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Dynamic Platform');
+                        plugin.storageContext.set('softwareVersion', 1);
+                        plugin.storageContext.set('softwareVersionString', this.matterbridgeVersion);
                         plugin.commissioningServer = this.createCommisioningServer(plugin.storageContext, plugin.name);
                         this.log.debug(`Creating aggregator for plugin ${plg}${plugin.name}${db}`);
                         plugin.aggregator = this.createMatterAggregator(plugin.storageContext); // Generate serialNumber and uniqueId
@@ -1018,7 +1073,7 @@ export class Matterbridge extends EventEmitter {
                 });
                 if (!allStarted)
                     return;
-                this.log.info('Starting matter server');
+                this.log.info('Starting matter server...');
                 // Setting reachability to true
                 this.registeredPlugins.forEach((plugin) => {
                     if (!plugin.enabled)
@@ -1035,13 +1090,27 @@ export class Matterbridge extends EventEmitter {
                     });
                 });
                 await this.startMatterServer();
+                this.log.info('Matter server started');
                 for (const plugin of this.registeredPlugins) {
-                    this.showCommissioningQRCode(plugin.commissioningServer, plugin.storageContext, plugin.name);
+                    if (!plugin.enabled)
+                        continue;
+                    if (!plugin.commissioningServer) {
+                        this.log.error(`Commissioning server not found for plugin ${plg}${plugin.name}${er}`);
+                        continue;
+                    }
+                    if (!plugin.storageContext) {
+                        this.log.error(`Storage context not found for plugin ${plg}${plugin.name}${er}`);
+                        continue;
+                    }
+                    if (!plugin.nodeContext) {
+                        this.log.error(`Node storage context not found for plugin ${plg}${plugin.name}${er}`);
+                        continue;
+                    }
+                    await this.showCommissioningQRCode(plugin.commissioningServer, plugin.storageContext, plugin.nodeContext, plugin.name);
                 }
                 Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
                 clearInterval(startMatterInterval);
             }, 1000);
-            return;
         }
     }
     async startMatterServer() {
@@ -1107,9 +1176,9 @@ export class Matterbridge extends EventEmitter {
         storageContext.set('serialNumber', storageContext.get('serialNumber', random));
         storageContext.set('uniqueId', storageContext.get('uniqueId', random));
         storageContext.set('softwareVersion', softwareVersion ?? 1);
-        storageContext.set('softwareVersionString', softwareVersionString ?? '1.0.0');
+        storageContext.set('softwareVersionString', softwareVersionString ?? '1.0');
         storageContext.set('hardwareVersion', hardwareVersion ?? 1);
-        storageContext.set('hardwareVersionString', hardwareVersionString ?? '1.0.0');
+        storageContext.set('hardwareVersionString', hardwareVersionString ?? '1.0');
         return storageContext;
     }
     /**
@@ -1123,7 +1192,7 @@ export class Matterbridge extends EventEmitter {
      * @param storageContext - The storage context to store the pairing codes.
      * @param pluginName - The name of the commissioning server.
      */
-    async showCommissioningQRCode(commissioningServer, storageContext, pluginName) {
+    async showCommissioningQRCode(commissioningServer, storageContext, nodeContext, pluginName) {
         if (!commissioningServer || !storageContext || !pluginName)
             return;
         if (!commissioningServer.isCommissioned()) {
@@ -1131,41 +1200,27 @@ export class Matterbridge extends EventEmitter {
             const { qrPairingCode, manualPairingCode } = commissioningServer.getPairingCode();
             storageContext.set('qrPairingCode', qrPairingCode);
             storageContext.set('manualPairingCode', manualPairingCode);
+            await nodeContext.set('qrPairingCode', qrPairingCode);
+            await nodeContext.set('manualPairingCode', manualPairingCode);
             const QrCode = new QrCodeSchema();
-            this.log.info(`Pairing code:\n\n${QrCode.encode(qrPairingCode)}\nManual pairing code: ${manualPairingCode}\n`);
-            if (this.bridgeMode === 'bridge') {
-                await this.nodeContext?.set('qrPairingCode', qrPairingCode);
-                await this.nodeContext?.set('manualPairingCode', manualPairingCode);
-            }
-            if (this.bridgeMode === 'childbridge') {
+            this.log.info(`Pairing code:\n\n${QrCode.encode(qrPairingCode)}\n${plg}${pluginName}${nf}\n\nqrPairingCode: ${qrPairingCode}\n\nManual pairing code: ${manualPairingCode}\n`);
+            if (pluginName !== 'Matterbridge') {
                 const plugin = this.findPlugin(pluginName);
                 if (plugin) {
-                    await plugin.nodeContext?.set('qrPairingCode', qrPairingCode);
-                    await plugin.nodeContext?.set('manualPairingCode', manualPairingCode);
-                    await this.nodeContext?.set('plugins', this.getBaseRegisteredPlugins());
                     plugin.paired = false;
                 }
             }
+            await this.nodeContext?.set('plugins', this.getBaseRegisteredPlugins());
         }
         else {
             this.log.info(`***The commissioning server for ${plg}${pluginName}${nf} is already commissioned. Waiting for controllers to connect ...`);
-            if (this.bridgeMode === 'bridge') {
-                const qrPairingCode = storageContext.get('qrPairingCode', '');
-                const manualPairingCode = storageContext.get('manualPairingCode', '');
-                await this.nodeContext?.set('qrPairingCode', qrPairingCode);
-                await this.nodeContext?.set('manualPairingCode', manualPairingCode);
-            }
-            if (this.bridgeMode === 'childbridge') {
+            if (pluginName !== 'Matterbridge') {
                 const plugin = this.findPlugin(pluginName);
-                if (plugin && plugin.storageContext && plugin.nodeContext) {
-                    plugin.qrPairingCode = plugin.storageContext.get('qrPairingCode', '');
-                    plugin.manualPairingCode = plugin.storageContext.get('manualPairingCode', '');
-                    await plugin.nodeContext.set('qrPairingCode', plugin.qrPairingCode);
-                    await plugin.nodeContext.set('manualPairingCode', plugin.manualPairingCode);
-                    await this.nodeContext?.set('plugins', this.getBaseRegisteredPlugins());
+                if (plugin) {
                     plugin.paired = true;
                 }
             }
+            await this.nodeContext?.set('plugins', this.getBaseRegisteredPlugins());
         }
     }
     /**
@@ -1186,11 +1241,11 @@ export class Matterbridge extends EventEmitter {
      * Creates a matter commissioning server.
      *
      * @param {StorageContext} context - The storage context.
-     * @param {string} name - The name of the commissioning server.
+     * @param {string} pluginName - The name of the commissioning server.
      * @returns {CommissioningServer} The created commissioning server.
      */
-    createCommisioningServer(context, name) {
-        this.log.debug(`Creating matter commissioning server for plugin ${plg}${name}${db}`);
+    createCommisioningServer(context, pluginName) {
+        this.log.debug(`Creating matter commissioning server for plugin ${plg}${pluginName}${db}`);
         const deviceName = context.get('deviceName');
         const deviceType = context.get('deviceType');
         const vendorId = context.get('vendorId');
@@ -1199,9 +1254,14 @@ export class Matterbridge extends EventEmitter {
         const productName = context.get('productName'); // Home app = Model
         const serialNumber = context.get('serialNumber');
         const uniqueId = context.get('uniqueId');
-        this.log.debug(
-        // eslint-disable-next-line max-len
-        `Creating matter commissioning server for plugin ${plg}${name}${db} with deviceName ${deviceName} deviceType ${deviceType}(0x${deviceType.toString(16).padStart(4, '0')}) uniqueId ${uniqueId} serialNumber ${serialNumber}`);
+        const softwareVersion = context.get('softwareVersion', 1);
+        const softwareVersionString = context.get('softwareVersionString', '1.0.0'); // Home app = Firmware Revision
+        const hardwareVersion = context.get('hardwareVersion', 1);
+        const hardwareVersionString = context.get('hardwareVersionString', '1.0.0');
+        this.log.debug(`Creating matter commissioning server for plugin ${plg}${pluginName}${db} with deviceName ${deviceName} deviceType ${deviceType}(0x${deviceType.toString(16).padStart(4, '0')})`);
+        this.log.debug(`Creating matter commissioning server for plugin ${plg}${pluginName}${db} with uniqueId ${uniqueId} serialNumber ${serialNumber}`);
+        this.log.debug(`Creating matter commissioning server for plugin ${plg}${pluginName}${db} with softwareVersion ${softwareVersion} softwareVersionString ${softwareVersionString}`);
+        this.log.debug(`Creating matter commissioning server for plugin ${plg}${pluginName}${db} with hardwareVersion ${hardwareVersion} hardwareVersionString ${hardwareVersionString}`);
         const commissioningServer = new CommissioningServer({
             port: undefined,
             passcode: undefined,
@@ -1215,10 +1275,10 @@ export class Matterbridge extends EventEmitter {
                 productName,
                 nodeLabel: productName,
                 productLabel: productName,
-                softwareVersion: context.get('softwareVersion', 1),
-                softwareVersionString: context.get('softwareVersionString', '1.0.0'), // Home app = Firmware Revision
-                hardwareVersion: context.get('hardwareVersion', 1),
-                hardwareVersionString: context.get('hardwareVersionString', '1.0.0'),
+                softwareVersion,
+                softwareVersionString, // Home app = Firmware Revision
+                hardwareVersion,
+                hardwareVersionString,
                 uniqueId,
                 serialNumber,
                 reachable: true,
@@ -1227,15 +1287,15 @@ export class Matterbridge extends EventEmitter {
                 const info = commissioningServer.getActiveSessionInformation(fabricIndex);
                 let connected = false;
                 info.forEach((session) => {
-                    this.log.debug(`***Active session changed on fabric ${fabricIndex} ${session.fabric?.rootVendorId}/${session.fabric?.label} for ${plg}${name}${nf}`, debugStringify(session));
+                    this.log.debug(`***Active session changed on fabric ${fabricIndex} ${session.fabric?.rootVendorId}/${session.fabric?.label} for ${plg}${pluginName}${nf}`, debugStringify(session));
                     if (session.isPeerActive === true && session.secure === true && session.numberOfActiveSubscriptions >= 1) {
-                        this.log.info(`***Controller ${session.fabric?.rootVendorId}/${session.fabric?.label} connected to ${plg}${name}${nf}`);
+                        this.log.info(`***Controller ${session.fabric?.rootVendorId}/${session.fabric?.label} connected to ${plg}${pluginName}${nf}`);
                         connected = true;
                     }
                 });
                 if (connected) {
                     if (this.bridgeMode === 'childbridge') {
-                        const plugin = this.findPlugin(name);
+                        const plugin = this.findPlugin(pluginName);
                         if (plugin) {
                             plugin.paired = true;
                             plugin.connected = true;
@@ -1248,16 +1308,15 @@ export class Matterbridge extends EventEmitter {
                                 if (!plugin.enabled)
                                     continue;
                                 this.startPlugin(plugin, 'Matterbridge is commissioned and controllers are connected', true); // No await do it asyncronously with also configurePlugin
-                                //this.configurePlugin(plugin); // No await do it asyncronously
                             }
                             Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
                         }
                         if (this.bridgeMode === 'childbridge') {
                             //Logger.defaultLogLevel = Level.INFO;
-                            const plugin = this.findPlugin(name);
+                            const plugin = this.findPlugin(pluginName);
                             if (plugin && plugin.type === 'DynamicPlatform' && plugin.configured !== true) {
                                 for (const registeredDevice of this.registeredDevices) {
-                                    if (registeredDevice.plugin === name) {
+                                    if (registeredDevice.plugin === pluginName) {
                                         this.log.info(`Adding bridged device ${dev}${registeredDevice.device.name}-${registeredDevice.device.deviceName}${nf} to aggregator for plugin ${plg}${plugin.name}${db}`);
                                         if (!plugin.aggregator) {
                                             this.log.error(`****Aggregator not found for plugin ${plg}${plugin.name}${er}`);
@@ -1274,7 +1333,7 @@ export class Matterbridge extends EventEmitter {
                                 }
                             }
                             for (const plugin of this.registeredPlugins) {
-                                if (plugin.name === name && plugin.platform && plugin.configured !== true) {
+                                if (plugin.name === pluginName && plugin.platform && plugin.configured !== true) {
                                     this.configurePlugin(plugin); // No await do it asyncronously
                                 }
                             }
@@ -1284,12 +1343,29 @@ export class Matterbridge extends EventEmitter {
                     }, 2000);
                 }
             },
-            commissioningChangedCallback: (fabricIndex) => {
+            commissioningChangedCallback: async (fabricIndex) => {
                 const info = commissioningServer.getCommissionedFabricInformation(fabricIndex);
-                this.log.debug(`***Commissioning changed on fabric ${fabricIndex} for ${plg}${name}${nf}`, debugStringify(info));
+                this.log.debug(`***Commissioning changed on fabric ${fabricIndex} for ${plg}${pluginName}${nf}`, debugStringify(info));
                 if (info.length === 0) {
-                    this.log.warn(`***Commissioning removed from fabric ${fabricIndex} for ${plg}${name}${nf}. Resetting the commissioning server ...`);
-                    commissioningServer.factoryReset(); // TODO delete from storage also "matterbridge-eve-weather.EndpointStructure"
+                    this.log.warn(`***Commissioning removed from fabric ${fabricIndex} for ${plg}${pluginName}${nf}. Resetting the commissioning server ...`);
+                    await commissioningServer.factoryReset();
+                    if (pluginName === 'Matterbridge') {
+                        this.matterbridgeContext?.delete(`${pluginName}.EndpointStructure`);
+                        this.matterbridgeContext?.delete(`${pluginName}.EventHandler`);
+                        this.matterbridgeContext?.delete(`${pluginName}.SessionManager`);
+                    }
+                    else {
+                        for (const plugin of this.registeredPlugins) {
+                            if (plugin.name === pluginName) {
+                                await plugin.platform?.onShutdown('Commissioning removed by the controller');
+                                plugin.paired = false;
+                                plugin.connected = false;
+                                plugin.storageContext?.delete(`${pluginName}.EndpointStructure`);
+                                plugin.storageContext?.delete(`${pluginName}.EventHandler`);
+                                plugin.storageContext?.delete(`${pluginName}.SessionManager`);
+                            }
+                        }
+                    }
                 }
             },
         });
@@ -1444,16 +1520,20 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`- System Uptime: ${this.systemInformation.systemUptime}`);
         // Home directory
         this.homeDirectory = os.homedir();
+        this.matterbridgeInformation.homeDirectory = this.homeDirectory;
         this.log.debug(`Home Directory: ${this.homeDirectory}`);
         // Package root directory
         const currentFileDirectory = path.dirname(fileURLToPath(import.meta.url));
         this.rootDirectory = path.resolve(currentFileDirectory, '../');
+        this.matterbridgeInformation.rootDirectory = this.rootDirectory;
         this.log.debug(`Root Directory: ${this.rootDirectory}`);
         // Global node_modules directory
-        this.globalModulesDir = await this.getGlobalNodeModules();
-        this.log.debug(`Global node_modules Directory: ${this.globalModulesDir}`);
+        this.globalModulesDirectory = await this.getGlobalNodeModules();
+        this.matterbridgeInformation.globalModulesDirectory = this.globalModulesDirectory;
+        this.log.debug(`Global node_modules Directory: ${this.globalModulesDirectory}`);
         // Create the data directory .matterbridge in the home directory
         this.matterbridgeDirectory = path.join(this.homeDirectory, '.matterbridge');
+        this.matterbridgeInformation.matterbridgeDirectory = this.matterbridgeDirectory;
         try {
             await fs.access(this.matterbridgeDirectory);
         }
@@ -1477,6 +1557,7 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`Matterbridge Directory: ${this.matterbridgeDirectory}`);
         // Create the data directory .matterbridge in the home directory
         this.matterbridgePluginDirectory = path.join(this.homeDirectory, 'Matterbridge');
+        this.matterbridgeInformation.matterbridgePluginDirectory = this.matterbridgePluginDirectory;
         try {
             await fs.access(this.matterbridgePluginDirectory);
         }
@@ -1501,8 +1582,10 @@ export class Matterbridge extends EventEmitter {
         // Matterbridge version
         const packageJson = JSON.parse(await fs.readFile(path.join(this.rootDirectory, 'package.json'), 'utf-8'));
         this.matterbridgeVersion = packageJson.version;
+        this.matterbridgeInformation.matterbridgeVersion = this.matterbridgeVersion;
         this.log.debug(`Matterbridge Version: ${this.matterbridgeVersion}`);
         this.matterbridgeLatestVersion = await this.getLatestVersion('matterbridge');
+        this.matterbridgeInformation.matterbridgeLatestVersion = this.matterbridgeLatestVersion;
         this.log.debug(`Matterbridge Latest Version: ${this.matterbridgeLatestVersion}`);
         if (this.matterbridgeVersion !== this.matterbridgeLatestVersion) {
             this.log.warn(`Matterbridge is out of date. Current version: ${this.matterbridgeVersion}, Latest version: ${this.matterbridgeLatestVersion}`);
@@ -1583,6 +1666,13 @@ export class Matterbridge extends EventEmitter {
             this.log.debug('The frontend sent /api/system-info');
             res.json(this.systemInformation);
         });
+        // Endpoint to provide matterbridge information
+        this.expressApp.get('/api/matterbridge-info', (req, res) => {
+            this.log.debug('The frontend sent /api/matterbridge-info');
+            this.matterbridgeInformation.bridgeMode = this.bridgeMode;
+            this.matterbridgeInformation.debugEnabled = this.debugEnabled;
+            res.json(this.matterbridgeInformation);
+        });
         // Endpoint to provide plugins
         this.expressApp.get('/api/plugins', (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
@@ -1703,27 +1793,33 @@ export class Matterbridge extends EventEmitter {
             }
             // Handle the command enableplugin from Home
             if (command === 'enableplugin') {
-                const plugin = this.findPlugin(param);
+                const plugins = await this.nodeContext?.get('plugins');
+                if (!plugins)
+                    return;
+                const plugin = plugins.find((plugin) => plugin.name === param);
                 if (plugin) {
                     plugin.enabled = true;
                     plugin.loaded = undefined;
                     plugin.started = undefined;
                     plugin.configured = undefined;
                     plugin.connected = undefined;
-                    await this.nodeContext?.set('plugins', this.getBaseRegisteredPlugins());
+                    await this.nodeContext?.set('plugins', plugins);
                     this.log.info(`Enabled plugin ${plg}${param}${nf}`);
                 }
             }
             // Handle the command disableplugin from Home
             if (command === 'disableplugin') {
-                const plugin = this.findPlugin(param);
+                const plugins = await this.nodeContext?.get('plugins');
+                if (!plugins)
+                    return;
+                const plugin = plugins.find((plugin) => plugin.name === param);
                 if (plugin) {
                     plugin.enabled = false;
                     plugin.loaded = undefined;
                     plugin.started = undefined;
                     plugin.configured = undefined;
                     plugin.connected = undefined;
-                    await this.nodeContext?.set('plugins', this.getBaseRegisteredPlugins());
+                    await this.nodeContext?.set('plugins', plugins);
                     this.log.info(`Disabled plugin ${plg}${param}${nf}`);
                 }
             }