matterbridge 1.1.8 → 1.1.10

package/dist/matterbridge.js

@@ -25,7 +25,8 @@ 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 { execSync } from 'child_process';
+import { exec, spawn } from 'child_process';
+import EventEmitter from 'events';
 import express from 'express';
 import os from 'os';
 import path from 'path';
@@ -44,7 +45,7 @@ const typ = '\u001B[38;5;207m';
 /**
  * Represents the Matterbridge application.
  */
-export class Matterbridge {
+export class Matterbridge extends EventEmitter {
     systemInformation = {
         ipv4Address: '',
         ipv6Address: '',
@@ -61,7 +62,9 @@ export class Matterbridge {
     homeDirectory = '';
     rootDirectory = '';
     matterbridgeDirectory = '';
+    matterbridgePluginDirectory = '';
     matterbridgeVersion = '';
+    matterbridgeLatestVersion = '';
     globalModulesDir = '';
     bridgeMode = '';
     debugEnabled = false;
@@ -71,7 +74,8 @@ export class Matterbridge {
     registeredDevices = [];
     nodeStorage;
     nodeContext;
-    app;
+    expressApp;
+    expressServer;
     storageManager;
     matterbridgeContext;
     mattercontrollerContext;
@@ -81,26 +85,25 @@ export class Matterbridge {
     commissioningController;
     static instance;
     constructor() {
-        // we load asynchroneously the instance
+        super();
+        // 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;
     }
@@ -115,6 +118,10 @@ export class Matterbridge {
      * @returns A Promise that resolves when the initialization is complete.
      */
     async initialize() {
+        /*
+        const wtf = await import('wtfnode');
+        wtf.dump();
+        */
         // Display the help
         if (hasParameter('help')) {
             // eslint-disable-next-line no-console
@@ -161,17 +168,54 @@ 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();
     }
+    /**
+     * Spawns a child process with the given command and arguments.
+     * @param command - The command to execute.
+     * @param args - The arguments to pass to the command (default: []).
+     * @returns A promise that resolves when the child process exits successfully, or rejects if there is an error.
+     */
+    async spawnCommand(command, args = []) {
+        /*
+        npm > npm.cmd on windows
+        */
+        return new Promise((resolve, reject) => {
+            const childProcess = spawn(command, args, {
+                stdio: 'inherit',
+            });
+            childProcess.on('error', (err) => {
+                this.log.error(`Failed to start child process: ${err.message}`);
+                reject(err); // Reject the promise on error
+            });
+            childProcess.on('close', (code) => {
+                if (code === 0) {
+                    this.log.info(`Child process stdio streams have closed with code ${code}`);
+                    resolve();
+                }
+                else {
+                    this.log.error(`Child process stdio streams have closed with code ${code}`);
+                    reject(new Error(`Process exited with code ${code}`));
+                }
+            });
+            // The 'exit' event might be redundant here since 'close' is also being handled
+            childProcess.on('exit', (code, signal) => {
+                this.log.info(`Child process exited with code ${code} and signal ${signal}`);
+            });
+            childProcess.on('disconnect', () => {
+                this.log.info('Child process has been disconnected from the parent');
+            });
+        });
+    }
     /**
      * Parses the command line arguments and performs the corresponding actions.
      * @private
@@ -190,26 +234,31 @@ export class Matterbridge {
                     this.log.info(`│ └─ ${db}${plugin.path}${db}`);
                 }
             });
+            this.emit('shutdown');
             process.exit(0);
         }
         if (getParameter('add')) {
             this.log.debug(`Registering plugin ${getParameter('add')}`);
             await this.executeCommandLine(getParameter('add'), 'add');
+            this.emit('shutdown');
             process.exit(0);
         }
         if (getParameter('remove')) {
             this.log.debug(`Unregistering plugin ${getParameter('remove')}`);
             await this.executeCommandLine(getParameter('remove'), 'remove');
+            this.emit('shutdown');
             process.exit(0);
         }
         if (getParameter('enable')) {
             this.log.debug(`Enable plugin ${getParameter('enable')}`);
             await this.executeCommandLine(getParameter('enable'), 'enable');
+            this.emit('shutdown');
             process.exit(0);
         }
         if (getParameter('disable')) {
             this.log.debug(`Disable plugin ${getParameter('disable')}`);
             await this.executeCommandLine(getParameter('disable'), 'disable');
+            this.emit('shutdown');
             process.exit(0);
         }
         // Start the storage (we need it now for frontend and later for matterbridge)
@@ -227,8 +276,10 @@ export class Matterbridge {
             this.bridgeMode = 'bridge';
             MatterbridgeDevice.bridgeMode = 'bridge';
             for (const plugin of this.registeredPlugins) {
-                if (!plugin.enabled)
+                if (!plugin.enabled) {
+                    this.log.info(`Plugin ${plg}${plugin.name}${nf} not enabled`);
                     continue;
+                }
                 plugin.loaded = false;
                 plugin.started = false;
                 plugin.configured = false;
@@ -243,8 +294,10 @@ export class Matterbridge {
             this.bridgeMode = 'childbridge';
             MatterbridgeDevice.bridgeMode = 'childbridge';
             for (const plugin of this.registeredPlugins) {
-                if (!plugin.enabled)
+                if (!plugin.enabled) {
+                    this.log.info(`Plugin ${plg}${plugin.name}${nf} not enabled`);
                     continue;
+                }
                 plugin.loaded = false;
                 plugin.started = false;
                 plugin.configured = false;
@@ -275,7 +328,7 @@ export class Matterbridge {
             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}`);
+            //this.log.debug(`Got ${packageJsonPath}`);
         }
         try {
             // Load the package.json of the plugin
@@ -360,7 +413,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}`);
@@ -371,21 +423,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('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)
@@ -408,23 +471,55 @@ export class Matterbridge {
               if (this.bridgeMode === 'childbridge' && plugin.type === 'DynamicPlatform') registeredDevice.device.setBridgedDeviceReachability(false);
             });
             */
-            setTimeout(async () => {
+            // Close the express server
+            if (this.expressServer) {
+                this.expressServer.close();
+                this.expressServer = undefined;
+            }
+            // Remove listeners
+            if (this.expressApp) {
+                this.expressApp.removeAllListeners();
+                this.expressApp = undefined;
+            }
+            const cleanupTimeout1 = 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(() => {
-                    this.log.info('Cleanup completed.');
-                    process.exit(0);
+                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 = [];
+                const cleanupTimeout2 = setTimeout(async () => {
+                    if (restart) {
+                        this.log.info('Cleanup completed. Restarting...');
+                        Matterbridge.instance = undefined;
+                        this.emit('restart');
+                    }
+                    else {
+                        this.log.info('Cleanup completed. Shutting down...');
+                        Matterbridge.instance = undefined;
+                        this.emit('shutdown');
+                    }
                 }, 2 * 1000);
+                cleanupTimeout2.unref();
             }, 3 * 1000);
+            cleanupTimeout1.unref();
         }
     }
     /**
@@ -448,29 +543,33 @@ export class Matterbridge {
      * @returns A Promise that resolves when the device is added successfully.
      */
     async addDevice(pluginName, device) {
-        this.log.debug(`Adding device ${dev}${device.name}${db} for plugin ${plg}${pluginName}${db}`);
+        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`);
+            return;
+        }
+        this.log.debug(`Adding device ${dev}${device.name}-${device.deviceName}${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}-${device.deviceName}${er} plugin ${plg}${pluginName}${er} not found`);
             return;
         }
         // 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++;
             if (plugin.addedDevices !== undefined)
                 plugin.addedDevices++;
-            this.log.info(`Added and registered device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
+            this.log.info(`Added and registered device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.name}-${device.deviceName}${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}${nf} for plugin ${plg}${pluginName}${nf}`);
+            this.log.info(`Registered device ${dev}${device.name}-${device.deviceName}${nf} for plugin ${plg}${pluginName}${nf}`);
         }
     }
     /**
@@ -480,29 +579,111 @@ export class Matterbridge {
      * @returns {Promise<void>} - A promise that resolves when the storage process is started.
      */
     async addBridgedDevice(pluginName, device) {
-        this.log.debug(`Adding bridged device ${db}${device.name}${nf} for plugin ${plg}${pluginName}${db}`);
+        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`);
+            return;
+        }
+        this.log.debug(`Adding bridged device ${db}${device.name}-${device.deviceName}${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}-${device.deviceName}${er} plugin ${plg}${pluginName}${er} not found`);
             return;
         }
         // 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++;
             if (plugin.addedDevices !== undefined)
                 plugin.addedDevices++;
-            this.log.info(`Added and registered bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.name}${nf} for plugin ${plg}${pluginName}${nf}`);
+            this.log.info(`Added and registered bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.name}-${device.deviceName}${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}${nf} for plugin ${plg}${pluginName}${nf}`);
+            this.log.info(`Registered bridged device ${dev}${device.name}-${device.deviceName}${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`);
+            return;
+        }
+        this.log.debug(`Removing bridged device ${db}${device.name}-${device.deviceName}${nf} 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`);
+            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`);
+            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;
+        }
+        // Register and add the device to matterbridge aggregator in bridge mode
+        if (this.bridgeMode === 'bridge') {
+            this.matterAggregator.removeBridgedDevice(device);
+            this.registeredDevices.forEach((registeredDevice, index) => {
+                if (registeredDevice.device === device) {
+                    this.registeredDevices.splice(index, 1);
+                    return;
+                }
+            });
+            if (plugin.registeredDevices !== undefined)
+                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}`);
+        }
+        // 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`);
+            }
+            else if (plugin.type === 'DynamicPlatform') {
+                this.registeredDevices.forEach((registeredDevice, index) => {
+                    if (registeredDevice.device === device) {
+                        this.registeredDevices.splice(index, 1);
+                        return;
+                    }
+                });
+                plugin.aggregator.removeBridgedDevice(device);
+            }
+            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}`);
+        }
+    }
+    /**
+     * Removes all bridged devices associated with a specific plugin.
+     *
+     * @param pluginName - The name of the plugin.
+     * @returns A promise that resolves when all devices have been removed.
+     */
+    async removeAllBridgedDevices(pluginName) {
+        const plugin = this.findPlugin(pluginName);
+        if (this.bridgeMode === 'childbridge' && plugin?.type === 'AccessoryPlatform') {
+            this.log.warn(`Removing devices for plugin ${plg}${pluginName}${wr} error: AccessoryPlatform not supported in childbridge mode`);
+            return;
+        }
+        const devicesToRemove = [];
+        for (const registeredDevice of this.registeredDevices) {
+            if (registeredDevice.plugin === pluginName) {
+                devicesToRemove.push(registeredDevice);
+            }
+        }
+        for (const registeredDevice of devicesToRemove) {
+            this.removeBridgedDevice(pluginName, registeredDevice.device);
         }
     }
     /**
@@ -512,18 +693,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');
@@ -533,7 +718,7 @@ export class Matterbridge {
         }
         catch (error) {
             this.log.error('Storage initialize() error!');
-            process.exit(1);
+            await this.cleanup('Storage initialize() error!');
         }
     }
     /**
@@ -568,8 +753,11 @@ 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() {
         /*
@@ -734,13 +922,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}`);
@@ -754,17 +956,22 @@ 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.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(`**Waiting in startMatterBridge interval for plugin ${plg}${plugin.name}${db} loaded: ${plugin.loaded} started: ${plugin.started}...`);
                         return;
@@ -774,7 +981,7 @@ 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.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}`);
@@ -784,9 +991,7 @@ 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');
                         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
@@ -840,6 +1045,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');
@@ -879,6 +1089,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);
@@ -1044,7 +1258,7 @@ export class Matterbridge {
                             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}`);
+                                        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}`);
                                             continue;
@@ -1052,7 +1266,9 @@ export class Matterbridge {
                                         plugin.aggregator.addBridgedDevice(registeredDevice.device);
                                         if (plugin.addedDevices !== undefined)
                                             plugin.addedDevices++;
-                                        this.log.info(`Added bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${registeredDevice.device.name}${nf} for plugin ${plg}${plugin.name}${nf}`);
+                                        this.log.info(
+                                        // eslint-disable-next-line max-len
+                                        `Added bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${registeredDevice.device.name}-${registeredDevice.device.deviceName}${nf} for plugin ${plg}${plugin.name}${nf}`);
                                         registeredDevice.added = true;
                                     }
                                 }
@@ -1088,6 +1304,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.
@@ -1135,6 +1352,43 @@ 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());
+                }
+            });
+        });
+    }
+    /**
+     * Retrieves the path to the global Node.js modules directory.
+     * @returns A promise that resolves to the path of the global Node.js modules directory.
+     */
+    async getGlobalNodeModules() {
+        return new Promise((resolve, reject) => {
+            exec('npm root -g', (error, stdout) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(stdout.trim());
+                }
+            });
+        });
     }
     /**
      * Logs the node and system information.
@@ -1196,7 +1450,7 @@ export class Matterbridge {
         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.globalModulesDir = await this.getGlobalNodeModules();
         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');
@@ -1204,13 +1458,55 @@ export class Matterbridge {
             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}`);
@@ -1262,14 +1558,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);
@@ -1281,17 +1579,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) => {
@@ -1318,7 +1616,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}`);
@@ -1360,12 +1658,83 @@ export class Matterbridge {
             });
             res.json(data);
         });
+        // Endpoint to receive commands
+        this.expressApp.post('/api/command/:command/:param', async (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 from Settings
+            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 from Header
+            if (command === 'restart') {
+                this.restartProcess();
+            }
+            // Handle the command update from Header
+            if (command === 'update') {
+                this.log.warn(`The /api/command/${command} is not yet implemented`);
+            }
+            // Handle the command addplugin from Header
+            if (command === 'addplugin') {
+                this.log.warn(`The /api/command/${command}/${param} is not yet implemented`);
+            }
+            // Handle the command enableplugin from Home
+            if (command === 'enableplugin') {
+                const plugin = this.findPlugin(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());
+                    this.log.info(`Enabled plugin ${plg}${param}${nf}`);
+                }
+            }
+            // Handle the command disableplugin from Home
+            if (command === 'disableplugin') {
+                const plugin = this.findPlugin(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());
+                    this.log.info(`Disabled plugin ${plg}${param}${nf}`);
+                }
+            }
+            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}`);
@@ -1413,6 +1782,23 @@ 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');