matterbridge 1.1.7 → 1.1.9

package/dist/matterbridge.js

@@ -25,6 +25,7 @@ import { NodeStorageManager } from 'node-persist-manager';
 import { AnsiLogger, BRIGHT, RESET, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, stringify, er, nf, rs, wr } from 'node-ansi-logger';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { promises as fs } from 'fs';
+import { exec, execSync } from 'child_process';
 import express from 'express';
 import os from 'os';
 import path from 'path';
@@ -60,7 +61,10 @@ export class Matterbridge {
     homeDirectory = '';
     rootDirectory = '';
     matterbridgeDirectory = '';
+    matterbridgePluginDirectory = '';
     matterbridgeVersion = '';
+    matterbridgeLatestVersion = '';
+    globalModulesDir = '';
     bridgeMode = '';
     debugEnabled = false;
     log;
@@ -69,7 +73,8 @@ export class Matterbridge {
     registeredDevices = [];
     nodeStorage;
     nodeContext;
-    app;
+    expressApp;
+    expressServer;
     storageManager;
     matterbridgeContext;
     mattercontrollerContext;
@@ -79,26 +84,24 @@ export class Matterbridge {
     commissioningController;
     static instance;
     constructor() {
-        // we load asynchroneously the instance
+        // We load asyncronously
     }
     /**
      * Loads an instance of the Matterbridge class.
      * If an instance already exists, return that instance.
      * @returns The loaded instance of the Matterbridge class.
      */
-    static async loadInstance(cli = false) {
-        // eslint-disable-next-line no-console
-        console.error('loadInstance cli:', cli);
+    static async loadInstance(initialize = false) {
         if (!Matterbridge.instance) {
             // eslint-disable-next-line no-console
-            console.error('Matterbridge instance does not exists');
+            console.log('Matterbridge instance does not exists');
             Matterbridge.instance = new Matterbridge();
-            if (cli)
+            if (initialize)
                 await Matterbridge.instance.initialize();
         }
         else {
             // eslint-disable-next-line no-console
-            console.error('Matterbridge instance already exists');
+            console.log('Matterbridge instance already exists');
         }
         return Matterbridge.instance;
     }
@@ -124,10 +127,14 @@ export class Matterbridge {
       - frontend [port]:       start the frontend on the given port (default 3000)
       - debug:                 enable debug mode (default false)
       - list:                  list the registered plugins
-      - add [plugin path]:     register the plugin
-      - remove [plugin path]:  remove the plugin
-      - enable [plugin path]:  enable the plugin
-      - disable [plugin path]: disable the plugin\n`);
+      - 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
+      - remove [plugin path]:  remove the plugin from the given absolute or relative path
+      - remove [plugin name]:  remove the globally installed plugin with the given name
+      - enable [plugin path]:  enable the plugin from the given absolute or relative path
+      - enable [plugin name]:  enable the globally installed plugin with the given name
+      - disable [plugin path]: disable the plugin from the given absolute or relative path
+      - disable [plugin name]: disable the globally installed plugin with the given name\n`);
             process.exit(0);
         }
         // set Matterbridge logger
@@ -155,13 +162,13 @@ export class Matterbridge {
         this.registeredPlugins = await this.nodeContext.get('plugins', []);
         for (const plugin of this.registeredPlugins) {
             this.log.debug(`Creating node storage context for plugin ${plugin.name}`);
-            plugin.nodeContext = await this.nodeStorage?.createStorage(plugin.name);
-            await plugin.nodeContext?.set('name', plugin.name);
-            await plugin.nodeContext?.set('type', plugin.type);
-            await plugin.nodeContext?.set('path', plugin.path);
-            await plugin.nodeContext?.set('version', plugin.version);
-            await plugin.nodeContext?.set('description', plugin.description);
-            await plugin.nodeContext?.set('author', plugin.author);
+            plugin.nodeContext = await this.nodeStorage.createStorage(plugin.name);
+            await plugin.nodeContext.set('name', plugin.name);
+            await plugin.nodeContext.set('type', plugin.type);
+            await plugin.nodeContext.set('path', plugin.path);
+            await plugin.nodeContext.set('version', plugin.version);
+            await plugin.nodeContext.set('description', plugin.description);
+            await plugin.nodeContext.set('author', plugin.author);
         }
         // Parse command line
         this.parseCommandLine();
@@ -215,7 +222,7 @@ export class Matterbridge {
         if (hasParameter('test')) {
             this.bridgeMode = 'childbridge';
             MatterbridgeDevice.bridgeMode = 'childbridge';
-            this.testStartMatterBridge(); // No await do it asyncronously
+            await this.testStartMatterBridge(); // No await do it asyncronously
         }
         if (hasParameter('bridge')) {
             this.bridgeMode = 'bridge';
@@ -227,6 +234,8 @@ export class Matterbridge {
                 plugin.started = false;
                 plugin.configured = false;
                 plugin.connected = undefined;
+                plugin.qrPairingCode = undefined;
+                plugin.manualPairingCode = undefined;
                 this.loadPlugin(plugin); // No await do it asyncronously
             }
             await this.startMatterBridge();
@@ -241,11 +250,49 @@ export class Matterbridge {
                 plugin.started = false;
                 plugin.configured = false;
                 plugin.connected = false;
+                plugin.qrPairingCode = (await plugin.nodeContext?.get('qrPairingCode', undefined)) ?? undefined;
+                plugin.manualPairingCode = (await plugin.nodeContext?.get('manualPairingCode', undefined)) ?? undefined;
                 this.loadPlugin(plugin, true, 'Matterbridge is starting'); // No await do it asyncronously
             }
             await this.startMatterBridge();
         }
     }
+    async resolvePluginName(pluginPath) {
+        if (!pluginPath.endsWith('package.json'))
+            pluginPath = path.join(pluginPath, 'package.json');
+        // Resolve the package.json of the plugin
+        let packageJsonPath = path.resolve(pluginPath);
+        this.log.debug(`Loading plugin from ${plg}${packageJsonPath}${db}`);
+        // Check if the package.json file exists
+        let packageJsonExists = false;
+        try {
+            await fs.access(packageJsonPath);
+            packageJsonExists = true;
+        }
+        catch {
+            packageJsonExists = false;
+        }
+        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(`Got ${packageJsonPath}`);
+        }
+        try {
+            // Load the package.json of the plugin
+            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+            if (!packageJson.name) {
+                this.log.debug(`Package.json name not found at ${packageJsonPath}`);
+                return null;
+            }
+            this.log.debug(`Package.json name: ${plg}${packageJson.name}${db} description: "${nf}${packageJson.description}${db}" found at "${nf}${packageJsonPath}${db}"`);
+            return packageJsonPath;
+        }
+        catch (err) {
+            this.log.debug(`Failed to load plugin from ${plg}${packageJsonPath}${er}: ${err}`);
+            return null;
+        }
+    }
     /**
      * Loads a plugin from the specified package.json file path.
      * @param packageJsonPath - The path to the package.json file of the plugin.
@@ -253,10 +300,7 @@ export class Matterbridge {
      * @returns A Promise that resolves when the plugin is loaded successfully, or rejects with an error if loading fails.
      */
     async executeCommandLine(packageJsonPath, mode) {
-        if (!packageJsonPath.endsWith('package.json'))
-            packageJsonPath = path.join(packageJsonPath, 'package.json');
-        // Resolve the package.json of the plugin
-        packageJsonPath = path.resolve(packageJsonPath);
+        packageJsonPath = (await this.resolvePluginName(packageJsonPath)) ?? packageJsonPath;
         this.log.debug(`Loading plugin from ${plg}${packageJsonPath}${db}`);
         try {
             // Load the package.json of the plugin
@@ -317,7 +361,6 @@ export class Matterbridge {
                     this.log.warn(`Plugin ${plg}${packageJsonPath}${wr} not registerd in matterbridge`);
                 }
             }
-            //}
         }
         catch (err) {
             this.log.error(`Failed to load plugin from ${plg}${packageJsonPath}${er}: ${err}`);
@@ -328,21 +371,32 @@ export class Matterbridge {
      * When either of these signals are received, the cleanup method is called with an appropriate message.
      */
     async registerSignalHandlers() {
-        process.on('SIGINT', async () => {
+        process.once('SIGINT', async () => {
             await this.cleanup('SIGINT received, cleaning up...');
         });
-        process.on('SIGTERM', async () => {
+        process.once('SIGTERM', async () => {
             await this.cleanup('SIGTERM received, cleaning up...');
         });
     }
+    /**
+     * Restarts the process by spawning a new process and exiting the current process.
+     */
+    async restartProcess() {
+        //this.log.info('Restarting still not implemented');
+        //return;
+        await this.cleanup('Matterbridge is restarting...', true);
+        this.hasCleanupStarted = false;
+    }
     /**
      * Performs cleanup operations before shutting down Matterbridge.
      * @param message - The reason for the cleanup.
      */
-    async cleanup(message) {
+    async cleanup(message, restart = false) {
         if (!this.hasCleanupStarted) {
             this.hasCleanupStarted = true;
             this.log.info(message);
+            process.removeAllListeners('SIGINT');
+            process.removeAllListeners('SIGTERM');
             // Callint the shutdown functions with a reason
             for (const plugin of this.registeredPlugins) {
                 if (plugin.platform)
@@ -365,21 +419,47 @@ export class Matterbridge {
               if (this.bridgeMode === 'childbridge' && plugin.type === 'DynamicPlatform') registeredDevice.device.setBridgedDeviceReachability(false);
             });
             */
+            // Close the express server
+            if (this.expressServer) {
+                this.expressServer.close();
+                this.expressServer = undefined;
+            }
+            // Remove listeners
+            if (this.expressApp) {
+                this.expressApp.removeAllListeners();
+                this.expressApp = undefined;
+            }
             setTimeout(async () => {
                 // Closing matter
                 await this.stopMatter();
                 // Closing storage
                 await this.stopStorage();
                 // Serialize registeredDevices
-                const serializedRegisteredDevices = [];
-                this.registeredDevices.forEach((registeredDevice) => {
-                    serializedRegisteredDevices.push(registeredDevice.device.serialize(registeredDevice.plugin));
-                });
-                //console.log('serializedRegisteredDevices:', serializedRegisteredDevices);
-                await this.nodeContext?.set('devices', serializedRegisteredDevices);
-                setTimeout(() => {
+                if (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.nodeContext = undefined;
+                    this.nodeStorage = undefined;
+                }
+                else {
+                    this.log.error('Error saving registered devices: nodeContext not found!');
+                }
+                this.registeredPlugins = [];
+                this.registeredDevices = [];
+                setTimeout(async () => {
                     this.log.info('Cleanup completed.');
-                    process.exit(0);
+                    //if (restart) console.log(this);
+                    if (restart)
+                        await this.initialize();
+                    else
+                        process.exit(0);
                 }, 2 * 1000);
             }, 3 * 1000);
         }
@@ -405,16 +485,20 @@ export class Matterbridge {
      * @returns A Promise that resolves when the device is added successfully.
      */
     async addDevice(pluginName, device) {
-        this.log.info(`Adding device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
+        if (this.bridgeMode === 'bridge' && !this.matterAggregator) {
+            this.log.error(`Adding device ${dev}${device.name}${er} for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
+            return;
+        }
+        this.log.debug(`Adding device ${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(`addDevice error: device ${dev}${device.name}${nf} plugin ${plg}${pluginName}${er} not found`);
+            this.log.error(`Error adding device ${dev}${device.name}${er} plugin ${plg}${pluginName}${er} not found`);
             return;
         }
-        // Add and register the device to the matterbridge in bridge mode
+        // Register and add the device to matterbridge aggregator in bridge mode
         if (this.bridgeMode === 'bridge') {
-            this.matterAggregator.addBridgedDevice(device);
+            this.matterAggregator?.addBridgedDevice(device);
             this.registeredDevices.push({ plugin: pluginName, device, added: true });
             if (plugin.registeredDevices !== undefined)
                 plugin.registeredDevices++;
@@ -437,16 +521,20 @@ export class Matterbridge {
      * @returns {Promise<void>} - A promise that resolves when the storage process is started.
      */
     async addBridgedDevice(pluginName, device) {
-        this.log.info(`Adding bridged device ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
+        if (this.bridgeMode === 'bridge' && !this.matterAggregator) {
+            this.log.error(`Adding bridged device ${dev}${device.name}${er} for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
+            return;
+        }
+        this.log.debug(`Adding bridged device ${db}${device.name}${nf} 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(`addBridgedDevice error: device ${dev}${device.name}${nf} plugin ${plg}${pluginName}${er} not found`);
+            this.log.error(`Error adding bridged device ${dev}${device.name}${er} plugin ${plg}${pluginName}${er} not found`);
             return;
         }
-        // Add and register the device to the matterbridge in bridge mode
+        // Register and add the device to matterbridge aggregator in bridge mode
         if (this.bridgeMode === 'bridge') {
-            this.matterAggregator.addBridgedDevice(device);
+            this.matterAggregator?.addBridgedDevice(device);
             this.registeredDevices.push({ plugin: pluginName, device, added: true });
             if (plugin.registeredDevices !== undefined)
                 plugin.registeredDevices++;
@@ -469,18 +557,22 @@ export class Matterbridge {
      * @returns {Promise<void>} - A promise that resolves when the storage process is started.
      */
     async startStorage(storageType, storageName) {
-        if (!storageName.endsWith('.json')) {
-            storageName += '.json';
-        }
         this.log.debug(`Starting storage ${storageType} ${storageName}`);
         if (storageType === 'disk') {
             const storageDisk = new StorageBackendDisk(storageName);
             this.storageManager = new StorageManager(storageDisk);
         }
-        if (storageType === 'json') {
+        else if (storageType === 'json') {
+            if (!storageName.endsWith('.json'))
+                storageName += '.json';
             const storageJson = new StorageBackendJsonFile(storageName);
             this.storageManager = new StorageManager(storageJson);
         }
+        else {
+            this.log.error(`Unsupported storage type ${storageType}`);
+            await this.cleanup('Unsupported storage type');
+            return;
+        }
         try {
             await this.storageManager.initialize();
             this.log.debug('Storage initialized');
@@ -490,7 +582,7 @@ export class Matterbridge {
         }
         catch (error) {
             this.log.error('Storage initialize() error!');
-            process.exit(1);
+            await this.cleanup('Storage initialize() error!');
         }
     }
     /**
@@ -525,41 +617,57 @@ export class Matterbridge {
      */
     async stopStorage() {
         this.log.debug('Stopping storage');
-        await this.storageManager.close();
+        await this.storageManager?.close();
         this.log.debug('Storage closed');
+        this.storageManager = undefined;
+        this.matterbridgeContext = undefined;
+        this.mattercontrollerContext = undefined;
     }
     async testStartMatterBridge() {
+        /*
+        this.log.error('****Start forEach registeredPlugin');
+        this.registeredPlugins
+          .filter((plugin) => plugin.enabled === true)
+          .forEach(async (plugin) => {
+            plugin.loaded = false;
+            plugin.started = false;
+            plugin.configured = false;
+            plugin.connected = undefined;
+            this.log.error(`****Starting registeredPlugin ${plugin.name}`);
+            this.loadPlugin(plugin, true, 'Matterbridge is starting');
+          });
+        this.log.error('****Stop forEach registeredPlugin');
+        */
+        /*
         for (const plugin of this.registeredPlugins) {
-            if (!plugin.enabled)
-                continue;
-            // No await do it asyncronously
-            this.loadPlugin(plugin)
-                .then(() => {
-                // No await do it asyncronously
-                this.startPlugin(plugin)
-                    .then(() => { })
-                    .catch((err) => {
-                    this.log.error(`Failed to start plugin ${plg}${plugin.name}${er}: ${err}`);
+          if (!plugin.enabled) continue;
+          // No await do it asyncronously
+          this.loadPlugin(plugin)
+            .then(() => {
+              // No await do it asyncronously
+              this.startPlugin(plugin)
+                .then(() => {})
+                .catch((err) => {
+                  this.log.error(`Failed to start plugin ${plg}${plugin.name}${er}: ${err}`);
                 });
             })
-                .catch((err) => {
-                this.log.error(`Failed to load plugin ${plg}${plugin.name}${er}: ${err}`);
+            .catch((err) => {
+              this.log.error(`Failed to load plugin ${plg}${plugin.name}${er}: ${err}`);
             });
         }
         for (const plugin of this.registeredPlugins) {
-            if (!plugin.enabled)
-                continue;
-            // Start the interval to check if the plugin is loaded and started
-            let times = 0;
-            const interval = setInterval(() => {
-                times++;
-                this.log.info(`Waiting ${times} secs for plugin ${plg}${plugin.name}${db} to load (${plugin.loaded}) and start (${plugin.started}) and send devices ...`);
-                if (!plugin.loaded || !plugin.started)
-                    return;
-                this.log.info(`Plugin ${plg}${plugin.name}${db} sent ${plugin.registeredDevices} devices`);
-                clearInterval(interval);
-            }, 1000);
+          if (!plugin.enabled) continue;
+          // Start the interval to check if the plugin is loaded and started
+          let times = 0;
+          const interval = setInterval(() => {
+            times++;
+            this.log.info(`Waiting ${times} secs for plugin ${plg}${plugin.name}${db} to load (${plugin.loaded}) and start (${plugin.started}) and send devices ...`);
+            if (!plugin.loaded || !plugin.started) return;
+            this.log.info(`Plugin ${plg}${plugin.name}${db} sent ${plugin.registeredDevices} devices`);
+            clearInterval(interval);
+          }, 1000);
         }
+        */
     }
     async startPlugin(plugin, message, configure = false) {
         if (!plugin.loaded || !plugin.platform) {
@@ -678,13 +786,27 @@ export class Matterbridge {
      * @returns {Promise<void>} A promise that resolves when the Matterbridge is started.
      */
     async startMatterBridge() {
+        if (!this.storageManager) {
+            this.log.error('No storage manager initialized');
+            await this.cleanup('No storage manager initialized');
+            return;
+        }
         this.log.debug('Starting matterbridge in mode', this.bridgeMode);
         this.createMatterServer(this.storageManager);
+        if (!this.matterServer) {
+            this.log.error('No matter server initialized');
+            await this.cleanup('No matter server initialized');
+            return;
+        }
         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 and plugin.started 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');
+            if (!this.matterbridgeContext) {
+                this.log.error(`Error creating storage context${er}`);
+                return;
+            }
             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}`);
@@ -698,19 +820,24 @@ export class Matterbridge {
             this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, 'Matterbridge');
         }
         if (this.bridgeMode === 'childbridge') {
-            // Plugins are loaded and started by loadPlugin on startup and plugin.loaded is set to true and plugin.started is set to true
+            // Plugins are loaded and started by loadPlugin on startup
             // addDevice and addBridgedDeevice just register the devices that are added here to the plugin commissioning server for Accessory Platform
             // or to the plugin aggregator for Dynamic Platform after the commissioning is done
             // Plugins are configured by callback when the plugin is commissioned
-            this.registeredPlugins.forEach(async (plugin) => {
+            this.registeredPlugins.forEach((plugin) => {
                 if (!plugin.enabled)
                     return;
                 // Start the interval to check if the plugins is started
                 // TODO set a counter or a timeout
-                this.log.info(`**Starting startMatterBridge interval for plugin ${plg}${plugin.name}${db} loaded: ${plugin.loaded} started: ${plugin.started}...`);
+                this.log.debug(`*Starting startMatterBridge interval for plugin ${plg}${plugin.name}${db} loaded: ${plugin.loaded} started: ${plugin.started}...`);
                 const startInterval = setInterval(async () => {
+                    if (!this.matterServer) {
+                        this.log.error('No matter server initialized');
+                        await this.cleanup('No matter server initialized');
+                        return;
+                    }
                     if (!plugin.loaded || !plugin.started) {
-                        this.log.info(`***Returning in startMatterBridge interval for plugin ${plg}${plugin.name}${db} loaded: ${plugin.loaded} started: ${plugin.started}...`);
+                        this.log.info(`**Waiting in startMatterBridge interval for plugin ${plg}${plugin.name}${db} loaded: ${plugin.loaded} started: ${plugin.started}...`);
                         return;
                     }
                     if (plugin.type === 'AccessoryPlatform') {
@@ -718,7 +845,11 @@ export class Matterbridge {
                             .filter((registeredDevice) => registeredDevice.plugin === plugin.name)
                             .forEach((registeredDevice) => {
                             if (!plugin.storageContext)
-                                plugin.storageContext = this.importCommissioningServerContext(plugin.name, registeredDevice.device); // Generate serialNumber and uniqueId
+                                plugin.storageContext = this.importCommissioningServerContext(plugin.name, registeredDevice.device);
+                            if (!plugin.storageContext) {
+                                this.log.error(`Error importing storage context for plugin ${plg}${plugin.name}${er}`);
+                                return;
+                            }
                             if (!plugin.commissioningServer)
                                 plugin.commissioningServer = this.createCommisioningServer(plugin.storageContext, plugin.name);
                             this.log.debug(`Adding device ${dev}${registeredDevice.device.name}${db} to commissioning server for plugin ${plg}${plugin.name}${db}`);
@@ -728,9 +859,11 @@ export class Matterbridge {
                         await this.matterServer.addCommissioningServer(plugin.commissioningServer, { uniqueStorageKey: plugin.name });
                     }
                     if (plugin.type === 'DynamicPlatform') {
-                        plugin.storageContext = this.createCommissioningServerContext(
-                        // Generate serialNumber and uniqueId
-                        plugin.name, 'Matterbridge Dynamic Platform', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Dynamic Platform');
+                        plugin.storageContext = this.createCommissioningServerContext(plugin.name, 'Matterbridge Dynamic Platform', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Dynamic Platform');
+                        if (!plugin.storageContext) {
+                            this.log.error(`Error creating storage context for plugin ${plg}${plugin.name}${er}`);
+                            return;
+                        }
                         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
@@ -744,19 +877,20 @@ export class Matterbridge {
             });
             // Start the interval to check if all plugins are loaded and started and so start the matter server
             // TODO set a counter or a timeout
-            this.log.info('**Starting start matter interval...');
+            this.log.debug('*Starting start matter interval...');
             const startMatterInterval = setInterval(async () => {
                 let allStarted = true;
                 this.registeredPlugins.forEach((plugin) => {
                     if (!plugin.enabled)
                         return;
-                    this.log.info(`**Waiting in start matter server interval for plugin ${plg}${plugin.name}${db} to load (${plugin.loaded}) and start (${plugin.started}) ...`);
                     if (plugin.enabled && (!plugin.loaded || !plugin.started))
                         allStarted = false;
+                    if (!allStarted)
+                        this.log.info(`**Waiting in start matter server interval for plugin ${plg}${plugin.name}${db} to load (${plugin.loaded}) and start (${plugin.started}) ...`);
                 });
                 if (!allStarted)
                     return;
-                this.log.info('**Starting matter server in start matter server interval...');
+                this.log.info('Starting matter server');
                 // Setting reachability to true
                 this.registeredPlugins.forEach((plugin) => {
                     if (!plugin.enabled)
@@ -783,6 +917,11 @@ export class Matterbridge {
         }
     }
     async startMatterServer() {
+        if (!this.matterServer) {
+            this.log.error('No matter server initialized');
+            await this.cleanup('No matter server initialized');
+            return;
+        }
         this.log.debug('Starting matter server');
         await this.matterServer.start();
         this.log.debug('Started matter server');
@@ -822,6 +961,10 @@ export class Matterbridge {
      * @returns The storage context for the commissioning server.
      */
     createCommissioningServerContext(pluginName, deviceName, deviceType, vendorId, vendorName, productId, productName, serialNumber, uniqueId, softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString) {
+        if (!this.storageManager) {
+            this.log.error('No storage manager initialized');
+            process.exit(1);
+        }
         this.log.debug(`Creating commissioning server storage context for ${plg}${pluginName}${db}`);
         const random = 'CS' + CryptoNode.getRandomData(8).toHex();
         const storageContext = this.storageManager.createContext(pluginName);
@@ -862,9 +1005,15 @@ export class Matterbridge {
             storageContext.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') {
                 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;
                 }
@@ -872,9 +1021,19 @@ export class Matterbridge {
         }
         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') {
                 const plugin = this.findPlugin(pluginName);
-                if (plugin) {
+                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());
                     plugin.paired = true;
                 }
@@ -960,7 +1119,7 @@ export class Matterbridge {
                             for (const plugin of this.registeredPlugins) {
                                 if (!plugin.enabled)
                                     continue;
-                                this.startPlugin(plugin, 'Matterbridge is commissioned and controllers are connected', true); // No await do it asyncronously
+                                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;
@@ -968,7 +1127,7 @@ export class Matterbridge {
                         if (this.bridgeMode === 'childbridge') {
                             //Logger.defaultLogLevel = Level.INFO;
                             const plugin = this.findPlugin(name);
-                            if (plugin && plugin.type === 'DynamicPlatform') {
+                            if (plugin && plugin.type === 'DynamicPlatform' && plugin.configured !== true) {
                                 for (const registeredDevice of this.registeredDevices) {
                                     if (registeredDevice.plugin === name) {
                                         this.log.info(`Adding bridged device ${dev}${registeredDevice.device.name}${nf} to aggregator for plugin ${plg}${plugin.name}${db}`);
@@ -985,7 +1144,7 @@ export class Matterbridge {
                                 }
                             }
                             for (const plugin of this.registeredPlugins) {
-                                if (plugin.name === name && plugin.platform) {
+                                if (plugin.name === name && plugin.platform && plugin.configured !== true) {
                                     this.configurePlugin(plugin); // No await do it asyncronously
                                 }
                             }
@@ -1015,6 +1174,7 @@ export class Matterbridge {
     createMatterServer(storageManager) {
         this.log.debug('Creating matter server');
         this.matterServer = new MatterServer(storageManager, { mdnsAnnounceInterface: undefined });
+        this.log.debug('Created matter server');
     }
     /**
      * Creates a Matter Aggregator.
@@ -1062,6 +1222,27 @@ export class Matterbridge {
         this.log.debug('Stopping matter server');
         await this.matterServer?.close();
         this.log.debug('Matter server closed');
+        this.commissioningController = undefined;
+        this.commissioningServer = undefined;
+        this.matterAggregator = undefined;
+        this.matterServer = undefined;
+    }
+    /**
+     * Retrieves the latest version of a package from the npm registry.
+     * @param packageName - The name of the package.
+     * @returns A Promise that resolves to the latest version of the package.
+     */
+    async getLatestVersion(packageName) {
+        return new Promise((resolve, reject) => {
+            exec(`npm view ${packageName} version`, (error, stdout) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(stdout.trim());
+                }
+            });
+        });
     }
     /**
      * Logs the node and system information.
@@ -1122,19 +1303,64 @@ export class Matterbridge {
         const currentFileDirectory = path.dirname(fileURLToPath(import.meta.url));
         this.rootDirectory = path.resolve(currentFileDirectory, '../');
         this.log.debug(`Root Directory: ${this.rootDirectory}`);
+        // Global node_modules directory
+        this.globalModulesDir = execSync('npm root -g').toString().trim();
+        this.log.debug(`Global node_modules Directory: ${this.globalModulesDir}`);
         // Create the data directory .matterbridge in the home directory
         this.matterbridgeDirectory = path.join(this.homeDirectory, '.matterbridge');
         try {
             await fs.access(this.matterbridgeDirectory);
         }
         catch (err) {
-            await fs.mkdir(this.matterbridgeDirectory);
+            if (err instanceof Error) {
+                const nodeErr = err;
+                if (nodeErr.code === 'ENOENT') {
+                    try {
+                        await fs.mkdir(this.matterbridgeDirectory, { recursive: true });
+                        this.log.info(`Created Matterbridge Directory: ${this.matterbridgeDirectory}`);
+                    }
+                    catch (err) {
+                        this.log.error(`Error creating directory: ${err}`);
+                    }
+                }
+                else {
+                    this.log.error(`Error accessing directory: ${err}`);
+                }
+            }
         }
         this.log.debug(`Matterbridge Directory: ${this.matterbridgeDirectory}`);
+        // Create the data directory .matterbridge in the home directory
+        this.matterbridgePluginDirectory = path.join(this.homeDirectory, 'Matterbridge');
+        try {
+            await fs.access(this.matterbridgePluginDirectory);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                const nodeErr = err;
+                if (nodeErr.code === 'ENOENT') {
+                    try {
+                        await fs.mkdir(this.matterbridgePluginDirectory, { recursive: true });
+                        this.log.info(`Created Matterbridge Plugin Directory: ${this.matterbridgePluginDirectory}`);
+                    }
+                    catch (err) {
+                        this.log.error(`Error creating directory: ${err}`);
+                    }
+                }
+                else {
+                    this.log.error(`Error accessing directory: ${err}`);
+                }
+            }
+        }
+        this.log.debug(`Matterbridge Plugin Directory: ${this.matterbridgePluginDirectory}`);
         // Matterbridge version
         const packageJson = JSON.parse(await fs.readFile(path.join(this.rootDirectory, 'package.json'), 'utf-8'));
         this.matterbridgeVersion = packageJson.version;
         this.log.debug(`Matterbridge Version: ${this.matterbridgeVersion}`);
+        this.matterbridgeLatestVersion = await this.getLatestVersion('matterbridge');
+        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}`);
+        }
         // Current working directory
         const currentDir = process.cwd();
         this.log.debug(`Current Working Directory: ${currentDir}`);
@@ -1157,6 +1383,8 @@ export class Matterbridge {
             paired: plugin.paired,
             connected: plugin.connected,
             registeredDevices: plugin.registeredDevices,
+            qrPairingCode: plugin.qrPairingCode,
+            manualPairingCode: plugin.manualPairingCode,
         }));
         return baseRegisteredPlugins;
     }
@@ -1184,14 +1412,16 @@ export class Matterbridge {
      */
     async initializeFrontend(port = 3000) {
         this.log.debug(`Initializing the frontend on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
-        this.app = express();
+        this.expressApp = express();
         // Serve React build directory
-        this.app.use(express.static(path.join(this.rootDirectory, 'frontend/build')));
+        this.expressApp.use(express.static(path.join(this.rootDirectory, 'frontend/build')));
         // Endpoint to provide QR pairing code
-        this.app.get('/api/qr-code', (req, res) => {
+        this.expressApp.get('/api/qr-code', (req, res) => {
             this.log.debug('The frontend sent /api/qr-code');
-            if (!this.matterbridgeContext)
-                this.matterbridgeContext = this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggregator');
+            if (!this.matterbridgeContext) {
+                res.json([]);
+                return;
+            }
             try {
                 const qrData = { qrPairingCode: this.matterbridgeContext.get('qrPairingCode'), manualPairingCode: this.matterbridgeContext.get('manualPairingCode') };
                 res.json(qrData);
@@ -1203,17 +1433,17 @@ export class Matterbridge {
             }
         });
         // Endpoint to provide system information
-        this.app.get('/api/system-info', (req, res) => {
+        this.expressApp.get('/api/system-info', (req, res) => {
             this.log.debug('The frontend sent /api/system-info');
             res.json(this.systemInformation);
         });
         // Endpoint to provide plugins
-        this.app.get('/api/plugins', (req, res) => {
+        this.expressApp.get('/api/plugins', (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
             res.json(this.getBaseRegisteredPlugins());
         });
         // Endpoint to provide devices
-        this.app.get('/api/devices', (req, res) => {
+        this.expressApp.get('/api/devices', (req, res) => {
             this.log.debug('The frontend sent /api/devices');
             const data = [];
             this.registeredDevices.forEach((registeredDevice) => {
@@ -1240,7 +1470,7 @@ export class Matterbridge {
             res.json(data);
         });
         // Endpoint to provide the cluster servers of the devices
-        this.app.get('/api/devices_clusters/:selectedPluginName/:selectedDeviceEndpoint', (req, res) => {
+        this.expressApp.get('/api/devices_clusters/:selectedPluginName/:selectedDeviceEndpoint', (req, res) => {
             const selectedPluginName = req.params.selectedPluginName;
             const selectedDeviceEndpoint = parseInt(req.params.selectedDeviceEndpoint, 10);
             this.log.debug(`The frontend sent /api/devices_clusters plugin:${selectedPluginName} endpoint:${selectedDeviceEndpoint}`);
@@ -1282,12 +1512,49 @@ export class Matterbridge {
             });
             res.json(data);
         });
+        // Endpoint to receive commands
+        this.expressApp.post('/api/command/:command/:param', (req, res) => {
+            const command = req.params.command;
+            const param = req.params.param;
+            this.log.debug(`The frontend sent /api/command/${command}/${param}`);
+            if (!command) {
+                res.status(400).json({ error: 'No command provided' });
+                return;
+            }
+            this.log.info(`***Received command: ${command}:${param}`);
+            // Handle the command debugLevel
+            if (command === 'setloglevel') {
+                if (param === 'Debug') {
+                    this.log.setLogDebug(true);
+                    this.debugEnabled = true;
+                    Logger.defaultLogLevel = Level.DEBUG;
+                }
+                else if (param === 'Info') {
+                    this.log.setLogDebug(false);
+                    this.debugEnabled = false;
+                    Logger.defaultLogLevel = Level.INFO;
+                }
+                else if (param === 'Warn') {
+                    this.log.setLogDebug(false);
+                    this.debugEnabled = false;
+                    Logger.defaultLogLevel = Level.WARN;
+                }
+                this.registeredPlugins.forEach((plugin) => {
+                    plugin.platform?.log.setLogDebug(this.debugEnabled);
+                });
+            }
+            // Handle the command debugLevel
+            if (command === 'restart') {
+                this.restartProcess();
+            }
+            res.json({ message: 'Command received' });
+        });
         // Fallback for routing
-        this.app.get('*', (req, res) => {
+        this.expressApp.get('*', (req, res) => {
             this.log.warn('The frontend sent *', req.url);
             res.sendFile(path.join(this.rootDirectory, 'frontend/build/index.html'));
         });
-        this.app.listen(port, () => {
+        this.expressServer = this.expressApp.listen(port, () => {
             this.log.info(`The frontend is running on ${UNDERLINE}http://localhost:${port}${UNDERLINEOFF}${rs}`);
         });
         this.log.debug(`Frontend initialized on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
@@ -1335,7 +1602,25 @@ export class Matterbridge {
 }
 /*
 TO IMPLEMENT
+
+import { spawn } from 'child_process';
+
+function restartProcess() {
+  // Spawn a new process
+  const newProcess = spawn(process.argv[0], process.argv.slice(1), {
+    detached: true,
+    stdio: 'inherit',
+  });
+
+  // Unreference the new process so that the current process can exit
+  newProcess.unref();
+
+  // Exit the current process
+  process.exit();
+}
+
 import * as WebSocket from 'ws';
+const globalModulesDir = require('global-modules');
 
 const wss = new WebSocket.Server({ port: 8080 });