matterbridge 1.1.9 → 1.1.11

package/dist/matterbridge.js

@@ -25,11 +25,12 @@ 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 { exec, spawn } from 'child_process';
+import EventEmitter from 'events';
 import express from 'express';
 import os from 'os';
 import path from 'path';
-import { CommissioningServer, MatterServer } from '@project-chip/matter-node.js';
+import { CommissioningController, CommissioningServer, MatterServer } from '@project-chip/matter-node.js';
 import { BasicInformationCluster, BridgedDeviceBasicInformationCluster, ClusterServer } from '@project-chip/matter-node.js/cluster';
 import { DeviceTypeId, VendorId } from '@project-chip/matter-node.js/datatype';
 import { Aggregator, DeviceTypes } from '@project-chip/matter-node.js/device';
@@ -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: '',
@@ -58,13 +59,24 @@ export class Matterbridge {
         freeMemory: '',
         systemUptime: '',
     };
+    matterbridgeInformation = {
+        homeDirectory: '',
+        rootDirectory: '',
+        matterbridgeDirectory: '',
+        matterbridgePluginDirectory: '',
+        globalModulesDirectory: '',
+        matterbridgeVersion: '',
+        matterbridgeLatestVersion: '',
+        bridgeMode: '',
+        debugEnabled: false,
+    };
     homeDirectory = '';
     rootDirectory = '';
     matterbridgeDirectory = '';
     matterbridgePluginDirectory = '';
+    globalModulesDirectory = '';
     matterbridgeVersion = '';
     matterbridgeLatestVersion = '';
-    globalModulesDir = '';
     bridgeMode = '';
     debugEnabled = false;
     log;
@@ -84,6 +96,7 @@ export class Matterbridge {
     commissioningController;
     static instance;
     constructor() {
+        super();
         // We load asyncronously
     }
     /**
@@ -116,6 +129,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
@@ -173,6 +190,43 @@ export class Matterbridge {
         // 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
@@ -191,26 +245,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)
@@ -224,12 +283,20 @@ export class Matterbridge {
             MatterbridgeDevice.bridgeMode = 'childbridge';
             await this.testStartMatterBridge(); // No await do it asyncronously
         }
+        if (hasParameter('controller')) {
+            this.bridgeMode = 'controller';
+            this.log.info('Creating mattercontrollerContext: mattercontrollerContext');
+            this.mattercontrollerContext = this.storageManager?.createContext('mattercontrollerContext');
+            await this.startMatterBridge();
+        }
         if (hasParameter('bridge')) {
             this.bridgeMode = 'bridge';
             MatterbridgeDevice.bridgeMode = 'bridge';
             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;
@@ -244,8 +311,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;
@@ -274,8 +343,8 @@ export class Matterbridge {
         }
         if (!packageJsonExists) {
             this.log.debug(`Package.json not found at ${packageJsonPath}`);
-            this.log.debug(`Trying at ${this.globalModulesDir}`);
-            packageJsonPath = path.join(this.globalModulesDir, pluginPath);
+            this.log.debug(`Trying at ${this.globalModulesDirectory}`);
+            packageJsonPath = path.join(this.globalModulesDirectory, pluginPath);
             //this.log.debug(`Got ${packageJsonPath}`);
         }
         try {
@@ -384,7 +453,7 @@ export class Matterbridge {
     async restartProcess() {
         //this.log.info('Restarting still not implemented');
         //return;
-        await this.cleanup('Matterbridge is restarting...', true);
+        await this.cleanup('restarting...', true);
         this.hasCleanupStarted = false;
     }
     /**
@@ -397,7 +466,7 @@ export class Matterbridge {
             this.log.info(message);
             process.removeAllListeners('SIGINT');
             process.removeAllListeners('SIGTERM');
-            // Callint the shutdown functions with a reason
+            // Calling the shutdown functions with a reason
             for (const plugin of this.registeredPlugins) {
                 if (plugin.platform)
                     await plugin.platform.onShutdown('Matterbridge is closing: ' + message);
@@ -429,23 +498,26 @@ export class Matterbridge {
                 this.expressApp.removeAllListeners();
                 this.expressApp = undefined;
             }
-            setTimeout(async () => {
+            const cleanupTimeout1 = setTimeout(async () => {
                 // Closing matter
                 await this.stopMatter();
                 // Closing storage
                 await this.stopStorage();
                 // Serialize registeredDevices
-                if (this.nodeContext) {
+                if (this.nodeStorage && this.nodeContext) {
                     this.log.info('Saving registered devices...');
                     const serializedRegisteredDevices = [];
                     this.registeredDevices.forEach((registeredDevice) => {
                         serializedRegisteredDevices.push(registeredDevice.device.serialize(registeredDevice.plugin));
                     });
-                    //console.log('serializedRegisteredDevices:', serializedRegisteredDevices);
                     await this.nodeContext.set('devices', serializedRegisteredDevices);
                     this.log.info('Saved registered devices');
                     // Clear nodeContext and nodeStorage (they just need 1000ms to write the data to disk)
+                    this.log.debug('Closing node storage context...');
+                    this.nodeContext.close();
                     this.nodeContext = undefined;
+                    this.log.debug('Closing node storage manager...');
+                    this.nodeStorage.close();
                     this.nodeStorage = undefined;
                 }
                 else {
@@ -453,15 +525,22 @@ export class Matterbridge {
                 }
                 this.registeredPlugins = [];
                 this.registeredDevices = [];
-                setTimeout(async () => {
-                    this.log.info('Cleanup completed.');
-                    //if (restart) console.log(this);
-                    if (restart)
-                        await this.initialize();
-                    else
-                        process.exit(0);
+                this.log.info('Waiting for matter to deliver last messages...');
+                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();
         }
     }
     /**
@@ -486,14 +565,14 @@ export class Matterbridge {
      */
     async addDevice(pluginName, device) {
         if (this.bridgeMode === 'bridge' && !this.matterAggregator) {
-            this.log.error(`Adding device ${dev}${device.name}${er} for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
+            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}${db} for plugin ${plg}${pluginName}${db}`);
+        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(`Error adding device ${dev}${device.name}${er} 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
@@ -504,14 +583,14 @@ export class Matterbridge {
                 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}`);
         }
     }
     /**
@@ -522,14 +601,14 @@ export class Matterbridge {
      */
     async addBridgedDevice(pluginName, device) {
         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`);
+            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}${nf} for plugin ${plg}${pluginName}${db}`);
+        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(`Error adding bridged device ${dev}${device.name}${er} 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
@@ -540,14 +619,92 @@ export class Matterbridge {
                 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);
         }
     }
     /**
@@ -798,13 +955,33 @@ export class Matterbridge {
             await this.cleanup('No matter server initialized');
             return;
         }
+        if (this.bridgeMode === 'controller') {
+            this.log.info('Creating matter commissioning controller');
+            this.commissioningController = new CommissioningController({
+                autoConnect: false,
+            });
+            this.log.info('Adding matter commissioning controller to matter server');
+            await this.matterServer.addCommissioningController(this.commissioningController);
+            this.log.info('Starting matter server');
+            await this.matterServer.start();
+            this.log.info('Matter server started');
+            if (hasParameter('discover')) {
+                const discover = await this.commissioningController.discoverCommissionableDevices({ productId: 0x8000, deviceType: 0xfff1 });
+                console.log(discover);
+            }
+            this.log.info(`Commissioning controller is already commisioned: ${this.commissioningController.isCommissioned()}`);
+            const nodes = this.commissioningController.getCommissionedNodes();
+            nodes.forEach(async (nodeId) => {
+                this.log.warn(`Connecting to commissioned node: ${nodeId}`);
+            });
+        }
         if (this.bridgeMode === 'bridge') {
             // Plugins are loaded by loadPlugin on startup and plugin.loaded is set to true
             // Plugins are started and configured by callback when Matterbridge is commissioned
             this.log.debug(`Creating commissioning server context for ${plg}Matterbridge${db}`);
             this.matterbridgeContext = this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggregator');
             if (!this.matterbridgeContext) {
-                this.log.error(`Error creating storage context${er}`);
+                this.log.error(`Error creating storage context for ${plg}Matterbridge${er}`);
                 return;
             }
             this.log.debug(`Creating commissioning server for ${plg}Matterbridge${db}`);
@@ -815,8 +992,9 @@ export class Matterbridge {
             this.commissioningServer.addDevice(this.matterAggregator);
             this.log.debug('Adding matterbridge commissioning server to matter server');
             await this.matterServer.addCommissioningServer(this.commissioningServer, { uniqueStorageKey: 'Matterbridge' });
-            this.log.debug('Starting matter server');
+            this.log.debug('Starting matter server...');
             await this.startMatterServer();
+            this.log.info('Matter server started');
             this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, 'Matterbridge');
         }
         if (this.bridgeMode === 'childbridge') {
@@ -846,10 +1024,6 @@ export class Matterbridge {
                             .forEach((registeredDevice) => {
                             if (!plugin.storageContext)
                                 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}`);
@@ -860,10 +1034,6 @@ export class Matterbridge {
                     }
                     if (plugin.type === 'DynamicPlatform') {
                         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
@@ -890,7 +1060,7 @@ export class Matterbridge {
                 });
                 if (!allStarted)
                     return;
-                this.log.info('Starting matter server');
+                this.log.info('Starting matter server...');
                 // Setting reachability to true
                 this.registeredPlugins.forEach((plugin) => {
                     if (!plugin.enabled)
@@ -907,13 +1077,13 @@ export class Matterbridge {
                     });
                 });
                 await this.startMatterServer();
+                this.log.info('Matter server started');
                 for (const plugin of this.registeredPlugins) {
                     this.showCommissioningQRCode(plugin.commissioningServer, plugin.storageContext, plugin.name);
                 }
                 Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
                 clearInterval(startMatterInterval);
             }, 1000);
-            return;
         }
     }
     async startMatterServer() {
@@ -979,9 +1149,9 @@ export class Matterbridge {
         storageContext.set('serialNumber', storageContext.get('serialNumber', random));
         storageContext.set('uniqueId', storageContext.get('uniqueId', random));
         storageContext.set('softwareVersion', softwareVersion ?? 1);
-        storageContext.set('softwareVersionString', softwareVersionString ?? '1.0.0');
+        storageContext.set('softwareVersionString', softwareVersionString ?? '1.0');
         storageContext.set('hardwareVersion', hardwareVersion ?? 1);
-        storageContext.set('hardwareVersionString', hardwareVersionString ?? '1.0.0');
+        storageContext.set('hardwareVersionString', hardwareVersionString ?? '1.0');
         return storageContext;
     }
     /**
@@ -1130,7 +1300,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;
@@ -1138,7 +1308,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;
                                     }
                                 }
@@ -1244,6 +1416,22 @@ export class Matterbridge {
             });
         });
     }
+    /**
+     * 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.
      */
@@ -1298,16 +1486,20 @@ export class Matterbridge {
         this.log.debug(`- System Uptime: ${this.systemInformation.systemUptime}`);
         // Home directory
         this.homeDirectory = os.homedir();
+        this.matterbridgeInformation.homeDirectory = this.homeDirectory;
         this.log.debug(`Home Directory: ${this.homeDirectory}`);
         // Package root directory
         const currentFileDirectory = path.dirname(fileURLToPath(import.meta.url));
         this.rootDirectory = path.resolve(currentFileDirectory, '../');
+        this.matterbridgeInformation.rootDirectory = this.rootDirectory;
         this.log.debug(`Root Directory: ${this.rootDirectory}`);
         // Global node_modules directory
-        this.globalModulesDir = execSync('npm root -g').toString().trim();
-        this.log.debug(`Global node_modules Directory: ${this.globalModulesDir}`);
+        this.globalModulesDirectory = await this.getGlobalNodeModules();
+        this.matterbridgeInformation.globalModulesDirectory = this.globalModulesDirectory;
+        this.log.debug(`Global node_modules Directory: ${this.globalModulesDirectory}`);
         // Create the data directory .matterbridge in the home directory
         this.matterbridgeDirectory = path.join(this.homeDirectory, '.matterbridge');
+        this.matterbridgeInformation.matterbridgeDirectory = this.matterbridgeDirectory;
         try {
             await fs.access(this.matterbridgeDirectory);
         }
@@ -1331,6 +1523,7 @@ export class Matterbridge {
         this.log.debug(`Matterbridge Directory: ${this.matterbridgeDirectory}`);
         // Create the data directory .matterbridge in the home directory
         this.matterbridgePluginDirectory = path.join(this.homeDirectory, 'Matterbridge');
+        this.matterbridgeInformation.matterbridgePluginDirectory = this.matterbridgePluginDirectory;
         try {
             await fs.access(this.matterbridgePluginDirectory);
         }
@@ -1355,8 +1548,10 @@ export class Matterbridge {
         // Matterbridge version
         const packageJson = JSON.parse(await fs.readFile(path.join(this.rootDirectory, 'package.json'), 'utf-8'));
         this.matterbridgeVersion = packageJson.version;
+        this.matterbridgeInformation.matterbridgeVersion = this.matterbridgeVersion;
         this.log.debug(`Matterbridge Version: ${this.matterbridgeVersion}`);
         this.matterbridgeLatestVersion = await this.getLatestVersion('matterbridge');
+        this.matterbridgeInformation.matterbridgeLatestVersion = this.matterbridgeLatestVersion;
         this.log.debug(`Matterbridge Latest Version: ${this.matterbridgeLatestVersion}`);
         if (this.matterbridgeVersion !== this.matterbridgeLatestVersion) {
             this.log.warn(`Matterbridge is out of date. Current version: ${this.matterbridgeVersion}, Latest version: ${this.matterbridgeLatestVersion}`);
@@ -1437,6 +1632,13 @@ export class Matterbridge {
             this.log.debug('The frontend sent /api/system-info');
             res.json(this.systemInformation);
         });
+        // Endpoint to provide matterbridge information
+        this.expressApp.get('/api/matterbridge-info', (req, res) => {
+            this.log.debug('The frontend sent /api/matterbridge-info');
+            this.matterbridgeInformation.bridgeMode = this.bridgeMode;
+            this.matterbridgeInformation.debugEnabled = this.debugEnabled;
+            res.json(this.matterbridgeInformation);
+        });
         // Endpoint to provide plugins
         this.expressApp.get('/api/plugins', (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
@@ -1513,7 +1715,7 @@ export class Matterbridge {
             res.json(data);
         });
         // Endpoint to receive commands
-        this.expressApp.post('/api/command/:command/:param', (req, res) => {
+        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}`);
@@ -1522,7 +1724,7 @@ export class Matterbridge {
                 return;
             }
             this.log.info(`***Received command: ${command}:${param}`);
-            // Handle the command debugLevel
+            // Handle the command debugLevel from Settings
             if (command === 'setloglevel') {
                 if (param === 'Debug') {
                     this.log.setLogDebug(true);
@@ -1543,10 +1745,50 @@ export class Matterbridge {
                     plugin.platform?.log.setLogDebug(this.debugEnabled);
                 });
             }
-            // Handle the command debugLevel
+            // 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 plugins = await this.nodeContext?.get('plugins');
+                if (!plugins)
+                    return;
+                const plugin = plugins.find((plugin) => plugin.name === param);
+                if (plugin) {
+                    plugin.enabled = true;
+                    plugin.loaded = undefined;
+                    plugin.started = undefined;
+                    plugin.configured = undefined;
+                    plugin.connected = undefined;
+                    await this.nodeContext?.set('plugins', plugins);
+                    this.log.info(`Enabled plugin ${plg}${param}${nf}`);
+                }
+            }
+            // Handle the command disableplugin from Home
+            if (command === 'disableplugin') {
+                const plugins = await this.nodeContext?.get('plugins');
+                if (!plugins)
+                    return;
+                const plugin = plugins.find((plugin) => plugin.name === param);
+                if (plugin) {
+                    plugin.enabled = false;
+                    plugin.loaded = undefined;
+                    plugin.started = undefined;
+                    plugin.configured = undefined;
+                    plugin.connected = undefined;
+                    await this.nodeContext?.set('plugins', plugins);
+                    this.log.info(`Disabled plugin ${plg}${param}${nf}`);
+                }
+            }
             res.json({ message: 'Command received' });
         });
         // Fallback for routing