matterbridge 1.7.2-dev.7 → 1.7.2

package/dist/matterbridge.js

@@ -1,3 +1,26 @@
+/**
+ * This file contains the class Matterbridge.
+ *
+ * @file matterbridge.ts
+ * @author Luca Liguori
+ * @date 2023-12-29
+ * @version 1.5.2
+ *
+ * Copyright 2023, 2024, 2025 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.js modules
 import { fileURLToPath } from 'url';
 import { promises as fs } from 'fs';
 import { exec, spawn } from 'child_process';
@@ -6,27 +29,36 @@ import EventEmitter from 'events';
 import os from 'os';
 import path from 'path';
 import { randomBytes } from 'crypto';
+// Package modules
 import https from 'https';
 import express from 'express';
 import WebSocket, { WebSocketServer } from 'ws';
+// NodeStorage and AnsiLogger modules
 import { NodeStorageManager } from 'node-persist-manager';
 import { AnsiLogger, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugStringify, stringify, BRIGHT, RESET, er, nf, rs, wr, RED, GREEN, zb, CYAN, nt, idn, or, hk, BLUE } from 'node-ansi-logger';
+// Matterbridge
 import { MatterbridgeDevice } from './matterbridgeDevice.js';
 import { WS_ID_LOG, WS_ID_REFRESH_NEEDED, WS_ID_RESTART_NEEDED, wsMessageHandler } from './matterbridgeWebsocket.js';
 import { logInterfaces, wait, waiter, createZip, copyDirectory, getParameter, getIntParameter, hasParameter } from './utils/utils.js';
 import { PluginManager } from './pluginManager.js';
 import { DeviceManager } from './deviceManager.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+// @matter
 import { DeviceTypeId, Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, VendorId, StorageManager, EndpointServer, StorageService, Environment } from '@matter/main';
 import { BasicInformationCluster, BridgedDeviceBasicInformation, BridgedDeviceBasicInformationCluster, FixedLabelCluster, GeneralCommissioning, PowerSourceCluster, SwitchCluster, ThreadNetworkDiagnosticsCluster, UserLabelCluster, } from '@matter/main/clusters';
 import { getClusterNameById, ManualPairingCodeCodec, QrCodeSchema } from '@matter/main/types';
 import { StorageBackendDisk, StorageBackendJsonFile } from '@matter/nodejs';
+// @project-chip
 import { CommissioningController, CommissioningServer, MatterServer } from '@project-chip/matter.js';
 import { Aggregator, DeviceTypes, NodeStateInformation } from '@project-chip/matter.js/device';
 import { aggregator } from './matterbridgeDeviceTypes.js';
+// Default colors
 const plg = '\u001B[38;5;33m';
 const dev = '\u001B[38;5;79m';
 const typ = '\u001B[38;5;207m';
+/**
+ * Represents the Matterbridge application.
+ */
 export class Matterbridge extends EventEmitter {
     systemInformation = {
         interfaceName: '',
@@ -63,7 +95,7 @@ export class Matterbridge extends EventEmitter {
         edge: hasParameter('edge'),
         readOnly: hasParameter('readonly'),
         profile: getParameter('profile'),
-        loggerLevel: "info",
+        loggerLevel: "info" /* LogLevel.INFO */,
         fileLogger: false,
         matterLoggerLevel: MatterLogLevel.INFO,
         matterFileLogger: false,
@@ -102,6 +134,7 @@ export class Matterbridge extends EventEmitter {
     nodeContext;
     matterStorageName = 'matterbridge' + (getParameter('profile') ? '.' + getParameter('profile') : '') + '.json';
     nodeStorageName = 'storage' + (getParameter('profile') ? '.' + getParameter('profile') : '');
+    // Cleanup
     hasCleanupStarted = false;
     initialized = false;
     execRunningCount = 0;
@@ -113,16 +146,18 @@ export class Matterbridge extends EventEmitter {
     sigtermHandler;
     exceptionHandler;
     rejectionHandler;
+    // Frontend
     expressApp;
     httpServer;
     httpsServer;
     webSocketServer;
-    mdnsInterface;
-    ipv4address;
-    ipv6address;
-    port = 5540;
-    passcode;
-    discriminator;
+    // Matter
+    mdnsInterface; // matter server mdnsInterface: e.g. 'eth0' or 'wlan0' or 'WiFi'
+    ipv4address; // matter commissioning server listeningAddressIpv4
+    ipv6address; // matter commissioning server listeningAddressIpv6
+    port = 5540; // first commissioning server port
+    passcode; // first commissioning server passcode
+    discriminator; // first commissioning server discriminator
     storageManager;
     matterbridgeContext;
     mattercontrollerContext;
@@ -133,19 +168,40 @@ export class Matterbridge extends EventEmitter {
     aggregatorVendorId = VendorId(getIntParameter('vendorId') ?? 0xfff1);
     aggregatorProductId = getIntParameter('productId') ?? 0x8000;
     static instance;
+    // We load asyncronously so is private
     constructor() {
         super();
+        // Bind the handler to the instance
         this.matterbridgeMessageHandler = wsMessageHandler.bind(this);
     }
+    /**
+     * Retrieves the list of Matterbridge devices.
+     * @returns {MatterbridgeDevice[]} An array of MatterbridgeDevice objects.
+     */
     getDevices() {
         return this.devices.array();
     }
+    /**
+     * Retrieves the list of registered plugins.
+     * @returns {RegisteredPlugin[]} An array of RegisteredPlugin objects.
+     */
     getPlugins() {
         return this.plugins.array();
     }
     matterbridgeMessageHandler;
+    /** ***********************************************************************************************************************************/
+    /**                                              loadInstance() and cleanup() methods                                                 */
+    /** ***********************************************************************************************************************************/
+    /**
+     * Loads an instance of the Matterbridge class.
+     * If an instance already exists, return that instance.
+     *
+     * @param initialize - Whether to initialize the Matterbridge instance after loading.
+     * @returns The loaded Matterbridge instance.
+     */
     static async loadInstance(initialize = false) {
         if (!Matterbridge.instance) {
+            // eslint-disable-next-line no-console
             if (hasParameter('debug'))
                 console.log(GREEN + 'Creating a new instance of Matterbridge.', initialize ? 'Initializing...' : 'Not initializing...', rs);
             Matterbridge.instance = new Matterbridge();
@@ -154,6 +210,11 @@ export class Matterbridge extends EventEmitter {
         }
         return Matterbridge.instance;
     }
+    /**
+     * Call cleanup().
+     * @deprecated This method is deprecated and is only used for jest tests.
+     *
+     */
     async destroyInstance() {
         await this.cleanup('destroying instance...', false);
         await waiter('destroying instance...', () => {
@@ -161,39 +222,60 @@ export class Matterbridge extends EventEmitter {
         }, false, 60000, 100, false);
         await wait(1000, 'Wait for the global node_modules and matterbridge version', false);
     }
+    /**
+     * Initializes the Matterbridge application.
+     *
+     * @remarks
+     * This method performs the necessary setup and initialization steps for the Matterbridge application.
+     * It displays the help information if the 'help' parameter is provided, sets up the logger, checks the
+     * node version, registers signal handlers, initializes storage, and parses the command line.
+     *
+     * @returns A Promise that resolves when the initialization is complete.
+     */
     async initialize() {
+        // Set the restart mode
         if (hasParameter('service'))
             this.restartMode = 'service';
         if (hasParameter('docker'))
             this.restartMode = 'docker';
+        // Set the matterbridge directory
         this.homeDirectory = getParameter('homedir') ?? os.homedir();
         this.matterbridgeDirectory = path.join(this.homeDirectory, '.matterbridge');
-        this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
+        // Create matterbridge logger
+        this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: hasParameter('debug') ? "debug" /* LogLevel.DEBUG */ : "info" /* LogLevel.INFO */ });
+        // Initialize nodeStorage and nodeContext
         try {
             this.log.debug(`Creating node storage manager: ${CYAN}${this.nodeStorageName}${db}`);
             this.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridgeDirectory, this.nodeStorageName), writeQueue: false, expiredInterval: undefined, logging: false });
             this.log.debug('Creating node storage context for matterbridge');
             this.nodeContext = await this.nodeStorage.createStorage('matterbridge');
+            // TODO: Remove this code when node-persist-manager is updated
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const keys = (await this.nodeStorage?.storage.keys());
             for (const key of keys) {
                 this.log.debug(`Checking node storage manager key: ${CYAN}${key}${db}`);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 await this.nodeStorage?.storage.get(key);
             }
             const storages = await this.nodeStorage.getStorageNames();
             for (const storage of storages) {
                 this.log.debug(`Checking storage: ${CYAN}${storage}${db}`);
                 const nodeContext = await this.nodeStorage?.createStorage(storage);
+                // TODO: Remove this code when node-persist-manager is updated
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const keys = (await nodeContext?.storage.keys());
                 keys.forEach(async (key) => {
                     this.log.debug(`Checking key: ${CYAN}${storage}:${key}${db}`);
                     await nodeContext?.get(key);
                 });
             }
+            // Creating a backup of the node storage since it is not corrupted
             this.log.debug('Creating node storage backup...');
             await copyDirectory(path.join(this.matterbridgeDirectory, this.nodeStorageName), path.join(this.matterbridgeDirectory, this.nodeStorageName + '.backup'));
             this.log.debug('Created node storage backup');
         }
         catch (error) {
+            // Restoring the backup of the node storage since it is corrupted
             this.log.error(`Error creating node storage manager and context: ${error instanceof Error ? error.message : error}`);
             if (hasParameter('norestore')) {
                 this.log.fatal(`The matterbridge node storage is corrupted. Parameter -norestore found: exiting...`);
@@ -208,45 +290,51 @@ export class Matterbridge extends EventEmitter {
             this.log.fatal('Fatal error creating node storage manager and context for matterbridge');
             throw new Error('Fatal error creating node storage manager and context for matterbridge');
         }
+        // Set the first port to use for the commissioning server (will be incremented in childbridge mode)
         this.port = getIntParameter('port') ?? (await this.nodeContext.get('matterport', 5540)) ?? 5540;
+        // Set the first passcode to use for the commissioning server (will be incremented in childbridge mode)
         this.passcode = this.passcode ?? getIntParameter('passcode') ?? (await this.nodeContext.get('matterpasscode'));
+        // Set the first discriminator to use for the commissioning server (will be incremented in childbridge mode)
         this.discriminator = this.discriminator ?? getIntParameter('discriminator') ?? (await this.nodeContext.get('matterdiscriminator'));
         this.log.debug(`Initializing commissioning server for Matterbridge... on port ${this.port} with passcode ${this.passcode} and discriminator ${this.discriminator}`);
+        // Set matterbridge logger level (context: matterbridgeLogLevel)
         if (hasParameter('logger')) {
             const level = getParameter('logger');
             if (level === 'debug') {
-                this.log.logLevel = "debug";
+                this.log.logLevel = "debug" /* LogLevel.DEBUG */;
             }
             else if (level === 'info') {
-                this.log.logLevel = "info";
+                this.log.logLevel = "info" /* LogLevel.INFO */;
             }
             else if (level === 'notice') {
-                this.log.logLevel = "notice";
+                this.log.logLevel = "notice" /* LogLevel.NOTICE */;
             }
             else if (level === 'warn') {
-                this.log.logLevel = "warn";
+                this.log.logLevel = "warn" /* LogLevel.WARN */;
             }
             else if (level === 'error') {
-                this.log.logLevel = "error";
+                this.log.logLevel = "error" /* LogLevel.ERROR */;
             }
             else if (level === 'fatal') {
-                this.log.logLevel = "fatal";
+                this.log.logLevel = "fatal" /* LogLevel.FATAL */;
             }
             else {
                 this.log.warn(`Invalid matterbridge logger level: ${level}. Using default level "info".`);
-                this.log.logLevel = "info";
+                this.log.logLevel = "info" /* LogLevel.INFO */;
             }
         }
         else {
-            this.log.logLevel = await this.nodeContext.get('matterbridgeLogLevel', "info");
+            this.log.logLevel = await this.nodeContext.get('matterbridgeLogLevel', "info" /* LogLevel.INFO */);
         }
         MatterbridgeDevice.logLevel = this.log.logLevel;
+        // Create the file logger for matterbridge (context: matterbridgeFileLog)
         if (hasParameter('filelogger') || (await this.nodeContext.get('matterbridgeFileLog', false))) {
             AnsiLogger.setGlobalLogfile(path.join(this.matterbridgeDirectory, this.matterbrideLoggerFile), this.log.logLevel, true);
             this.matterbridgeInformation.fileLogger = true;
         }
         this.log.notice('Matterbridge is starting...');
         this.log.debug(`Matterbridge logLevel: ${this.log.logLevel} fileLoger: ${this.matterbridgeInformation.fileLogger}.`);
+        // Set matter.js logger level, format and logger (context: matterLogLevel)
         if (hasParameter('matterlogger')) {
             const level = getParameter('matterlogger');
             if (level === 'debug') {
@@ -277,6 +365,7 @@ export class Matterbridge extends EventEmitter {
         }
         Logger.format = MatterLogFormat.ANSI;
         Logger.setLogger('default', this.createMatterLogger());
+        // Create the file logger for matter.js (context: matterFileLog)
         if (hasParameter('matterfilelogger') || (await this.nodeContext.get('matterFileLog', false))) {
             this.matterbridgeInformation.matterFileLogger = true;
             Logger.addLogger('matterfilelogger', await this.createMatterFileLogger(path.join(this.matterbridgeDirectory, this.matterLoggerFile), true), {
@@ -285,6 +374,7 @@ export class Matterbridge extends EventEmitter {
             });
         }
         this.log.debug(`Matter logLevel: ${Logger.defaultLogLevel} fileLoger: ${this.matterbridgeInformation.matterFileLogger}.`);
+        // Set the interface to use for the matter server mdnsInterface
         if (hasParameter('mdnsinterface')) {
             this.mdnsInterface = getParameter('mdnsinterface');
         }
@@ -293,6 +383,7 @@ export class Matterbridge extends EventEmitter {
             if (this.mdnsInterface === '')
                 this.mdnsInterface = undefined;
         }
+        // Set the listeningAddressIpv4 for the matter commissioning server
         if (hasParameter('ipv4address')) {
             this.ipv4address = getParameter('ipv4address');
         }
@@ -301,6 +392,7 @@ export class Matterbridge extends EventEmitter {
             if (this.ipv4address === '')
                 this.ipv4address = undefined;
         }
+        // Set the listeningAddressIpv6 for the matter commissioning server
         if (hasParameter('ipv6address')) {
             this.ipv6address = getParameter('ipv6address');
         }
@@ -309,17 +401,23 @@ export class Matterbridge extends EventEmitter {
             if (this.ipv6address === '')
                 this.ipv6address = undefined;
         }
+        // Initialize PluginManager
         this.plugins = new PluginManager(this);
         await this.plugins.loadFromStorage();
+        // Initialize DeviceManager
         this.devices = new DeviceManager(this, this.nodeContext);
+        // Get the plugins from node storage and create the plugins node storage contexts
         for (const plugin of this.plugins) {
             const packageJson = await this.plugins.parse(plugin);
             if (packageJson === null && !hasParameter('add')) {
+                // Try to reinstall the plugin from npm (for Docker pull and external plugins)
+                // We don't do this when the add parameter is set because we shut down the process after adding the plugin
                 this.log.info(`Error parsing plugin ${plg}${plugin.name}${nf}. Trying to reinstall it from npm.`);
                 try {
                     await this.spawnCommand('npm', ['install', '-g', plugin.name, '--omit=dev', '--verbose']);
                     this.log.info(`Plugin ${plg}${plugin.name}${nf} reinstalled.`);
                     plugin.error = false;
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 }
                 catch (error) {
                     plugin.error = true;
@@ -336,6 +434,7 @@ export class Matterbridge extends EventEmitter {
             await plugin.nodeContext.set('description', plugin.description);
             await plugin.nodeContext.set('author', plugin.author);
         }
+        // Log system info and create .matterbridge directory
         await this.logNodeAndSystemInfo();
         this.log.notice(`Matterbridge version ${this.matterbridgeVersion} ` +
             `${hasParameter('bridge') || (!hasParameter('childbridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'bridge') ? 'mode bridge ' : ''}` +
@@ -343,6 +442,7 @@ export class Matterbridge extends EventEmitter {
             `${hasParameter('controller') ? 'mode controller ' : ''}` +
             `${this.restartMode !== '' ? 'restart mode ' + this.restartMode + ' ' : ''}` +
             `running on ${this.systemInformation.osType} (v.${this.systemInformation.osRelease}) platform ${this.systemInformation.osPlatform} arch ${this.systemInformation.osArch}`);
+        // Check node version and throw error
         const minNodeVersion = 18;
         const nodeVersion = process.versions.node;
         const versionMajor = parseInt(nodeVersion.split('.')[0]);
@@ -350,10 +450,17 @@ export class Matterbridge extends EventEmitter {
             this.log.error(`Node version ${versionMajor} is not supported. Please upgrade to ${minNodeVersion} or above.`);
             throw new Error(`Node version ${versionMajor} is not supported. Please upgrade to ${minNodeVersion} or above.`);
         }
+        // Register process handlers
         this.registerProcessHandlers();
+        // Parse command line
         await this.parseCommandLine();
         this.initialized = true;
     }
+    /**
+     * Parses the command line arguments and performs the corresponding actions.
+     * @private
+     * @returns {Promise<void>} A promise that resolves when the command line arguments have been processed, or the process exits.
+     */
     async parseCommandLine() {
         if (hasParameter('help')) {
             this.log.info(`\nUsage: matterbridge [options]\n
@@ -461,6 +568,7 @@ export class Matterbridge extends EventEmitter {
         }
         if (hasParameter('factoryreset')) {
             try {
+                // Delete old matter storage file
                 const file = path.join(this.matterbridgeDirectory, 'matterbridge' + (getParameter('profile') ? '.' + getParameter('profile') : '') + '.json');
                 this.log.info(`Unlinking old matter storage file: ${file}`);
                 await fs.unlink(file);
@@ -471,6 +579,7 @@ export class Matterbridge extends EventEmitter {
                 }
             }
             try {
+                // Delete matter node storage directory with its subdirectories
                 const dir = path.join(this.matterbridgeDirectory, 'matterstorage' + (getParameter('profile') ? '.' + getParameter('profile') : ''));
                 this.log.info(`Removing matter node storage directory: ${dir}`);
                 await fs.rm(dir, { recursive: true });
@@ -481,6 +590,7 @@ export class Matterbridge extends EventEmitter {
                 }
             }
             try {
+                // Delete node storage directory with its subdirectories
                 const dir = path.join(this.matterbridgeDirectory, 'storage' + (getParameter('profile') ? '.' + getParameter('profile') : ''));
                 this.log.info(`Removing storage directory: ${dir}`);
                 await fs.rm(dir, { recursive: true });
@@ -498,6 +608,7 @@ export class Matterbridge extends EventEmitter {
             this.emit('shutdown');
             return;
         }
+        // Start the matter storage and create the matterbridge context
         try {
             await this.startMatterStorage('json', path.join(this.matterbridgeDirectory, this.matterStorageName));
         }
@@ -505,6 +616,7 @@ export class Matterbridge extends EventEmitter {
             this.log.fatal(`Fatal error creating matter storage: ${error instanceof Error ? error.message : error}`);
             throw new Error(`Fatal error creating matter storage: ${error instanceof Error ? error.message : error}`);
         }
+        // Clear the matterbridge context if the reset parameter is set
         if (!this.edge && hasParameter('reset') && getParameter('reset') === undefined) {
             this.log.info('Resetting Matterbridge commissioning information...');
             await this.matterbridgeContext?.clearAll();
@@ -513,6 +625,7 @@ export class Matterbridge extends EventEmitter {
             this.emit('shutdown');
             return;
         }
+        // Clear matterbridge plugin context if the reset parameter is set
         if (!this.edge && hasParameter('reset') && getParameter('reset') !== undefined) {
             this.log.debug(`Reset plugin ${getParameter('reset')}`);
             const plugin = this.plugins.get(getParameter('reset'));
@@ -532,28 +645,34 @@ export class Matterbridge extends EventEmitter {
             this.emit('shutdown');
             return;
         }
+        // Initialize frontend
         if (getIntParameter('frontend') !== 0 || getIntParameter('frontend') === undefined)
             await this.initializeFrontend(getIntParameter('frontend'));
+        // Check each 60 minutes the latest versions
         this.checkUpdateInterval = setInterval(() => {
             this.getMatterbridgeLatestVersion();
             for (const plugin of this.plugins) {
                 this.getPluginLatestVersion(plugin);
             }
         }, 60 * 60 * 1000);
+        // Start the matterbridge in mode test
         if (hasParameter('test')) {
             this.bridgeMode = 'bridge';
             MatterbridgeDevice.bridgeMode = 'bridge';
             return;
         }
+        // Start the matterbridge in mode controller
         if (hasParameter('controller')) {
             this.bridgeMode = 'controller';
             await this.startController();
             return;
         }
+        // Check if the bridge mode is set and start matterbridge in bridge mode if not set
         if (!hasParameter('bridge') && !hasParameter('childbridge') && (await this.nodeContext?.get('bridgeMode', '')) === '') {
             this.log.info('Setting default matterbridge start mode to bridge');
             await this.nodeContext?.set('bridgeMode', 'bridge');
         }
+        // Start matterbridge in bridge mode
         if (hasParameter('bridge') || (!hasParameter('childbridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'bridge')) {
             this.bridgeMode = 'bridge';
             MatterbridgeDevice.bridgeMode = 'bridge';
@@ -562,6 +681,7 @@ export class Matterbridge extends EventEmitter {
             await this.startBridge();
             return;
         }
+        // Start matterbridge in childbridge mode
         if (hasParameter('childbridge') || (!hasParameter('bridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'childbridge')) {
             this.bridgeMode = 'childbridge';
             MatterbridgeDevice.bridgeMode = 'childbridge';
@@ -571,17 +691,28 @@ export class Matterbridge extends EventEmitter {
             return;
         }
     }
+    /**
+     * Asynchronously loads and starts the registered plugins.
+     *
+     * This method is responsible for initializing and staarting all enabled plugins.
+     * It ensures that each plugin is properly loaded and started before the ridge starts.
+     *
+     * @returns {Promise<void>} A promise that resolves when all plugins have been loaded and started.
+     */
     async startPlugins() {
+        // Check, load and start the plugins
         for (const plugin of this.plugins) {
             plugin.configJson = await this.plugins.loadConfig(plugin);
             plugin.schemaJson = await this.plugins.loadSchema(plugin);
+            // Check if the plugin is available
             if (!(await this.plugins.resolve(plugin.path))) {
                 this.log.error(`Plugin ${plg}${plugin.name}${er} not found or not validated. Disabling it.`);
                 plugin.enabled = false;
                 plugin.error = true;
                 continue;
             }
-            this.getPluginLatestVersion(plugin);
+            // Check if the plugin has a new version
+            this.getPluginLatestVersion(plugin); // No await do it asyncronously
             if (!plugin.enabled) {
                 this.log.info(`Plugin ${plg}${plugin.name}${nf} not enabled`);
                 continue;
@@ -596,20 +727,26 @@ export class Matterbridge extends EventEmitter {
             plugin.addedDevices = undefined;
             plugin.qrPairingCode = undefined;
             plugin.manualPairingCode = undefined;
-            this.plugins.load(plugin, true, 'Matterbridge is starting');
+            this.plugins.load(plugin, true, 'Matterbridge is starting'); // No await do it asyncronously
         }
         this.wssSendRefreshRequired();
     }
+    /**
+     * Registers the process handlers for uncaughtException, unhandledRejection, SIGINT and SIGTERM.
+     * When either of these signals are received, the cleanup method is called with an appropriate message.
+     */
     registerProcessHandlers() {
         this.log.debug(`Registering uncaughtException and unhandledRejection handlers...`);
         process.removeAllListeners('uncaughtException');
         process.removeAllListeners('unhandledRejection');
         this.exceptionHandler = async (error) => {
             this.log.fatal('Unhandled Exception detected at:', error.stack || error, rs);
+            // await this.cleanup('Unhandled Exception detected, cleaning up...');
         };
         process.on('uncaughtException', this.exceptionHandler);
         this.rejectionHandler = async (reason, promise) => {
             this.log.fatal('Unhandled Rejection detected at:', promise, 'reason:', reason instanceof Error ? reason.stack : reason, rs);
+            // await this.cleanup('Unhandled Rejection detected, cleaning up...');
         };
         process.on('unhandledRejection', this.rejectionHandler);
         this.log.debug(`Registering SIGINT and SIGTERM signal handlers...`);
@@ -622,6 +759,9 @@ export class Matterbridge extends EventEmitter {
         };
         process.on('SIGTERM', this.sigtermHandler);
     }
+    /**
+     * Deregisters the process uncaughtException, unhandledRejection, SIGINT and SIGTERM signal handlers.
+     */
     deregisterProcesslHandlers() {
         this.log.debug(`Deregistering uncaughtException and unhandledRejection handlers...`);
         if (this.exceptionHandler)
@@ -638,7 +778,11 @@ export class Matterbridge extends EventEmitter {
             process.off('SIGTERM', this.sigtermHandler);
         this.sigtermHandler = undefined;
     }
+    /**
+     * Logs the node and system information.
+     */
     async logNodeAndSystemInfo() {
+        // IP address information
         const networkInterfaces = os.networkInterfaces();
         this.systemInformation.ipv4Address = '';
         this.systemInformation.ipv6Address = '';
@@ -658,7 +802,7 @@ export class Matterbridge extends EventEmitter {
                     this.systemInformation.macAddress = detail.mac;
                 }
             }
-            if (this.systemInformation.ipv4Address !== '') {
+            if (this.systemInformation.ipv4Address !== '' /* && this.systemInformation.ipv6Address !== ''*/) {
                 this.log.debug(`Using interface: '${this.systemInformation.interfaceName}'`);
                 this.log.debug(`- with MAC address: '${this.systemInformation.macAddress}'`);
                 this.log.debug(`- with IPv4 address: '${this.systemInformation.ipv4Address}'`);
@@ -666,19 +810,22 @@ export class Matterbridge extends EventEmitter {
                 break;
             }
         }
+        // Node information
         this.systemInformation.nodeVersion = process.versions.node;
         const versionMajor = parseInt(this.systemInformation.nodeVersion.split('.')[0]);
         const versionMinor = parseInt(this.systemInformation.nodeVersion.split('.')[1]);
         const versionPatch = parseInt(this.systemInformation.nodeVersion.split('.')[2]);
+        // Host system information
         this.systemInformation.hostname = os.hostname();
         this.systemInformation.user = os.userInfo().username;
-        this.systemInformation.osType = os.type();
-        this.systemInformation.osRelease = os.release();
-        this.systemInformation.osPlatform = os.platform();
-        this.systemInformation.osArch = os.arch();
-        this.systemInformation.totalMemory = (os.totalmem() / 1024 / 1024 / 1024).toFixed(2) + ' GB';
-        this.systemInformation.freeMemory = (os.freemem() / 1024 / 1024 / 1024).toFixed(2) + ' GB';
-        this.systemInformation.systemUptime = (os.uptime() / 60 / 60).toFixed(2) + ' hours';
+        this.systemInformation.osType = os.type(); // "Windows_NT", "Darwin", etc.
+        this.systemInformation.osRelease = os.release(); // Kernel version
+        this.systemInformation.osPlatform = os.platform(); // "win32", "linux", "darwin", etc.
+        this.systemInformation.osArch = os.arch(); // "x64", "arm", etc.
+        this.systemInformation.totalMemory = (os.totalmem() / 1024 / 1024 / 1024).toFixed(2) + ' GB'; // Convert to GB
+        this.systemInformation.freeMemory = (os.freemem() / 1024 / 1024 / 1024).toFixed(2) + ' GB'; // Convert to GB
+        this.systemInformation.systemUptime = (os.uptime() / 60 / 60).toFixed(2) + ' hours'; // Convert to hours
+        // Log the system information
         this.log.debug('Host System Information:');
         this.log.debug(`- Hostname: ${this.systemInformation.hostname}`);
         this.log.debug(`- User: ${this.systemInformation.user}`);
@@ -694,15 +841,19 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`- Total Memory: ${this.systemInformation.totalMemory}`);
         this.log.debug(`- Free Memory: ${this.systemInformation.freeMemory}`);
         this.log.debug(`- System Uptime: ${this.systemInformation.systemUptime}`);
+        // Home directory
         this.homeDirectory = getParameter('homedir') ?? os.homedir();
         this.matterbridgeInformation.homeDirectory = this.homeDirectory;
         this.log.debug(`Home Directory: ${this.homeDirectory}`);
+        // Package root directory
         const currentFileDirectory = path.dirname(fileURLToPath(import.meta.url));
         this.rootDirectory = path.resolve(currentFileDirectory, '../');
         this.matterbridgeInformation.rootDirectory = this.rootDirectory;
         this.log.debug(`Root Directory: ${this.rootDirectory}`);
+        // Global node_modules directory
         if (this.nodeContext)
             this.globalModulesDirectory = await this.nodeContext.get('globalModulesDirectory', '');
+        // First run of Matterbridge so the node storage is empty
         if (this.globalModulesDirectory === '') {
             try {
                 this.globalModulesDirectory = await this.getGlobalNodeModules();
@@ -726,6 +877,7 @@ export class Matterbridge extends EventEmitter {
                 this.log.error(`Error getting global node_modules directory: ${error}`);
             });
         }
+        // Create the data directory .matterbridge in the home directory
         this.matterbridgeDirectory = path.join(this.homeDirectory, '.matterbridge');
         this.matterbridgeInformation.matterbridgeDirectory = this.matterbridgeDirectory;
         try {
@@ -749,6 +901,7 @@ export class Matterbridge extends EventEmitter {
             }
         }
         this.log.debug(`Matterbridge Directory: ${this.matterbridgeDirectory}`);
+        // Create the plugin directory Matterbridge in the home directory
         this.matterbridgePluginDirectory = path.join(this.homeDirectory, 'Matterbridge');
         this.matterbridgeInformation.matterbridgePluginDirectory = this.matterbridgePluginDirectory;
         try {
@@ -772,19 +925,28 @@ export class Matterbridge extends EventEmitter {
             }
         }
         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.matterbridgeInformation.matterbridgeVersion = this.matterbridgeVersion;
         this.log.debug(`Matterbridge Version: ${this.matterbridgeVersion}`);
+        // Matterbridge latest version
         if (this.nodeContext)
             this.matterbridgeLatestVersion = await this.nodeContext.get('matterbridgeLatestVersion', '');
         this.log.debug(`Matterbridge Latest Version: ${this.matterbridgeLatestVersion}`);
         this.getMatterbridgeLatestVersion();
+        // Current working directory
         const currentDir = process.cwd();
         this.log.debug(`Current Working Directory: ${currentDir}`);
+        // Command line arguments (excluding 'node' and the script name)
         const cmdArgs = process.argv.slice(2).join(' ');
         this.log.debug(`Command Line Arguments: ${cmdArgs}`);
     }
+    /**
+     * 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) => {
             this.execRunningCount++;
@@ -799,6 +961,10 @@ export class Matterbridge extends EventEmitter {
             });
         });
     }
+    /**
+     * Retrieves the path to the global Node.js modules directory.
+     * @returns A promise that resolves to the path of the global Node.js modules directory.
+     */
     async getGlobalNodeModules() {
         return new Promise((resolve, reject) => {
             this.execRunningCount++;
@@ -813,6 +979,11 @@ export class Matterbridge extends EventEmitter {
             });
         });
     }
+    /**
+     * Retrieves the latest version of Matterbridge and performs necessary actions based on the version comparison.
+     * @private
+     * @returns {Promise<void>} A promise that resolves when the latest version is retrieved and actions are performed.
+     */
     async getMatterbridgeLatestVersion() {
         this.getLatestVersion('matterbridge')
             .then(async (matterbridgeLatestVersion) => {
@@ -829,8 +1000,19 @@ export class Matterbridge extends EventEmitter {
         })
             .catch((error) => {
             this.log.error(`Error getting Matterbridge latest version: ${error.message}`);
+            // error.stack && this.log.debug(error.stack);
         });
     }
+    /**
+     * Retrieves the latest version of a plugin and updates the plugin's latestVersion property.
+     * If the plugin's version is different from the latest version, logs a warning message.
+     * If the plugin's version is the same as the latest version, logs an info message.
+     * If there is an error retrieving the latest version, logs an error message.
+     *
+     * @private
+     * @param {RegisteredPlugin} plugin - The plugin for which to retrieve the latest version.
+     * @returns {Promise<void>} A promise that resolves when the latest version is retrieved and actions are performed.
+     */
     async getPluginLatestVersion(plugin) {
         this.getLatestVersion(plugin.name)
             .then(async (latestVersion) => {
@@ -842,40 +1024,54 @@ export class Matterbridge extends EventEmitter {
         })
             .catch((error) => {
             this.log.error(`Error getting ${plg}${plugin.name}${er} latest version: ${error.message}`);
+            // error.stack && this.log.debug(error.stack);
         });
     }
+    /**
+     * Creates a MatterLogger function to show the matter.js log messages in AnsiLogger (for the frontend).
+     *
+     * @returns {Function} The MatterLogger function.
+     */
     createMatterLogger() {
-        const matterLogger = new AnsiLogger({ logName: 'Matter', logTimestampFormat: 4, logLevel: "debug" });
+        const matterLogger = new AnsiLogger({ logName: 'Matter', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: "debug" /* LogLevel.DEBUG */ });
         return (_level, formattedLog) => {
             const logger = formattedLog.slice(44, 44 + 20).trim();
             const message = formattedLog.slice(65);
             matterLogger.logName = logger;
             switch (_level) {
                 case MatterLogLevel.DEBUG:
-                    matterLogger.log("debug", message);
+                    matterLogger.log("debug" /* LogLevel.DEBUG */, message);
                     break;
                 case MatterLogLevel.INFO:
-                    matterLogger.log("info", message);
+                    matterLogger.log("info" /* LogLevel.INFO */, message);
                     break;
                 case MatterLogLevel.NOTICE:
-                    matterLogger.log("notice", message);
+                    matterLogger.log("notice" /* LogLevel.NOTICE */, message);
                     break;
                 case MatterLogLevel.WARN:
-                    matterLogger.log("warn", message);
+                    matterLogger.log("warn" /* LogLevel.WARN */, message);
                     break;
                 case MatterLogLevel.ERROR:
-                    matterLogger.log("error", message);
+                    matterLogger.log("error" /* LogLevel.ERROR */, message);
                     break;
                 case MatterLogLevel.FATAL:
-                    matterLogger.log("fatal", message);
+                    matterLogger.log("fatal" /* LogLevel.FATAL */, message);
                     break;
                 default:
-                    matterLogger.log("debug", message);
+                    matterLogger.log("debug" /* LogLevel.DEBUG */, message);
                     break;
             }
         };
     }
+    /**
+     * Creates a Matter File Logger.
+     *
+     * @param {string} filePath - The path to the log file.
+     * @param {boolean} [unlink=false] - Whether to unlink the log file before creating a new one.
+     * @returns {Function} - A function that logs formatted messages to the log file.
+     */
     async createMatterFileLogger(filePath, unlink = false) {
+        // 2024-08-21 08:55:19.488 DEBUG InteractionMessenger Sending DataReport chunk with 28 attributes and 0 events: 1004 bytes
         let fileSize = 0;
         if (unlink) {
             try {
@@ -924,18 +1120,30 @@ export class Matterbridge extends EventEmitter {
             }
         };
     }
+    /**
+     * Update matterbridge and cleanup.
+     */
     async updateProcess() {
         await this.cleanup('updating...', false);
     }
+    /**
+     * Restarts the process by spawning a new process and exiting the current process.
+     */
     async restartProcess() {
         await this.cleanup('restarting...', true);
     }
+    /**
+     * Shut down the process by exiting the current process.
+     */
     async shutdownProcess() {
         await this.cleanup('shutting down...', false);
     }
+    /**
+     * Shut down the process and reset.
+     */
     async unregisterAndShutdownProcess() {
         this.log.info('Unregistering all devices and shutting down...');
-        for (const plugin of this.plugins) {
+        for (const plugin of this.plugins /* .filter((plugin) => plugin.enabled && !plugin.error))*/) {
             if (this.edge)
                 await this.removeAllBridgedEndpoints(plugin.name);
             else
@@ -943,37 +1151,55 @@ export class Matterbridge extends EventEmitter {
         }
         await this.cleanup('unregistered all devices and shutting down...', false);
     }
+    /**
+     * Shut down the process and reset.
+     */
     async shutdownProcessAndReset() {
         await this.cleanup('shutting down with reset...', false);
     }
+    /**
+     * Shut down the process and factory reset.
+     */
     async shutdownProcessAndFactoryReset() {
         await this.cleanup('shutting down with factory reset...', false);
     }
+    /**
+     * Cleans up the Matterbridge instance.
+     * @param message - The cleanup message.
+     * @param restart - Indicates whether to restart the instance after cleanup. Default is `false`.
+     * @returns A promise that resolves when the cleanup is completed.
+     */
     async cleanup(message, restart = false) {
         if (this.initialized && !this.hasCleanupStarted) {
             this.hasCleanupStarted = true;
             this.log.info(message);
+            // Deregisters the process handlers
             this.deregisterProcesslHandlers();
+            // Clear the start matter interval
             if (this.startMatterInterval) {
                 clearInterval(this.startMatterInterval);
                 this.startMatterInterval = undefined;
                 this.log.debug('Start matter interval cleared');
             }
+            // Clear the check update interval
             if (this.checkUpdateInterval) {
                 clearInterval(this.checkUpdateInterval);
                 this.checkUpdateInterval = undefined;
                 this.log.debug('Check update interval cleared');
             }
+            // Clear the configure timeout
             if (this.configureTimeout) {
                 clearTimeout(this.configureTimeout);
                 this.configureTimeout = undefined;
                 this.log.debug('Matterbridge configure timeout cleared');
             }
+            // Clear the reachability timeout
             if (this.reachabilityTimeout) {
                 clearTimeout(this.reachabilityTimeout);
                 this.reachabilityTimeout = undefined;
                 this.log.debug('Matterbridge reachability timeout cleared');
             }
+            // Calling the shutdown method of each plugin and clear the reachability timeout
             for (const plugin of this.plugins) {
                 if (!plugin.enabled || plugin.error)
                     continue;
@@ -984,6 +1210,7 @@ export class Matterbridge extends EventEmitter {
                     this.log.debug(`Plugin ${plg}${plugin.name}${db} reachability timeout cleared`);
                 }
             }
+            // Convert the matter storage to the new format
             if (!hasParameter('nostorageconversion') && this.edge === false && this.matterbridgeContext && ['updating...', 'restarting...', 'shutting down...'].includes(message)) {
                 if (this.bridgeMode === 'bridge') {
                     await this.convertStorage(this.matterbridgeContext, 'Matterbridge');
@@ -996,24 +1223,29 @@ export class Matterbridge extends EventEmitter {
                     }
                 }
             }
+            // Close the http server
             if (this.httpServer) {
                 this.httpServer.close();
                 this.httpServer.removeAllListeners();
                 this.httpServer = undefined;
                 this.log.debug('Frontend http server closed successfully');
             }
+            // Close the https server
             if (this.httpsServer) {
                 this.httpsServer.close();
                 this.httpsServer.removeAllListeners();
                 this.httpsServer = undefined;
                 this.log.debug('Frontend https server closed successfully');
             }
+            // 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) {
+                // Close all active connections
                 this.webSocketServer.clients.forEach((client) => {
                     if (client.readyState === WebSocket.OPEN) {
                         client.close();
@@ -1029,26 +1261,35 @@ export class Matterbridge extends EventEmitter {
                 });
                 this.webSocketServer = undefined;
             }
+            // Closing matter
             await this.stopMatterServer();
+            // Closing matter storage
             await this.stopMatterStorage();
+            // Remove the matterfilelogger
             try {
                 Logger.removeLogger('matterfilelogger');
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
             }
             catch (error) {
+                // this.log.debug(`Error removing the matterfilelogger for file ${CYAN}${path.join(this.matterbridgeDirectory, this.matterLoggerFile)}${er}: ${error instanceof Error ? error.message : error}`);
             }
+            // Serialize registeredDevices
             if (this.nodeStorage && this.nodeContext) {
                 this.log.info('Saving registered devices...');
                 const serializedRegisteredDevices = [];
                 this.devices.forEach(async (device) => {
                     const serializedMatterbridgeDevice = device.serialize();
+                    // this.log.info(`- ${serializedMatterbridgeDevice.deviceName}${rs}\n`, serializedMatterbridgeDevice);
                     if (serializedMatterbridgeDevice)
                         serializedRegisteredDevices.push(serializedMatterbridgeDevice);
                 });
                 await this.nodeContext.set('devices', serializedRegisteredDevices);
                 this.log.info(`Saved registered devices (${serializedRegisteredDevices?.length})`);
+                // Clear nodeContext and nodeStorage (they just need 1000ms to write the data to disk)
                 this.log.debug(`Closing node storage context for ${plg}Matterbridge${db}...`);
                 await this.nodeContext.close();
                 this.nodeContext = undefined;
+                // Clear nodeContext for each plugin (they just need 1000ms to write the data to disk)
                 for (const plugin of this.plugins) {
                     if (plugin.nodeContext) {
                         this.log.debug(`Closing node storage context for plugin ${plg}${plugin.name}${db}...`);
@@ -1080,6 +1321,7 @@ export class Matterbridge extends EventEmitter {
             else {
                 if (message === 'shutting down with reset...' || message === 'shutting down with factory reset...') {
                     try {
+                        // Delete old matter storage file
                         const file = path.join(this.matterbridgeDirectory, 'matterbridge' + (getParameter('profile') ? '.' + getParameter('profile') : '') + '.json');
                         this.log.info(`Unlinking old matter storage file: ${file}`);
                         await fs.unlink(file);
@@ -1088,6 +1330,7 @@ export class Matterbridge extends EventEmitter {
                         this.log.debug(`Error resetting old matter storage file: ${error}`);
                     }
                     try {
+                        // Delete matter node storage directory with its subdirectories
                         const dir = path.join(this.matterbridgeDirectory, 'matterstorage' + (getParameter('profile') ? '.' + getParameter('profile') : ''));
                         this.log.info(`Removing matter node storage directory: ${dir}`);
                         await fs.rm(dir, { recursive: true });
@@ -1099,6 +1342,7 @@ export class Matterbridge extends EventEmitter {
                 }
                 if (message === 'shutting down with factory reset...') {
                     try {
+                        // Delete node storage directory with its subdirectories
                         this.log.info('Resetting Matterbridge storage...');
                         await fs.rm(path.join(this.matterbridgeDirectory, this.nodeStorageName), { recursive: true });
                     }
@@ -1115,19 +1359,33 @@ export class Matterbridge extends EventEmitter {
             this.initialized = false;
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async addBridgedEndpoint(pluginName, device) {
+        // Nothing to do here
     }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async removeBridgedEndpoint(pluginName, device) {
+        // Nothing to do here
     }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async removeAllBridgedEndpoints(pluginName) {
+        // Nothing to do here
     }
+    /**
+     * Adds a bridged device to the Matterbridge.
+     * @param pluginName - The name of the plugin.
+     * @param device - The bridged device to add.
+     * @returns {Promise<void>} - A promise that resolves when the device is added.
+     */
     async addBridgedDevice(pluginName, device) {
         this.log.debug(`Adding bridged device ${dev}${device.deviceName}${db} (${zb}${device.name}${db}) for plugin ${plg}${pluginName}${db}`);
+        // Check if the plugin is registered
         const plugin = this.plugins.get(pluginName);
         if (!plugin) {
             this.log.error(`Error adding bridged device ${dev}${device.deviceName}${er} (${zb}${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') {
             if (!this.matterAggregator) {
                 this.log.error(`Adding bridged device ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) for plugin ${plg}${pluginName}${er} error: matterAggregator not found`);
@@ -1135,8 +1393,11 @@ export class Matterbridge extends EventEmitter {
             }
             this.matterAggregator.addBridgedDevice(device);
         }
+        // The first time create the commissioning server and the aggregator for DynamicPlatform
+        // Register and add the device in childbridge mode
         if (this.bridgeMode === 'childbridge') {
             if (plugin.type === 'AccessoryPlatform') {
+                // Check if the plugin is locked with the commissioning server
                 if (!plugin.locked) {
                     plugin.locked = true;
                     plugin.storageContext = await this.importCommissioningServerContext(plugin.name, device);
@@ -1150,6 +1411,7 @@ export class Matterbridge extends EventEmitter {
                 }
             }
             if (plugin.type === 'DynamicPlatform') {
+                // Check if the plugin is locked with the commissioning server and the aggregator
                 if (!plugin.locked) {
                     plugin.locked = true;
                     this.log.debug(`Creating commissioning server context for ${plg}${plugin.name}${db}`);
@@ -1170,16 +1432,25 @@ export class Matterbridge extends EventEmitter {
             plugin.registeredDevices++;
         if (plugin.addedDevices !== undefined)
             plugin.addedDevices++;
+        // Add the device to the DeviceManager
         this.devices.set(device);
         this.log.info(`Added and registered bridged device (${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${dev}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
     }
+    /**
+     * Removes a bridged device from the Matterbridge.
+     * @param pluginName - The name of the plugin.
+     * @param device - The device to be removed.
+     * @returns A Promise that resolves when the device is successfully removed.
+     */
     async removeBridgedDevice(pluginName, device) {
         this.log.debug(`Removing bridged device ${dev}${device.deviceName}${db} (${zb}${device.name}${db}) for plugin ${plg}${pluginName}${db}`);
+        // Check if the plugin is registered
         const plugin = this.plugins.get(pluginName);
         if (!plugin) {
             this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) for plugin ${plg}${pluginName}${er}: plugin not found`);
             return;
         }
+        // Remove the device from matterbridge aggregator in bridge mode
         if (this.bridgeMode === 'bridge') {
             if (!this.matterAggregator) {
                 this.log.error(`Error removing bridged device ${dev}${device.deviceName}${er} (${zb}${device.name}${er}) for plugin ${plg}${pluginName}${er}: matterAggregator not found`);
@@ -1189,6 +1460,8 @@ export class Matterbridge extends EventEmitter {
                 device.setBridgedDeviceReachability(false);
                 device.getClusterServerById(BridgedDeviceBasicInformation.Cluster.id)?.triggerReachableChangedEvent({ reachableNewValue: false });
             }
+            // device.getClusterServerById(BridgedDeviceBasicInformation.Cluster.id)?.triggerShutDownEvent({});
+            // device.getClusterServerById(BridgedDeviceBasicInformation.Cluster.id)?.triggerLeaveEvent({});
             this.matterAggregator?.removeBridgedDevice(device);
             this.log.info(`Removed bridged device(${plugin.registeredDevices}/${plugin.addedDevices}) ${dev}${device.deviceName}${nf} (${zb}${device.name}${nf}) for plugin ${plg}${pluginName}${nf}`);
             if (plugin.registeredDevices !== undefined)
@@ -1196,6 +1469,7 @@ export class Matterbridge extends EventEmitter {
             if (plugin.addedDevices !== undefined)
                 plugin.addedDevices--;
         }
+        // Remove the device in childbridge mode
         if (this.bridgeMode === 'childbridge') {
             if (plugin.type === 'AccessoryPlatform') {
                 if (!plugin.commissioningServer) {
@@ -1219,14 +1493,22 @@ export class Matterbridge extends EventEmitter {
                 plugin.registeredDevices--;
             if (plugin.addedDevices !== undefined)
                 plugin.addedDevices--;
+            // Remove the commissioning server
             if (plugin.registeredDevices === 0 && plugin.addedDevices === 0 && plugin.commissioningServer) {
                 this.matterServer?.removeCommissioningServer(plugin.commissioningServer);
                 plugin.commissioningServer = undefined;
                 this.log.info(`Removed commissioning server for plugin ${plg}${pluginName}${nf}`);
             }
         }
+        // Remove the device from the DeviceManager
         this.devices.remove(device);
     }
+    /**
+     * Removes all bridged devices associated with a specific plugin.
+     *
+     * @param pluginName - The name of the plugin.
+     * @returns A promise that resolves when all devices have been removed.
+     */
     async removeAllBridgedDevices(pluginName) {
         this.log.debug(`Removing all bridged devices for plugin ${plg}${pluginName}${db}`);
         this.devices.forEach(async (device) => {
@@ -1235,7 +1517,13 @@ export class Matterbridge extends EventEmitter {
             }
         });
     }
+    /**
+     * Starts the Matterbridge in bridge mode.
+     * @private
+     * @returns {Promise<void>} A promise that resolves when the Matterbridge is started.
+     */
     async startBridge() {
+        // Plugins are configured by a timer when matter server is started and plugin.configured is set to true
         if (!this.storageManager)
             throw new Error('No storage manager initialized');
         if (!this.matterbridgeContext)
@@ -1254,6 +1542,7 @@ export class Matterbridge extends EventEmitter {
         let failCount = 0;
         this.startMatterInterval = setInterval(async () => {
             for (const plugin of this.plugins) {
+                // new code to not start the bridge if one plugin is in error cause the controllers will delete the devices loosing all the configuration
                 if (!plugin.enabled)
                     continue;
                 if (plugin.error) {
@@ -1278,15 +1567,18 @@ export class Matterbridge extends EventEmitter {
             clearInterval(this.startMatterInterval);
             this.startMatterInterval = undefined;
             this.log.debug('Cleared startMatterInterval interval for Matterbridge');
+            // Start the Matter server
             await this.startMatterServer();
             this.log.notice('Matter server started');
+            // Show the QR code for commissioning or log the already commissioned message
             await this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, this.nodeContext, 'Matterbridge');
+            // Configure the plugins
             this.configureTimeout = setTimeout(async () => {
                 for (const plugin of this.plugins) {
                     if (!plugin.enabled || !plugin.loaded || !plugin.started || plugin.error)
                         continue;
                     try {
-                        await this.plugins.configure(plugin);
+                        await this.plugins.configure(plugin); // TODO No await do it in parallel
                     }
                     catch (error) {
                         plugin.error = true;
@@ -1295,6 +1587,7 @@ export class Matterbridge extends EventEmitter {
                 }
                 this.wssSendRefreshRequired();
             }, 30 * 1000);
+            // Setting reachability to true
             this.reachabilityTimeout = setTimeout(() => {
                 this.log.info(`Setting reachability to true for ${plg}Matterbridge${db}`);
                 if (this.commissioningServer)
@@ -1304,7 +1597,14 @@ export class Matterbridge extends EventEmitter {
             }, 60 * 1000);
         }, 1000);
     }
+    /**
+     * Starts the Matterbridge in childbridge mode.
+     * @private
+     * @returns {Promise<void>} A promise that resolves when the Matterbridge is started.
+     */
     async startChildbridge() {
+        // Matterbridge.addBridgedDevice creates the commissionig servers and add the devices to the the commissioning server or to the aggregator
+        // Plugins are configured by a timer when matter server is started and plugin.configured is set to true
         if (!this.storageManager)
             throw new Error('No storage manager initialized');
         this.matterServer = await this.createMatterServer(this.storageManager);
@@ -1314,6 +1614,7 @@ export class Matterbridge extends EventEmitter {
         this.startMatterInterval = setInterval(async () => {
             let allStarted = true;
             for (const plugin of this.plugins) {
+                // Prevents to start the bridge if one plugin is in error cause the controllers will delete the devices loosing all the configuration
                 if (!plugin.enabled)
                     continue;
                 if (plugin.error) {
@@ -1341,14 +1642,16 @@ export class Matterbridge extends EventEmitter {
             clearInterval(this.startMatterInterval);
             this.startMatterInterval = undefined;
             this.log.debug('Cleared startMatterInterval interval in childbridge mode');
+            // Start the Matter server
             await this.startMatterServer();
             this.log.notice('Matter server started');
+            // Configure the plugins
             this.configureTimeout = setTimeout(async () => {
                 for (const plugin of this.plugins) {
                     if (!plugin.enabled || !plugin.loaded || !plugin.started || plugin.error)
                         continue;
                     try {
-                        await this.plugins.configure(plugin);
+                        await this.plugins.configure(plugin); // TODO No await do it in parallel
                     }
                     catch (error) {
                         plugin.error = true;
@@ -1377,6 +1680,7 @@ export class Matterbridge extends EventEmitter {
                     continue;
                 }
                 await this.showCommissioningQRCode(plugin.commissioningServer, plugin.storageContext, plugin.nodeContext, plugin.name);
+                // Setting reachability to true
                 plugin.reachabilityTimeout = setTimeout(() => {
                     this.log.info(`Setting reachability to true for ${plg}${plugin.name}${db}`);
                     if (plugin.commissioningServer)
@@ -1389,6 +1693,11 @@ export class Matterbridge extends EventEmitter {
             }
         }, 1000);
     }
+    /**
+     * Starts the Matterbridge controller.
+     * @private
+     * @returns {Promise<void>} A promise that resolves when the Matterbridge is started.
+     */
     async startController() {
         if (!this.storageManager) {
             this.log.error('No storage manager initialized');
@@ -1451,7 +1760,7 @@ export class Matterbridge extends EventEmitter {
             const nodeId = await this.commissioningController.commissionNode(options);
             this.log.info(`Commissioning successfully done with nodeId: ${nodeId}`);
             this.log.info('ActiveSessionInformation:', this.commissioningController.getActiveSessionInformation());
-        }
+        } // (hasParameter('pairingcode'))
         if (hasParameter('unpairall')) {
             this.log.info('***Commissioning controller unpairing all nodes...');
             const nodeIds = this.commissioningController.getCommissionedNodes();
@@ -1462,6 +1771,8 @@ export class Matterbridge extends EventEmitter {
             return;
         }
         if (hasParameter('discover')) {
+            // const discover = await this.commissioningController.discoverCommissionableDevices({ productId: 0x8000, deviceType: 0xfff1 });
+            // console.log(discover);
         }
         if (!this.commissioningController.isCommissioned()) {
             this.log.info('***Commissioning controller is not commissioned: use matterbridge -controller -pairingcode [pairingcode] to commission a device');
@@ -1502,10 +1813,12 @@ export class Matterbridge extends EventEmitter {
                 },
             });
             node.logStructure();
+            // Get the interaction client
             this.log.info('Getting the interaction client');
             const interactionClient = await node.getInteractionClient();
             let cluster;
             let attributes;
+            // Log BasicInformationCluster
             cluster = BasicInformationCluster;
             attributes = await interactionClient.getMultipleAttributes({
                 attributes: [{ clusterId: cluster.id }],
@@ -1515,6 +1828,7 @@ export class Matterbridge extends EventEmitter {
             attributes.forEach((attribute) => {
                 this.log.info(`- endpoint ${or}${attribute.path.endpointId}${nf} cluster ${hk}${getClusterNameById(attribute.path.clusterId)}${nf} (${hk}0x${attribute.path.clusterId.toString(16)}${nf}) attribute ${zb}${attribute.path.attributeName}${nf} (${zb}0x${attribute.path.attributeId.toString(16)}${nf}): ${typeof attribute.value === 'object' ? stringify(attribute.value) : attribute.value}`);
             });
+            // Log PowerSourceCluster
             cluster = PowerSourceCluster;
             attributes = await interactionClient.getMultipleAttributes({
                 attributes: [{ clusterId: cluster.id }],
@@ -1524,6 +1838,7 @@ export class Matterbridge extends EventEmitter {
             attributes.forEach((attribute) => {
                 this.log.info(`- endpoint ${or}${attribute.path.endpointId}${nf} cluster ${hk}${getClusterNameById(attribute.path.clusterId)}${nf} (${hk}0x${attribute.path.clusterId.toString(16)}${nf}) attribute ${zb}${attribute.path.attributeName}${nf} (${zb}0x${attribute.path.attributeId.toString(16)}${nf}): ${typeof attribute.value === 'object' ? stringify(attribute.value) : attribute.value}`);
             });
+            // Log ThreadNetworkDiagnostics
             cluster = ThreadNetworkDiagnosticsCluster;
             attributes = await interactionClient.getMultipleAttributes({
                 attributes: [{ clusterId: cluster.id }],
@@ -1533,6 +1848,7 @@ export class Matterbridge extends EventEmitter {
             attributes.forEach((attribute) => {
                 this.log.info(`- endpoint ${or}${attribute.path.endpointId}${nf} cluster ${hk}${getClusterNameById(attribute.path.clusterId)}${nf} (${hk}0x${attribute.path.clusterId.toString(16)}${nf}) attribute ${zb}${attribute.path.attributeName}${nf} (${zb}0x${attribute.path.attributeId.toString(16)}${nf}): ${typeof attribute.value === 'object' ? stringify(attribute.value) : attribute.value}`);
             });
+            // Log SwitchCluster
             cluster = SwitchCluster;
             attributes = await interactionClient.getMultipleAttributes({
                 attributes: [{ clusterId: cluster.id }],
@@ -1553,6 +1869,15 @@ export class Matterbridge extends EventEmitter {
             this.log.info('Subscribed to all attributes and events');
         }
     }
+    /** ***********************************************************************************************************************************/
+    /**                                                     Matter.js methods                                                             */
+    /** ***********************************************************************************************************************************/
+    /**
+     * Starts the matter storage process based on the specified storage type and name.
+     * @param {string} storageType - The type of storage to start (e.g., 'disk', 'json').
+     * @param {string} storageName - The name of the storage file.
+     * @returns {Promise<void>} - A promise that resolves when the storage process is started.
+     */
     async startMatterStorage(storageType, storageName) {
         this.log.debug(`Starting matter ${storageType} storage ${CYAN}${storageName}${db}`);
         if (storageType === 'disk') {
@@ -1601,6 +1926,12 @@ export class Matterbridge extends EventEmitter {
         await this.matterbridgeContext.set('passcode', this.passcode);
         await this.matterbridgeContext.set('discriminator', this.discriminator);
     }
+    /**
+     * Convert the old API matter storage to the new API format.
+     * @param {StorageContext} context - The context of Matterbridge or of the plugin.
+     * @param {string} pluginName - The name of the plugin or Matterbridge.
+     * @returns {Promise<void>} - A promise that resolves when the storage process is started.
+     */
     async convertStorage(context, pluginName) {
         if (this.edge !== false)
             return;
@@ -1615,13 +1946,19 @@ export class Matterbridge extends EventEmitter {
             else {
                 this.log.notice(`Converting matter node storage to Matterbridge edge for ${plg}${pluginName}${nt}...`);
             }
+            // Read FabricManager from the old storage and get FabricManager.fabrics and FabricManager.nextFabricIndex
             const fabricManagerContext = context.createContext('FabricManager');
             const fabrics = (await fabricManagerContext.get('fabrics', []));
             const nextFabricIndex = await fabricManagerContext.get('nextFabricIndex', 0);
+            // Read EventHandler from the old storage
             const eventHandlerContext = context.createContext('EventHandler');
+            // Read SessionManager from the old storage
             const sessionManagerContext = context.createContext('SessionManager');
+            // Read EndpointStructure from the old storage
             const endpointStructureContext = context.createContext('EndpointStructure');
+            // Read generalCommissioning from the old storage
             const generalCommissioningContext = context.createContext('Cluster-0-48');
+            // Read basicInformation from the old storage
             const basicInformationContext = context.createContext('Cluster-0-40');
             const fabricInfo = {};
             const fabricInfoArray = [];
@@ -1675,8 +2012,13 @@ export class Matterbridge extends EventEmitter {
             await nodeStorage.createContext('root').createContext('commissioning').set('fabrics', fabricInfo);
             await nodeStorage.createContext('root').createContext('operationalCredentials').set('commissionedFabrics', fabricInfoArray.length);
             await nodeStorage.createContext('root').createContext('operationalCredentials').set('fabrics', fabricInfoArray);
+            // operationalCredentials.nocs ==>> [{noc: fabric.operationalCert, icac: null, fabricIndex: fabric.fabricIndex }]
             await nodeStorage.createContext('root').createContext('operationalCredentials').set('nocs', nocArray);
+            // operationalCredentials.trustedRootCertificates ==>> ["{\"__object__\":\"Uint8Array\",\"__value__\":\"" + fabric.rootCert + "\"}"]
             await nodeStorage.createContext('root').createContext('operationalCredentials').set('trustedRootCertificates', trcArray);
+            // ACL updated, updating ACL manager { fabricIndex: 3, privilege: 5, authMode: 2, subjects: [ 18446744060825763897 ], targets: null }
+            // From fabric.rootNodeId if fabric.scopedClusterData.get(0x1f).get('acl') is empty
+            // [{"fabricIndex":3,"privilege":5,"authMode":2,"subjects":["{\"__object__\":\"BigInt\",\"__value__\":\"18446744060825763897\"}"],"targets":null}]
             await nodeStorage.createContext('root').createContext('accessControl').set('acl', aclArray);
             await nodeStorage
                 .createContext('root')
@@ -1699,6 +2041,25 @@ export class Matterbridge extends EventEmitter {
                 .createContext('root')
                 .createContext('productDescription')
                 .set('vendorId', await context.get('vendorId', 0xfff1));
+            /*
+            "Matterbridge.EndpointStructure": {
+              "unique_d60ca095a002f160-index_0": 1,
+              "unique_d60ca095a002f160-index_0-custom_Switch0": 2,
+              "unique_d60ca095a002f160-index_0-custom_Outlet0": 3,
+              "unique_d60ca095a002f160-index_0-custom_Light0": 4,
+              "unique_d60ca095a002f160-index_0-unique_7ddb4752b982ee108d5928e934f0fcfa": 2,
+              "unique_d60ca095a002f160-index_0-unique_7ddb4752b982ee108d5928e934f0fcfa-custom_PowerSource": 3,
+              "unique_d60ca095a002f160-index_0-unique_7ddb4752b982ee108d5928e934f0fcfa-custom_light:0": 4,
+              "unique_d60ca095a002f160-index_0-unique_7ddb4752b982ee108d5928e934f0fcfa-custom_light:1": 5,
+              "unique_d60ca095a002f160-index_0-unique_7ddb4752b982ee108d5928e934f0fcfa-custom_light:2": 6,
+              "unique_d60ca095a002f160-index_0-unique_7ddb4752b982ee108d5928e934f0fcfa-custom_light:3": 7,
+              "unique_d60ca095a002f160-index_0-unique_7ddb4752b982ee108d5928e934f0fcfa-custom_meter:0": 8,
+              "unique_d60ca095a002f160-index_0-unique_7ddb4752b982ee108d5928e934f0fcfa-custom_meter:1": 9,
+              "unique_d60ca095a002f160-index_0-unique_7ddb4752b982ee108d5928e934f0fcfa-custom_meter:2": 10,
+              "unique_d60ca095a002f160-index_0-unique_7ddb4752b982ee108d5928e934f0fcfa-custom_meter:3": 11,
+              "nextEndpointId": 5
+            },
+            */
             const rootDeviceName = (await context.get('deviceName', '')).replace(/[ .]/g, '');
             this.log.info(`Converting ${pluginName}.EndpointStructure to root.parts.${rootDeviceName}...`);
             for (const key of await endpointStructureContext.keys()) {
@@ -1777,6 +2138,12 @@ export class Matterbridge extends EventEmitter {
             this.log.error(`convertStorage error converting matter storage to Matterbridge edge for ${plg}${pluginName}${er}:`, error);
         }
     }
+    /**
+     * Makes a backup copy of the specified matter JSON storage file.
+     *
+     * @param storageName - The name of the JSON storage file to be backed up.
+     * @param backupName - The name of the backup file to be created.
+     */
     async backupMatterStorage(storageName, backupName) {
         try {
             this.log.debug(`Making backup copy of ${storageName}`);
@@ -1797,6 +2164,12 @@ export class Matterbridge extends EventEmitter {
             }
         }
     }
+    /**
+     * Restore the specified matter JSON storage file.
+     *
+     * @param backupName - The name of the backup file to restore from.
+     * @param storageName - The name of the JSON storage file to restored.
+     */
     async restoreMatterStorage(backupName, storageName) {
         try {
             this.log.notice(`Restoring the backup copy of ${storageName}`);
@@ -1817,6 +2190,10 @@ export class Matterbridge extends EventEmitter {
             }
         }
     }
+    /**
+     * Stops the matter storage.
+     * @returns {Promise<void>} A promise that resolves when the storage is stopped.
+     */
     async stopMatterStorage() {
         this.log.debug('Stopping storage');
         await this.storageManager?.close();
@@ -1825,8 +2202,14 @@ export class Matterbridge extends EventEmitter {
         this.matterbridgeContext = undefined;
         this.mattercontrollerContext = undefined;
     }
+    /**
+     * Creates a Matter server using the provided storage manager and the provided mdnsInterface.
+     * @param storageManager The storage manager to be used by the Matter server.
+     *
+     */
     async createMatterServer(storageManager) {
         this.log.debug('Creating matter server');
+        // Validate mdnsInterface
         if (this.mdnsInterface) {
             const networkInterfaces = os.networkInterfaces();
             const availableInterfaces = Object.keys(networkInterfaces);
@@ -1842,6 +2225,10 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`Created matter server with mdnsInterface: ${this.mdnsInterface ?? 'all available interfaces'}`);
         return matterServer;
     }
+    /**
+     * Starts the Matter server.
+     * If the Matter server is not initialized, it logs an error and performs cleanup.
+     */
     async startMatterServer() {
         if (!this.matterServer) {
             this.log.error('No matter server initialized');
@@ -1851,7 +2238,11 @@ export class Matterbridge extends EventEmitter {
         this.log.debug('Starting matter server...');
         await this.matterServer.start();
         this.log.debug('Started matter server');
+        // this.commissioningServer?.getRootEndpoint() && logEndpoint(this.commissioningServer?.getRootEndpoint());
     }
+    /**
+     * Stops the Matter server, commissioningServer and commissioningController.
+     */
     async stopMatterServer() {
         this.log.debug('Stopping matter commissioningServer');
         await this.commissioningServer?.close();
@@ -1865,23 +2256,35 @@ export class Matterbridge extends EventEmitter {
         this.matterAggregator = undefined;
         this.matterServer = undefined;
     }
+    /**
+     * Creates a Matter Aggregator.
+     * @param {StorageContext} context - The storage context.
+     * @returns {Aggregator} - The created Matter Aggregator.
+     */
     async createMatterAggregator(context, pluginName) {
         this.log.debug(`Creating matter aggregator for ${plg}${pluginName}${db}`);
         const matterAggregator = new Aggregator();
         return matterAggregator;
     }
+    /**
+     * Creates a matter commissioning server.
+     *
+     * @param {StorageContext} context - The storage context.
+     * @param {string} pluginName - The name of the commissioning server.
+     * @returns {CommissioningServer} The created commissioning server.
+     */
     async createCommisioningServer(context, pluginName) {
         this.log.debug(`Creating matter commissioning server for plugin ${plg}${pluginName}${db}`);
         const deviceName = await context.get('deviceName');
         const deviceType = await context.get('deviceType');
         const vendorId = await context.get('vendorId');
-        const vendorName = await context.get('vendorName');
+        const vendorName = await context.get('vendorName'); // Home app = Manufacturer
         const productId = await context.get('productId');
-        const productName = await context.get('productName');
+        const productName = await context.get('productName'); // Home app = Model
         const serialNumber = await context.get('serialNumber');
         const uniqueId = await context.get('uniqueId');
         const softwareVersion = await context.get('softwareVersion', 1);
-        const softwareVersionString = await context.get('softwareVersionString', '1.0.0');
+        const softwareVersionString = await context.get('softwareVersionString', '1.0.0'); // Home app = Firmware Revision
         const hardwareVersion = await context.get('hardwareVersion', 1);
         const hardwareVersionString = await context.get('hardwareVersionString', '1.0.0');
         this.log.debug(`Creating matter commissioning server for plugin ${plg}${pluginName}${db} with deviceName '${deviceName}' deviceType ${deviceType}(0x${deviceType.toString(16).padStart(4, '0')})`);
@@ -1889,6 +2292,7 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`Creating matter commissioning server for plugin ${plg}${pluginName}${db} with softwareVersion ${softwareVersion} softwareVersionString ${softwareVersionString}`);
         this.log.debug(`Creating matter commissioning server for plugin ${plg}${pluginName}${db} with hardwareVersion ${hardwareVersion} hardwareVersionString ${hardwareVersionString}`);
         this.log.debug(`Creating matter commissioning server for plugin ${plg}${pluginName}${db} with nodeLabel '${productName}' port ${CYAN}${this.port}${db} discriminator ${CYAN}${this.discriminator}${db} passcode ${CYAN}${this.passcode}${db} `);
+        // Validate ipv4address
         if (this.ipv4address) {
             const networkInterfaces = os.networkInterfaces();
             const availableAddresses = Object.values(networkInterfaces)
@@ -1903,6 +2307,7 @@ export class Matterbridge extends EventEmitter {
                 this.log.info(`Using ipv4address '${this.ipv4address}' for the Matter commissioning server.`);
             }
         }
+        // Validate ipv6address
         if (this.ipv6address) {
             const networkInterfaces = os.networkInterfaces();
             const availableAddresses = Object.values(networkInterfaces)
@@ -1933,7 +2338,7 @@ export class Matterbridge extends EventEmitter {
                 nodeLabel: productName,
                 productLabel: productName,
                 softwareVersion,
-                softwareVersionString,
+                softwareVersionString, // Home app = Firmware Revision
                 hardwareVersion,
                 hardwareVersionString,
                 uniqueId,
@@ -2029,6 +2434,24 @@ export class Matterbridge extends EventEmitter {
         commissioningServer.addCommandHandler('testEventTrigger', async ({ request: { enableKey, eventTrigger } }) => this.log.info(`testEventTrigger called on GeneralDiagnostic cluster: ${enableKey} ${eventTrigger}`));
         return commissioningServer;
     }
+    /**
+     * Creates a commissioning server storage context.
+     *
+     * @param pluginName - The name of the plugin.
+     * @param deviceName - The name of the device.
+     * @param deviceType - The type of the device.
+     * @param vendorId - The vendor ID.
+     * @param vendorName - The vendor name.
+     * @param productId - The product ID.
+     * @param productName - The product name.
+     * @param serialNumber - The serial number of the device (optional).
+     * @param uniqueId - The unique ID of the device (optional).
+     * @param softwareVersion - The software version of the device (optional).
+     * @param softwareVersionString - The software version string of the device (optional).
+     * @param hardwareVersion - The hardware version of the device (optional).
+     * @param hardwareVersionString - The hardware version string of the device (optional).
+     * @returns The storage context for the commissioning server.
+     */
     async createCommissioningServerContext(pluginName, deviceName, deviceType, vendorId, vendorName, productId, productName) {
         if (!this.storageManager)
             throw new Error('No storage manager initialized');
@@ -2056,6 +2479,13 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`- hardwareVersion: ${await storageContext.get('hardwareVersion')} hardwareVersionString: ${await storageContext.get('hardwareVersionString')}`);
         return storageContext;
     }
+    /**
+     * Imports the commissioning server context for a specific plugin and device.
+     * @param pluginName - The name of the plugin.
+     * @param device - The MatterbridgeDevice object representing the device.
+     * @returns The commissioning server context.
+     * @throws Error if the BasicInformationCluster is not found.
+     */
     async importCommissioningServerContext(pluginName, device) {
         this.log.debug(`Importing matter commissioning server storage context from device for ${plg}${pluginName}${db}`);
         const basic = device.getClusterServer(BasicInformationCluster);
@@ -2090,6 +2520,14 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`- hardwareVersion: ${await storageContext.get('hardwareVersion')} hardwareVersionString: ${await storageContext.get('hardwareVersionString')}`);
         return storageContext;
     }
+    /**
+     * Shows the commissioning server QR code for a given plugin.
+     * @param {CommissioningServer} commissioningServer - The commissioning server instance.
+     * @param {StorageContext} storageContext - The storage context instance.
+     * @param {NodeStorage} nodeContext - The node storage instance.
+     * @param {string} pluginName - The name of the plugin of Matterbridge in bridge mode.
+     * @returns {Promise<void>} - A promise that resolves when the QR code is shown.
+     */
     async showCommissioningQRCode(commissioningServer, storageContext, nodeContext, pluginName) {
         if (!commissioningServer || !storageContext || !nodeContext || !pluginName) {
             this.log.error(`showCommissioningQRCode error: commissioningServer: ${!commissioningServer} storageContext: ${!storageContext} nodeContext: ${!nodeContext} pluginName: ${pluginName}`);
@@ -2100,7 +2538,8 @@ export class Matterbridge extends EventEmitter {
             const { qrPairingCode, manualPairingCode } = commissioningServer.getPairingCode();
             const QrCode = new QrCodeSchema();
             this.log.info(`*The commissioning server on port ${commissioningServer.getPort()} for ${plg}${pluginName}${nf} is not commissioned. Pair it scanning the QR code:\n\n`);
-            if (this.log.logLevel === "debug" || this.log.logLevel === "info")
+            // eslint-disable-next-line no-console
+            if (this.log.logLevel === "debug" /* LogLevel.DEBUG */ || this.log.logLevel === "info" /* LogLevel.INFO */)
                 console.log(`${QrCode.encode(qrPairingCode)}\n`);
             this.log.info(`${plg}${pluginName}${nf} \n\nqrPairingCode: ${qrPairingCode} \n\nManual pairing code: ${manualPairingCode}\n`);
             if (pluginName === 'Matterbridge') {
@@ -2147,6 +2586,12 @@ export class Matterbridge extends EventEmitter {
         }
         this.wssSendRefreshRequired();
     }
+    /**
+     * Sanitizes the fabric information by converting bigint properties to string cause res.json doesn't know bigint.
+     *
+     * @param fabricInfo - The array of exposed fabric information objects.
+     * @returns An array of sanitized exposed fabric information objects.
+     */
     sanitizeFabricInformations(fabricInfo) {
         return fabricInfo.map((info) => {
             return {
@@ -2160,6 +2605,12 @@ export class Matterbridge extends EventEmitter {
             };
         });
     }
+    /**
+     * Sanitizes the session information by converting bigint properties to string.
+     *
+     * @param sessionInfo - The array of session information objects.
+     * @returns An array of sanitized session information objects.
+     */
     sanitizeSessionInformation(sessionInfo) {
         return sessionInfo
             .filter((session) => session.isPeerActive)
@@ -2187,6 +2638,12 @@ export class Matterbridge extends EventEmitter {
             };
         });
     }
+    /**
+     * Sets the reachability of a commissioning server and trigger.
+     *
+     * @param {CommissioningServer} commissioningServer - The commissioning server to set the reachability for.
+     * @param {boolean} reachable - The new reachability status.
+     */
     setCommissioningServerReachability(commissioningServer, reachable) {
         const basicInformationCluster = commissioningServer?.getRootClusterServer(BasicInformationCluster);
         if (basicInformationCluster && basicInformationCluster.attributes.reachable !== undefined)
@@ -2194,6 +2651,11 @@ export class Matterbridge extends EventEmitter {
         if (basicInformationCluster && basicInformationCluster.triggerReachableChangedEvent)
             basicInformationCluster.triggerReachableChangedEvent({ reachableNewValue: reachable });
     }
+    /**
+     * Sets the reachability of the specified matter aggregator and its bridged devices and trigger.
+     * @param {Aggregator} matterAggregator - The matter aggregator to set the reachability for.
+     * @param {boolean} reachable - A boolean indicating the reachability status to set.
+     */
     setAggregatorReachability(matterAggregator, reachable) {
         const basicInformationCluster = matterAggregator.getClusterServer(BasicInformationCluster);
         if (basicInformationCluster && basicInformationCluster.attributes.reachable !== undefined)
@@ -2206,6 +2668,12 @@ export class Matterbridge extends EventEmitter {
             device.getClusterServer(BridgedDeviceBasicInformationCluster)?.triggerReachableChangedEvent({ reachableNewValue: reachable });
         });
     }
+    /**
+     * Sets the reachability of a device and trigger.
+     *
+     * @param {MatterbridgeDevice} device - The device to set the reachability for.
+     * @param {boolean} reachable - The new reachability status of the device.
+     */
     setDeviceReachability(device, reachable) {
         const basicInformationCluster = device.getClusterServer(BasicInformationCluster);
         if (basicInformationCluster && basicInformationCluster.attributes.reachable !== undefined)
@@ -2254,6 +2722,10 @@ export class Matterbridge extends EventEmitter {
         }
         return vendorName;
     };
+    /**
+     * Retrieves the base registered plugins sanitized for res.json().
+     * @returns {BaseRegisteredPlugin[]} A promise that resolves to an array of BaseRegisteredPlugin objects.
+     */
     async getBaseRegisteredPlugins() {
         const baseRegisteredPlugins = [];
         for (const plugin of this.plugins) {
@@ -2285,13 +2757,36 @@ export class Matterbridge extends EventEmitter {
         }
         return baseRegisteredPlugins;
     }
+    /**
+     * Spawns a child process with the given command and arguments.
+     * @param {string} command - The command to execute.
+     * @param {string[]} args - The arguments to pass to the command (default: []).
+     * @returns {Promise<boolean>} A promise that resolves when the child process exits successfully, or rejects if there is an error.
+     */
     async spawnCommand(command, args = []) {
+        /*
+        npm > npm.cmd on windows
+        cmd.exe ['dir'] on windows
+        await this.spawnCommand('npm', ['install', '-g', 'matterbridge']);
+        process.on('unhandledRejection', (reason, promise) => {
+          this.log.error('Unhandled Rejection at:', promise, 'reason:', reason);
+        });
+    
+        spawn - [14:27:21.125] [Matterbridge:spawn]: changed 38 packages in 4s
+        spawn - [14:27:21.125] [Matterbridge:spawn]: 10 packages are looking for funding run `npm fund` for details
+        debug - [14:27:21.131] [Matterbridge]: Child process exited with code 0 and signal null
+        debug - [14:27:21.131] [Matterbridge]: Child process stdio streams have closed with code 0
+        */
         const cmdLine = command + ' ' + args.join(' ');
         if (process.platform === 'win32' && command === 'npm') {
+            // Must be spawn('cmd.exe', ['/c', 'npm -g install <package>']);
             const argstring = 'npm ' + args.join(' ');
             args.splice(0, args.length, '/c', argstring);
             command = 'cmd.exe';
         }
+        // Decide when using sudo on linux
+        // When you need sudo: Spawn stderr: npm error Error: EACCES: permission denied
+        // When you don't need sudo: Failed to start child process "npm install -g matterbridge-eve-door": spawn sudo ENOENT
         if (hasParameter('sudo') || (process.platform === 'linux' && command === 'npm' && !hasParameter('docker') && !hasParameter('nosudo'))) {
             args.unshift(command);
             command = 'sudo';
@@ -2349,55 +2844,102 @@ export class Matterbridge extends EventEmitter {
             }
         });
     }
+    /**
+     * Sends a WebSocket message to all connected clients.
+     *
+     * @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.
+     */
     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, '"');
+        // 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.
+     *
+     */
     wssSendRefreshRequired() {
         this.matterbridgeInformation.refreshRequired = 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_REFRESH_NEEDED, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', params: {} }));
             }
         });
     }
+    /**
+     * Sends a need to restart WebSocket message to all connected clients.
+     *
+     */
     wssSendRestartRequired() {
         this.matterbridgeInformation.restartRequired = 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_RESTART_NEEDED, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', params: {} }));
             }
         });
     }
+    /**
+     * Initializes the frontend of Matterbridge.
+     *
+     * @param port The port number to run the frontend server on. Default is 8283.
+     */
     async initializeFrontend(port = 8283) {
         let initializeError = false;
         this.log.debug(`Initializing the frontend ${hasParameter('ssl') ? 'https' : 'http'} server on port ${YELLOW}${port}${db}`);
+        // Create the express app that serves the frontend
         this.expressApp = express();
+        // Log all requests to the server for debugging
+        /*
+        if (hasParameter('homedir')) {
+          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.rootDirectory, 'frontend/build')));
         if (!hasParameter('ssl')) {
+            // Create an HTTP server and attach the express app
             this.httpServer = createServer(this.expressApp);
+            // Listen on the specified port
             if (hasParameter('ingress')) {
                 this.httpServer.listen(port, '0.0.0.0', () => {
                     this.log.info(`The frontend http server is listening on ${UNDERLINE}http://0.0.0.0:${port}${UNDERLINEOFF}${rs}`);
@@ -2411,6 +2953,7 @@ export class Matterbridge extends EventEmitter {
                         this.log.info(`The frontend http server is listening on ${UNDERLINE}http://[${this.systemInformation.ipv6Address}]:${port}${UNDERLINEOFF}${rs}`);
                 });
             }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this.httpServer.on('error', (error) => {
                 this.log.error(`Frontend http server error listening on ${port}`);
                 switch (error.code) {
@@ -2426,6 +2969,7 @@ export class Matterbridge extends EventEmitter {
             });
         }
         else {
+            // Load the SSL certificate, the private key and optionally the CA certificate
             let cert;
             try {
                 cert = await fs.readFile(path.join(this.matterbridgeDirectory, 'certs/cert.pem'), 'utf8');
@@ -2453,7 +2997,9 @@ export class Matterbridge extends EventEmitter {
                 this.log.info(`CA certificate file ${path.join(this.matterbridgeDirectory, 'certs/ca.pem')} not loaded: ${error}`);
             }
             const serverOptions = { cert, key, ca };
+            // Create an HTTPS server with the SSL certificate and private key (ca is optional) and attach the express app
             this.httpsServer = https.createServer(serverOptions, this.expressApp);
+            // Listen on the specified port
             if (hasParameter('ingress')) {
                 this.httpsServer.listen(port, '0.0.0.0', () => {
                     this.log.info(`The frontend https server is listening on ${UNDERLINE}https://0.0.0.0:${port}${UNDERLINEOFF}${rs}`);
@@ -2467,6 +3013,7 @@ export class Matterbridge extends EventEmitter {
                         this.log.info(`The frontend https server is listening on ${UNDERLINE}https://[${this.systemInformation.ipv6Address}]:${port}${UNDERLINEOFF}${rs}`);
                 });
             }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this.httpsServer.on('error', (error) => {
                 this.log.error(`Frontend https server error listening on ${port}`);
                 switch (error.code) {
@@ -2483,12 +3030,13 @@ export class Matterbridge extends EventEmitter {
         }
         if (initializeError)
             return;
+        // Createe a WebSocket server and attach it to the http or https server
         const wssPort = port;
         const wssHost = hasParameter('ssl') ? `wss://${this.systemInformation.ipv4Address}:${wssPort}` : `ws://${this.systemInformation.ipv4Address}:${wssPort}`;
         this.webSocketServer = new WebSocketServer(hasParameter('ssl') ? { server: this.httpsServer } : { server: this.httpServer });
         this.webSocketServer.on('connection', (ws, request) => {
             const clientIp = request.socket.remoteAddress;
-            AnsiLogger.setGlobalCallback(this.wssSendMessage.bind(this), "debug");
+            AnsiLogger.setGlobalCallback(this.wssSendMessage.bind(this), "debug" /* LogLevel.DEBUG */);
             this.log.info(`WebSocketServer client "${clientIp}" connected to Matterbridge`);
             ws.on('message', (message) => {
                 this.log.debug(`WebSocket client message: ${message}`);
@@ -2521,6 +3069,7 @@ export class Matterbridge extends EventEmitter {
         this.webSocketServer.on('error', (ws, error) => {
             this.log.error(`WebSocketServer error: ${error}`);
         });
+        // Endpoint to validate login code
         this.expressApp.post('/api/login', express.json(), async (req, res) => {
             const { password } = req.body;
             this.log.debug('The frontend sent /api/login', password);
@@ -2539,12 +3088,24 @@ export class Matterbridge 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
+        this.expressApp.get('/health', (req, res) => {
+            this.log.debug('Express received /health');
+            const healthStatus = {
+                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 settings
         this.expressApp.get('/api/settings', express.json(), async (req, res) => {
             this.log.debug('The frontend sent /api/settings');
             this.matterbridgeInformation.bridgeMode = this.bridgeMode;
@@ -2565,13 +3126,17 @@ export class Matterbridge extends EventEmitter {
             this.matterbridgeInformation.matterbridgeSessionInformations = Array.from(this.matterbridgeSessionInformations.values());
             this.matterbridgeInformation.profile = this.profile;
             const response = { systemInformation: this.systemInformation, matterbridgeInformation: this.matterbridgeInformation };
+            // this.log.debug('Response:', debugStringify(response));
             res.json(response);
         });
+        // Endpoint to provide plugins
         this.expressApp.get('/api/plugins', async (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
             const response = await this.getBaseRegisteredPlugins();
+            // this.log.debug('Response:', debugStringify(response));
             res.json(response);
         });
+        // Endpoint to provide devices
         this.expressApp.get('/api/devices', (req, res) => {
             this.log.debug('The frontend sent /api/devices');
             const devices = [];
@@ -2604,8 +3169,10 @@ export class Matterbridge extends EventEmitter {
                     cluster: cluster,
                 });
             });
+            // this.log.debug('Response:', debugStringify(data));
             res.json(devices);
         });
+        // Endpoint to provide the cluster servers of the devices
         this.expressApp.get('/api/devices_clusters/:selectedPluginName/:selectedDeviceEndpoint', (req, res) => {
             const selectedPluginName = req.params.selectedPluginName;
             const selectedDeviceEndpoint = parseInt(req.params.selectedDeviceEndpoint, 10);
@@ -2625,6 +3192,7 @@ export class Matterbridge extends EventEmitter {
                         Object.entries(clusterServer.attributes).forEach(([key, value]) => {
                             if (clusterServer.name === 'EveHistory')
                                 return;
+                            // this.log.debug(`***--clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute:${key}(${value.id}) ${value.isFixed} ${value.isWritable} ${value.isWritable}`);
                             let attributeValue;
                             try {
                                 if (typeof value.getLocal() === 'object')
@@ -2635,6 +3203,7 @@ export class Matterbridge extends EventEmitter {
                             catch (error) {
                                 attributeValue = 'Fabric-Scoped';
                                 this.log.debug(`GetLocal value ${error} in clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute: ${key}(${value.id})`);
+                                // console.log(error);
                             }
                             data.push({
                                 endpoint: device.number ? device.number.toString() : '...',
@@ -2647,12 +3216,14 @@ export class Matterbridge extends EventEmitter {
                         });
                     });
                     device.getChildEndpoints().forEach((childEndpoint) => {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         const name = this.edge ? childEndpoint.endpoint?.id : childEndpoint.uniqueStorageKey;
                         const clusterServers = childEndpoint.getAllClusterServers();
                         clusterServers.forEach((clusterServer) => {
                             Object.entries(clusterServer.attributes).forEach(([key, value]) => {
                                 if (clusterServer.name === 'EveHistory')
                                     return;
+                                // this.log.debug(`***--clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute:${key}(${value.id}) ${value.isFixed} ${value.isWritable} ${value.isWritable}`);
                                 let attributeValue;
                                 try {
                                     if (typeof value.getLocal() === 'object')
@@ -2663,6 +3234,7 @@ export class Matterbridge extends EventEmitter {
                                 catch (error) {
                                     attributeValue = 'Unavailable';
                                     this.log.debug(`GetLocal error ${error} in clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute: ${key}(${value.id})`);
+                                    // console.log(error);
                                 }
                                 data.push({
                                     endpoint: (childEndpoint.number ? childEndpoint.number.toString() : '...') + (name ? ' (' + name + ')' : ''),
@@ -2679,6 +3251,7 @@ export class Matterbridge extends EventEmitter {
             });
             res.json(data);
         });
+        // Endpoint to view the log
         this.expressApp.get('/api/view-log', async (req, res) => {
             this.log.debug('The frontend sent /api/log');
             try {
@@ -2691,10 +3264,12 @@ export class Matterbridge extends EventEmitter {
                 res.status(500).send('Error reading log file');
             }
         });
+        // Endpoint to download the matterbridge log
         this.expressApp.get('/api/download-mblog', async (req, res) => {
             this.log.debug('The frontend sent /api/download-mblog');
             try {
                 await fs.access(path.join(this.matterbridgeDirectory, this.matterbrideLoggerFile), fs.constants.F_OK);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
             }
             catch (error) {
                 fs.appendFile(path.join(this.matterbridgeDirectory, this.matterbrideLoggerFile), 'Enable the log on file in the settings to enable the file logger');
@@ -2706,10 +3281,12 @@ export class Matterbridge extends EventEmitter {
                 }
             });
         });
+        // Endpoint to download the matter log
         this.expressApp.get('/api/download-mjlog', async (req, res) => {
             this.log.debug('The frontend sent /api/download-mjlog');
             try {
                 await fs.access(path.join(this.matterbridgeDirectory, this.matterLoggerFile), fs.constants.F_OK);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
             }
             catch (error) {
                 fs.appendFile(path.join(this.matterbridgeDirectory, this.matterLoggerFile), 'Enable the log on file in the settings to enable the file logger');
@@ -2721,6 +3298,7 @@ export class Matterbridge extends EventEmitter {
                 }
             });
         });
+        // Endpoint to download the matter storage file
         this.expressApp.get('/api/download-mjstorage', (req, res) => {
             this.log.debug('The frontend sent /api/download-mjstorage');
             res.download(path.join(this.matterbridgeDirectory, this.matterStorageName), 'matterbridge.json', (error) => {
@@ -2730,6 +3308,7 @@ export class Matterbridge extends EventEmitter {
                 }
             });
         });
+        // 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.nodeStorageName}.zip`), path.join(this.matterbridgeDirectory, this.nodeStorageName));
@@ -2740,6 +3319,7 @@ export class Matterbridge extends EventEmitter {
                 }
             });
         });
+        // 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.matterbridgePluginDirectory);
@@ -2750,9 +3330,11 @@ export class Matterbridge extends EventEmitter {
                 }
             });
         });
+        // 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.matterbridgeDirectory, '*.config.json')));
+            // await createZip(path.join(os.tmpdir(), `matterbridge.pluginconfig.zip`), path.relative(process.cwd(), path.join(this.matterbridgeDirectory, 'certs', '*.*')), path.relative(process.cwd(), path.join(this.matterbridgeDirectory, '*.config.json')));
             res.download(path.join(os.tmpdir(), `matterbridge.pluginconfig.zip`), `matterbridge.pluginconfig.zip`, (error) => {
                 if (error) {
                     this.log.error(`Error downloading file matterbridge.pluginstorage.zip: ${error instanceof Error ? error.message : error}`);
@@ -2760,6 +3342,7 @@ export class Matterbridge extends EventEmitter {
                 }
             });
         });
+        // Endpoint to download the matterbridge plugin config files
         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) => {
@@ -2769,6 +3352,7 @@ export class Matterbridge extends EventEmitter {
                 }
             });
         });
+        // Endpoint to receive commands
         this.expressApp.post('/api/command/:command/:param', express.json(), async (req, res) => {
             const command = req.params.command;
             let param = req.params.param;
@@ -2778,13 +3362,15 @@ export class Matterbridge extends EventEmitter {
                 return;
             }
             this.log.debug(`Received frontend command: ${command}:${param}`);
+            // Handle the command setpassword from Settings
             if (command === 'setpassword') {
-                const password = param.slice(1, -1);
+                const password = param.slice(1, -1); // Remove the first and last characters
                 this.log.debug('setpassword', param, password);
                 await this.nodeContext?.set('password', password);
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command setbridgemode from Settings
             if (command === 'setbridgemode') {
                 this.log.debug(`setbridgemode: ${param}`);
                 this.wssSendRestartRequired();
@@ -2792,6 +3378,7 @@ export class Matterbridge extends EventEmitter {
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command backup from Settings
             if (command === 'backup') {
                 this.log.notice(`Prepairing the backup...`);
                 await createZip(path.join(os.tmpdir(), `matterbridge.backup.zip`), path.join(this.matterbridgeDirectory), path.join(this.matterbridgePluginDirectory));
@@ -2799,25 +3386,26 @@ export class Matterbridge extends EventEmitter {
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command setmbloglevel from Settings
             if (command === 'setmbloglevel') {
                 this.log.debug('Matterbridge log level:', param);
                 if (param === 'Debug') {
-                    this.log.logLevel = "debug";
+                    this.log.logLevel = "debug" /* LogLevel.DEBUG */;
                 }
                 else if (param === 'Info') {
-                    this.log.logLevel = "info";
+                    this.log.logLevel = "info" /* LogLevel.INFO */;
                 }
                 else if (param === 'Notice') {
-                    this.log.logLevel = "notice";
+                    this.log.logLevel = "notice" /* LogLevel.NOTICE */;
                 }
                 else if (param === 'Warn') {
-                    this.log.logLevel = "warn";
+                    this.log.logLevel = "warn" /* LogLevel.WARN */;
                 }
                 else if (param === 'Error') {
-                    this.log.logLevel = "error";
+                    this.log.logLevel = "error" /* LogLevel.ERROR */;
                 }
                 else if (param === 'Fatal') {
-                    this.log.logLevel = "fatal";
+                    this.log.logLevel = "fatal" /* LogLevel.FATAL */;
                 }
                 await this.nodeContext?.set('matterbridgeLogLevel', this.log.logLevel);
                 MatterbridgeDevice.logLevel = this.log.logLevel;
@@ -2825,12 +3413,13 @@ export class Matterbridge extends EventEmitter {
                 for (const plugin of this.plugins) {
                     if (!plugin.platform || !plugin.platform.config)
                         continue;
-                    plugin.platform.log.logLevel = plugin.platform.config.debug ? "debug" : this.log.logLevel;
-                    await plugin.platform.onChangeLoggerLevel(plugin.platform.config.debug ? "debug" : this.log.logLevel);
+                    plugin.platform.log.logLevel = plugin.platform.config.debug ? "debug" /* LogLevel.DEBUG */ : this.log.logLevel;
+                    await plugin.platform.onChangeLoggerLevel(plugin.platform.config.debug ? "debug" /* LogLevel.DEBUG */ : this.log.logLevel);
                 }
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command setmbloglevel from Settings
             if (command === 'setmjloglevel') {
                 this.log.debug('Matter.js log level:', param);
                 if (param === 'Debug') {
@@ -2855,30 +3444,34 @@ export class Matterbridge extends EventEmitter {
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command setmdnsinterface from Settings
             if (command === 'setmdnsinterface') {
-                param = param.slice(1, -1);
+                param = param.slice(1, -1); // Remove the first and last characters *mdns*
                 this.matterbridgeInformation.mattermdnsinterface = param;
                 this.log.debug('Matter.js mdns interface:', param === '' ? 'All interfaces' : param);
                 await this.nodeContext?.set('mattermdnsinterface', param);
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command setipv4address from Settings
             if (command === 'setipv4address') {
-                param = param.slice(1, -1);
+                param = param.slice(1, -1); // Remove the first and last characters *ip*
                 this.matterbridgeInformation.matteripv4address = param;
                 this.log.debug('Matter.js ipv4 address:', param === '' ? 'All ipv4 addresses' : param);
                 await this.nodeContext?.set('matteripv4address', param);
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command setipv6address from Settings
             if (command === 'setipv6address') {
-                param = param.slice(1, -1);
+                param = param.slice(1, -1); // Remove the first and last characters *ip*
                 this.matterbridgeInformation.matteripv6address = param;
                 this.log.debug('Matter.js ipv6 address:', param === '' ? 'All ipv6 addresses' : param);
                 await this.nodeContext?.set('matteripv6address', param);
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command setmatterport from Settings
             if (command === 'setmatterport') {
                 const port = Math.min(Math.max(parseInt(param), 5540), 5560);
                 this.matterbridgeInformation.matterPort = port;
@@ -2887,6 +3480,7 @@ export class Matterbridge extends EventEmitter {
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command setmatterdiscriminator from Settings
             if (command === 'setmatterdiscriminator') {
                 const discriminator = Math.min(Math.max(parseInt(param), 1000), 4095);
                 this.matterbridgeInformation.matterDiscriminator = discriminator;
@@ -2895,6 +3489,7 @@ export class Matterbridge extends EventEmitter {
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command setmatterpasscode from Settings
             if (command === 'setmatterpasscode') {
                 const passcode = Math.min(Math.max(parseInt(param), 10000000), 90000000);
                 this.matterbridgeInformation.matterPasscode = passcode;
@@ -2903,17 +3498,20 @@ export class Matterbridge extends EventEmitter {
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command setmbloglevel from Settings
             if (command === 'setmblogfile') {
                 this.log.debug('Matterbridge file log:', param);
                 this.matterbridgeInformation.fileLogger = param === 'true';
                 await this.nodeContext?.set('matterbridgeFileLog', param === 'true');
+                // Create the file logger for matterbridge
                 if (param === 'true')
-                    AnsiLogger.setGlobalLogfile(path.join(this.matterbridgeDirectory, this.matterbrideLoggerFile), "debug", true);
+                    AnsiLogger.setGlobalLogfile(path.join(this.matterbridgeDirectory, this.matterbrideLoggerFile), "debug" /* LogLevel.DEBUG */, true);
                 else
                     AnsiLogger.setGlobalLogfile(undefined);
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command setmbloglevel from Settings
             if (command === 'setmjlogfile') {
                 this.log.debug('Matter file log:', param);
                 this.matterbridgeInformation.matterFileLogger = param === 'true';
@@ -2940,36 +3538,43 @@ export class Matterbridge extends EventEmitter {
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command unregister from Settings
             if (command === 'unregister') {
                 await this.unregisterAndShutdownProcess();
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command reset from Settings
             if (command === 'reset') {
                 await this.shutdownProcessAndReset();
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command factoryreset from Settings
             if (command === 'factoryreset') {
                 await this.shutdownProcessAndFactoryReset();
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command shutdown from Header
             if (command === 'shutdown') {
                 await this.shutdownProcess();
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command restart from Header
             if (command === 'restart') {
                 await this.restartProcess();
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command update from Header
             if (command === 'update') {
                 this.log.info('Updating matterbridge...');
                 try {
                     await this.spawnCommand('npm', ['install', '-g', 'matterbridge', '--omit=dev', '--verbose']);
                     this.log.info('Matterbridge has been updated. Full restart required.');
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 }
                 catch (error) {
                     this.log.error('Error updating matterbridge');
@@ -2979,9 +3584,11 @@ export class Matterbridge extends EventEmitter {
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command saveconfig from Home
             if (command === 'saveconfig') {
                 param = param.replace(/\*/g, '\\');
                 this.log.info(`Saving config for plugin ${plg}${param}${nf}...`);
+                // console.log('Req.body:', JSON.stringify(req.body, null, 2));
                 if (!this.plugins.has(param)) {
                     this.log.warn(`Plugin ${plg}${param}${wr} not found in matterbridge`);
                 }
@@ -2995,33 +3602,39 @@ export class Matterbridge extends EventEmitter {
                 res.json({ message: 'Command received' });
                 return;
             }
+            // Handle the command installplugin from Home
             if (command === 'installplugin') {
                 param = param.replace(/\*/g, '\\');
                 this.log.info(`Installing plugin ${plg}${param}${nf}...`);
                 try {
                     await this.spawnCommand('npm', ['install', '-g', param, '--omit=dev', '--verbose']);
                     this.log.info(`Plugin ${plg}${param}${nf} installed. Full restart required.`);
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 }
                 catch (error) {
                     this.log.error(`Error installing plugin ${plg}${param}${er}`);
                 }
                 this.wssSendRestartRequired();
                 param = param.split('@')[0];
+                // Also add the plugin to matterbridge so no return!
                 if (param === 'matterbridge') {
+                    // If we used the command installplugin to install a dev or a specific version of matterbridge we don't want to add it to matterbridge
                     res.json({ message: 'Command received' });
                     return;
                 }
             }
+            // Handle the command addplugin from Home
             if (command === 'addplugin' || command === 'installplugin') {
                 param = param.replace(/\*/g, '\\');
                 const plugin = await this.plugins.add(param);
                 if (plugin) {
-                    this.plugins.load(plugin, true, 'The plugin has been added', true);
+                    this.plugins.load(plugin, true, 'The plugin has been added', true); // No await do it in the background
                 }
                 res.json({ message: 'Command received' });
                 this.wssSendRefreshRequired();
                 return;
             }
+            // Handle the command removeplugin from Home
             if (command === 'removeplugin') {
                 if (!this.plugins.has(param)) {
                     this.log.warn(`Plugin ${plg}${param}${wr} not found in matterbridge`);
@@ -3035,6 +3648,7 @@ export class Matterbridge extends EventEmitter {
                 this.wssSendRefreshRequired();
                 return;
             }
+            // Handle the command enableplugin from Home
             if (command === 'enableplugin') {
                 if (!this.plugins.has(param)) {
                     this.log.warn(`Plugin ${plg}${param}${wr} not found in matterbridge`);
@@ -3052,13 +3666,14 @@ export class Matterbridge extends EventEmitter {
                         plugin.registeredDevices = undefined;
                         plugin.addedDevices = undefined;
                         await this.plugins.enable(param);
-                        this.plugins.load(plugin, true, 'The plugin has been enabled', true);
+                        this.plugins.load(plugin, true, 'The plugin has been enabled', true); // No await do it in the background
                     }
                 }
                 res.json({ message: 'Command received' });
                 this.wssSendRefreshRequired();
                 return;
             }
+            // Handle the command disableplugin from Home
             if (command === 'disableplugin') {
                 if (!this.plugins.has(param)) {
                     this.log.warn(`Plugin ${plg}${param}${wr} not found in matterbridge`);
@@ -3075,6 +3690,7 @@ export class Matterbridge extends EventEmitter {
                 return;
             }
         });
+        // Fallback for routing (must be the last route)
         this.expressApp.get('*', (req, res) => {
             this.log.debug('The frontend sent:', req.url);
             this.log.debug('Response send file:', path.join(this.rootDirectory, 'frontend/build/index.html'));
@@ -3082,6 +3698,11 @@ export class Matterbridge extends EventEmitter {
         });
         this.log.debug(`Frontend initialized on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
     }
+    /**
+     * Retrieves the cluster text description from a given device.
+     * @param {MatterbridgeDevice} device - The MatterbridgeDevice object.
+     * @returns {string} The attributes description of the cluster servers in the device.
+     */
     getClusterTextFromDevice(device) {
         const stringifyUserLabel = (endpoint) => {
             const labelList = endpoint.getClusterServer(UserLabelCluster)?.attributes.labelList.getLocal();
@@ -3104,9 +3725,11 @@ export class Matterbridge extends EventEmitter {
                 return '';
         };
         let attributes = '';
+        // this.log.debug(`***getClusterTextFromDevice: ${device.deviceName} (${device.name})`);
         const clusterServers = device.getAllClusterServers();
         clusterServers.forEach((clusterServer) => {
             try {
+                // this.log.debug(`**--clusterServer: ${clusterServer.id} (${clusterServer.name})`);
                 if (clusterServer.name === 'OnOff')
                     attributes += `OnOff: ${clusterServer.attributes.onOff.getLocal()} `;
                 if (clusterServer.name === 'Switch')
@@ -3157,18 +3780,30 @@ export class Matterbridge extends EventEmitter {
                     attributes += `${stringifyFixedLabel(device)} `;
                 if (clusterServer.name === 'UserLabel')
                     attributes += `${stringifyUserLabel(device)} `;
+                // this.log.debug(`*--clusterServer: ${clusterServer.id} (${clusterServer.name})`);
             }
             catch (error) {
                 this.log.error(`getClusterTextFromDevice with ${clusterServer.name} error: ${error}`);
             }
         });
+        // this.log.debug(`*getClusterTextFromDevice: ${device.deviceName} (${device.name})`);
         return attributes;
     }
+    /**
+     * Initializes the Matterbridge instance as extension for zigbee2mqtt.
+     * @deprecated This method is deprecated and will be removed in a future version.
+     *
+     * @returns A Promise that resolves when the initialization is complete.
+     */
     async startExtension(dataPath, extensionVersion, port = 5540) {
+        // Set the bridge mode
         this.bridgeMode = 'bridge';
+        // Set the first port to use
         this.port = port;
-        this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4, logLevel: "info" });
+        // Set Matterbridge logger
+        this.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: "info" /* LogLevel.INFO */ });
         this.log.debug('Matterbridge extension is starting...');
+        // Initialize NodeStorage
         this.matterbridgeDirectory = dataPath;
         this.log.debug('Creating node storage manager dir: ' + path.join(this.matterbridgeDirectory, 'node_storage'));
         this.nodeStorage = new NodeStorageManager({ dir: path.join(this.matterbridgeDirectory, 'node_storage'), logging: false });
@@ -3187,10 +3822,13 @@ export class Matterbridge extends EventEmitter {
         };
         this.plugins.set(plugin);
         this.plugins.saveToStorage();
+        // Log system info and create .matterbridge directory
         await this.logNodeAndSystemInfo();
         this.matterbridgeDirectory = dataPath;
+        // Set matter.js logger level and format
         Logger.defaultLogLevel = MatterLogLevel.INFO;
         Logger.format = MatterLogFormat.ANSI;
+        // Start the storage and create matterbridgeContext
         await this.startMatterStorage('json', path.join(this.matterbridgeDirectory, this.matterStorageName));
         if (!this.storageManager)
             return false;
@@ -3200,7 +3838,7 @@ export class Matterbridge extends EventEmitter {
         await this.matterbridgeContext.set('softwareVersion', 1);
         await this.matterbridgeContext.set('softwareVersionString', this.matterbridgeVersion);
         await this.matterbridgeContext.set('hardwareVersion', 1);
-        await this.matterbridgeContext.set('hardwareVersionString', extensionVersion);
+        await this.matterbridgeContext.set('hardwareVersionString', extensionVersion); // Update with the extension version
         this.matterServer = await this.createMatterServer(this.storageManager);
         this.log.debug(`Creating commissioning server for ${plg}Matterbridge${db}`);
         this.commissioningServer = await this.createCommisioningServer(this.matterbridgeContext, 'Matterbridge');
@@ -3213,6 +3851,7 @@ export class Matterbridge extends EventEmitter {
         await this.startMatterServer();
         this.log.info('Matter server started');
         await this.showCommissioningQRCode(this.commissioningServer, this.matterbridgeContext, this.nodeContext, 'Matterbridge');
+        // Set reachability to true and trigger event after 60 seconds
         setTimeout(() => {
             this.log.info(`Setting reachability to true for ${plg}Matterbridge${db}`);
             if (this.commissioningServer)
@@ -3222,14 +3861,31 @@ export class Matterbridge extends EventEmitter {
         }, 60 * 1000);
         return this.commissioningServer.isCommissioned();
     }
+    /**
+     * Close the Matterbridge instance as extension for zigbee2mqtt.
+     * @deprecated This method is deprecated and will be removed in a future version.
+     *
+     * @returns A Promise that resolves when the initialization is complete.
+     */
     async stopExtension() {
+        // Closing matter
         await this.stopMatterServer();
+        // Clearing the session manager
+        // this.matterbridgeContext?.createContext('SessionManager').clear();
+        // Closing storage
         await this.stopMatterStorage();
         this.log.info('Matter server stopped');
     }
+    /**
+     * Checks if the extension is commissioned.
+     * @deprecated This method is deprecated and will be removed in a future version.
+     *
+     * @returns {boolean} Returns true if the extension is commissioned, false otherwise.
+     */
     isExtensionCommissioned() {
         if (!this.commissioningServer)
             return false;
         return this.commissioningServer.isCommissioned();
     }
 }
+//# sourceMappingURL=matterbridge.js.map