matterbridge 1.1.8 → 1.1.9

package/dist/matterbridge.js

@@ -25,7 +25,7 @@ import { NodeStorageManager } from 'node-persist-manager';
 import { AnsiLogger, BRIGHT, RESET, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, stringify, er, nf, rs, wr } from 'node-ansi-logger';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { promises as fs } from 'fs';
-import { execSync } from 'child_process';
+import { exec, execSync } from 'child_process';
 import express from 'express';
 import os from 'os';
 import path from 'path';
@@ -61,7 +61,9 @@ export class Matterbridge {
     homeDirectory = '';
     rootDirectory = '';
     matterbridgeDirectory = '';
+    matterbridgePluginDirectory = '';
     matterbridgeVersion = '';
+    matterbridgeLatestVersion = '';
     globalModulesDir = '';
     bridgeMode = '';
     debugEnabled = false;
@@ -71,7 +73,8 @@ export class Matterbridge {
     registeredDevices = [];
     nodeStorage;
     nodeContext;
-    app;
+    expressApp;
+    expressServer;
     storageManager;
     matterbridgeContext;
     mattercontrollerContext;
@@ -81,26 +84,24 @@ export class Matterbridge {
     commissioningController;
     static instance;
     constructor() {
-        // we load asynchroneously the instance
+        // We load asyncronously
     }
     /**
      * Loads an instance of the Matterbridge class.
      * If an instance already exists, return that instance.
      * @returns The loaded instance of the Matterbridge class.
      */
-    static async loadInstance(cli = false) {
-        // eslint-disable-next-line no-console
-        console.error('loadInstance cli:', cli);
+    static async loadInstance(initialize = false) {
         if (!Matterbridge.instance) {
             // eslint-disable-next-line no-console
-            console.error('Matterbridge instance does not exists');
+            console.log('Matterbridge instance does not exists');
             Matterbridge.instance = new Matterbridge();
-            if (cli)
+            if (initialize)
                 await Matterbridge.instance.initialize();
         }
         else {
             // eslint-disable-next-line no-console
-            console.error('Matterbridge instance already exists');
+            console.log('Matterbridge instance already exists');
         }
         return Matterbridge.instance;
     }
@@ -161,13 +162,13 @@ export class Matterbridge {
         this.registeredPlugins = await this.nodeContext.get('plugins', []);
         for (const plugin of this.registeredPlugins) {
             this.log.debug(`Creating node storage context for plugin ${plugin.name}`);
-            plugin.nodeContext = await this.nodeStorage?.createStorage(plugin.name);
-            await plugin.nodeContext?.set('name', plugin.name);
-            await plugin.nodeContext?.set('type', plugin.type);
-            await plugin.nodeContext?.set('path', plugin.path);
-            await plugin.nodeContext?.set('version', plugin.version);
-            await plugin.nodeContext?.set('description', plugin.description);
-            await plugin.nodeContext?.set('author', plugin.author);
+            plugin.nodeContext = await this.nodeStorage.createStorage(plugin.name);
+            await plugin.nodeContext.set('name', plugin.name);
+            await plugin.nodeContext.set('type', plugin.type);
+            await plugin.nodeContext.set('path', plugin.path);
+            await plugin.nodeContext.set('version', plugin.version);
+            await plugin.nodeContext.set('description', plugin.description);
+            await plugin.nodeContext.set('author', plugin.author);
         }
         // Parse command line
         this.parseCommandLine();
@@ -275,7 +276,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 +361,6 @@ export class Matterbridge {
                     this.log.warn(`Plugin ${plg}${packageJsonPath}${wr} not registerd in matterbridge`);
                 }
             }
-            //}
         }
         catch (err) {
             this.log.error(`Failed to load plugin from ${plg}${packageJsonPath}${er}: ${err}`);
@@ -371,21 +371,32 @@ export class Matterbridge {
      * When either of these signals are received, the cleanup method is called with an appropriate message.
      */
     async registerSignalHandlers() {
-        process.on('SIGINT', async () => {
+        process.once('SIGINT', async () => {
             await this.cleanup('SIGINT received, cleaning up...');
         });
-        process.on('SIGTERM', async () => {
+        process.once('SIGTERM', async () => {
             await this.cleanup('SIGTERM received, cleaning up...');
         });
     }
+    /**
+     * Restarts the process by spawning a new process and exiting the current process.
+     */
+    async restartProcess() {
+        //this.log.info('Restarting still not implemented');
+        //return;
+        await this.cleanup('Matterbridge is restarting...', true);
+        this.hasCleanupStarted = false;
+    }
     /**
      * Performs cleanup operations before shutting down Matterbridge.
      * @param message - The reason for the cleanup.
      */
-    async cleanup(message) {
+    async cleanup(message, restart = false) {
         if (!this.hasCleanupStarted) {
             this.hasCleanupStarted = true;
             this.log.info(message);
+            process.removeAllListeners('SIGINT');
+            process.removeAllListeners('SIGTERM');
             // Callint the shutdown functions with a reason
             for (const plugin of this.registeredPlugins) {
                 if (plugin.platform)
@@ -408,21 +419,47 @@ export class Matterbridge {
               if (this.bridgeMode === 'childbridge' && plugin.type === 'DynamicPlatform') registeredDevice.device.setBridgedDeviceReachability(false);
             });
             */
+            // Close the express server
+            if (this.expressServer) {
+                this.expressServer.close();
+                this.expressServer = undefined;
+            }
+            // Remove listeners
+            if (this.expressApp) {
+                this.expressApp.removeAllListeners();
+                this.expressApp = undefined;
+            }
             setTimeout(async () => {
                 // Closing matter
                 await this.stopMatter();
                 // Closing storage
                 await this.stopStorage();
                 // Serialize registeredDevices
-                const serializedRegisteredDevices = [];
-                this.registeredDevices.forEach((registeredDevice) => {
-                    serializedRegisteredDevices.push(registeredDevice.device.serialize(registeredDevice.plugin));
-                });
-                //console.log('serializedRegisteredDevices:', serializedRegisteredDevices);
-                await this.nodeContext?.set('devices', serializedRegisteredDevices);
-                setTimeout(() => {
+                if (this.nodeContext) {
+                    this.log.info('Saving registered devices...');
+                    const serializedRegisteredDevices = [];
+                    this.registeredDevices.forEach((registeredDevice) => {
+                        serializedRegisteredDevices.push(registeredDevice.device.serialize(registeredDevice.plugin));
+                    });
+                    //console.log('serializedRegisteredDevices:', serializedRegisteredDevices);
+                    await this.nodeContext.set('devices', serializedRegisteredDevices);
+                    this.log.info('Saved registered devices');
+                    // Clear nodeContext and nodeStorage (they just need 1000ms to write the data to disk)
+                    this.nodeContext = undefined;
+                    this.nodeStorage = undefined;
+                }
+                else {
+                    this.log.error('Error saving registered devices: nodeContext not found!');
+                }
+                this.registeredPlugins = [];
+                this.registeredDevices = [];
+                setTimeout(async () => {
                     this.log.info('Cleanup completed.');
-                    process.exit(0);
+                    //if (restart) console.log(this);
+                    if (restart)
+                        await this.initialize();
+                    else
+                        process.exit(0);
                 }, 2 * 1000);
             }, 3 * 1000);
         }
@@ -448,16 +485,20 @@ export class Matterbridge {
      * @returns A Promise that resolves when the device is added successfully.
      */
     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`);
+            return;
+        }
         this.log.debug(`Adding device ${dev}${device.name}${db} for plugin ${plg}${pluginName}${db}`);
         // Check if the plugin is registered
         const plugin = this.registeredPlugins.find((plugin) => plugin.name === pluginName);
         if (!plugin) {
-            this.log.error(`addDevice error: device ${dev}${device.name}${nf} plugin ${plg}${pluginName}${er} not found`);
+            this.log.error(`Error adding device ${dev}${device.name}${er} plugin ${plg}${pluginName}${er} not found`);
             return;
         }
         // 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++;
@@ -480,16 +521,20 @@ export class Matterbridge {
      * @returns {Promise<void>} - A promise that resolves when the storage process is started.
      */
     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`);
+            return;
+        }
         this.log.debug(`Adding bridged device ${db}${device.name}${nf} for plugin ${plg}${pluginName}${db}`);
         // Check if the plugin is registered
         const plugin = this.registeredPlugins.find((plugin) => plugin.name === pluginName);
         if (!plugin) {
-            this.log.error(`addBridgedDevice error: device ${dev}${device.name}${nf} plugin ${plg}${pluginName}${er} not found`);
+            this.log.error(`Error adding bridged device ${dev}${device.name}${er} plugin ${plg}${pluginName}${er} not found`);
             return;
         }
         // 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++;
@@ -512,18 +557,22 @@ export class Matterbridge {
      * @returns {Promise<void>} - A promise that resolves when the storage process is started.
      */
     async startStorage(storageType, storageName) {
-        if (!storageName.endsWith('.json')) {
-            storageName += '.json';
-        }
         this.log.debug(`Starting storage ${storageType} ${storageName}`);
         if (storageType === 'disk') {
             const storageDisk = new StorageBackendDisk(storageName);
             this.storageManager = new StorageManager(storageDisk);
         }
-        if (storageType === 'json') {
+        else if (storageType === 'json') {
+            if (!storageName.endsWith('.json'))
+                storageName += '.json';
             const storageJson = new StorageBackendJsonFile(storageName);
             this.storageManager = new StorageManager(storageJson);
         }
+        else {
+            this.log.error(`Unsupported storage type ${storageType}`);
+            await this.cleanup('Unsupported storage type');
+            return;
+        }
         try {
             await this.storageManager.initialize();
             this.log.debug('Storage initialized');
@@ -533,7 +582,7 @@ export class Matterbridge {
         }
         catch (error) {
             this.log.error('Storage initialize() error!');
-            process.exit(1);
+            await this.cleanup('Storage initialize() error!');
         }
     }
     /**
@@ -568,8 +617,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 +786,27 @@ export class Matterbridge {
      * @returns {Promise<void>} A promise that resolves when the Matterbridge is started.
      */
     async startMatterBridge() {
+        if (!this.storageManager) {
+            this.log.error('No storage manager initialized');
+            await this.cleanup('No storage manager initialized');
+            return;
+        }
         this.log.debug('Starting matterbridge in mode', this.bridgeMode);
         this.createMatterServer(this.storageManager);
+        if (!this.matterServer) {
+            this.log.error('No matter server initialized');
+            await this.cleanup('No matter server initialized');
+            return;
+        }
         if (this.bridgeMode === 'bridge') {
             // Plugins are loaded by loadPlugin on startup and plugin.loaded is set to true
-            // Plugins are started and configured by callback when Matterbridge is commissioned and plugin.started is set to true
+            // Plugins are started and configured by callback when Matterbridge is commissioned
             this.log.debug(`Creating commissioning server context for ${plg}Matterbridge${db}`);
             this.matterbridgeContext = this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggregator');
+            if (!this.matterbridgeContext) {
+                this.log.error(`Error creating storage context${er}`);
+                return;
+            }
             this.log.debug(`Creating commissioning server for ${plg}Matterbridge${db}`);
             this.commissioningServer = this.createCommisioningServer(this.matterbridgeContext, 'Matterbridge');
             this.log.debug(`Creating matter aggregator for ${plg}Matterbridge${db}`);
@@ -754,17 +820,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 +845,11 @@ export class Matterbridge {
                             .filter((registeredDevice) => registeredDevice.plugin === plugin.name)
                             .forEach((registeredDevice) => {
                             if (!plugin.storageContext)
-                                plugin.storageContext = this.importCommissioningServerContext(plugin.name, registeredDevice.device); // Generate serialNumber and uniqueId
+                                plugin.storageContext = this.importCommissioningServerContext(plugin.name, registeredDevice.device);
+                            if (!plugin.storageContext) {
+                                this.log.error(`Error importing storage context for plugin ${plg}${plugin.name}${er}`);
+                                return;
+                            }
                             if (!plugin.commissioningServer)
                                 plugin.commissioningServer = this.createCommisioningServer(plugin.storageContext, plugin.name);
                             this.log.debug(`Adding device ${dev}${registeredDevice.device.name}${db} to commissioning server for plugin ${plg}${plugin.name}${db}`);
@@ -784,9 +859,11 @@ export class Matterbridge {
                         await this.matterServer.addCommissioningServer(plugin.commissioningServer, { uniqueStorageKey: plugin.name });
                     }
                     if (plugin.type === 'DynamicPlatform') {
-                        plugin.storageContext = this.createCommissioningServerContext(
-                        // Generate serialNumber and uniqueId
-                        plugin.name, 'Matterbridge Dynamic Platform', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Dynamic Platform');
+                        plugin.storageContext = this.createCommissioningServerContext(plugin.name, 'Matterbridge Dynamic Platform', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Dynamic Platform');
+                        if (!plugin.storageContext) {
+                            this.log.error(`Error creating storage context for plugin ${plg}${plugin.name}${er}`);
+                            return;
+                        }
                         plugin.commissioningServer = this.createCommisioningServer(plugin.storageContext, plugin.name);
                         this.log.debug(`Creating aggregator for plugin ${plg}${plugin.name}${db}`);
                         plugin.aggregator = this.createMatterAggregator(plugin.storageContext); // Generate serialNumber and uniqueId
@@ -840,6 +917,11 @@ export class Matterbridge {
         }
     }
     async startMatterServer() {
+        if (!this.matterServer) {
+            this.log.error('No matter server initialized');
+            await this.cleanup('No matter server initialized');
+            return;
+        }
         this.log.debug('Starting matter server');
         await this.matterServer.start();
         this.log.debug('Started matter server');
@@ -879,6 +961,10 @@ export class Matterbridge {
      * @returns The storage context for the commissioning server.
      */
     createCommissioningServerContext(pluginName, deviceName, deviceType, vendorId, vendorName, productId, productName, serialNumber, uniqueId, softwareVersion, softwareVersionString, hardwareVersion, hardwareVersionString) {
+        if (!this.storageManager) {
+            this.log.error('No storage manager initialized');
+            process.exit(1);
+        }
         this.log.debug(`Creating commissioning server storage context for ${plg}${pluginName}${db}`);
         const random = 'CS' + CryptoNode.getRandomData(8).toHex();
         const storageContext = this.storageManager.createContext(pluginName);
@@ -1088,6 +1174,7 @@ export class Matterbridge {
     createMatterServer(storageManager) {
         this.log.debug('Creating matter server');
         this.matterServer = new MatterServer(storageManager, { mdnsAnnounceInterface: undefined });
+        this.log.debug('Created matter server');
     }
     /**
      * Creates a Matter Aggregator.
@@ -1135,6 +1222,27 @@ export class Matterbridge {
         this.log.debug('Stopping matter server');
         await this.matterServer?.close();
         this.log.debug('Matter server closed');
+        this.commissioningController = undefined;
+        this.commissioningServer = undefined;
+        this.matterAggregator = undefined;
+        this.matterServer = undefined;
+    }
+    /**
+     * Retrieves the latest version of a package from the npm registry.
+     * @param packageName - The name of the package.
+     * @returns A Promise that resolves to the latest version of the package.
+     */
+    async getLatestVersion(packageName) {
+        return new Promise((resolve, reject) => {
+            exec(`npm view ${packageName} version`, (error, stdout) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(stdout.trim());
+                }
+            });
+        });
     }
     /**
      * Logs the node and system information.
@@ -1204,13 +1312,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 +1412,16 @@ export class Matterbridge {
      */
     async initializeFrontend(port = 3000) {
         this.log.debug(`Initializing the frontend on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
-        this.app = express();
+        this.expressApp = express();
         // Serve React build directory
-        this.app.use(express.static(path.join(this.rootDirectory, 'frontend/build')));
+        this.expressApp.use(express.static(path.join(this.rootDirectory, 'frontend/build')));
         // Endpoint to provide QR pairing code
-        this.app.get('/api/qr-code', (req, res) => {
+        this.expressApp.get('/api/qr-code', (req, res) => {
             this.log.debug('The frontend sent /api/qr-code');
-            if (!this.matterbridgeContext)
-                this.matterbridgeContext = this.createCommissioningServerContext('Matterbridge', 'Matterbridge', DeviceTypes.AGGREGATOR.code, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge aggregator');
+            if (!this.matterbridgeContext) {
+                res.json([]);
+                return;
+            }
             try {
                 const qrData = { qrPairingCode: this.matterbridgeContext.get('qrPairingCode'), manualPairingCode: this.matterbridgeContext.get('manualPairingCode') };
                 res.json(qrData);
@@ -1281,17 +1433,17 @@ export class Matterbridge {
             }
         });
         // Endpoint to provide system information
-        this.app.get('/api/system-info', (req, res) => {
+        this.expressApp.get('/api/system-info', (req, res) => {
             this.log.debug('The frontend sent /api/system-info');
             res.json(this.systemInformation);
         });
         // Endpoint to provide plugins
-        this.app.get('/api/plugins', (req, res) => {
+        this.expressApp.get('/api/plugins', (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
             res.json(this.getBaseRegisteredPlugins());
         });
         // Endpoint to provide devices
-        this.app.get('/api/devices', (req, res) => {
+        this.expressApp.get('/api/devices', (req, res) => {
             this.log.debug('The frontend sent /api/devices');
             const data = [];
             this.registeredDevices.forEach((registeredDevice) => {
@@ -1318,7 +1470,7 @@ export class Matterbridge {
             res.json(data);
         });
         // Endpoint to provide the cluster servers of the devices
-        this.app.get('/api/devices_clusters/:selectedPluginName/:selectedDeviceEndpoint', (req, res) => {
+        this.expressApp.get('/api/devices_clusters/:selectedPluginName/:selectedDeviceEndpoint', (req, res) => {
             const selectedPluginName = req.params.selectedPluginName;
             const selectedDeviceEndpoint = parseInt(req.params.selectedDeviceEndpoint, 10);
             this.log.debug(`The frontend sent /api/devices_clusters plugin:${selectedPluginName} endpoint:${selectedDeviceEndpoint}`);
@@ -1360,12 +1512,49 @@ export class Matterbridge {
             });
             res.json(data);
         });
+        // Endpoint to receive commands
+        this.expressApp.post('/api/command/:command/:param', (req, res) => {
+            const command = req.params.command;
+            const param = req.params.param;
+            this.log.debug(`The frontend sent /api/command/${command}/${param}`);
+            if (!command) {
+                res.status(400).json({ error: 'No command provided' });
+                return;
+            }
+            this.log.info(`***Received command: ${command}:${param}`);
+            // Handle the command debugLevel
+            if (command === 'setloglevel') {
+                if (param === 'Debug') {
+                    this.log.setLogDebug(true);
+                    this.debugEnabled = true;
+                    Logger.defaultLogLevel = Level.DEBUG;
+                }
+                else if (param === 'Info') {
+                    this.log.setLogDebug(false);
+                    this.debugEnabled = false;
+                    Logger.defaultLogLevel = Level.INFO;
+                }
+                else if (param === 'Warn') {
+                    this.log.setLogDebug(false);
+                    this.debugEnabled = false;
+                    Logger.defaultLogLevel = Level.WARN;
+                }
+                this.registeredPlugins.forEach((plugin) => {
+                    plugin.platform?.log.setLogDebug(this.debugEnabled);
+                });
+            }
+            // Handle the command debugLevel
+            if (command === 'restart') {
+                this.restartProcess();
+            }
+            res.json({ message: 'Command received' });
+        });
         // Fallback for routing
-        this.app.get('*', (req, res) => {
+        this.expressApp.get('*', (req, res) => {
             this.log.warn('The frontend sent *', req.url);
             res.sendFile(path.join(this.rootDirectory, 'frontend/build/index.html'));
         });
-        this.app.listen(port, () => {
+        this.expressServer = this.expressApp.listen(port, () => {
             this.log.info(`The frontend is running on ${UNDERLINE}http://localhost:${port}${UNDERLINEOFF}${rs}`);
         });
         this.log.debug(`Frontend initialized on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
@@ -1413,6 +1602,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');