matterbridge 1.2.6 → 1.2.8

package/dist/matterbridge.js

@@ -22,7 +22,7 @@
  */
 import { MatterbridgeDevice } from './matterbridgeDevice.js';
 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 { AnsiLogger, BRIGHT, RESET, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, stringify, er, nf, rs, wr, RED, GREEN } from 'node-ansi-logger';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { promises as fs } from 'fs';
 import { exec, spawn } from 'child_process';
@@ -30,6 +30,7 @@ import EventEmitter from 'events';
 import express from 'express';
 import os from 'os';
 import path from 'path';
+import WebSocket, { WebSocketServer } from 'ws';
 import { CommissioningController, CommissioningServer, MatterServer } from '@project-chip/matter-node.js';
 import { BasicInformationCluster, BooleanStateCluster, 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -90,6 +91,7 @@ export class Matterbridge extends EventEmitter {
     nodeContext;
     expressApp;
     expressServer;
+    webSocketServer;
     storageManager;
     matterbridgeContext;
     mattercontrollerContext;
@@ -112,13 +114,74 @@ export class Matterbridge extends EventEmitter {
     static async loadInstance(initialize = false) {
         if (!Matterbridge.instance) {
             // eslint-disable-next-line no-console
-            console.log(wr + 'Matterbridge instance does not exists!', initialize ? 'Initializing...' : 'Not initializing...', rs);
+            if (hasParameter('debug'))
+                console.log(wr + 'Creating a new instance of Matterbridge.', initialize ? 'Initializing...' : 'Not initializing...', rs);
             Matterbridge.instance = new Matterbridge();
             if (initialize)
                 await Matterbridge.instance.initialize();
         }
         return Matterbridge.instance;
     }
+    /**
+     * Initializes the Matterbridge instance as extension for zigbee2mqtt.
+     *
+     * @returns A Promise that resolves when the initialization is complete.
+     */
+    async initializeAsExtension(dataPath, debugEnabled) {
+        // Set the first port to use
+        this.port = 5560;
+        // Set Matterbridge logger
+        this.debugEnabled = debugEnabled;
+        this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: this.debugEnabled });
+        this.log.debug('Matterbridge extension is starting...');
+        // Initialize NodeStorage
+        this.matterbridgeDirectory = dataPath;
+        this.log.debug('Creating node storage manager dir: ' + path.join(this.matterbridgeDirectory, 'node_storage'));
+        this.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridgeDirectory, 'node_storage'), logging: false });
+        this.log.debug('Creating node storage context for matterbridge: matterbridge');
+        this.nodeContext = await this.nodeStorage.createStorage('matterbridge');
+        // Log system info and create .matterbridge directory
+        await this.logNodeAndSystemInfo();
+        this.matterbridgeDirectory = dataPath;
+        // Set matter.js logger level and format
+        Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
+        Logger.format = Format.ANSI;
+        // Start the storage and create matterbridgeContext
+        await this.startStorage('json', path.join(this.matterbridgeDirectory, 'matterbridge.json'));
+        this.matterbridgeContext = await this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggregator');
+        if (!this.storageManager || !this.matterbridgeContext)
+            return;
+        await this.matterbridgeContext.set('softwareVersion', 1);
+        await this.matterbridgeContext.set('softwareVersionString', this.matterbridgeVersion);
+        await this.matterbridgeContext.set('hardwareVersion', 0);
+        await this.matterbridgeContext.set('hardwareVersionString', '0.0.1');
+        this.createMatterServer(this.storageManager);
+        this.log.debug(`Creating commissioning server for ${plg}Matterbridge${db}`);
+        this.commissioningServer = await this.createCommisioningServer(this.matterbridgeContext, 'Matterbridge');
+        this.log.debug(`Creating matter aggregator for ${plg}Matterbridge${db}`);
+        this.matterAggregator = await this.createMatterAggregator(this.matterbridgeContext);
+        this.log.debug('Adding matterbridge aggregator to commissioning server');
+        this.commissioningServer.addDevice(this.matterAggregator);
+        this.log.debug('Adding matterbridge commissioning server to matter server');
+        await this.matterServer?.addCommissioningServer(this.commissioningServer, { uniqueStorageKey: 'Matterbridge' });
+        this.log.debug(`Setting reachability to true for ${plg}Matterbridge${db}`);
+        this.commissioningServer.setReachability(true);
+        this.log.debug('Starting matter server...');
+        await this.startMatterServer();
+        this.log.info('Matter server started');
+        await this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, this.nodeContext, 'Matterbridge');
+    }
+    /**
+     * Close the Matterbridge instance as extension for zigbee2mqtt.
+     *
+     * @returns A Promise that resolves when the initialization is complete.
+     */
+    async closeAsExtension() {
+        // Closing matter
+        await this.stopMatter();
+        // Closing storage
+        await this.stopStorage();
+    }
     /**
      * Initializes the Matterbridge application.
      *
@@ -199,72 +262,9 @@ export class Matterbridge extends EventEmitter {
         // Set matter.js logger level and format
         Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
         Logger.format = Format.ANSI;
-        // Initialize NodeStorage
-        /*
-        this.log.debug('Creating node storage manager');
-        this.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridgeDirectory, 'storage'), logging: false });
-        this.log.debug('Creating node storage context for matterbridge');
-        this.nodeContext = await this.nodeStorage.createStorage('matterbridge');
-        // Get the plugins from node storage
-        this.registeredPlugins = await this.nodeContext.get<RegisteredPlugin[]>('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<string>('name', plugin.name);
-          await plugin.nodeContext.set<string>('type', plugin.type);
-          await plugin.nodeContext.set<string>('path', plugin.path);
-          await plugin.nodeContext.set<string>('version', plugin.version);
-          await plugin.nodeContext.set<string>('description', plugin.description);
-          await plugin.nodeContext.set<string>('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
-        */
-        if (process.platform === 'win32' && command === 'npm') {
-            command = command + '.cmd';
-        }
-        if (process.platform === 'linux' && command === 'npm') {
-            args.unshift(command);
-            command = 'sudo';
-        }
-        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
@@ -272,15 +272,27 @@ export class Matterbridge extends EventEmitter {
      */
     async parseCommandLine() {
         if (hasParameter('list')) {
-            this.log.info('Registered plugins:');
+            this.log.info('│ Registered plugins');
             this.registeredPlugins.forEach((plugin, index) => {
-                if (index === this.registeredPlugins.length - 1) {
-                    this.log.info(`└─┬─ ${plg}${plugin.name}${nf}: "${plg}${BRIGHT}${plugin.description}${RESET}${nf}" type: ${typ}${plugin.type}${nf} ${YELLOW}${plugin.enabled ? 'enabled' : 'disabled'}${nf}`);
-                    this.log.info(`  └─ ${db}${plugin.path}${db}`);
+                if (index !== this.registeredPlugins.length - 1) {
+                    this.log.info(`├─┬─ plugin ${plg}${plugin.name}${nf}: "${plg}${BRIGHT}${plugin.description}${RESET}${nf}" type: ${typ}${plugin.type}${nf} ${plugin.enabled ? GREEN : RED}enabled ${plugin.paired ? GREEN : RED}paired${nf}`);
+                    this.log.info(`│ └─ entry ${UNDERLINE}${db}${plugin.path}${UNDERLINEOFF}${db}`);
                 }
                 else {
-                    this.log.info(`├─┬─ ${plg}${plugin.name}${nf}: "${plg}${BRIGHT}${plugin.description}${RESET}${nf}" type: ${typ}${plugin.type}${nf} ${YELLOW}${plugin.enabled ? 'enabled' : 'disabled'}${nf}`);
-                    this.log.info(`│ └─ ${db}${plugin.path}${db}`);
+                    this.log.info(`└─┬─ plugin ${plg}${plugin.name}${nf}: "${plg}${BRIGHT}${plugin.description}${RESET}${nf}" type: ${typ}${plugin.type}${nf} ${plugin.enabled ? GREEN : RED}enabled ${plugin.paired ? GREEN : RED}paired${nf}`);
+                    this.log.info(`  └─ entry ${UNDERLINE}${db}${plugin.path}${UNDERLINEOFF}${db}`);
+                }
+            });
+            const serializedRegisteredDevices = await this.nodeContext?.get('devices', []);
+            this.log.info('│ Registered devices');
+            serializedRegisteredDevices?.forEach((device, index) => {
+                if (index !== serializedRegisteredDevices.length - 1) {
+                    this.log.info(`├─┬─ plugin ${plg}${device.pluginName}${nf} device: ${dev}${device.deviceName}${nf} uniqueId: ${YELLOW}${device.uniqueId}${nf}`);
+                    this.log.info(`│ └─ endpoint ${RED}${device.endpoint}${nf} ${typ}${device.endpointName}${nf} ${debugStringify(device.clusterServersId)}`);
+                }
+                else {
+                    this.log.info(`└─┬─ plugin ${plg}${device.pluginName}${nf} device: ${dev}${device.deviceName}${nf} uniqueId: ${YELLOW}${device.uniqueId}${nf}`);
+                    this.log.info(`  └─ endpoint ${RED}${device.endpoint}${nf} ${typ}${device.endpointName}${nf} ${debugStringify(device.clusterServersId)}`);
                 }
             });
             this.emit('shutdown');
@@ -631,6 +643,24 @@ export class Matterbridge extends EventEmitter {
                 this.expressApp.removeAllListeners();
                 this.expressApp = undefined;
             }
+            // Close the WebSocket server
+            if (this.webSocketServer) {
+                // Close all active connections
+                this.webSocketServer.clients.forEach((client) => {
+                    if (client.readyState === WebSocket.OPEN) {
+                        client.close();
+                    }
+                });
+                this.webSocketServer.close((error) => {
+                    if (error) {
+                        this.log.error(`Error closing WebSocket server: ${error}`);
+                    }
+                    else {
+                        this.log.debug('WebSocket server closed successfully');
+                    }
+                });
+                this.webSocketServer = undefined;
+            }
             /*const cleanupTimeout1 =*/ setTimeout(async () => {
                 // Closing matter
                 await this.stopMatter();
@@ -641,7 +671,9 @@ export class Matterbridge extends EventEmitter {
                     this.log.info('Saving registered devices...');
                     const serializedRegisteredDevices = [];
                     this.registeredDevices.forEach((registeredDevice) => {
-                        serializedRegisteredDevices.push(registeredDevice.device.serialize(registeredDevice.plugin));
+                        const serializedMatterbridgeDevice = registeredDevice.device.serialize(registeredDevice.plugin);
+                        //this.log.info(`- ${serializedMatterbridgeDevice.deviceName}${rs}\n`, serializedMatterbridgeDevice);
+                        serializedRegisteredDevices.push(serializedMatterbridgeDevice);
                     });
                     await this.nodeContext.set('devices', serializedRegisteredDevices);
                     this.log.info('Saved registered devices');
@@ -677,7 +709,7 @@ export class Matterbridge extends EventEmitter {
                         Matterbridge.instance = undefined;
                         this.emit('shutdown');
                     }
-                }, 1 * 1000);
+                }, 2 * 1000);
                 //cleanupTimeout2.unref();
             }, 3 * 1000);
             //cleanupTimeout1.unref();
@@ -812,10 +844,10 @@ export class Matterbridge extends EventEmitter {
             if (plugin.addedDevices !== undefined)
                 plugin.addedDevices--;
         }
-        // Only register the device in childbridge mode
+        // Remove the device in childbridge mode
         if (this.bridgeMode === 'childbridge') {
             if (plugin.type === 'AccessoryPlatform') {
-                this.log.warn(`Removing bridged device ${dev}${device.deviceName}${wr} (${dev}${device.name}${wr}) for plugin ${plg}${pluginName}${wr}: AccessoryPlatform not supported in childbridge mode`);
+                this.log.info(`Removing bridged device ${dev}${device.deviceName}${nf} (${dev}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}: AccessoryPlatform not supported in childbridge mode`);
             }
             else if (plugin.type === 'DynamicPlatform') {
                 this.registeredDevices.forEach((registeredDevice, index) => {
@@ -844,7 +876,7 @@ export class Matterbridge extends EventEmitter {
     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`);
+            this.log.info(`Removing devices for plugin ${plg}${pluginName}${nf}: AccessoryPlatform not supported in childbridge mode`);
             return;
         }
         const devicesToRemove = [];
@@ -1209,7 +1241,9 @@ export class Matterbridge extends EventEmitter {
             // Call the default export function of the plugin, passing this MatterBridge instance
             if (pluginInstance.default) {
                 const config = await this.loadPluginConfig(plugin);
-                const platform = pluginInstance.default(this, new AnsiLogger({ logName: plugin.description, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: this.debugEnabled }), config);
+                const log = new AnsiLogger({ logName: plugin.description, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logDebug: this.debugEnabled });
+                //log.setCallback(this.wssSendMessage.bind(this));
+                const platform = pluginInstance.default(this, log, config);
                 platform.name = packageJson.name;
                 platform.config = config;
                 plugin.name = packageJson.name;
@@ -2017,11 +2051,6 @@ export class Matterbridge extends EventEmitter {
         this.matterbridgeInformation.rootDirectory = this.rootDirectory;
         this.log.debug(`Root Directory: ${this.rootDirectory}`);
         // Global node_modules directory
-        /*
-        this.globalModulesDirectory = await this.getGlobalNodeModules();
-        this.matterbridgeInformation.globalModulesDirectory = this.globalModulesDirectory;
-        this.log.debug(`Global node_modules Directory: ${this.globalModulesDirectory}`);
-        */
         if (this.nodeContext)
             this.globalModulesDirectory = await this.nodeContext.get('globalModulesDirectory', '');
         this.log.debug(`Global node_modules Directory: ${this.globalModulesDirectory}`);
@@ -2089,11 +2118,6 @@ export class Matterbridge extends EventEmitter {
         this.matterbridgeInformation.matterbridgeVersion = this.matterbridgeVersion;
         this.log.debug(`Matterbridge Version: ${this.matterbridgeVersion}`);
         // Matterbridge latest version
-        /*
-        this.matterbridgeLatestVersion = await this.getLatestVersion('matterbridge');
-        this.matterbridgeInformation.matterbridgeLatestVersion = this.matterbridgeLatestVersion;
-        this.log.debug(`Matterbridge Latest Version: ${this.matterbridgeLatestVersion}`);
-        */
         if (this.nodeContext)
             this.matterbridgeLatestVersion = await this.nodeContext.get('matterbridgeLatestVersion', '');
         this.log.debug(`Matterbridge Latest Version: ${this.matterbridgeLatestVersion}`);
@@ -2163,15 +2187,121 @@ export class Matterbridge extends EventEmitter {
         }));
         return baseRegisteredPlugins;
     }
+    /**
+     * 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
+        cmd.exe ['dir'] on windows
+        await this.spawnCommand('npm', ['install', '-g', 'matterbridge']);
+        process.on('unhandledRejection', (reason, promise) => {
+          this.log.error('Unhandled Rejection at:', promise, 'reason:', reason);
+        });
+        */
+        if (process.platform === 'win32' && command === 'npm') {
+            // Must be spawn('cmd.exe', ['/c', 'npm -g install <package>']);
+            const argstring = 'npm ' + args.join(' ');
+            args.splice(0, args.length, '/c', argstring);
+            command = 'cmd.exe';
+        }
+        if (process.platform === 'linux' && command === 'npm' && !hasParameter('docker')) {
+            args.unshift(command);
+            command = 'sudo';
+        }
+        this.log.debug(`Spawning command ${command} with ${debugStringify(args)}`);
+        return new Promise((resolve, reject) => {
+            const childProcess = spawn(command, args, {
+                stdio: ['inherit', 'pipe', 'pipe'],
+            });
+            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.debug(`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(`Child process stdio streams have closed with code  ${code}`));
+                }
+            });
+            childProcess.on('exit', (code, signal) => {
+                if (code === 0) {
+                    this.log.debug(`Child process exited with code ${code} and signal ${signal}`);
+                    resolve();
+                }
+                else {
+                    this.log.error(`Child process exited with code ${code} and signal ${signal}`);
+                    reject(new Error(`Child process exited with code ${code} and signal ${signal}`));
+                }
+            });
+            childProcess.on('disconnect', () => {
+                this.log.debug('Child process has been disconnected from the parent');
+                resolve();
+            });
+            if (childProcess.stdout) {
+                childProcess.stdout.on('data', (data) => {
+                    const message = data.toString().trim();
+                    //this.log.info('\n' + message);
+                    this.wssSendMessage('spawn', 'stdout', message);
+                });
+            }
+            if (childProcess.stderr) {
+                childProcess.stderr.on('data', (data) => {
+                    const message = data.toString().trim();
+                    //this.log.debug('\n' + message);
+                    this.wssSendMessage('spawn', 'stderr', message);
+                });
+            }
+        });
+    }
+    wssSendMessage(type, subType, message) {
+        // Remove ANSI escape codes from the message
+        // eslint-disable-next-line no-control-regex
+        const cleanMessage = message.replace(/\x1B\[[0-9;]*[m|s|u|K]/g, '');
+        // Remove leading asterisks from the message
+        const finalMessage = cleanMessage.replace(/^\*+/, '');
+        this.webSocketServer?.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(JSON.stringify({ type, subType, message: finalMessage }));
+            }
+        });
+    }
     /**
      * Initializes the frontend of Matterbridge.
      *
      * @param port The port number to run the frontend server on. Default is 3000.
      */
-    async initializeFrontend(port = 3000) {
+    async initializeFrontend(port = 8283) {
         this.log.debug(`Initializing the frontend on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
-        this.expressApp = express();
+        // Create a WebSocket server
+        this.webSocketServer = new WebSocketServer({ port: 8284 });
+        this.webSocketServer.on('connection', (ws) => {
+            this.log.debug('WebSocketServer client connected');
+            this.log.setGlobalCallback(this.wssSendMessage.bind(this));
+            this.log.debug('WebSocketServer activated logger callback');
+            ws.on('message', (message) => {
+                this.log.debug(`WebSocketServer received message => ${message}`);
+            });
+            ws.on('close', () => {
+                this.log.debug('WebSocketServer client disconnected');
+                if (this.webSocketServer?.clients.size === 0) {
+                    this.log.setGlobalCallback(undefined);
+                    this.log.debug('WebSocketServer deactivated logger callback');
+                }
+            });
+            ws.on('error', (error) => {
+                this.log.error(`WebSocketServer error: ${error}`);
+            });
+        });
         // Serve React build directory
+        this.expressApp = express();
         this.expressApp.use(express.static(path.join(this.rootDirectory, 'frontend/build')));
         // Endpoint to provide login code
         this.expressApp.post('/api/login', express.json(), async (req, res) => {
@@ -2193,6 +2323,34 @@ export class Matterbridge extends EventEmitter {
                 res.json({ valid: false });
             }
         });
+        // Endpoint to provide host
+        this.expressApp.get('/api/wsshost', express.json(), async (req, res) => {
+            this.log.debug('The frontend sent /api/wsshost');
+            res.json({ host: os.hostname() });
+        });
+        // Endpoint to provide port
+        this.expressApp.get('/api/wssport', express.json(), async (req, res) => {
+            this.log.debug('The frontend sent /api/wssport');
+            res.json({ port: 8284 });
+        });
+        // Endpoint to provide manual pairing code
+        this.expressApp.get('/api/pairing-code', (req, res) => {
+            this.log.debug('The frontend sent /api/pairing-code');
+            if (!this.matterbridgeContext) {
+                this.log.error('/api/pairing-code matterbridgeContext not found');
+                res.json([]);
+                return;
+            }
+            try {
+                const qrData = { qrPairingCode: this.matterbridgeContext.get('qrPairingCode'), manualPairingCode: this.matterbridgeContext.get('manualPairingCode') };
+                res.json(qrData);
+            }
+            catch (error) {
+                if (this.bridgeMode === 'bridge')
+                    this.log.error('qrPairingCode for /api/qr-code not found');
+                res.json({});
+            }
+        });
         // Endpoint to provide QR pairing code
         this.expressApp.get('/api/qr-code', (req, res) => {
             this.log.debug('The frontend sent /api/qr-code');
@@ -2307,7 +2465,7 @@ export class Matterbridge extends EventEmitter {
                 res.status(400).json({ error: 'No command provided' });
                 return;
             }
-            this.log.debug(`*Received frontend command: ${command}:${param}`);
+            this.log.debug(`Received frontend command: ${command}:${param}`);
             // Handle the command setpassword from Settings
             if (command === 'setpassword') {
                 const password = param.slice(1, -1); // Remove the first and last characters
@@ -2345,32 +2503,34 @@ export class Matterbridge extends EventEmitter {
             }
             // Handle the command update from Header
             if (command === 'update') {
-                this.log.warn(`***Updating matterbridge ${plg}${param}${db}`);
+                this.log.info('Updating matterbridge...');
+                //this.wssSendMessage('cmd', 'update', 'Updating matterbridge');
                 try {
-                    await this.spawnCommand('npm', ['install', '-g', 'matterbridge']);
+                    await this.spawnCommand('npm', ['install', '-g', 'matterbridge', '--loglevel=verbose']);
                     this.log.info('Matterbridge has been updated. Full restart required.');
+                    //this.wssSendMessage('cmd', 'update', 'Matterbridge has been updated. Full restart required.');
                 }
                 catch (error) {
                     this.log.error('Error updating matterbridge');
+                    //this.wssSendMessage('cmd', 'update', 'Error updating matterbridge');
                     res.json({ message: 'Command received' });
                     return;
                 }
                 this.updateProcess();
             }
-            // Handle the command update from Header
-            if (command === 'update') {
-                this.log.warn(`The /api/command/${command} is not yet implemented`);
-            }
             // Handle the command installplugin from Home
             if (command === 'installplugin') {
                 param = param.replace(/\*/g, '\\');
-                this.log.warn(`***Installing plugin ${plg}${param}${db}`);
+                this.log.info(`Installing plugin ${plg}${param}${db}...`);
+                //this.wssSendMessage('cmd', 'installplugin', `Installing plugin ${param}`);
                 try {
-                    await this.spawnCommand('npm', ['install', '-g', param]);
-                    this.log.info(`Plugin ${plg}${param}${nf} installed. Restart required.`);
+                    await this.spawnCommand('npm', ['install', '-g', param, '--loglevel=verbose']);
+                    this.log.info(`Plugin ${plg}${param}${nf} installed. Full restart required.`);
+                    //this.wssSendMessage('cmd', 'installplugin', `Plugin ${param} installed. Full restart required.`);
                 }
                 catch (error) {
                     this.log.error(`Error installing plugin ${plg}${param}${er}`);
+                    //this.wssSendMessage('cmd', 'installplugin', `Error installing plugin${param}`);
                     res.json({ message: 'Command received' });
                     return;
                 }
@@ -2563,7 +2723,6 @@ function restartProcess() {
 }
 
 import * as WebSocket from 'ws';
-const globalModulesDir = require('global-modules');
 
 const wss = new WebSocket.Server({ port: 8080 });
 
@@ -2582,13 +2741,6 @@ ws.onmessage = (event) => {
   console.log(`Received message => ${event.data}`);
 };
 
-*/
-/*
-// In Matterbridge
-global.matterbridgeInstance = Matterbridge.loadInstance();
-
-// In plugins
-const matterbridge = global.matterbridgeInstance;
 */
 /*
 npx create-react-app matterbridge-frontend