matterbridge 1.7.3 → 2.0.0-edge.2

package/dist/frontend.js

@@ -0,0 +1,1203 @@
+import { EndpointServer, Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat } from '@matter/main';
+import { createServer } from 'http';
+import https from 'https';
+import express from 'express';
+import WebSocket, { WebSocketServer } from 'ws';
+import os from 'os';
+import path from 'path';
+import { promises as fs } from 'fs';
+import { AnsiLogger, CYAN, db, debugStringify, er, nf, rs, stringify, UNDERLINE, UNDERLINEOFF, wr, YELLOW } from 'node-ansi-logger';
+import { createZip, hasParameter, isValidNumber, isValidObject, isValidString } from './utils/utils.js';
+import { plg } from './matterbridgeTypes.js';
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+export const WS_ID_LOG = 0;
+export const WS_ID_REFRESH_NEEDED = 1;
+export const WS_ID_RESTART_NEEDED = 2;
+export class Frontend {
+    matterbridge;
+    log;
+    port = 8283;
+    initializeError = false;
+    expressApp;
+    httpServer;
+    httpsServer;
+    webSocketServer;
+    constructor(matterbridge) {
+        this.matterbridge = matterbridge;
+        this.log = new AnsiLogger({ logName: 'Frontend', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
+    }
+    async start(port = 8283) {
+        this.port = port;
+        this.log.debug(`Initializing the frontend ${hasParameter('ssl') ? 'https' : 'http'} server on port ${YELLOW}${this.port}${db}`);
+        this.expressApp = express();
+        this.expressApp.use(express.static(path.join(this.matterbridge.rootDirectory, 'frontend/build')));
+        if (!hasParameter('ssl')) {
+            this.httpServer = createServer(this.expressApp);
+            if (hasParameter('ingress')) {
+                this.httpServer.listen(this.port, '0.0.0.0', () => {
+                    this.log.info(`The frontend http server is listening on ${UNDERLINE}http://0.0.0.0:${this.port}${UNDERLINEOFF}${rs}`);
+                });
+            }
+            else {
+                this.httpServer.listen(this.port, () => {
+                    if (this.matterbridge.systemInformation.ipv4Address !== '')
+                        this.log.info(`The frontend http server is listening on ${UNDERLINE}http://${this.matterbridge.systemInformation.ipv4Address}:${this.port}${UNDERLINEOFF}${rs}`);
+                    if (this.matterbridge.systemInformation.ipv6Address !== '')
+                        this.log.info(`The frontend http server is listening on ${UNDERLINE}http://[${this.matterbridge.systemInformation.ipv6Address}]:${this.port}${UNDERLINEOFF}${rs}`);
+                });
+            }
+            this.httpServer.on('error', (error) => {
+                this.log.error(`Frontend http server error listening on ${this.port}`);
+                switch (error.code) {
+                    case 'EACCES':
+                        this.log.error(`Port ${this.port} requires elevated privileges`);
+                        break;
+                    case 'EADDRINUSE':
+                        this.log.error(`Port ${this.port} is already in use`);
+                        break;
+                }
+                this.initializeError = true;
+                return;
+            });
+        }
+        else {
+            let cert;
+            try {
+                cert = await fs.readFile(path.join(this.matterbridge.matterbridgeDirectory, 'certs/cert.pem'), 'utf8');
+                this.log.info(`Loaded certificate file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs/cert.pem')}`);
+            }
+            catch (error) {
+                this.log.error(`Error reading certificate file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs/cert.pem')}: ${error}`);
+                return;
+            }
+            let key;
+            try {
+                key = await fs.readFile(path.join(this.matterbridge.matterbridgeDirectory, 'certs/key.pem'), 'utf8');
+                this.log.info(`Loaded key file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs/key.pem')}`);
+            }
+            catch (error) {
+                this.log.error(`Error reading key file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs/key.pem')}: ${error}`);
+                return;
+            }
+            let ca;
+            try {
+                ca = await fs.readFile(path.join(this.matterbridge.matterbridgeDirectory, 'certs/ca.pem'), 'utf8');
+                this.log.info(`Loaded CA certificate file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs/ca.pem')}`);
+            }
+            catch (error) {
+                this.log.info(`CA certificate file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs/ca.pem')} not loaded: ${error}`);
+            }
+            const serverOptions = { cert, key, ca };
+            this.httpsServer = https.createServer(serverOptions, this.expressApp);
+            if (hasParameter('ingress')) {
+                this.httpsServer.listen(this.port, '0.0.0.0', () => {
+                    this.log.info(`The frontend https server is listening on ${UNDERLINE}https://0.0.0.0:${this.port}${UNDERLINEOFF}${rs}`);
+                });
+            }
+            else {
+                this.httpsServer.listen(this.port, () => {
+                    if (this.matterbridge.systemInformation.ipv4Address !== '')
+                        this.log.info(`The frontend https server is listening on ${UNDERLINE}https://${this.matterbridge.systemInformation.ipv4Address}:${this.port}${UNDERLINEOFF}${rs}`);
+                    if (this.matterbridge.systemInformation.ipv6Address !== '')
+                        this.log.info(`The frontend https server is listening on ${UNDERLINE}https://[${this.matterbridge.systemInformation.ipv6Address}]:${this.port}${UNDERLINEOFF}${rs}`);
+                });
+            }
+            this.httpsServer.on('error', (error) => {
+                this.log.error(`Frontend https server error listening on ${this.port}`);
+                switch (error.code) {
+                    case 'EACCES':
+                        this.log.error(`Port ${this.port} requires elevated privileges`);
+                        break;
+                    case 'EADDRINUSE':
+                        this.log.error(`Port ${this.port} is already in use`);
+                        break;
+                }
+                this.initializeError = true;
+                return;
+            });
+        }
+        if (this.initializeError)
+            return;
+        const wssPort = this.port;
+        const wssHost = hasParameter('ssl') ? `wss://${this.matterbridge.systemInformation.ipv4Address}:${wssPort}` : `ws://${this.matterbridge.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");
+            this.log.info(`WebSocketServer client "${clientIp}" connected to Matterbridge`);
+            ws.on('message', (message) => {
+                this.wsMessageHandler(ws, message);
+            });
+            ws.on('ping', () => {
+                this.log.debug('WebSocket client ping');
+                ws.pong();
+            });
+            ws.on('pong', () => {
+                this.log.debug('WebSocket client pong');
+            });
+            ws.on('close', () => {
+                this.log.info('WebSocket client disconnected');
+                if (this.webSocketServer?.clients.size === 0) {
+                    AnsiLogger.setGlobalCallback(undefined);
+                    this.log.debug('All WebSocket clients disconnected. WebSocketServer logger global callback removed');
+                }
+            });
+            ws.on('error', (error) => {
+                this.log.error(`WebSocket client error: ${error}`);
+            });
+        });
+        this.webSocketServer.on('close', () => {
+            this.log.debug(`WebSocketServer closed`);
+        });
+        this.webSocketServer.on('listening', () => {
+            this.log.info(`The WebSocketServer is listening on ${UNDERLINE}${wssHost}${UNDERLINEOFF}${rs}`);
+        });
+        this.webSocketServer.on('error', (ws, error) => {
+            this.log.error(`WebSocketServer error: ${error}`);
+        });
+        this.expressApp.post('/api/login', express.json(), async (req, res) => {
+            const { password } = req.body;
+            this.log.debug('The frontend sent /api/login', password);
+            if (!this.matterbridge.nodeContext) {
+                this.log.error('/api/login nodeContext not found');
+                res.json({ valid: false });
+                return;
+            }
+            try {
+                const storedPassword = await this.matterbridge.nodeContext.get('password', '');
+                if (storedPassword === '' || password === storedPassword) {
+                    this.log.debug('/api/login password valid');
+                    res.json({ valid: true });
+                }
+                else {
+                    this.log.warn('/api/login error wrong password');
+                    res.json({ valid: false });
+                }
+            }
+            catch (error) {
+                this.log.error('/api/login error getting password');
+                res.json({ valid: false });
+            }
+        });
+        this.expressApp.get('/health', (req, res) => {
+            this.log.debug('Express received /health');
+            const healthStatus = {
+                status: 'ok',
+                uptime: process.uptime(),
+                timestamp: new Date().toISOString(),
+            };
+            res.status(200).json(healthStatus);
+        });
+        this.expressApp.get('/api/settings', express.json(), async (req, res) => {
+            this.log.debug('The frontend sent /api/settings');
+            this.matterbridge.matterbridgeInformation.bridgeMode = this.matterbridge.bridgeMode;
+            this.matterbridge.matterbridgeInformation.restartMode = this.matterbridge.restartMode;
+            this.matterbridge.matterbridgeInformation.loggerLevel = this.log.logLevel;
+            this.matterbridge.matterbridgeInformation.matterLoggerLevel = Logger.defaultLogLevel;
+            this.matterbridge.matterbridgeInformation.mattermdnsinterface = (await this.matterbridge.nodeContext?.get('mattermdnsinterface', '')) || '';
+            this.matterbridge.matterbridgeInformation.matteripv4address = (await this.matterbridge.nodeContext?.get('matteripv4address', '')) || '';
+            this.matterbridge.matterbridgeInformation.matteripv6address = (await this.matterbridge.nodeContext?.get('matteripv6address', '')) || '';
+            this.matterbridge.matterbridgeInformation.matterPort = (await this.matterbridge.nodeContext?.get('matterport', 5540)) ?? 5540;
+            this.matterbridge.matterbridgeInformation.matterDiscriminator = await this.matterbridge.nodeContext?.get('matterdiscriminator');
+            this.matterbridge.matterbridgeInformation.matterPasscode = await this.matterbridge.nodeContext?.get('matterpasscode');
+            this.matterbridge.matterbridgeInformation.matterbridgePaired = this.matterbridge.matterbridgePaired;
+            this.matterbridge.matterbridgeInformation.matterbridgeConnected = this.matterbridge.matterbridgeConnected;
+            this.matterbridge.matterbridgeInformation.matterbridgeQrPairingCode = this.matterbridge.matterbridgeQrPairingCode;
+            this.matterbridge.matterbridgeInformation.matterbridgeManualPairingCode = this.matterbridge.matterbridgeManualPairingCode;
+            this.matterbridge.matterbridgeInformation.matterbridgeFabricInformations = this.matterbridge.matterbridgeFabricInformations;
+            this.matterbridge.matterbridgeInformation.matterbridgeSessionInformations = Array.from(this.matterbridge.matterbridgeSessionInformations.values());
+            this.matterbridge.matterbridgeInformation.profile = this.matterbridge.profile;
+            const response = { systemInformation: this.matterbridge.systemInformation, matterbridgeInformation: this.matterbridge.matterbridgeInformation };
+            res.json(response);
+        });
+        this.expressApp.get('/api/plugins', async (req, res) => {
+            this.log.debug('The frontend sent /api/plugins');
+            const response = await this.getBaseRegisteredPlugins();
+            res.json(response);
+        });
+        this.expressApp.get('/api/devices', (req, res) => {
+            this.log.debug('The frontend sent /api/devices');
+            const devices = [];
+            this.matterbridge.devices.forEach(async (device) => {
+                if (!device.plugin || !device.name || !device.deviceName || !device.serialNumber || !device.uniqueId)
+                    return;
+                const cluster = this.getClusterTextFromDevice(device);
+                devices.push({
+                    pluginName: device.plugin,
+                    type: device.name + ' (0x' + device.deviceType.toString(16).padStart(4, '0') + ')',
+                    endpoint: device.number,
+                    name: device.deviceName,
+                    serial: device.serialNumber,
+                    productUrl: device.productUrl,
+                    configUrl: device.configUrl,
+                    uniqueId: device.uniqueId,
+                    cluster: cluster,
+                });
+            });
+            res.json(devices);
+        });
+        this.expressApp.get('/api/devices_clusters/:selectedPluginName/:selectedDeviceEndpoint', (req, res) => {
+            const selectedPluginName = req.params.selectedPluginName;
+            const selectedDeviceEndpoint = parseInt(req.params.selectedDeviceEndpoint, 10);
+            this.log.debug(`The frontend sent /api/devices_clusters plugin:${selectedPluginName} endpoint:${selectedDeviceEndpoint}`);
+            if (selectedPluginName === 'none') {
+                res.json([]);
+                return;
+            }
+            const data = [];
+            this.matterbridge.devices.forEach(async (device) => {
+                const pluginName = device.plugin;
+                if (pluginName === selectedPluginName && device.number === selectedDeviceEndpoint) {
+                    const endpointServer = EndpointServer.forEndpoint(device);
+                    const clusterServers = endpointServer.getAllClusterServers();
+                    clusterServers.forEach((clusterServer) => {
+                        Object.entries(clusterServer.attributes).forEach(([key, value]) => {
+                            if (clusterServer.name === 'EveHistory')
+                                return;
+                            let attributeValue;
+                            try {
+                                if (typeof value.getLocal() === 'object')
+                                    attributeValue = stringify(value.getLocal());
+                                else
+                                    attributeValue = value.getLocal().toString();
+                            }
+                            catch (error) {
+                                attributeValue = 'Fabric-Scoped';
+                                this.log.debug(`GetLocal value ${error} in clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute: ${key}(${value.id})`);
+                            }
+                            data.push({
+                                endpoint: device.number ? device.number.toString() : '...',
+                                clusterName: clusterServer.name,
+                                clusterId: '0x' + clusterServer.id.toString(16).padStart(2, '0'),
+                                attributeName: key,
+                                attributeId: '0x' + value.id.toString(16).padStart(2, '0'),
+                                attributeValue,
+                            });
+                        });
+                    });
+                    endpointServer.getChildEndpoints().forEach((childEndpoint) => {
+                        const name = childEndpoint.name;
+                        const clusterServers = childEndpoint.getAllClusterServers();
+                        clusterServers.forEach((clusterServer) => {
+                            Object.entries(clusterServer.attributes).forEach(([key, value]) => {
+                                if (clusterServer.name === 'EveHistory')
+                                    return;
+                                let attributeValue;
+                                try {
+                                    if (typeof value.getLocal() === 'object')
+                                        attributeValue = stringify(value.getLocal());
+                                    else
+                                        attributeValue = value.getLocal().toString();
+                                }
+                                catch (error) {
+                                    attributeValue = 'Fabric-Scoped';
+                                    this.log.debug(`GetLocal error ${error} in clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute: ${key}(${value.id})`);
+                                }
+                                data.push({
+                                    endpoint: (childEndpoint.number ? childEndpoint.number.toString() : '...') + (name ? ' (' + name + ')' : ''),
+                                    clusterName: clusterServer.name,
+                                    clusterId: '0x' + clusterServer.id.toString(16).padStart(2, '0'),
+                                    attributeName: key,
+                                    attributeId: '0x' + value.id.toString(16).padStart(2, '0'),
+                                    attributeValue,
+                                });
+                            });
+                        });
+                    });
+                }
+            });
+            res.json(data);
+        });
+        this.expressApp.get('/api/view-log', async (req, res) => {
+            this.log.debug('The frontend sent /api/log');
+            try {
+                const data = await fs.readFile(path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterbrideLoggerFile), 'utf8');
+                res.type('text/plain');
+                res.send(data);
+            }
+            catch (error) {
+                this.log.error(`Error reading log file ${this.matterbridge.matterbrideLoggerFile}: ${error instanceof Error ? error.message : error}`);
+                res.status(500).send('Error reading log file');
+            }
+        });
+        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.matterbridge.matterbridgeDirectory, this.matterbridge.matterbrideLoggerFile), fs.constants.F_OK);
+            }
+            catch (error) {
+                fs.appendFile(path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterbrideLoggerFile), 'Enable the log on file in the settings to enable the file logger');
+            }
+            res.download(path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterbrideLoggerFile), 'matterbridge.log', (error) => {
+                if (error) {
+                    this.log.error(`Error downloading log file ${this.matterbridge.matterbrideLoggerFile}: ${error instanceof Error ? error.message : error}`);
+                    res.status(500).send('Error downloading the matterbridge log file');
+                }
+            });
+        });
+        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.matterbridge.matterbridgeDirectory, this.matterbridge.matterLoggerFile), fs.constants.F_OK);
+            }
+            catch (error) {
+                fs.appendFile(path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterLoggerFile), 'Enable the log on file in the settings to enable the file logger');
+            }
+            res.download(path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterLoggerFile), 'matter.log', (error) => {
+                if (error) {
+                    this.log.error(`Error downloading log file ${this.matterbridge.matterLoggerFile}: ${error instanceof Error ? error.message : error}`);
+                    res.status(500).send('Error downloading the matter log file');
+                }
+            });
+        });
+        this.expressApp.get('/api/download-mjstorage', async (req, res) => {
+            this.log.debug('The frontend sent /api/download-mjstorage');
+            await createZip(path.join(os.tmpdir(), `matterbridge.${this.matterbridge.matterStorageName}.zip`), path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterStorageName));
+            res.download(path.join(os.tmpdir(), `matterbridge.${this.matterbridge.matterStorageName}.zip`), `matterbridge.${this.matterbridge.matterStorageName}.zip`, (error) => {
+                if (error) {
+                    this.log.error(`Error downloading the matter storage matterbridge.${this.matterbridge.matterStorageName}.zip: ${error instanceof Error ? error.message : error}`);
+                    res.status(500).send('Error downloading the matter storage zip file');
+                }
+            });
+        });
+        this.expressApp.get('/api/download-mbstorage', async (req, res) => {
+            this.log.debug('The frontend sent /api/download-mbstorage');
+            await createZip(path.join(os.tmpdir(), `matterbridge.${this.matterbridge.nodeStorageName}.zip`), path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.nodeStorageName));
+            res.download(path.join(os.tmpdir(), `matterbridge.${this.matterbridge.nodeStorageName}.zip`), `matterbridge.${this.matterbridge.nodeStorageName}.zip`, (error) => {
+                if (error) {
+                    this.log.error(`Error downloading file ${`matterbridge.${this.matterbridge.nodeStorageName}.zip`}: ${error instanceof Error ? error.message : error}`);
+                    res.status(500).send('Error downloading the matterbridge storage file');
+                }
+            });
+        });
+        this.expressApp.get('/api/download-pluginstorage', async (req, res) => {
+            this.log.debug('The frontend sent /api/download-pluginstorage');
+            await createZip(path.join(os.tmpdir(), `matterbridge.pluginstorage.zip`), this.matterbridge.matterbridgePluginDirectory);
+            res.download(path.join(os.tmpdir(), `matterbridge.pluginstorage.zip`), `matterbridge.pluginstorage.zip`, (error) => {
+                if (error) {
+                    this.log.error(`Error downloading file matterbridge.pluginstorage.zip: ${error instanceof Error ? error.message : error}`);
+                    res.status(500).send('Error downloading the matterbridge plugin storage file');
+                }
+            });
+        });
+        this.expressApp.get('/api/download-pluginconfig', async (req, res) => {
+            this.log.debug('The frontend sent /api/download-pluginconfig');
+            await createZip(path.join(os.tmpdir(), `matterbridge.pluginconfig.zip`), path.relative(process.cwd(), path.join(this.matterbridge.matterbridgeDirectory, '*.config.json')));
+            res.download(path.join(os.tmpdir(), `matterbridge.pluginconfig.zip`), `matterbridge.pluginconfig.zip`, (error) => {
+                if (error) {
+                    this.log.error(`Error downloading file matterbridge.pluginstorage.zip: ${error instanceof Error ? error.message : error}`);
+                    res.status(500).send('Error downloading the matterbridge plugin storage file');
+                }
+            });
+        });
+        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) => {
+                if (error) {
+                    this.log.error(`Error downloading file matterbridge.backup.zip: ${error instanceof Error ? error.message : error}`);
+                    res.status(500).send(`Error downloading file matterbridge.backup.zip: ${error instanceof Error ? error.message : error}`);
+                }
+            });
+        });
+        this.expressApp.post('/api/command/:command/:param', express.json(), async (req, res) => {
+            const command = req.params.command;
+            let param = req.params.param;
+            this.log.debug(`The frontend sent /api/command/${command}/${param}`);
+            if (!command) {
+                res.status(400).json({ error: 'No command provided' });
+                return;
+            }
+            this.log.debug(`Received frontend command: ${command}:${param}`);
+            if (command === 'setpassword') {
+                const password = param.slice(1, -1);
+                this.log.debug('setpassword', param, password);
+                await this.matterbridge.nodeContext?.set('password', password);
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'setbridgemode') {
+                this.log.debug(`setbridgemode: ${param}`);
+                this.wssSendRestartRequired();
+                await this.matterbridge.nodeContext?.set('bridgeMode', param);
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'backup') {
+                this.log.notice(`Prepairing the backup...`);
+                await createZip(path.join(os.tmpdir(), `matterbridge.backup.zip`), path.join(this.matterbridge.matterbridgeDirectory), path.join(this.matterbridge.matterbridgePluginDirectory));
+                this.log.notice(`Backup ready to be downloaded.`);
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'setmbloglevel') {
+                this.log.debug('Matterbridge log level:', param);
+                if (param === 'Debug') {
+                    this.log.logLevel = "debug";
+                }
+                else if (param === 'Info') {
+                    this.log.logLevel = "info";
+                }
+                else if (param === 'Notice') {
+                    this.log.logLevel = "notice";
+                }
+                else if (param === 'Warn') {
+                    this.log.logLevel = "warn";
+                }
+                else if (param === 'Error') {
+                    this.log.logLevel = "error";
+                }
+                else if (param === 'Fatal') {
+                    this.log.logLevel = "fatal";
+                }
+                await this.matterbridge.nodeContext?.set('matterbridgeLogLevel', this.log.logLevel);
+                MatterbridgeEndpoint.logLevel = this.log.logLevel;
+                this.matterbridge.plugins.logLevel = this.log.logLevel;
+                for (const plugin of this.matterbridge.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);
+                }
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'setmjloglevel') {
+                this.log.debug('Matter.js log level:', param);
+                if (param === 'Debug') {
+                    Logger.defaultLogLevel = MatterLogLevel.DEBUG;
+                }
+                else if (param === 'Info') {
+                    Logger.defaultLogLevel = MatterLogLevel.INFO;
+                }
+                else if (param === 'Notice') {
+                    Logger.defaultLogLevel = MatterLogLevel.NOTICE;
+                }
+                else if (param === 'Warn') {
+                    Logger.defaultLogLevel = MatterLogLevel.WARN;
+                }
+                else if (param === 'Error') {
+                    Logger.defaultLogLevel = MatterLogLevel.ERROR;
+                }
+                else if (param === 'Fatal') {
+                    Logger.defaultLogLevel = MatterLogLevel.FATAL;
+                }
+                await this.matterbridge.nodeContext?.set('matterLogLevel', Logger.defaultLogLevel);
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'setmdnsinterface') {
+                param = param.slice(1, -1);
+                this.matterbridge.matterbridgeInformation.mattermdnsinterface = param;
+                this.log.debug('Matter.js mdns interface:', param === '' ? 'All interfaces' : param);
+                await this.matterbridge.nodeContext?.set('mattermdnsinterface', param);
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'setipv4address') {
+                param = param.slice(1, -1);
+                this.matterbridge.matterbridgeInformation.matteripv4address = param;
+                this.log.debug('Matter.js ipv4 address:', param === '' ? 'All ipv4 addresses' : param);
+                await this.matterbridge.nodeContext?.set('matteripv4address', param);
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'setipv6address') {
+                param = param.slice(1, -1);
+                this.matterbridge.matterbridgeInformation.matteripv6address = param;
+                this.log.debug('Matter.js ipv6 address:', param === '' ? 'All ipv6 addresses' : param);
+                await this.matterbridge.nodeContext?.set('matteripv6address', param);
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'setmatterport') {
+                const port = Math.min(Math.max(parseInt(param), 5540), 5560);
+                this.matterbridge.matterbridgeInformation.matterPort = port;
+                this.log.debug(`Set matter commissioning port to ${CYAN}${port}${db}`);
+                await this.matterbridge.nodeContext?.set('matterport', port);
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'setmatterdiscriminator') {
+                const discriminator = Math.min(Math.max(parseInt(param), 1000), 4095);
+                this.matterbridge.matterbridgeInformation.matterDiscriminator = discriminator;
+                this.log.debug(`Set matter commissioning discriminator to ${CYAN}${discriminator}${db}`);
+                await this.matterbridge.nodeContext?.set('matterdiscriminator', discriminator);
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'setmatterpasscode') {
+                const passcode = Math.min(Math.max(parseInt(param), 10000000), 90000000);
+                this.matterbridge.matterbridgeInformation.matterPasscode = passcode;
+                this.log.debug(`Set matter commissioning passcode to ${CYAN}${passcode}${db}`);
+                await this.matterbridge.nodeContext?.set('matterpasscode', passcode);
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'setmblogfile') {
+                this.log.debug('Matterbridge file log:', param);
+                this.matterbridge.matterbridgeInformation.fileLogger = param === 'true';
+                await this.matterbridge.nodeContext?.set('matterbridgeFileLog', param === 'true');
+                if (param === 'true')
+                    AnsiLogger.setGlobalLogfile(path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterbrideLoggerFile), "debug", true);
+                else
+                    AnsiLogger.setGlobalLogfile(undefined);
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'setmjlogfile') {
+                this.log.debug('Matter file log:', param);
+                this.matterbridge.matterbridgeInformation.matterFileLogger = param === 'true';
+                await this.matterbridge.nodeContext?.set('matterFileLog', param === 'true');
+                if (param === 'true') {
+                    try {
+                        Logger.addLogger('matterfilelogger', await this.matterbridge.createMatterFileLogger(path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterLoggerFile), true), {
+                            defaultLogLevel: MatterLogLevel.DEBUG,
+                            logFormat: MatterLogFormat.PLAIN,
+                        });
+                    }
+                    catch (error) {
+                        this.log.debug(`Error adding the matterfilelogger for file ${CYAN}${path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterLoggerFile)}${er}: ${error instanceof Error ? error.message : error}`);
+                    }
+                }
+                else {
+                    try {
+                        Logger.removeLogger('matterfilelogger');
+                    }
+                    catch (error) {
+                        this.log.debug(`Error removing the matterfilelogger for file ${CYAN}${path.join(this.matterbridge.matterbridgeDirectory, this.matterbridge.matterLoggerFile)}${er}: ${error instanceof Error ? error.message : error}`);
+                    }
+                }
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'unregister') {
+                await this.matterbridge.unregisterAndShutdownProcess();
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'reset') {
+                await this.matterbridge.shutdownProcessAndReset();
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'factoryreset') {
+                await this.matterbridge.shutdownProcessAndFactoryReset();
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'shutdown') {
+                await this.matterbridge.shutdownProcess();
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'restart') {
+                await this.matterbridge.restartProcess();
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'update') {
+                this.log.info('Updating matterbridge...');
+                try {
+                    await this.matterbridge.spawnCommand('npm', ['install', '-g', 'matterbridge', '--omit=dev', '--verbose']);
+                    this.log.info('Matterbridge has been updated. Full restart required.');
+                }
+                catch (error) {
+                    this.log.error('Error updating matterbridge');
+                }
+                await this.matterbridge.updateProcess();
+                this.wssSendRestartRequired();
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'saveconfig') {
+                param = param.replace(/\*/g, '\\');
+                this.log.info(`Saving config for plugin ${plg}${param}${nf}...`);
+                if (!this.matterbridge.plugins.has(param)) {
+                    this.log.warn(`Plugin ${plg}${param}${wr} not found in matterbridge`);
+                }
+                else {
+                    const plugin = this.matterbridge.plugins.get(param);
+                    if (!plugin)
+                        return;
+                    this.matterbridge.plugins.saveConfigFromJson(plugin, req.body);
+                }
+                this.wssSendRestartRequired();
+                res.json({ message: 'Command received' });
+                return;
+            }
+            if (command === 'installplugin') {
+                param = param.replace(/\*/g, '\\');
+                this.log.info(`Installing plugin ${plg}${param}${nf}...`);
+                try {
+                    await this.matterbridge.spawnCommand('npm', ['install', '-g', param, '--omit=dev', '--verbose']);
+                    this.log.info(`Plugin ${plg}${param}${nf} installed. Full restart required.`);
+                }
+                catch (error) {
+                    this.log.error(`Error installing plugin ${plg}${param}${er}`);
+                }
+                this.wssSendRestartRequired();
+                param = param.split('@')[0];
+                if (param === 'matterbridge') {
+                    res.json({ message: 'Command received' });
+                    return;
+                }
+            }
+            if (command === 'addplugin' || command === 'installplugin') {
+                param = param.replace(/\*/g, '\\');
+                const plugin = await this.matterbridge.plugins.add(param);
+                if (plugin) {
+                    if (this.matterbridge.bridgeMode === 'childbridge') {
+                        this.matterbridge.createDynamicPlugin(plugin, true);
+                    }
+                    this.matterbridge.plugins.load(plugin, true, 'The plugin has been added', true);
+                }
+                res.json({ message: 'Command received' });
+                this.wssSendRefreshRequired();
+                return;
+            }
+            if (command === 'removeplugin') {
+                if (!this.matterbridge.plugins.has(param)) {
+                    this.log.warn(`Plugin ${plg}${param}${wr} not found in matterbridge`);
+                }
+                else {
+                    const plugin = this.matterbridge.plugins.get(param);
+                    await this.matterbridge.plugins.shutdown(plugin, 'The plugin has been removed.', true);
+                    await this.matterbridge.plugins.remove(param);
+                }
+                res.json({ message: 'Command received' });
+                this.wssSendRefreshRequired();
+                return;
+            }
+            if (command === 'enableplugin') {
+                if (!this.matterbridge.plugins.has(param)) {
+                    this.log.warn(`Plugin ${plg}${param}${wr} not found in matterbridge`);
+                }
+                else {
+                    const plugin = this.matterbridge.plugins.get(param);
+                    if (plugin && !plugin.enabled) {
+                        plugin.locked = undefined;
+                        plugin.error = undefined;
+                        plugin.loaded = undefined;
+                        plugin.started = undefined;
+                        plugin.configured = undefined;
+                        plugin.connected = undefined;
+                        plugin.platform = undefined;
+                        plugin.registeredDevices = undefined;
+                        plugin.addedDevices = undefined;
+                        await this.matterbridge.plugins.enable(param);
+                        if (this.matterbridge.bridgeMode === 'childbridge' && plugin.type === 'DynamicPlatform') {
+                            this.matterbridge.createDynamicPlugin(plugin, true);
+                        }
+                        this.matterbridge.plugins.load(plugin, true, 'The plugin has been enabled', true);
+                    }
+                }
+                res.json({ message: 'Command received' });
+                this.wssSendRefreshRequired();
+                return;
+            }
+            if (command === 'disableplugin') {
+                if (!this.matterbridge.plugins.has(param)) {
+                    this.log.warn(`Plugin ${plg}${param}${wr} not found in matterbridge`);
+                }
+                else {
+                    const plugin = this.matterbridge.plugins.get(param);
+                    if (plugin && plugin.enabled) {
+                        await this.matterbridge.plugins.shutdown(plugin, 'The plugin has been disabled.', true);
+                        await this.matterbridge.plugins.disable(param);
+                    }
+                }
+                res.json({ message: 'Command received' });
+                this.wssSendRefreshRequired();
+                return;
+            }
+        });
+        this.expressApp.get('*', (req, res) => {
+            this.log.debug('The frontend sent:', req.url);
+            this.log.debug('Response send file:', path.join(this.matterbridge.rootDirectory, 'frontend/build/index.html'));
+            res.sendFile(path.join(this.matterbridge.rootDirectory, 'frontend/build/index.html'));
+        });
+        this.log.debug(`Frontend initialized on port ${YELLOW}${this.port}${db} static ${UNDERLINE}${path.join(this.matterbridge.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
+    }
+    async stop() {
+        if (this.httpServer) {
+            this.httpServer.close();
+            this.httpServer.removeAllListeners();
+            this.httpServer = undefined;
+            this.log.debug('Frontend http server closed successfully');
+        }
+        if (this.httpsServer) {
+            this.httpsServer.close();
+            this.httpsServer.removeAllListeners();
+            this.httpsServer = undefined;
+            this.log.debug('Frontend https server closed successfully');
+        }
+        if (this.expressApp) {
+            this.expressApp.removeAllListeners();
+            this.expressApp = undefined;
+            this.log.debug('Frontend app closed successfully');
+        }
+        if (this.webSocketServer) {
+            this.webSocketServer.clients.forEach((client) => {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.close();
+                }
+            });
+            this.webSocketServer.close((error) => {
+                if (error) {
+                    this.log.error(`Error closing WebSocket server: ${error}`);
+                }
+                else {
+                    this.log.debug('WebSocket server closed successfully');
+                }
+            });
+            this.webSocketServer = undefined;
+        }
+    }
+    getClusterTextFromDevice(device) {
+        const getAttribute = (device, cluster, attribute) => {
+            let value = undefined;
+            Object.entries(device.state)
+                .filter(([clusterName]) => clusterName.toLowerCase() === cluster.toLowerCase())
+                .forEach(([, clusterAttributes]) => {
+                Object.entries(clusterAttributes)
+                    .filter(([attributeName]) => attributeName.toLowerCase() === attribute.toLowerCase())
+                    .forEach(([, attributeValue]) => {
+                    value = attributeValue;
+                });
+            });
+            if (value === undefined)
+                this.log.error(`Cluster ${cluster} or attribute ${attribute} not found in device ${device.deviceName}`);
+            return value;
+        };
+        const getUserLabel = (device) => {
+            const labelList = getAttribute(device, 'userLabel', 'labelList');
+            if (!labelList)
+                return;
+            const composed = labelList.find((entry) => entry.label === 'composed');
+            if (composed)
+                return 'Composed: ' + composed.value;
+            else
+                return '';
+        };
+        const getFixedLabel = (device) => {
+            const labelList = getAttribute(device, 'fixedLabel', 'labelList');
+            if (!labelList)
+                return;
+            const composed = labelList.find((entry) => entry.label === 'composed');
+            if (composed)
+                return 'Composed: ' + composed.value;
+            else
+                return '';
+        };
+        let attributes = '';
+        Object.entries(device.state).forEach(([clusterName, clusterAttributes]) => {
+            Object.entries(clusterAttributes).forEach(([attributeName, attributeValue]) => {
+                if (clusterName === 'onOff' && attributeName === 'onOff')
+                    attributes += `OnOff: ${attributeValue} `;
+                if (clusterName === 'switch' && attributeName === 'currentPosition')
+                    attributes += `Position: ${attributeValue} `;
+                if (clusterName === 'windowCovering' && attributeName === 'currentPositionLiftPercent100ths')
+                    attributes += `Cover position: ${attributeValue / 100}% `;
+                if (clusterName === 'doorLock' && attributeName === 'lockState')
+                    attributes += `State: ${attributeValue === 1 ? 'Locked' : 'Not locked'} `;
+                if (clusterName === 'thermostat' && attributeName === 'localTemperature')
+                    attributes += `Temperature: ${attributeValue / 100}°C `;
+                if (clusterName === 'thermostat' && attributeName === 'occupiedHeatingSetpoint')
+                    attributes += `Heat to: ${attributeValue / 100}°C `;
+                if (clusterName === 'thermostat' && attributeName === 'occupiedCoolingSetpoint')
+                    attributes += `Cool to: ${attributeValue / 100}°C `;
+                if (clusterName === 'pumpConfigurationAndControl' && attributeName === 'operationMode')
+                    attributes += `Mode: ${attributeValue} `;
+                if (clusterName === 'valveConfigurationAndControl' && attributeName === 'currentState')
+                    attributes += `State: ${attributeValue} `;
+                if (clusterName === 'levelControl' && attributeName === 'currentLevel')
+                    attributes += `Level: ${attributeValue}% `;
+                if (clusterName === 'colorControl' && attributeName === 'colorMode')
+                    attributes += `Mode: ${['HS', 'XY', 'CT'][attributeValue]} `;
+                if (clusterName === 'colorControl' && getAttribute(device, 'colorControl', 'colorMode') === 0 && attributeName === 'currentHue')
+                    attributes += `Hue: ${Math.round(attributeValue)} `;
+                if (clusterName === 'colorControl' && getAttribute(device, 'colorControl', 'colorMode') === 0 && attributeName === 'currentSaturation')
+                    attributes += `Saturation: ${Math.round(attributeValue)} `;
+                if (clusterName === 'colorControl' && getAttribute(device, 'colorControl', 'colorMode') === 1 && attributeName === 'currentX')
+                    attributes += `X: ${Math.round(attributeValue)} `;
+                if (clusterName === 'colorControl' && getAttribute(device, 'colorControl', 'colorMode') === 1 && attributeName === 'currentY')
+                    attributes += `Y: ${Math.round(attributeValue)} `;
+                if (clusterName === 'colorControl' && getAttribute(device, 'colorControl', 'colorMode') === 2 && attributeName === 'colorTemperatureMireds')
+                    attributes += `ColorTemp: ${Math.round(attributeValue)} `;
+                if (clusterName === 'booleanState' && attributeName === 'stateValue')
+                    attributes += `Contact: ${attributeValue} `;
+                if (clusterName === 'booleanStateConfiguration' && attributeName === 'alarmsActive')
+                    attributes += `Active alarms: ${stringify(attributeValue)} `;
+                if (clusterName === 'smokeCoAlarm' && attributeName === 'smokeState')
+                    attributes += `Smoke: ${attributeValue} `;
+                if (clusterName === 'smokeCoAlarm' && attributeName === 'coState')
+                    attributes += `Co: ${attributeValue} `;
+                if (clusterName === 'fanControl' && attributeName === 'fanMode')
+                    attributes += `Mode: ${attributeValue} `;
+                if (clusterName === 'fanControl' && attributeName === 'percentCurrent')
+                    attributes += `Percent: ${attributeValue} `;
+                if (clusterName === 'fanControl' && attributeName === 'speedCurrent')
+                    attributes += `Speed: ${attributeValue} `;
+                if (clusterName === 'occupancySensing' && attributeName === 'occupancy')
+                    attributes += `Occupancy: ${attributeValue.occupied} `;
+                if (clusterName === 'illuminanceMeasurement' && attributeName === 'measuredValue')
+                    attributes += `Illuminance: ${attributeValue} `;
+                if (clusterName === 'airQuality' && attributeName === 'airQuality')
+                    attributes += `Air quality: ${attributeValue} `;
+                if (clusterName === 'tvocMeasurement' && attributeName === 'measuredValue')
+                    attributes += `Voc: ${attributeValue} `;
+                if (clusterName === 'temperatureMeasurement' && attributeName === 'measuredValue')
+                    attributes += `Temperature: ${attributeValue / 100}°C `;
+                if (clusterName === 'relativeHumidityMeasurement' && attributeName === 'measuredValue')
+                    attributes += `Humidity: ${attributeValue / 100}% `;
+                if (clusterName === 'pressureMeasurement' && attributeName === 'measuredValue')
+                    attributes += `Pressure: ${attributeValue} `;
+                if (clusterName === 'flowMeasurement' && attributeName === 'measuredValue')
+                    attributes += `Flow: ${attributeValue} `;
+                if (clusterName === 'fixedLabel' && attributeName === 'labelList')
+                    attributes += `${getFixedLabel(device)} `;
+                if (clusterName === 'userLabel' && attributeName === 'labelList')
+                    attributes += `${getUserLabel(device)} `;
+            });
+        });
+        return attributes.trimStart().trimEnd();
+    }
+    async getBaseRegisteredPlugins() {
+        const baseRegisteredPlugins = [];
+        for (const plugin of this.matterbridge.plugins) {
+            baseRegisteredPlugins.push({
+                path: plugin.path,
+                type: plugin.type,
+                name: plugin.name,
+                version: plugin.version,
+                description: plugin.description,
+                author: plugin.author,
+                latestVersion: plugin.latestVersion,
+                locked: plugin.locked,
+                error: plugin.error,
+                enabled: plugin.enabled,
+                loaded: plugin.loaded,
+                started: plugin.started,
+                configured: plugin.configured,
+                paired: plugin.paired,
+                connected: plugin.connected,
+                fabricInformations: plugin.fabricInformations,
+                sessionInformations: plugin.sessionInformations,
+                registeredDevices: plugin.registeredDevices,
+                addedDevices: plugin.addedDevices,
+                qrPairingCode: plugin.qrPairingCode,
+                manualPairingCode: plugin.manualPairingCode,
+                configJson: plugin.configJson,
+                schemaJson: plugin.schemaJson,
+            });
+        }
+        return baseRegisteredPlugins;
+    }
+    async wsMessageHandler(client, message) {
+        let data;
+        try {
+            data = JSON.parse(message.toString());
+            if (!isValidNumber(data.id) || !isValidString(data.dst) || !isValidString(data.src) || !isValidString(data.method) || !isValidObject(data.params) || data.dst !== 'Matterbridge') {
+                this.log.error(`Invalid message from websocket client: ${debugStringify(data)}`);
+                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid message' }));
+                return;
+            }
+            this.log.debug(`Received message from websocket client: ${debugStringify(data)}`);
+            if (data.method === 'ping') {
+                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: 'pong' }));
+                return;
+            }
+            else if (data.method === '/api/login') {
+                if (!this.matterbridge.nodeContext) {
+                    this.log.error('Login nodeContext not found');
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Internal error: nodeContext not found' }));
+                    return;
+                }
+                const storedPassword = await this.matterbridge.nodeContext.get('password', '');
+                if (storedPassword === '' || storedPassword === data.params.password) {
+                    this.log.debug('Login password valid');
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: { valid: true } }));
+                    return;
+                }
+                else {
+                    this.log.debug('Error wrong password');
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong password' }));
+                    return;
+                }
+            }
+            else if (data.method === '/api/install') {
+                if (!isValidString(data.params.packageName, 10)) {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter packageName in /api/install' }));
+                    return;
+                }
+                this.matterbridge
+                    .spawnCommand('npm', ['install', '-g', data.params.packageName, '--omit=dev', '--verbose'])
+                    .then((response) => {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response }));
+                })
+                    .catch((error) => {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: error instanceof Error ? error.message : error }));
+                });
+                return;
+            }
+            else if (data.method === '/api/uninstall') {
+                if (!isValidString(data.params.packageName, 10)) {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter packageName in /api/uninstall' }));
+                    return;
+                }
+                this.matterbridge
+                    .spawnCommand('npm', ['uninstall', '-g', data.params.packageName, '--verbose'])
+                    .then((response) => {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response }));
+                })
+                    .catch((error) => {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: error instanceof Error ? error.message : error }));
+                });
+                return;
+            }
+            else if (data.method === '/api/restart') {
+                await this.matterbridge.restartProcess();
+                return;
+            }
+            else if (data.method === '/api/shutdown') {
+                await this.matterbridge.shutdownProcess();
+                return;
+            }
+            else if (data.method === '/api/settings') {
+                this.matterbridge.matterbridgeInformation.bridgeMode = this.matterbridge.bridgeMode;
+                this.matterbridge.matterbridgeInformation.restartMode = this.matterbridge.restartMode;
+                this.matterbridge.matterbridgeInformation.loggerLevel = this.log.logLevel;
+                this.matterbridge.matterbridgeInformation.matterLoggerLevel = Logger.defaultLogLevel;
+                this.matterbridge.matterbridgeInformation.mattermdnsinterface = (await this.matterbridge.nodeContext?.get('mattermdnsinterface', '')) || '';
+                this.matterbridge.matterbridgeInformation.matteripv4address = (await this.matterbridge.nodeContext?.get('matteripv4address', '')) || '';
+                this.matterbridge.matterbridgeInformation.matteripv6address = (await this.matterbridge.nodeContext?.get('matteripv6address', '')) || '';
+                this.matterbridge.matterbridgeInformation.matterPort = (await this.matterbridge.nodeContext?.get('matterport', 5540)) ?? 5540;
+                this.matterbridge.matterbridgeInformation.matterDiscriminator = await this.matterbridge.nodeContext?.get('matterdiscriminator');
+                this.matterbridge.matterbridgeInformation.matterPasscode = await this.matterbridge.nodeContext?.get('matterpasscode');
+                this.matterbridge.matterbridgeInformation.matterbridgePaired = this.matterbridge.matterbridgePaired;
+                this.matterbridge.matterbridgeInformation.matterbridgeConnected = this.matterbridge.matterbridgeConnected;
+                this.matterbridge.matterbridgeInformation.matterbridgeQrPairingCode = this.matterbridge.matterbridgeQrPairingCode;
+                this.matterbridge.matterbridgeInformation.matterbridgeManualPairingCode = this.matterbridge.matterbridgeManualPairingCode;
+                this.matterbridge.matterbridgeInformation.matterbridgeFabricInformations = this.matterbridge.matterbridgeFabricInformations;
+                this.matterbridge.matterbridgeInformation.matterbridgeSessionInformations = Array.from(this.matterbridge.matterbridgeSessionInformations.values());
+                this.matterbridge.matterbridgeInformation.profile = this.matterbridge.profile;
+                const response = { systemInformation: this.matterbridge.systemInformation, matterbridgeInformation: this.matterbridge.matterbridgeInformation };
+                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response }));
+                return;
+            }
+            else if (data.method === '/api/plugins') {
+                const response = await this.getBaseRegisteredPlugins();
+                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response }));
+                return;
+            }
+            else if (data.method === '/api/devices') {
+                const devices = [];
+                this.matterbridge.devices.forEach(async (device) => {
+                    if (data.params.pluginName && data.params.pluginName !== device.plugin)
+                        return;
+                    if (!device.plugin || !device.name || !device.deviceName || !device.serialNumber || !device.uniqueId)
+                        return;
+                    const cluster = this.getClusterTextFromDevice(device);
+                    devices.push({
+                        pluginName: device.plugin,
+                        type: device.name + ' (0x' + device.deviceType.toString(16).padStart(4, '0') + ')',
+                        endpoint: device.number,
+                        name: device.deviceName,
+                        serial: device.serialNumber,
+                        productUrl: device.productUrl,
+                        configUrl: device.configUrl,
+                        uniqueId: device.uniqueId,
+                        cluster: cluster,
+                    });
+                });
+                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: devices }));
+                return;
+            }
+            else if (data.method === '/api/clusters') {
+                if (!isValidString(data.params.plugin, 10)) {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/clusters' }));
+                    return;
+                }
+                if (!isValidNumber(data.params.endpoint, 1)) {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter endpoint in /api/clusters' }));
+                    return;
+                }
+                const clusters = [];
+                let deviceName = '';
+                let serialNumber = '';
+                let deviceTypes = [];
+                this.matterbridge.devices.forEach(async (device) => {
+                    if (data.params.plugin !== device.plugin)
+                        return;
+                    if (data.params.endpoint !== device.number)
+                        return;
+                    deviceName = device.deviceName ?? 'Unknown';
+                    serialNumber = device.serialNumber ?? 'Unknown';
+                    deviceTypes = [];
+                    const endpointServer = EndpointServer.forEndpoint(device);
+                    const clusterServers = endpointServer.getAllClusterServers();
+                    clusterServers.forEach((clusterServer) => {
+                        Object.entries(clusterServer.attributes).forEach(([key, value]) => {
+                            if (clusterServer.name === 'EveHistory')
+                                return;
+                            if (clusterServer.name === 'Descriptor' && key === 'deviceTypeList') {
+                                value.getLocal().forEach((deviceType) => {
+                                    deviceTypes.push(deviceType.deviceType);
+                                });
+                            }
+                            let attributeValue;
+                            let attributeLocalValue;
+                            try {
+                                if (typeof value.getLocal() === 'object')
+                                    attributeValue = stringify(value.getLocal());
+                                else
+                                    attributeValue = value.getLocal().toString();
+                                attributeLocalValue = value.getLocal();
+                            }
+                            catch (error) {
+                                attributeValue = 'Fabric-Scoped';
+                                attributeLocalValue = 'Fabric-Scoped';
+                                this.log.debug(`GetLocal value ${error} in clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute: ${key}(${value.id})`);
+                            }
+                            clusters.push({
+                                endpoint: device.number ? device.number.toString() : '...',
+                                id: 'main',
+                                deviceTypes,
+                                clusterName: clusterServer.name,
+                                clusterId: '0x' + clusterServer.id.toString(16).padStart(2, '0'),
+                                attributeName: key,
+                                attributeId: '0x' + value.id.toString(16).padStart(2, '0'),
+                                attributeValue,
+                                attributeLocalValue,
+                            });
+                        });
+                    });
+                    endpointServer.getChildEndpoints().forEach((childEndpoint) => {
+                        deviceTypes = [];
+                        const name = childEndpoint.endpoint?.id;
+                        const clusterServers = childEndpoint.getAllClusterServers();
+                        clusterServers.forEach((clusterServer) => {
+                            Object.entries(clusterServer.attributes).forEach(([key, value]) => {
+                                if (clusterServer.name === 'EveHistory')
+                                    return;
+                                if (clusterServer.name === 'Descriptor' && key === 'deviceTypeList') {
+                                    value.getLocal().forEach((deviceType) => {
+                                        deviceTypes.push(deviceType.deviceType);
+                                    });
+                                }
+                                let attributeValue;
+                                let attributeLocalValue;
+                                try {
+                                    if (typeof value.getLocal() === 'object')
+                                        attributeValue = stringify(value.getLocal());
+                                    else
+                                        attributeValue = value.getLocal().toString();
+                                    attributeLocalValue = value.getLocal();
+                                }
+                                catch (error) {
+                                    attributeValue = 'Fabric-Scoped';
+                                    attributeLocalValue = 'Fabric-Scoped';
+                                    this.log.debug(`GetLocal error ${error} in clusterServer: ${clusterServer.name}(${clusterServer.id}) attribute: ${key}(${value.id})`);
+                                }
+                                clusters.push({
+                                    endpoint: childEndpoint.number ? childEndpoint.number.toString() : '...',
+                                    id: name,
+                                    deviceTypes,
+                                    clusterName: clusterServer.name,
+                                    clusterId: '0x' + clusterServer.id.toString(16).padStart(2, '0'),
+                                    attributeName: key,
+                                    attributeId: '0x' + value.id.toString(16).padStart(2, '0'),
+                                    attributeValue,
+                                    attributeLocalValue,
+                                });
+                            });
+                        });
+                    });
+                });
+                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, plugin: data.params.plugin, deviceName, serialNumber, endpoint: data.params.endpoint, deviceTypes, response: clusters }));
+                return;
+            }
+            else if (data.method === '/api/select') {
+                if (!isValidString(data.params.plugin, 10)) {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/select' }));
+                    return;
+                }
+                const plugin = this.matterbridge.plugins.get(data.params.plugin);
+                if (!plugin) {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/select' }));
+                    return;
+                }
+                const selectDeviceValues = plugin.platform?.selectDevice ? Array.from(plugin.platform.selectDevice.values()).sort((keyA, keyB) => keyA.name.localeCompare(keyB.name)) : [];
+                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, plugin: data.params.plugin, response: selectDeviceValues }));
+                return;
+            }
+            else if (data.method === '/api/select/entities') {
+                if (!isValidString(data.params.plugin, 10)) {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/select/entities' }));
+                    return;
+                }
+                const plugin = this.matterbridge.plugins.get(data.params.plugin);
+                if (!plugin) {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/select/entities' }));
+                    return;
+                }
+                const selectEntityValues = plugin.platform?.selectDevice ? Array.from(plugin.platform.selectEntity.values()).sort((keyA, keyB) => keyA.name.localeCompare(keyB.name)) : [];
+                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, plugin: data.params.plugin, response: selectEntityValues }));
+                return;
+            }
+            else {
+                this.log.error(`Invalid method from websocket client: ${debugStringify(data)}`);
+                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid method' }));
+                return;
+            }
+        }
+        catch (error) {
+            this.log.error(`Error parsing message "${message}" from websocket client:`, error instanceof Error ? error.message : error);
+            return;
+        }
+    }
+    wssSendMessage(level, time, name, message) {
+        if (!level || !time || !name || !message)
+            return;
+        message = message.replace(/\x1B\[[0-9;]*[m|s|u|K]/g, '');
+        message = message.replace(/^\*+/, '');
+        message = message.replace(/[\t\n]/g, '');
+        message = message.replace(/[\x00-\x1F\x7F]/g, '');
+        message = message.replace(/\\"/g, '"');
+        const maxContinuousLength = 100;
+        const keepStartLength = 20;
+        const keepEndLength = 20;
+        message = message
+            .split(' ')
+            .map((word) => {
+            if (word.length > maxContinuousLength) {
+                return word.slice(0, keepStartLength) + ' ... ' + word.slice(-keepEndLength);
+            }
+            return word;
+        })
+            .join(' ');
+        this.webSocketServer?.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(JSON.stringify({ id: WS_ID_LOG, src: 'Matterbridge', level, time, name, message }));
+            }
+        });
+    }
+    wssSendRefreshRequired() {
+        this.log.debug('Sending a refresh required message to all connected clients');
+        this.matterbridge.matterbridgeInformation.refreshRequired = true;
+        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: {} }));
+            }
+        });
+    }
+    wssSendRestartRequired() {
+        this.log.debug('Sending a restart required message to all connected clients');
+        this.matterbridge.matterbridgeInformation.restartRequired = true;
+        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: {} }));
+            }
+        });
+    }
+}