matterbridge 3.2.6-dev-20250906-4b022a0 → 3.2.6

package/dist/frontend.js

@@ -1,30 +1,126 @@
+/**
+ * This file contains the class Frontend.
+ *
+ * @file frontend.ts
+ * @author Luca Liguori
+ * @created 2025-01-13
+ * @version 1.2.0
+ * @license Apache-2.0
+ *
+ * Copyright 2025, 2026, 2027 Luca Liguori.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Node modules
 import { createServer } from 'node:http';
 import https from 'node:https';
 import os from 'node:os';
 import path from 'node:path';
 import { existsSync, promises as fs } from 'node:fs';
 import EventEmitter from 'node:events';
+// Third-party modules
 import express from 'express';
 import WebSocket, { WebSocketServer } from 'ws';
 import multer from 'multer';
+// AnsiLogger module
 import { AnsiLogger, stringify, debugStringify, CYAN, db, er, nf, rs, UNDERLINE, UNDERLINEOFF, YELLOW, nt } from 'node-ansi-logger';
+// @matter
 import { Logger, LogLevel as MatterLogLevel, Lifecycle } from '@matter/main';
 import { BridgedDeviceBasicInformation, PowerSource } from '@matter/main/clusters';
+// Matterbridge
 import { createZip, isValidArray, isValidNumber, isValidObject, isValidString, isValidBoolean, withTimeout, hasParameter } from './utils/export.js';
 import { plg } from './matterbridgeTypes.js';
 import { capitalizeFirstLetter, getAttribute } from './matterbridgeEndpointHelpers.js';
 import { cliEmitter, lastCpuUsage } from './cliEmitter.js';
+/**
+ * Websocket message ID for logging.
+ *
+ * @constant {number}
+ */
 export const WS_ID_LOG = 0;
+/**
+ * Websocket message ID indicating a refresh is needed.
+ *
+ * @constant {number}
+ */
 export const WS_ID_REFRESH_NEEDED = 1;
+/**
+ * Websocket message ID indicating a restart is needed.
+ *
+ * @constant {number}
+ */
 export const WS_ID_RESTART_NEEDED = 2;
+/**
+ * Websocket message ID indicating a cpu update.
+ *
+ * @constant {number}
+ */
 export const WS_ID_CPU_UPDATE = 3;
+/**
+ * Websocket message ID indicating a memory update.
+ *
+ * @constant {number}
+ */
 export const WS_ID_MEMORY_UPDATE = 4;
+/**
+ * Websocket message ID indicating an uptime update.
+ *
+ * @constant {number}
+ */
 export const WS_ID_UPTIME_UPDATE = 5;
+/**
+ * Websocket message ID indicating a snackbar message.
+ *
+ * @constant {number}
+ */
 export const WS_ID_SNACKBAR = 6;
+/**
+ * Websocket message ID indicating matterbridge has un update available.
+ *
+ * @constant {number}
+ */
 export const WS_ID_UPDATE_NEEDED = 7;
+/**
+ * Websocket message ID indicating a state update.
+ *
+ * @constant {number}
+ */
 export const WS_ID_STATEUPDATE = 8;
+/**
+ * Websocket message ID indicating to close a permanent snackbar message.
+ *
+ * @constant {number}
+ */
 export const WS_ID_CLOSE_SNACKBAR = 9;
+/**
+ * Websocket message ID indicating a shelly system update.
+ * check:
+ * curl -k http://127.0.0.1:8101/api/updates/sys/check
+ * perform:
+ * curl -k http://127.0.0.1:8101/api/updates/sys/perform
+ *
+ * @constant {number}
+ */
 export const WS_ID_SHELLY_SYS_UPDATE = 100;
+/**
+ * Websocket message ID indicating a shelly main update.
+ * check:
+ * curl -k http://127.0.0.1:8101/api/updates/main/check
+ * perform:
+ * curl -k http://127.0.0.1:8101/api/updates/main/perform
+ *
+ * @constant {number}
+ */
 export const WS_ID_SHELLY_MAIN_UPDATE = 101;
 export class Frontend extends EventEmitter {
     matterbridge;
@@ -37,7 +133,7 @@ export class Frontend extends EventEmitter {
     constructor(matterbridge) {
         super();
         this.matterbridge = matterbridge;
-        this.log = new AnsiLogger({ logName: 'Frontend', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
+        this.log = new AnsiLogger({ logName: 'Frontend', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: hasParameter('debug') ? "debug" /* LogLevel.DEBUG */ : "info" /* LogLevel.INFO */ });
     }
     set logLevel(logLevel) {
         this.log.logLevel = logLevel;
@@ -45,10 +141,39 @@ export class Frontend extends EventEmitter {
     async start(port = 8283) {
         this.port = port;
         this.log.debug(`Initializing the frontend ${hasParameter('ssl') ? 'https' : 'http'} server on port ${YELLOW}${this.port}${db}`);
-        const uploadDir = path.join(this.matterbridge.matterbridgeDirectory, 'uploads');
+        // Initialize multer with the upload directory
+        const uploadDir = path.join(this.matterbridge.matterbridgeDirectory, 'uploads'); // Is created by matterbridge initialize
         const upload = multer({ dest: uploadDir });
+        // Create the express app that serves the frontend
         this.expressApp = express();
+        // Inject logging/debug wrapper for route/middleware registration
+        /*
+        const methods = ['get', 'post', 'put', 'delete', 'use'];
+        for (const method of methods) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const original = (this.expressApp as any)[method].bind(this.expressApp);
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (this.expressApp as any)[method] = (path: any, ...rest: any) => {
+            try {
+              console.log(`[DEBUG] Registering ${method.toUpperCase()} route:`, path);
+              return original(path, ...rest);
+            } catch (err) {
+              console.error(`[ERROR] Failed to register route: ${path}`);
+              throw err;
+            }
+          };
+        }
+        */
+        // Log all requests to the server for debugging
+        /*
+        this.expressApp.use((req, res, next) => {
+          this.log.debug(`***Received request on expressApp: ${req.method} ${req.url}`);
+          next();
+        });
+        */
+        // Serve static files from '/static' endpoint
         this.expressApp.use(express.static(path.join(this.matterbridge.rootDirectory, 'frontend/build')));
+        // Read the package.json file to get the frontend version
         try {
             this.log.debug(`Reading frontend package.json...`);
             const frontendJson = await fs.readFile(path.join(this.matterbridge.rootDirectory, 'frontend/package.json'), 'utf8');
@@ -56,9 +181,11 @@ export class Frontend extends EventEmitter {
             this.log.debug(`Frontend version ${CYAN}${this.matterbridge.matterbridgeInformation.frontendVersion}${db}`);
         }
         catch (error) {
+            // istanbul ignore next
             this.log.error(`Failed to read frontend package.json: ${error instanceof Error ? error.message : String(error)}`);
         }
         if (!hasParameter('ssl')) {
+            // Create an HTTP server and attach the express app
             try {
                 this.log.debug(`Creating HTTP server...`);
                 this.httpServer = createServer(this.expressApp);
@@ -68,6 +195,7 @@ export class Frontend extends EventEmitter {
                 this.emit('server_error', error);
                 return;
             }
+            // Listen on the specified port
             if (hasParameter('ingress')) {
                 this.httpServer.listen(this.port, '0.0.0.0', () => {
                     this.log.info(`The frontend http server is listening on ${UNDERLINE}http://0.0.0.0:${this.port}${UNDERLINEOFF}${rs}`);
@@ -106,6 +234,7 @@ export class Frontend extends EventEmitter {
             let passphrase;
             let httpsServerOptions = {};
             if (existsSync(path.join(this.matterbridge.matterbridgeDirectory, 'certs/cert.p12'))) {
+                // Load the p12 certificate and the passphrase
                 try {
                     pfx = await fs.readFile(path.join(this.matterbridge.matterbridgeDirectory, 'certs/cert.p12'));
                     this.log.info(`Loaded p12 certificate file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs/cert.p12')}`);
@@ -117,7 +246,7 @@ export class Frontend extends EventEmitter {
                 }
                 try {
                     passphrase = await fs.readFile(path.join(this.matterbridge.matterbridgeDirectory, 'certs/cert.pass'), 'utf8');
-                    passphrase = passphrase.trim();
+                    passphrase = passphrase.trim(); // Ensure no extra characters
                     this.log.info(`Loaded p12 passphrase file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs/cert.pass')}`);
                 }
                 catch (error) {
@@ -128,6 +257,7 @@ export class Frontend extends EventEmitter {
                 httpsServerOptions = { pfx, passphrase };
             }
             else {
+                // Load the SSL certificate, the private key and optionally the CA certificate. If the CA certificate is present, it will be used to create a full chain certificate.
                 try {
                     cert = await fs.readFile(path.join(this.matterbridge.matterbridgeDirectory, 'certs/cert.pem'), 'utf8');
                     this.log.info(`Loaded certificate file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs/cert.pem')}`);
@@ -157,9 +287,10 @@ export class Frontend extends EventEmitter {
                 httpsServerOptions = { cert: fullChain ?? cert, key, ca };
             }
             if (hasParameter('mtls')) {
-                httpsServerOptions.requestCert = true;
-                httpsServerOptions.rejectUnauthorized = true;
+                httpsServerOptions.requestCert = true; // Request client certificate
+                httpsServerOptions.rejectUnauthorized = true; // Require client certificate validation
             }
+            // Create an HTTPS server with the SSL certificate and private key (ca is optional) and attach the express app
             try {
                 this.log.debug(`Creating HTTPS server...`);
                 this.httpsServer = https.createServer(httpsServerOptions, this.expressApp);
@@ -169,6 +300,7 @@ export class Frontend extends EventEmitter {
                 this.emit('server_error', error);
                 return;
             }
+            // Listen on the specified port
             if (hasParameter('ingress')) {
                 this.httpsServer.listen(this.port, '0.0.0.0', () => {
                     this.log.info(`The frontend https server is listening on ${UNDERLINE}https://0.0.0.0:${this.port}${UNDERLINEOFF}${rs}`);
@@ -198,17 +330,19 @@ export class Frontend extends EventEmitter {
                 return;
             });
         }
+        // Create a WebSocket server and attach it to the http or https server
         const wssPort = this.port;
         const wssHost = hasParameter('ssl') ? `wss://${this.matterbridge.systemInformation.ipv4Address}:${wssPort}` : `ws://${this.matterbridge.systemInformation.ipv4Address}:${wssPort}`;
         this.log.debug(`Creating WebSocketServer on host ${CYAN}${wssHost}${db}...`);
         this.webSocketServer = new WebSocketServer(hasParameter('ssl') ? { server: this.httpsServer } : { server: this.httpServer });
         this.webSocketServer.on('connection', (ws, request) => {
             const clientIp = request.socket.remoteAddress;
-            let callbackLogLevel = "notice";
-            if (this.matterbridge.matterbridgeInformation.loggerLevel === "info" || this.matterbridge.matterbridgeInformation.matterLoggerLevel === MatterLogLevel.INFO)
-                callbackLogLevel = "info";
-            if (this.matterbridge.matterbridgeInformation.loggerLevel === "debug" || this.matterbridge.matterbridgeInformation.matterLoggerLevel === MatterLogLevel.DEBUG)
-                callbackLogLevel = "debug";
+            // Set the global logger callback for the WebSocketServer
+            let callbackLogLevel = "notice" /* LogLevel.NOTICE */;
+            if (this.matterbridge.matterbridgeInformation.loggerLevel === "info" /* LogLevel.INFO */ || this.matterbridge.matterbridgeInformation.matterLoggerLevel === MatterLogLevel.INFO)
+                callbackLogLevel = "info" /* LogLevel.INFO */;
+            if (this.matterbridge.matterbridgeInformation.loggerLevel === "debug" /* LogLevel.DEBUG */ || this.matterbridge.matterbridgeInformation.matterLoggerLevel === MatterLogLevel.DEBUG)
+                callbackLogLevel = "debug" /* LogLevel.DEBUG */;
             AnsiLogger.setGlobalCallback(this.wssSendMessage.bind(this), callbackLogLevel);
             this.log.debug(`WebSocketServer logger global callback set to ${callbackLogLevel}`);
             this.log.info(`WebSocketServer client "${clientIp}" connected to Matterbridge`);
@@ -230,6 +364,7 @@ export class Frontend extends EventEmitter {
                 }
             });
             ws.on('error', (error) => {
+                // istanbul ignore next
                 this.log.error(`WebSocket client error: ${error}`);
             });
         });
@@ -243,6 +378,7 @@ export class Frontend extends EventEmitter {
         this.webSocketServer.on('error', (ws, error) => {
             this.log.error(`WebSocketServer error: ${error}`);
         });
+        // Subscribe to cli events
         cliEmitter.removeAllListeners();
         cliEmitter.on('uptime', (systemUptime, processUptime) => {
             this.wssSendUptimeUpdate(systemUptime, processUptime);
@@ -253,6 +389,8 @@ export class Frontend extends EventEmitter {
         cliEmitter.on('cpu', (cpuUsage) => {
             this.wssSendCpuUpdate(cpuUsage);
         });
+        // Endpoint to validate login code
+        // curl -X POST "http://localhost:8283/api/login" -H "Content-Type: application/json" -d "{\"password\":\"Here\"}"
         this.expressApp.post('/api/login', express.json(), async (req, res) => {
             const { password } = req.body;
             this.log.debug('The frontend sent /api/login', password);
@@ -271,23 +409,27 @@ export class Frontend extends EventEmitter {
                     this.log.warn('/api/login error wrong password');
                     res.json({ valid: false });
                 }
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
             }
             catch (error) {
                 this.log.error('/api/login error getting password');
                 res.json({ valid: false });
             }
         });
+        // Endpoint to provide health check for docker
         this.expressApp.get('/health', (req, res) => {
             this.log.debug('Express received /health');
             const healthStatus = {
-                status: 'ok',
-                uptime: process.uptime(),
-                timestamp: new Date().toISOString(),
+                status: 'ok', // Indicate service is healthy
+                uptime: process.uptime(), // Server uptime in seconds
+                timestamp: new Date().toISOString(), // Current timestamp
             };
             res.status(200).json(healthStatus);
         });
+        // Endpoint to provide memory usage details
         this.expressApp.get('/memory', async (req, res) => {
             this.log.debug('Express received /memory');
+            // Memory usage from process
             const memoryUsageRaw = process.memoryUsage();
             const memoryUsage = {
                 rss: this.formatMemoryUsage(memoryUsageRaw.rss),
@@ -296,10 +438,13 @@ export class Frontend extends EventEmitter {
                 external: this.formatMemoryUsage(memoryUsageRaw.external),
                 arrayBuffers: this.formatMemoryUsage(memoryUsageRaw.arrayBuffers),
             };
+            // V8 heap statistics
             const { default: v8 } = await import('node:v8');
             const heapStatsRaw = v8.getHeapStatistics();
             const heapSpacesRaw = v8.getHeapSpaceStatistics();
+            // Format heapStats
             const heapStats = Object.fromEntries(Object.entries(heapStatsRaw).map(([key, value]) => [key, this.formatMemoryUsage(value)]));
+            // Format heapSpaces
             const heapSpaces = heapSpacesRaw.map((space) => ({
                 ...space,
                 space_size: this.formatMemoryUsage(space.space_size),
@@ -317,19 +462,23 @@ export class Frontend extends EventEmitter {
             };
             res.status(200).json(memoryReport);
         });
+        // Endpoint to provide settings
         this.expressApp.get('/api/settings', express.json(), async (req, res) => {
             this.log.debug('The frontend sent /api/settings');
             res.json(await this.getApiSettings());
         });
+        // Endpoint to provide plugins
         this.expressApp.get('/api/plugins', async (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
             res.json(this.getPlugins());
         });
+        // Endpoint to provide devices
         this.expressApp.get('/api/devices', async (req, res) => {
             this.log.debug('The frontend sent /api/devices');
             const devices = await this.getDevices();
             res.json(devices);
         });
+        // Endpoint to view the matterbridge log
         this.expressApp.get('/api/view-mblog', async (req, res) => {
             this.log.debug('The frontend sent /api/view-mblog');
             try {
@@ -342,6 +491,7 @@ export class Frontend extends EventEmitter {
                 res.status(500).send('Error reading matterbridge log file. Please enable the matterbridge log on file in the settings.');
             }
         });
+        // Endpoint to view the matter.js log
         this.expressApp.get('/api/view-mjlog', async (req, res) => {
             this.log.debug('The frontend sent /api/view-mjlog');
             try {
@@ -354,6 +504,7 @@ export class Frontend extends EventEmitter {
                 res.status(500).send('Error reading matter log file. Please enable the matter log on file in the settings.');
             }
         });
+        // Endpoint to view the shelly log
         this.expressApp.get('/api/shellyviewsystemlog', async (req, res) => {
             this.log.debug('The frontend sent /api/shellyviewsystemlog');
             try {
@@ -366,6 +517,7 @@ export class Frontend extends EventEmitter {
                 res.status(500).send('Error reading shelly log file. Please create the shelly system log before loading it.');
             }
         });
+        // Endpoint to download the matterbridge log
         this.expressApp.get('/api/download-mblog', async (req, res) => {
             this.log.debug(`The frontend sent /api/download-mblog ${path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterbridgeLoggerFile)}`);
             try {
@@ -379,12 +531,14 @@ export class Frontend extends EventEmitter {
             }
             res.type('text/plain');
             res.download(path.join(os.tmpdir(), this.matterbridge.matterbridgeLoggerFile), 'matterbridge.log', (error) => {
+                /* istanbul ignore if */
                 if (error) {
                     this.log.error(`Error downloading log file ${this.matterbridge.matterbridgeLoggerFile}: ${error instanceof Error ? error.message : error}`);
                     res.status(500).send('Error downloading the matterbridge log file');
                 }
             });
         });
+        // Endpoint to download the matter log
         this.expressApp.get('/api/download-mjlog', async (req, res) => {
             this.log.debug(`The frontend sent /api/download-mjlog ${path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterbridgeLoggerFile)}`);
             try {
@@ -398,12 +552,14 @@ export class Frontend extends EventEmitter {
             }
             res.type('text/plain');
             res.download(path.join(os.tmpdir(), this.matterbridge.matterLoggerFile), 'matter.log', (error) => {
+                /* istanbul ignore if */
                 if (error) {
                     this.log.error(`Error downloading log file ${this.matterbridge.matterLoggerFile}: ${error instanceof Error ? error.message : error}`);
                     res.status(500).send('Error downloading the matter log file');
                 }
             });
         });
+        // Endpoint to download the shelly log
         this.expressApp.get('/api/shellydownloadsystemlog', async (req, res) => {
             this.log.debug('The frontend sent /api/shellydownloadsystemlog');
             try {
@@ -417,74 +573,90 @@ export class Frontend extends EventEmitter {
             }
             res.type('text/plain');
             res.download(path.join(os.tmpdir(), 'shelly.log'), 'shelly.log', (error) => {
+                /* istanbul ignore if */
                 if (error) {
                     this.log.error(`Error downloading Shelly system log file: ${error instanceof Error ? error.message : error}`);
                     res.status(500).send('Error downloading Shelly system log file');
                 }
             });
         });
+        // Endpoint to download the matterbridge storage directory
         this.expressApp.get('/api/download-mbstorage', async (req, res) => {
             this.log.debug('The frontend sent /api/download-mbstorage');
             await createZip(path.join(os.tmpdir(), `matterbridge.${this.matterbridge.nodeStorageName}.zip`), path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.nodeStorageName));
             res.download(path.join(os.tmpdir(), `matterbridge.${this.matterbridge.nodeStorageName}.zip`), `matterbridge.${this.matterbridge.nodeStorageName}.zip`, (error) => {
+                /* istanbul ignore if */
                 if (error) {
                     this.log.error(`Error downloading file ${`matterbridge.${this.matterbridge.nodeStorageName}.zip`}: ${error instanceof Error ? error.message : error}`);
                     res.status(500).send('Error downloading the matterbridge storage file');
                 }
             });
         });
+        // Endpoint to download the matter storage file
         this.expressApp.get('/api/download-mjstorage', async (req, res) => {
             this.log.debug('The frontend sent /api/download-mjstorage');
             await createZip(path.join(os.tmpdir(), `matterbridge.${this.matterbridge.matterStorageName}.zip`), path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterStorageName));
             res.download(path.join(os.tmpdir(), `matterbridge.${this.matterbridge.matterStorageName}.zip`), `matterbridge.${this.matterbridge.matterStorageName}.zip`, (error) => {
+                /* istanbul ignore if */
                 if (error) {
                     this.log.error(`Error downloading the matter storage matterbridge.${this.matterbridge.matterStorageName}.zip: ${error instanceof Error ? error.message : error}`);
                     res.status(500).send('Error downloading the matter storage zip file');
                 }
             });
         });
+        // Endpoint to download the matterbridge plugin directory
         this.expressApp.get('/api/download-pluginstorage', async (req, res) => {
             this.log.debug('The frontend sent /api/download-pluginstorage');
             await createZip(path.join(os.tmpdir(), `matterbridge.pluginstorage.zip`), this.matterbridge.matterbridgePluginDirectory);
             res.download(path.join(os.tmpdir(), `matterbridge.pluginstorage.zip`), `matterbridge.pluginstorage.zip`, (error) => {
+                /* istanbul ignore if */
                 if (error) {
                     this.log.error(`Error downloading file matterbridge.pluginstorage.zip: ${error instanceof Error ? error.message : error}`);
                     res.status(500).send('Error downloading the matterbridge plugin storage file');
                 }
             });
         });
+        // Endpoint to download the matterbridge plugin config files
         this.expressApp.get('/api/download-pluginconfig', async (req, res) => {
             this.log.debug('The frontend sent /api/download-pluginconfig');
             await createZip(path.join(os.tmpdir(), `matterbridge.pluginconfig.zip`), path.relative(process.cwd(), path.join(this.matterbridge.matterbridgeDirectory, '*.config.json')));
             res.download(path.join(os.tmpdir(), `matterbridge.pluginconfig.zip`), `matterbridge.pluginconfig.zip`, (error) => {
+                /* istanbul ignore if */
                 if (error) {
                     this.log.error(`Error downloading file matterbridge.pluginconfig.zip: ${error instanceof Error ? error.message : error}`);
                     res.status(500).send('Error downloading the matterbridge plugin config file');
                 }
             });
         });
+        // Endpoint to download the matterbridge backup (created with the backup command)
         this.expressApp.get('/api/download-backup', async (req, res) => {
             this.log.debug('The frontend sent /api/download-backup');
             res.download(path.join(os.tmpdir(), `matterbridge.backup.zip`), `matterbridge.backup.zip`, (error) => {
+                /* istanbul ignore if */
                 if (error) {
                     this.log.error(`Error downloading file matterbridge.backup.zip: ${error instanceof Error ? error.message : error}`);
                     res.status(500).send(`Error downloading file matterbridge.backup.zip: ${error instanceof Error ? error.message : error}`);
                 }
             });
         });
+        // Endpoint to upload a package
         this.expressApp.post('/api/uploadpackage', upload.single('file'), async (req, res) => {
             const { filename } = req.body;
             const file = req.file;
+            /* istanbul ignore if */
             if (!file || !filename) {
                 this.log.error(`uploadpackage: invalid request: file and filename are required`);
                 res.status(400).send('Invalid request: file and filename are required');
                 return;
             }
             this.wssSendSnackbarMessage(`Installing package ${filename}. Please wait...`, 0);
+            // Define the path where the plugin file will be saved
             const filePath = path.join(this.matterbridge.matterbridgeDirectory, 'uploads', filename);
             try {
+                // Move the uploaded file to the specified path
                 await fs.rename(file.path, filePath);
                 this.log.info(`File ${plg}${filename}${nf} uploaded successfully`);
+                // Install the plugin package
                 if (filename.endsWith('.tgz')) {
                     const { spawnCommand } = await import('./utils/spawn.js');
                     await spawnCommand(this.matterbridge, 'npm', ['install', '-g', filePath, '--omit=dev', '--verbose']);
@@ -504,6 +676,7 @@ export class Frontend extends EventEmitter {
                 res.status(500).send(`Error uploading or installing plugin package ${filename}`);
             }
         });
+        // Fallback for routing (must be the last route)
         this.expressApp.use((req, res) => {
             this.log.debug(`The frontend sent ${req.url} method ${req.method}: sending index.html as fallback`);
             res.sendFile(path.join(this.matterbridge.rootDirectory, 'frontend/build/index.html'));
@@ -512,13 +685,16 @@ export class Frontend extends EventEmitter {
     }
     async stop() {
         this.log.debug('Stopping the frontend...');
+        // Remove listeners from the express app
         if (this.expressApp) {
             this.expressApp.removeAllListeners();
             this.expressApp = undefined;
             this.log.debug('Frontend app closed successfully');
         }
+        // Close the WebSocket server
         if (this.webSocketServer) {
             this.log.debug('Closing WebSocket server...');
+            // Close all active connections
             this.webSocketServer.clients.forEach((client) => {
                 if (client.readyState === WebSocket.OPEN) {
                     client.close();
@@ -527,6 +703,7 @@ export class Frontend extends EventEmitter {
             await withTimeout(new Promise((resolve) => {
                 this.webSocketServer?.close((error) => {
                     if (error) {
+                        // istanbul ignore next
                         this.log.error(`Error closing WebSocket server: ${error}`);
                     }
                     else {
@@ -539,11 +716,13 @@ export class Frontend extends EventEmitter {
             this.webSocketServer.removeAllListeners();
             this.webSocketServer = undefined;
         }
+        // Close the http server
         if (this.httpServer) {
             this.log.debug('Closing http server...');
             await withTimeout(new Promise((resolve) => {
                 this.httpServer?.close((error) => {
                     if (error) {
+                        // istanbul ignore next
                         this.log.error(`Error closing http server: ${error}`);
                     }
                     else {
@@ -557,11 +736,13 @@ export class Frontend extends EventEmitter {
             this.httpServer = undefined;
             this.log.debug('Frontend http server closed successfully');
         }
+        // Close the https server
         if (this.httpsServer) {
             this.log.debug('Closing https server...');
             await withTimeout(new Promise((resolve) => {
                 this.httpsServer?.close((error) => {
                     if (error) {
+                        // istanbul ignore next
                         this.log.error(`Error closing https server: ${error}`);
                     }
                     else {
@@ -577,6 +758,7 @@ export class Frontend extends EventEmitter {
         }
         this.log.debug('Frontend stopped successfully');
     }
+    // Function to format bytes to KB, MB, or GB
     formatMemoryUsage = (bytes) => {
         if (bytes >= 1024 ** 3) {
             return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
@@ -588,6 +770,7 @@ export class Frontend extends EventEmitter {
             return `${(bytes / 1024).toFixed(2)} KB`;
         }
     };
+    // Function to format system uptime with only the most significant unit
     formatOsUpTime = (seconds) => {
         if (seconds >= 86400) {
             const days = Math.floor(seconds / 86400);
@@ -603,7 +786,13 @@ export class Frontend extends EventEmitter {
         }
         return `${seconds} second${seconds !== 1 ? 's' : ''}`;
     };
+    /**
+     * Retrieves the api settings data.
+     *
+     * @returns {Promise<{ matterbridgeInformation: MatterbridgeInformation, systemInformation: SystemInformation }>} A promise that resolve in the api settings object.
+     */
     async getApiSettings() {
+        // Update the system information
         this.matterbridge.systemInformation.totalMemory = this.formatMemoryUsage(os.totalmem());
         this.matterbridge.systemInformation.freeMemory = this.formatMemoryUsage(os.freemem());
         this.matterbridge.systemInformation.systemUptime = this.formatOsUpTime(os.uptime());
@@ -612,6 +801,7 @@ export class Frontend extends EventEmitter {
         this.matterbridge.systemInformation.rss = this.formatMemoryUsage(process.memoryUsage().rss);
         this.matterbridge.systemInformation.heapTotal = this.formatMemoryUsage(process.memoryUsage().heapTotal);
         this.matterbridge.systemInformation.heapUsed = this.formatMemoryUsage(process.memoryUsage().heapUsed);
+        // Update the matterbridge information
         this.matterbridge.matterbridgeInformation.bridgeMode = this.matterbridge.bridgeMode;
         this.matterbridge.matterbridgeInformation.restartMode = this.matterbridge.restartMode;
         this.matterbridge.matterbridgeInformation.profile = this.matterbridge.profile;
@@ -623,6 +813,7 @@ export class Frontend extends EventEmitter {
         this.matterbridge.matterbridgeInformation.matterPort = (await this.matterbridge.nodeContext?.get('matterport', 5540)) ?? 5540;
         this.matterbridge.matterbridgeInformation.matterDiscriminator = await this.matterbridge.nodeContext?.get('matterdiscriminator');
         this.matterbridge.matterbridgeInformation.matterPasscode = await this.matterbridge.nodeContext?.get('matterpasscode');
+        // Update the matterbridge information in bridge mode
         if (this.matterbridge.bridgeMode === 'bridge' && this.matterbridge.serverNode && !this.matterbridge.hasCleanupStarted) {
             this.matterbridge.matterbridgeInformation.matterbridgePaired = this.matterbridge.serverNode.state.commissioning.commissioned;
             this.matterbridge.matterbridgeInformation.matterbridgeQrPairingCode = this.matterbridge.matterbridgeInformation.matterbridgeEndAdvertise ? undefined : this.matterbridge.serverNode.state.commissioning.pairingCodes.qrPairingCode;
@@ -632,6 +823,12 @@ export class Frontend extends EventEmitter {
         }
         return { systemInformation: this.matterbridge.systemInformation, matterbridgeInformation: this.matterbridge.matterbridgeInformation };
     }
+    /**
+     * Retrieves the reachable attribute.
+     *
+     * @param {MatterbridgeEndpoint} device - The MatterbridgeEndpoint object.
+     * @returns {boolean} The reachable attribute.
+     */
     getReachability(device) {
         if (!device.lifecycle.isReady || device.construction.status !== Lifecycle.Status.Active)
             return false;
@@ -643,6 +840,12 @@ export class Frontend extends EventEmitter {
             return true;
         return false;
     }
+    /**
+     * Retrieves the power source attribute.
+     *
+     * @param {MatterbridgeEndpoint} endpoint - The MatterbridgeDevice to retrieve the power source from.
+     * @returns {'ac' | 'dc' | 'ok' | 'warning' | 'critical' | undefined} The power source attribute.
+     */
     getPowerSource(endpoint) {
         if (!endpoint.lifecycle.isReady || endpoint.construction.status !== Lifecycle.Status.Active)
             return undefined;
@@ -658,13 +861,21 @@ export class Frontend extends EventEmitter {
             }
             return;
         };
+        // Root endpoint
         if (endpoint.hasClusterServer(PowerSource.Cluster.id))
             return powerSource(endpoint);
+        // Child endpoints
         for (const child of endpoint.getChildEndpoints()) {
             if (child.hasClusterServer(PowerSource.Cluster.id))
                 return powerSource(child);
         }
     }
+    /**
+     * Retrieves the commissioned status, matter pairing codes, fabrics and sessions from a given device in server mode.
+     *
+     * @param {MatterbridgeEndpoint} device - The MatterbridgeEndpoint to retrieve the data from.
+     * @returns {ApiDevicesMatter | undefined} An ApiDevicesMatter object or undefined if not found.
+     */
     getMatterDataFromDevice(device) {
         if (device.mode === 'server' && device.serverNode) {
             return {
@@ -677,6 +888,13 @@ export class Frontend extends EventEmitter {
             };
         }
     }
+    /**
+     * Retrieves the cluster text description from a given device.
+     * The output is a string with the attributes description of the cluster servers in the device to show in the frontend.
+     *
+     * @param {MatterbridgeEndpoint} device - The MatterbridgeEndpoint to retrieve the cluster text from.
+     * @returns {string} The attributes description of the cluster servers in the device.
+     */
     getClusterTextFromDevice(device) {
         if (!device.lifecycle.isReady || device.construction.status !== Lifecycle.Status.Active)
             return '';
@@ -687,6 +905,7 @@ export class Frontend extends EventEmitter {
                 if (composed)
                     return 'Composed: ' + composed.value;
             }
+            // istanbul ignore next cause is not reachable
             return '';
         };
         const getFixedLabel = (device) => {
@@ -696,11 +915,13 @@ export class Frontend extends EventEmitter {
                 if (composed)
                     return 'Composed: ' + composed.value;
             }
+            // istanbul ignore next cause is not reacheable
             return '';
         };
         let attributes = '';
         let supportedModes = [];
         device.forEachAttribute((clusterName, clusterId, attributeName, attributeId, attributeValue) => {
+            // console.log(`${device.deviceName} => Cluster: ${clusterName}-${clusterId} Attribute: ${attributeName}-${attributeId} Value(${typeof attributeValue}): ${attributeValue}`);
             if (typeof attributeValue === 'undefined' || attributeValue === undefined)
                 return;
             if (clusterName === 'onOff' && attributeName === 'onOff')
@@ -790,11 +1011,17 @@ export class Frontend extends EventEmitter {
             if (clusterName === 'userLabel' && attributeName === 'labelList')
                 attributes += `${getUserLabel(device)} `;
         });
+        // console.log(`${device.deviceName}.forEachAttribute: ${attributes}`);
         return attributes.trimStart().trimEnd();
     }
+    /**
+     * Retrieves the registered plugins sanitized for res.json().
+     *
+     * @returns {BaseRegisteredPlugin[]} An array of BaseRegisteredPlugin.
+     */
     getPlugins() {
         if (this.matterbridge.hasCleanupStarted)
-            return [];
+            return []; // Skip if cleanup has started
         const baseRegisteredPlugins = [];
         for (const plugin of this.matterbridge.plugins) {
             baseRegisteredPlugins.push({
@@ -824,6 +1051,7 @@ export class Frontend extends EventEmitter {
                 schemaJson: plugin.schemaJson,
                 hasWhiteList: plugin.configJson?.whiteList !== undefined,
                 hasBlackList: plugin.configJson?.blackList !== undefined,
+                // Childbridge mode specific data
                 paired: plugin.serverNode && plugin.serverNode.lifecycle.isOnline ? plugin.serverNode.state.commissioning.commissioned : undefined,
                 qrPairingCode: this.matterbridge.matterbridgeInformation.matterbridgeEndAdvertise ? undefined : plugin.serverNode && plugin.serverNode.lifecycle.isOnline ? plugin.serverNode.state.commissioning.pairingCodes.qrPairingCode : undefined,
                 manualPairingCode: this.matterbridge.matterbridgeInformation.matterbridgeEndAdvertise ? undefined : plugin.serverNode && plugin.serverNode.lifecycle.isOnline ? plugin.serverNode.state.commissioning.pairingCodes.manualPairingCode : undefined,
@@ -833,13 +1061,21 @@ export class Frontend extends EventEmitter {
         }
         return baseRegisteredPlugins;
     }
+    /**
+     * Retrieves the devices from Matterbridge.
+     *
+     * @param {string} [pluginName] - The name of the plugin to filter devices by.
+     * @returns {Promise<ApiDevices[]>} A promise that resolves to an array of ApiDevices for the frontend.
+     */
     async getDevices(pluginName) {
         if (this.matterbridge.hasCleanupStarted)
-            return [];
+            return []; // Skip if cleanup has started
         const devices = [];
         for (const device of this.matterbridge.devices.array()) {
+            // Filter by pluginName if provided
             if (pluginName && pluginName !== device.plugin)
                 continue;
+            // Check if the device has the required properties
             if (!device.plugin || !device.deviceType || !device.name || !device.deviceName || !device.serialNumber || !device.uniqueId || !device.lifecycle.isReady)
                 continue;
             devices.push({
@@ -859,22 +1095,37 @@ export class Frontend extends EventEmitter {
         }
         return devices;
     }
+    /**
+     * Retrieves the clusters from a given plugin and endpoint number.
+     *
+     * Response for /api/clusters
+     *
+     * @param {string} pluginName - The name of the plugin.
+     * @param {number} endpointNumber - The endpoint number.
+     * @returns {ApiClustersResponse | undefined} A promise that resolves to the clusters or undefined if not found.
+     */
     getClusters(pluginName, endpointNumber) {
         const endpoint = this.matterbridge.devices.array().find((d) => d.plugin === pluginName && d.maybeNumber === endpointNumber);
         if (!endpoint || !endpoint.plugin || !endpoint.maybeNumber || !endpoint.deviceName || !endpoint.serialNumber) {
             this.log.error(`getClusters: no device found for plugin ${pluginName} and endpoint number ${endpointNumber}`);
             return;
         }
+        // this.log.debug(`***getClusters: getting clusters for device ${endpoint.deviceName} plugin ${pluginName} endpoint number ${endpointNumber}`);
+        // Get the device types from the main endpoint
         const deviceTypes = [];
         const clusters = [];
         endpoint.state.descriptor.deviceTypeList.forEach((d) => {
             deviceTypes.push(d.deviceType);
         });
+        // Get the clusters from the main endpoint
         endpoint.forEachAttribute((clusterName, clusterId, attributeName, attributeId, attributeValue) => {
             if (typeof attributeValue === 'undefined' || attributeValue === undefined)
                 return;
             if (clusterName === 'EveHistory' && ['configDataGet', 'configDataSet', 'historyStatus', 'historyEntries', 'historyRequest', 'historySetTime', 'rLoc'].includes(attributeName))
                 return;
+            // console.log(
+            //   `${idn}${endpoint.deviceName}${rs}${nf} => Cluster: ${CYAN}${clusterName} (0x${clusterId.toString(16).padStart(2, '0')})${nf} Attribute: ${CYAN}${attributeName} (0x${attributeId.toString(16).padStart(2, '0')})${nf} Value: ${YELLOW}${typeof attributeValue === 'object' ? stringify(attributeValue as object) : attributeValue}${nf}`,
+            // );
             clusters.push({
                 endpoint: endpoint.number.toString(),
                 id: 'main',
@@ -887,12 +1138,19 @@ export class Frontend extends EventEmitter {
                 attributeLocalValue: attributeValue,
             });
         });
+        // Get the child endpoints
         const childEndpoints = endpoint.getChildEndpoints();
+        // if (childEndpoints.length === 0) {
+        // this.log.debug(`***getClusters: found ${childEndpoints.length} child endpoints for device ${endpoint.deviceName} plugin ${pluginName} and endpoint number ${endpointNumber}`);
+        // }
         childEndpoints.forEach((childEndpoint) => {
+            // istanbul ignore if cause is not reachable: should never happen but ...
             if (!childEndpoint.maybeId || !childEndpoint.maybeNumber) {
                 this.log.error(`getClusters: no child endpoint found for plugin ${pluginName} and endpoint number ${endpointNumber}`);
                 return;
             }
+            // this.log.debug(`***getClusters: getting clusters for child endpoint ${childEndpoint.id} of device ${endpoint.deviceName} plugin ${pluginName} endpoint number ${childEndpoint.number}`);
+            // Get the device types of the child endpoint
             const deviceTypes = [];
             childEndpoint.state.descriptor.deviceTypeList.forEach((d) => {
                 deviceTypes.push(d.deviceType);
@@ -902,9 +1160,12 @@ export class Frontend extends EventEmitter {
                     return;
                 if (clusterName === 'EveHistory' && ['configDataGet', 'configDataSet', 'historyStatus', 'historyEntries', 'historyRequest', 'historySetTime', 'rLoc'].includes(attributeName))
                     return;
+                // console.log(
+                //   `${idn}${childEndpoint.deviceName}${rs}${nf} => Cluster: ${CYAN}${clusterName} (0x${clusterId.toString(16).padStart(2, '0')})${nf} Attribute: ${CYAN}${attributeName} (0x${attributeId.toString(16).padStart(2, '0')})${nf} Value: ${YELLOW}${typeof attributeValue === 'object' ? stringify(attributeValue as object) : attributeValue}${nf}`,
+                // );
                 clusters.push({
                     endpoint: childEndpoint.number.toString(),
-                    id: childEndpoint.maybeId ?? 'null',
+                    id: childEndpoint.maybeId ?? 'null', // Never happens
                     deviceTypes,
                     clusterName: capitalizeFirstLetter(clusterName),
                     clusterId: '0x' + clusterId.toString(16).padStart(2, '0'),
@@ -917,6 +1178,13 @@ export class Frontend extends EventEmitter {
         });
         return { plugin: endpoint.plugin, deviceName: endpoint.deviceName, serialNumber: endpoint.serialNumber, endpoint: endpoint.maybeNumber, deviceTypes, clusters };
     }
+    /**
+     * Handles incoming websocket messages for the Matterbridge frontend.
+     *
+     * @param {WebSocket} client - The websocket client that sent the message.
+     * @param {WebSocket.RawData} message - The raw data of the message received from the client.
+     * @returns {Promise<void>} A promise that resolves when the message has been handled.
+     */
     async wsMessageHandler(client, message) {
         let data;
         try {
@@ -963,35 +1231,48 @@ export class Frontend extends EventEmitter {
                     this.wssSendSnackbarMessage(`Installed package ${data.params.packageName}`, 5, 'success');
                     const packageName = data.params.packageName.replace(/@.*$/, '');
                     if (data.params.restart === false && packageName !== 'matterbridge') {
+                        // The install comes from InstallPlugins
                         this.matterbridge.plugins
                             .add(packageName)
                             .then((plugin) => {
+                            // istanbul ignore next if
                             if (plugin) {
+                                // The plugin is not registered
                                 this.wssSendSnackbarMessage(`Added plugin ${packageName}`, 5, 'success');
+                                // In childbridge mode the plugins server node is not started when added
                                 if (this.matterbridge.bridgeMode === 'childbridge')
                                     this.wssSendRestartRequired(true, true);
                                 this.matterbridge.plugins
                                     .load(plugin, true, 'The plugin has been added', true)
+                                    // eslint-disable-next-line promise/no-nesting
                                     .then(() => {
                                     this.wssSendSnackbarMessage(`Started plugin ${packageName}`, 5, 'success');
                                     this.wssSendRefreshRequired('plugins');
                                     return;
                                 })
+                                    // eslint-disable-next-line promise/no-nesting
                                     .catch((_error) => {
+                                    //
                                 });
                             }
                             else {
+                                // The plugin is already registered
                                 this.matterbridge.matterbridgeInformation.fixedRestartRequired = true;
                                 this.wssSendRefreshRequired('plugins');
                                 this.wssSendRestartRequired(true, true);
                             }
                             return;
                         })
+                            // eslint-disable-next-line promise/no-nesting
                             .catch((_error) => {
+                            //
                         });
                     }
                     else {
+                        // The package is matterbridge
+                        // istanbul ignore next
                         this.matterbridge.matterbridgeInformation.fixedRestartRequired = true;
+                        // istanbul ignore next if
                         if (this.matterbridge.restartMode !== '') {
                             this.wssSendSnackbarMessage(`Restarting matterbridge...`, 0);
                             this.matterbridge.shutdownProcess();
@@ -1013,7 +1294,9 @@ export class Frontend extends EventEmitter {
                     client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter packageName in /api/uninstall' }));
                     return;
                 }
+                // The package is a plugin
                 const plugin = this.matterbridge.plugins.get(data.params.packageName);
+                // istanbul ignore next if
                 if (plugin) {
                     await this.matterbridge.plugins.shutdown(plugin, 'The plugin has been removed.', true);
                     await this.matterbridge.plugins.remove(data.params.packageName);
@@ -1021,6 +1304,7 @@ export class Frontend extends EventEmitter {
                     this.wssSendRefreshRequired('plugins');
                     this.wssSendRefreshRequired('devices');
                 }
+                // Uninstall the package
                 this.wssSendSnackbarMessage(`Uninstalling package ${data.params.packageName}...`, 0);
                 const { spawnCommand } = await import('./utils/spawn.js');
                 spawnCommand(this.matterbridge, 'npm', ['uninstall', '-g', data.params.packageName, '--verbose'])
@@ -1061,6 +1345,7 @@ export class Frontend extends EventEmitter {
                         return;
                     })
                         .catch((_error) => {
+                        //
                     });
                 }
                 else {
@@ -1107,6 +1392,7 @@ export class Frontend extends EventEmitter {
                         return;
                     })
                         .catch((_error) => {
+                        //
                     });
                 }
                 client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
@@ -1132,6 +1418,7 @@ export class Frontend extends EventEmitter {
                 const plugin = this.matterbridge.plugins.get(data.params.pluginName);
                 await this.matterbridge.plugins.shutdown(plugin, 'The plugin is restarting.', false, true);
                 if (plugin.serverNode) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     await this.matterbridge.stopServerNode(plugin.serverNode);
                     plugin.serverNode = undefined;
                 }
@@ -1142,15 +1429,16 @@ export class Frontend extends EventEmitter {
                     }
                 }
                 await this.matterbridge.plugins.load(plugin, true, 'The plugin has been restarted', true);
-                plugin.restartRequired = false;
+                plugin.restartRequired = false; // Reset plugin restartRequired
                 let needRestart = 0;
                 for (const plugin of this.matterbridge.plugins) {
                     if (plugin.restartRequired)
                         needRestart++;
                 }
                 if (needRestart === 0) {
-                    this.wssSendRestartNotRequired(true);
+                    this.wssSendRestartNotRequired(true); // Reset global restart required message
                 }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 if (plugin.serverNode)
                     await this.matterbridge.startServerNode(plugin.serverNode);
                 this.wssSendSnackbarMessage(`Restarted plugin ${data.params.pluginName}`, 5, 'success');
@@ -1256,6 +1544,8 @@ export class Frontend extends EventEmitter {
             else if (data.method === '/api/advertise') {
                 const pairingCodes = await this.matterbridge.advertiseServerNode(this.matterbridge.serverNode);
                 this.matterbridge.matterbridgeInformation.matterbridgeAdvertise = true;
+                // this.matterbridge.matterbridgeQrPairingCode = pairingCodes?.qrPairingCode;
+                // this.matterbridge.matterbridgeManualPairingCode = pairingCodes?.manualPairingCode;
                 this.wssSendRefreshRequired('matterbridgeAdvertise');
                 this.wssSendSnackbarMessage(`Started fabrics share`, 0);
                 client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: pairingCodes, success: true }));
@@ -1378,22 +1668,22 @@ export class Frontend extends EventEmitter {
                         if (isValidString(data.params.value, 4)) {
                             this.log.debug('Matterbridge logger level:', data.params.value);
                             if (data.params.value === 'Debug') {
-                                await this.matterbridge.setLogLevel("debug");
+                                await this.matterbridge.setLogLevel("debug" /* LogLevel.DEBUG */);
                             }
                             else if (data.params.value === 'Info') {
-                                await this.matterbridge.setLogLevel("info");
+                                await this.matterbridge.setLogLevel("info" /* LogLevel.INFO */);
                             }
                             else if (data.params.value === 'Notice') {
-                                await this.matterbridge.setLogLevel("notice");
+                                await this.matterbridge.setLogLevel("notice" /* LogLevel.NOTICE */);
                             }
                             else if (data.params.value === 'Warn') {
-                                await this.matterbridge.setLogLevel("warn");
+                                await this.matterbridge.setLogLevel("warn" /* LogLevel.WARN */);
                             }
                             else if (data.params.value === 'Error') {
-                                await this.matterbridge.setLogLevel("error");
+                                await this.matterbridge.setLogLevel("error" /* LogLevel.ERROR */);
                             }
                             else if (data.params.value === 'Fatal') {
-                                await this.matterbridge.setLogLevel("fatal");
+                                await this.matterbridge.setLogLevel("fatal" /* LogLevel.FATAL */);
                             }
                             await this.matterbridge.nodeContext?.set('matterbridgeLogLevel', this.log.logLevel);
                             client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
@@ -1404,6 +1694,7 @@ export class Frontend extends EventEmitter {
                             this.log.debug('Matterbridge file log:', data.params.value);
                             this.matterbridge.matterbridgeInformation.fileLogger = data.params.value;
                             await this.matterbridge.nodeContext?.set('matterbridgeFileLog', data.params.value);
+                            // Create the file logger for matterbridge
                             if (data.params.value)
                                 AnsiLogger.setGlobalLogfile(path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterbridgeLoggerFile), this.matterbridge.matterbridgeInformation.loggerLevel, true);
                             else
@@ -1557,15 +1848,19 @@ export class Frontend extends EventEmitter {
                         return;
                     }
                     const config = plugin.configJson;
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const select = plugin.schemaJson?.properties?.blackList?.selectFrom;
+                    // this.log.debug(`SelectDevice(selectMode ${select}) data ${debugStringify(data)}`);
                     if (select === 'serial')
                         this.log.info(`Selected device serial ${data.params.serial}`);
                     if (select === 'name')
                         this.log.info(`Selected device name ${data.params.name}`);
                     if (config && select && (select === 'serial' || select === 'name')) {
+                        // Remove postfix from the serial if it exists
                         if (config.postfix) {
                             data.params.serial = data.params.serial.replace('-' + config.postfix, '');
                         }
+                        // Add the serial to the whiteList if the whiteList exists and the serial or name is not already in it
                         if (isValidArray(config.whiteList, 1)) {
                             if (select === 'serial' && !config.whiteList.includes(data.params.serial)) {
                                 config.whiteList.push(data.params.serial);
@@ -1574,6 +1869,7 @@ export class Frontend extends EventEmitter {
                                 config.whiteList.push(data.params.name);
                             }
                         }
+                        // Remove the serial from the blackList if the blackList exists and the serial or name is in it
                         if (isValidArray(config.blackList, 1)) {
                             if (select === 'serial' && config.blackList.includes(data.params.serial)) {
                                 config.blackList = config.blackList.filter((item) => item !== data.params.serial);
@@ -1604,7 +1900,9 @@ export class Frontend extends EventEmitter {
                         return;
                     }
                     const config = plugin.configJson;
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const select = plugin.schemaJson?.properties?.blackList?.selectFrom;
+                    // this.log.debug(`UnselectDevice(selectMode ${select}) data ${debugStringify(data)}`);
                     if (select === 'serial')
                         this.log.info(`Unselected device serial ${data.params.serial}`);
                     if (select === 'name')
@@ -1613,6 +1911,7 @@ export class Frontend extends EventEmitter {
                         if (config.postfix) {
                             data.params.serial = data.params.serial.replace('-' + config.postfix, '');
                         }
+                        // Remove the serial from the whiteList if the whiteList exists and the serial is in it
                         if (isValidArray(config.whiteList, 1)) {
                             if (select === 'serial' && config.whiteList.includes(data.params.serial)) {
                                 config.whiteList = config.whiteList.filter((item) => item !== data.params.serial);
@@ -1621,6 +1920,7 @@ export class Frontend extends EventEmitter {
                                 config.whiteList = config.whiteList.filter((item) => item !== data.params.name);
                             }
                         }
+                        // Add the serial to the blackList
                         if (isValidArray(config.blackList)) {
                             if (select === 'serial' && !config.blackList.includes(data.params.serial)) {
                                 config.blackList.push(data.params.serial);
@@ -1654,126 +1954,251 @@ export class Frontend extends EventEmitter {
             this.log.error(`Error parsing message "${message}" from websocket client:`, error instanceof Error ? error.message : error);
         }
     }
+    /**
+     * Sends a WebSocket log message to all connected clients. The function is called by AnsiLogger.setGlobalCallback.
+     *
+     * @param {string} level - The logger level of the message: debug info notice warn error fatal...
+     * @param {string} time - The time string of the message
+     * @param {string} name - The logger name of the message
+     * @param {string} message - The content of the message.
+     *
+     * @remarks
+     * The function removes ANSI escape codes, leading asterisks, non-printable characters, and replaces all occurrences of \t and \n.
+     * It also replaces all occurrences of \" with " and angle-brackets with &lt; and &gt;.
+     * The function sends the message to all connected clients.
+     */
     wssSendMessage(level, time, name, message) {
         if (!level || !time || !name || !message)
             return;
+        // Remove ANSI escape codes from the message
+        // eslint-disable-next-line no-control-regex
         message = message.replace(/\x1B\[[0-9;]*[m|s|u|K]/g, '');
+        // Remove leading asterisks from the message
         message = message.replace(/^\*+/, '');
+        // Replace all occurrences of \t and \n
         message = message.replace(/[\t\n]/g, '');
+        // Remove non-printable characters
+        // eslint-disable-next-line no-control-regex
         message = message.replace(/[\x00-\x1F\x7F]/g, '');
+        // Replace all occurrences of \" with "
         message = message.replace(/\\"/g, '"');
+        // Replace all occurrences of angle-brackets with &lt; and &gt;"
         message = message.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        // Define the maximum allowed length for continuous characters without a space
         const maxContinuousLength = 100;
         const keepStartLength = 20;
         const keepEndLength = 20;
+        // Split the message into words
         message = message
             .split(' ')
             .map((word) => {
+            // If the word length exceeds the max continuous length, insert spaces and truncate
             if (word.length > maxContinuousLength) {
                 return word.slice(0, keepStartLength) + ' ... ' + word.slice(-keepEndLength);
             }
             return word;
         })
             .join(' ');
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_LOG, src: 'Matterbridge', level, time, name, message }));
             }
         });
     }
+    /**
+     * Sends a need to refresh WebSocket message to all connected clients.
+     *
+     * @param {string} changed - The changed value. If null, the whole page will be refreshed.
+     * possible values:
+     * - 'matterbridgeLatestVersion'
+     * - 'matterbridgeDevVersion'
+     * - 'matterbridgeAdvertise'
+     * - 'online'
+     * - 'offline'
+     * - 'reachability'
+     * - 'settings'
+     * - 'plugins'
+     * - 'pluginsRestart'
+     * - 'devices'
+     * - 'fabrics'
+     * - 'sessions'
+     */
     wssSendRefreshRequired(changed = null) {
         this.log.debug('Sending a refresh required message to all connected clients');
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_REFRESH_NEEDED, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', params: { changed: changed } }));
             }
         });
     }
+    /**
+     * Sends a need to restart WebSocket message to all connected clients.
+     *
+     * @param {boolean} snackbar - If true, a snackbar message will be sent to all connected clients. Default is true.
+     * @param {boolean} fixed - If true, the restart is fixed and will not be reset by plugin restarts. Default is false.
+     */
     wssSendRestartRequired(snackbar = true, fixed = false) {
         this.log.debug('Sending a restart required message to all connected clients');
         this.matterbridge.matterbridgeInformation.restartRequired = true;
         this.matterbridge.matterbridgeInformation.fixedRestartRequired = fixed;
         if (snackbar === true)
             this.wssSendSnackbarMessage(`Restart required`, 0);
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_RESTART_NEEDED, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', params: { fixed } }));
             }
         });
     }
+    /**
+     * Sends a no need to restart WebSocket message to all connected clients.
+     *
+     * @param {boolean} snackbar - If true, the snackbar message will be cleared from all connected clients.
+     */
     wssSendRestartNotRequired(snackbar = true) {
         this.log.debug('Sending a restart not required message to all connected clients');
         this.matterbridge.matterbridgeInformation.restartRequired = false;
         if (snackbar === true)
             this.wssSendCloseSnackbarMessage(`Restart required`);
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_RESTART_NEEDED, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', params: {} }));
             }
         });
     }
+    /**
+     * Sends a need to update WebSocket message to all connected clients.
+     *
+     * @param {boolean} devVersion - If true, the update is for a development version.
+     */
     wssSendUpdateRequired(devVersion = false) {
         this.log.debug('Sending an update required message to all connected clients');
         this.matterbridge.matterbridgeInformation.updateRequired = true;
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_UPDATE_NEEDED, src: 'Matterbridge', dst: 'Frontend', method: devVersion ? 'update_required_dev' : 'update_required', params: {} }));
             }
         });
     }
+    /**
+     * Sends a cpu update message to all connected clients.
+     *
+     * @param {number} cpuUsage - The CPU usage percentage to send.
+     */
     wssSendCpuUpdate(cpuUsage) {
         if (hasParameter('debug'))
             this.log.debug('Sending a cpu update message to all connected clients');
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_CPU_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'cpu_update', params: { cpuUsage } }));
             }
         });
     }
+    /**
+     * Sends a memory update message to all connected clients.
+     *
+     * @param {string} totalMemory - The total memory in bytes.
+     * @param {string} freeMemory - The free memory in bytes.
+     * @param {string} rss - The resident set size in bytes.
+     * @param {string} heapTotal - The total heap memory in bytes.
+     * @param {string} heapUsed - The used heap memory in bytes.
+     * @param {string} external - The external memory in bytes.
+     * @param {string} arrayBuffers - The array buffers memory in bytes.
+     */
     wssSendMemoryUpdate(totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers) {
         if (hasParameter('debug'))
             this.log.debug('Sending a memory update message to all connected clients');
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_MEMORY_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'memory_update', params: { totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers } }));
             }
         });
     }
+    /**
+     * Sends an uptime update message to all connected clients.
+     *
+     * @param {string} systemUptime - The system uptime in a human-readable format.
+     * @param {string} processUptime - The process uptime in a human-readable format.
+     */
     wssSendUptimeUpdate(systemUptime, processUptime) {
         if (hasParameter('debug'))
             this.log.debug('Sending a uptime update message to all connected clients');
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_UPTIME_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'uptime_update', params: { systemUptime, processUptime } }));
             }
         });
     }
+    /**
+     * Sends an open snackbar message to all connected clients.
+     *
+     * @param {string} message - The message to send.
+     * @param {number} timeout - The timeout in seconds for the snackbar message.
+     * @param {'info' | 'warning' | 'error' | 'success'} severity - The severity of the snackbar message (default info).
+     */
     wssSendSnackbarMessage(message, timeout = 5, severity = 'info') {
         this.log.debug('Sending a snackbar message to all connected clients');
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_SNACKBAR, src: 'Matterbridge', dst: 'Frontend', params: { message, timeout, severity } }));
             }
         });
     }
+    /**
+     * Sends a close snackbar message to all connected clients.
+     *
+     * @param {string} message - The message to send.
+     */
     wssSendCloseSnackbarMessage(message) {
         this.log.debug('Sending a close snackbar message to all connected clients');
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_CLOSE_SNACKBAR, src: 'Matterbridge', dst: 'Frontend', params: { message } }));
             }
         });
     }
+    /**
+     * Sends an attribute update message to all connected WebSocket clients.
+     *
+     * @param {string | undefined} plugin - The name of the plugin.
+     * @param {string | undefined} serialNumber - The serial number of the device.
+     * @param {string | undefined} uniqueId - The unique identifier of the device.
+     * @param {string} cluster - The cluster name where the attribute belongs.
+     * @param {string} attribute - The name of the attribute that changed.
+     * @param {number | string | boolean} value - The new value of the attribute.
+     *
+     * @remarks
+     * This method logs a debug message and sends a JSON-formatted message to all connected WebSocket clients
+     * with the updated attribute information.
+     */
     wssSendAttributeChangedMessage(plugin, serialNumber, uniqueId, cluster, attribute, value) {
         this.log.debug('Sending an attribute update message to all connected clients');
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id: WS_ID_STATEUPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'state_update', params: { plugin, serialNumber, uniqueId, cluster, attribute, value } }));
             }
         });
     }
+    /**
+     * Sends a message to all connected clients.
+     *
+     * @param {number} id - The message id.
+     * @param {string} method - The message method.
+     * @param {Record<string, string | number | boolean>} params - The message parameters.
+     */
     wssBroadcastMessage(id, method, params) {
         this.log.debug(`Sending a broadcast message id ${id} method ${method} params ${debugStringify(params ?? {})} to all connected clients`);
+        // Send the message to all connected clients
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
                 client.send(JSON.stringify({ id, src: 'Matterbridge', dst: 'Frontend', method, params }));
@@ -1781,3 +2206,4 @@ export class Frontend extends EventEmitter {
         });
     }
 }
+//# sourceMappingURL=frontend.js.map