@matterbridge/core 3.7.2-dev-20260331-ac050d8 → 3.7.2

package/dist/backendWsServer.js

@@ -0,0 +1,307 @@
+import { Logger, LogLevel as MatterLogLevel } from '@matter/general';
+import { BroadcastServer } from '@matterbridge/thread';
+import { hasParameter } from '@matterbridge/utils/cli';
+import { inspectError } from '@matterbridge/utils/error';
+import { isValidNumber, isValidString } from '@matterbridge/utils/validate';
+import { withTimeout } from '@matterbridge/utils/wait';
+import { AnsiLogger, CYAN, debugStringify, nf } from 'node-ansi-logger';
+import WebSocket, { WebSocketServer } from 'ws';
+if (hasParameter('loader'))
+    console.log('\u001B[32mBackendWsServer loaded.\u001B[40;0m');
+export class BackendsWsServer {
+    debug;
+    verbose;
+    webSocketServer;
+    log;
+    backend;
+    matterbridge;
+    server;
+    constructor(matterbridge, backend) {
+        this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-frontend') || hasParameter('verbose-frontend');
+        this.verbose = hasParameter('verbose') || hasParameter('verbose-frontend');
+        this.backend = backend;
+        this.matterbridge = matterbridge;
+        this.log = new AnsiLogger({
+            logName: 'BackendWsServer',
+            logNameColor: '\x1b[38;5;97m',
+            logTimestampFormat: 4,
+            logLevel: this.debug ? "debug" : "info",
+        });
+        this.server = new BroadcastServer('frontend', this.log);
+        this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
+    }
+    destroy() {
+        this.server.off('broadcast_message', this.broadcastMsgHandler.bind(this));
+        this.server.close();
+    }
+    async broadcastMsgHandler(msg) {
+        if (this.server.isWorkerRequest(msg)) {
+            switch (msg.type) {
+                case 'get_log_level':
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
+                    break;
+                case 'set_log_level':
+                    this.log.logLevel = msg.params.logLevel;
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
+                    break;
+            }
+        }
+    }
+    async start() {
+        this.log.debug(`Creating WebSocketServer...`);
+        this.webSocketServer = new WebSocketServer({ noServer: true });
+        this.backend.emit('websocket_server_listening', hasParameter('ssl') ? 'wss' : 'ws');
+        this.webSocketServer.on('connection', (websocket, request) => {
+            const clientIp = request.socket.remoteAddress;
+            this.log.info(`WebSocketServer client ${CYAN}${clientIp}${nf} connected to Matterbridge`);
+            let callbackLogLevel = "notice";
+            if (this.log.logLevel === "info" || Logger.level === MatterLogLevel.INFO)
+                callbackLogLevel = "info";
+            if (this.log.logLevel === "debug" || Logger.level === MatterLogLevel.DEBUG)
+                callbackLogLevel = "debug";
+            AnsiLogger.setGlobalCallback(this.wssSendLogMessage.bind(this), callbackLogLevel);
+            this.log.debug(`WebSocketServer logger global callback set to ${callbackLogLevel}`);
+            websocket.on('message', (data) => {
+                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} sent a message`);
+                this.wsMessageHandler(websocket, data);
+            });
+            websocket.on('ping', () => {
+                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} ping received`);
+                websocket.pong();
+            });
+            websocket.on('pong', () => {
+                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} pong received`);
+            });
+            websocket.on('close', (code, reason) => {
+                this.log.info(`WebSocket client ${CYAN}${clientIp}${nf} disconnected code ${code} reason ${reason.toString()}`);
+                if (this.webSocketServer?.clients.size === 0) {
+                    AnsiLogger.setGlobalCallback(undefined);
+                    this.log.debug('All WebSocket clients disconnected. WebSocketServer logger global callback removed');
+                    setTimeout(() => {
+                        if (this.webSocketServer?.clients.size === 0) {
+                            this.log.debug('All WebSocket clients disconnected. Auth clients list cleared');
+                            this.backend.authClients.clear();
+                        }
+                    }, 1000).unref();
+                }
+                else {
+                    this.log.debug(`WebSocketServer still has ${this.webSocketServer?.clients.size} connected clients`);
+                }
+            });
+            websocket.on('error', (error) => {
+                inspectError(this.log, `WebSocket client error`, error);
+            });
+        });
+        this.webSocketServer.on('close', () => {
+            this.log.debug(`WebSocketServer closed`);
+        });
+        this.webSocketServer.on('error', (ws, error) => {
+            inspectError(this.log, `WebSocketServer error`, error);
+        });
+        return this.webSocketServer;
+    }
+    async stop() {
+        if (this.webSocketServer) {
+            this.log.debug('Closing WebSocket server...');
+            this.webSocketServer.clients.forEach((client) => {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.close();
+                }
+            });
+            await withTimeout(new Promise((resolve) => {
+                this.webSocketServer?.close((error) => {
+                    if (error) {
+                        inspectError(this.log, `Error closing WebSocket server`, error);
+                    }
+                    else {
+                        this.log.debug('WebSocket server closed successfully');
+                        this.backend.emit('websocket_server_stopped');
+                    }
+                    resolve();
+                });
+            }), 10000, false);
+            this.webSocketServer.removeAllListeners();
+            this.webSocketServer = undefined;
+        }
+        else {
+            this.log.debug('WebSocket server is not running');
+        }
+        return this.webSocketServer;
+    }
+    hasActiveClients() {
+        return this.webSocketServer !== undefined && this.webSocketServer.clients.size > 0;
+    }
+    async wsMessageHandler(client, rawData) {
+        let data;
+        const sendResponse = (data) => {
+            if (client.readyState === client.OPEN) {
+                if ('response' in data) {
+                    const { response, ...rest } = data;
+                    this.log.debug(`Sending api response message: ${debugStringify(rest)}`);
+                }
+                else if ('error' in data) {
+                    this.log.debug(`Sending api error message: ${debugStringify(data)}`);
+                }
+                client.send(JSON.stringify(data));
+            }
+            else {
+                this.log.error('Cannot send api response, client not connected');
+            }
+        };
+        try {
+            data = JSON.parse(rawData.toString());
+            if (!isValidNumber(data.id) || !isValidString(data.dst) || !isValidString(data.src) || !isValidString(data.method) || data.dst !== 'Matterbridge') {
+                this.log.error(`Invalid message from websocket client: ${debugStringify(data)}`);
+                sendResponse({ 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)}`);
+        }
+        catch (error) {
+            inspectError(this.log, `Error parsing message from websocket client`, error);
+            return;
+        }
+    }
+    wssBroadcastMessage(msg) {
+        if (!this.hasActiveClients())
+            return;
+        try {
+            const stringifiedMsg = JSON.stringify(msg);
+            if (this.verbose)
+                this.log.debug(`Sending a broadcast message: ${debugStringify(msg)}`);
+            this.webSocketServer?.clients.forEach((client) => {
+                if (client.readyState === client.OPEN) {
+                    client.send(stringifiedMsg);
+                }
+            });
+        }
+        catch (error) {
+            inspectError(this.log, `Error broadcasting message to websocket clients`, error);
+        }
+    }
+    wssSendLogMessage(level, time, name, message) {
+        if (!this.hasActiveClients())
+            return;
+        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;
+        if (level !== 'spawn') {
+            message = message
+                .split(' ')
+                .map((word) => {
+                if (word.length > maxContinuousLength) {
+                    return word.slice(0, keepStartLength) + ' ... ' + word.slice(-keepEndLength);
+                }
+                return word;
+            })
+                .join(' ');
+        }
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'log', success: true, response: { level, time, name, message } });
+    }
+    wssSendRefreshRequired(changed, params) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a refresh required message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', success: true, response: { changed, lock: params?.lock, ...params } });
+    }
+    wssSendRestartRequired(snackbar = true, fixed = false) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a restart required message to all connected clients');
+        this.backend.restartRequired = true;
+        this.backend.fixedRestartRequired = fixed;
+        if (snackbar === true)
+            this.wssSendSnackbarMessage(`Restart required`, 0);
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', success: true, response: { fixed } });
+    }
+    wssSendRestartNotRequired(snackbar = true) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a restart not required message to all connected clients');
+        this.backend.restartRequired = false;
+        if (snackbar === true)
+            this.wssSendCloseSnackbarMessage(`Restart required`);
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
+    }
+    wssSendUpdateRequired(devVersion = false) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending an update required message to all connected clients');
+        this.backend.updateRequired = true;
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'update_required', success: true, response: { devVersion } });
+    }
+    wssSendCpuUpdate(cpuUsage, processCpuUsage) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a cpu update message to all connected clients');
+        this.wssBroadcastMessage({
+            id: 0,
+            src: 'Matterbridge',
+            dst: 'Frontend',
+            method: 'cpu_update',
+            success: true,
+            response: { cpuUsage: Math.round(cpuUsage * 100) / 100, processCpuUsage: Math.round(processCpuUsage * 100) / 100 },
+        });
+    }
+    wssSendMemoryUpdate(totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a memory update message to all connected clients');
+        this.wssBroadcastMessage({
+            id: 0,
+            src: 'Matterbridge',
+            dst: 'Frontend',
+            method: 'memory_update',
+            success: true,
+            response: { totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers },
+        });
+    }
+    wssSendUptimeUpdate(systemUptime, processUptime) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a uptime update message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'uptime_update', success: true, response: { systemUptime, processUptime } });
+    }
+    wssSendSnackbarMessage(message, timeout = 5, severity = 'info') {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a snackbar message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'snackbar', success: true, response: { message, timeout, severity } });
+    }
+    wssSendCloseSnackbarMessage(message) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a close snackbar message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'close_snackbar', success: true, response: { message } });
+    }
+    wssSendAttributeChangedMessage(plugin, serialNumber, uniqueId, number, id, cluster, attribute, value) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending an attribute update message to all connected clients');
+        this.wssBroadcastMessage({
+            id: 0,
+            src: 'Matterbridge',
+            dst: 'Frontend',
+            method: 'state_update',
+            success: true,
+            response: { plugin, serialNumber, uniqueId, number, id, cluster, attribute, value },
+        });
+    }
+}

package/dist/cli.js

@@ -12,7 +12,8 @@ export let instance;
 export const tracker = new Tracker('Cli', false, false);
 export const inspector = new Inspector('Cli', false, false);
 const manager = new ThreadsManager();
-if (process.argv.includes('--no-ansi') || process.argv.includes('-no-ansi'))
+const colorEnabled = Boolean(process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== 'dumb' && process.env.FORCE_COLOR !== '0' && !hasParameter('no-ansi'));
+if (!colorEnabled)
     process.env.NO_COLOR = '1';
 const log = new AnsiLogger({ logName: 'Cli', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
 function startCpuMemoryCheck() {

package/dist/frontend.d.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'node:events';
 import { EndpointNumber } from '@matter/types/datatype';
-import type { ApiMatter, RefreshRequiredChanged, WsMessageBroadcast } from '@matterbridge/types';
+import type { ApiClusters, ApiDevice, ApiMatter, ApiPlugin, ApiSettings, RefreshRequiredChanged, WsMessageBroadcast } from '@matterbridge/types';
 import { LogLevel } from 'node-ansi-logger';
 import type { Matterbridge } from './matterbridge.js';
 interface FrontendEvents {
@@ -15,8 +15,8 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     private log;
     private port;
     private listening;
-    private storedPassword;
-    private authClients;
+    storedPassword: string | undefined;
+    authClients: Set<string>;
     private expressApp;
     private httpServer;
     private httpsServer;
@@ -25,22 +25,29 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     private serverFetchTimeout;
     private readonly debug;
     private readonly verbose;
+    readonly readOnly: boolean;
+    readonly shellyBoard: boolean;
+    shellySysUpdate: boolean;
+    shellyMainUpdate: boolean;
+    restartRequired: boolean;
+    fixedRestartRequired: boolean;
+    updateRequired: boolean;
     constructor(matterbridge: Matterbridge);
     destroy(): void;
-    private msgHandler;
+    private broadcastMsgHandler;
     set logLevel(logLevel: LogLevel);
     private validateReq;
     start(port?: number): Promise<void>;
     stop(): Promise<void>;
-    private getApiSettings;
+    getApiSettings(): ApiSettings;
     private getReachability;
     private getPowerSource;
     private getBatteryLevel;
     private getClusterTextFromDevice;
-    private getPlugins;
-    private getDevices;
-    private getClusters;
-    private generateDiagnostic;
+    getApiPlugins(): ApiPlugin[];
+    getApiDevices(pluginName?: string): ApiDevice[];
+    getClusters(pluginName: string, endpointNumber: number, serialNumber?: string, uniqueId?: string): ApiClusters | undefined;
+    generateDiagnostic(): Promise<void>;
     private wsMessageHandler;
     wssSendLogMessage(level: string, time: string, name: string, message: string): void;
     wssSendRefreshRequired(changed: RefreshRequiredChanged, params?: {

package/dist/frontend.js

@@ -1,5 +1,3 @@
-if (process.argv.includes('--loader') || process.argv.includes('-loader'))
-    console.log('\u001B[32mFrontend loaded.\u001B[40;0m');
 import EventEmitter from 'node:events';
 import os from 'node:os';
 import path from 'node:path';
@@ -10,7 +8,7 @@ import { PowerSource } from '@matter/types/clusters/power-source';
 import { CommissioningOptions } from '@matter/types/commissioning';
 import { FabricIndex } from '@matter/types/datatype';
 import { BroadcastServer } from '@matterbridge/thread/server';
-import { MATTER_LOGGER_FILE, MATTER_STORAGE_NAME, MATTERBRIDGE_DIAGNOSTIC_FILE, MATTERBRIDGE_HISTORY_FILE, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, } from '@matterbridge/types';
+import { MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_DIAGNOSTIC_FILE, MATTERBRIDGE_HISTORY_FILE, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, } from '@matterbridge/types';
 import { getParameter, hasParameter } from '@matterbridge/utils/cli';
 import { inspectError } from '@matterbridge/utils/error';
 import { formatBytes, formatPercent, formatUptime } from '@matterbridge/utils/format';
@@ -20,6 +18,8 @@ import { AnsiLogger, CYAN, db, debugStringify, er, nf, nt, rs, stringify, UNDERL
 import { cliEmitter, lastOsCpuUsage, lastProcessCpuUsage } from './cliEmitter.js';
 import { generateHistoryPage } from './cliHistory.js';
 import { capitalizeFirstLetter, getAttribute } from './matterbridgeEndpointHelpers.js';
+if (hasParameter('loader'))
+    console.log('\u001B[32mFrontend loaded.\u001B[40;0m');
 export class Frontend extends EventEmitter {
     matterbridge;
     log;
@@ -35,6 +35,13 @@ export class Frontend extends EventEmitter {
     serverFetchTimeout = 2000;
     debug = hasParameter('debug') || hasParameter('verbose');
     verbose = hasParameter('verbose');
+    readOnly = hasParameter('readonly') || hasParameter('shelly');
+    shellyBoard = hasParameter('shelly');
+    shellySysUpdate = false;
+    shellyMainUpdate = false;
+    restartRequired = false;
+    fixedRestartRequired = false;
+    updateRequired = false;
     constructor(matterbridge) {
         super();
         this.matterbridge = matterbridge;
@@ -45,13 +52,13 @@ export class Frontend extends EventEmitter {
             logLevel: hasParameter('debug') ? "debug" : "info",
         });
         this.server = new BroadcastServer('frontend', this.log);
-        this.server.on('broadcast_message', this.msgHandler.bind(this));
+        this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
     }
     destroy() {
-        this.server.off('broadcast_message', this.msgHandler.bind(this));
+        this.server.off('broadcast_message', this.broadcastMsgHandler.bind(this));
         this.server.close();
     }
-    async msgHandler(msg) {
+    async broadcastMsgHandler(msg) {
         if (this.server.isWorkerRequest(msg)) {
             if (this.verbose)
                 this.log.debug(`Received broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
@@ -116,6 +123,8 @@ export class Frontend extends EventEmitter {
                     if (msg.result && msg.result.packageCommand === 'install') {
                         this.wssSendCloseSnackbarMessage(`Installing package ${msg.result.packageName}...`);
                         if (msg.result.success) {
+                            this.restartRequired = true;
+                            this.fixedRestartRequired = true;
                             this.wssSendRestartRequired(true, true);
                             this.wssSendSnackbarMessage(`Installed package ${msg.result.packageName}`, 5, 'success');
                         }
@@ -126,6 +135,8 @@ export class Frontend extends EventEmitter {
                     if (msg.result && msg.result.packageCommand === 'uninstall') {
                         this.wssSendCloseSnackbarMessage(`Uninstalling package ${msg.result.packageName}...`);
                         if (msg.result.success) {
+                            this.restartRequired = true;
+                            this.fixedRestartRequired = true;
                             this.wssSendRestartRequired(true, true);
                             this.wssSendSnackbarMessage(`Uninstalled package ${msg.result.packageName}`, 5, 'success');
                         }
@@ -490,19 +501,19 @@ export class Frontend extends EventEmitter {
             this.log.debug('The frontend sent /api/settings');
             if (!this.validateReq(req, res))
                 return;
-            res.json(await this.getApiSettings());
+            res.json(this.getApiSettings());
         });
         this.expressApp.get('/api/plugins', async (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
             if (!this.validateReq(req, res))
                 return;
-            res.json(this.matterbridge.hasCleanupStarted ? [] : this.getPlugins());
+            res.json(this.getApiPlugins());
         });
         this.expressApp.get('/api/devices', async (req, res) => {
             this.log.debug('The frontend sent /api/devices');
             if (!this.validateReq(req, res))
                 return;
-            res.json(this.matterbridge.hasCleanupStarted ? [] : this.getDevices());
+            res.json(this.getApiDevices());
         });
         this.expressApp.get('/api/view-mblog', async (req, res) => {
             this.log.debug('The frontend sent /api/view-mblog');
@@ -699,14 +710,14 @@ export class Frontend extends EventEmitter {
             this.log.debug('The frontend sent /api/download-mjstorage');
             if (!this.validateReq(req, res))
                 return;
-            res.download(path.join(os.tmpdir(), `matterbridge.${MATTER_STORAGE_NAME}.zip`), `matterbridge.${MATTER_STORAGE_NAME}.zip`, (error) => {
+            res.download(path.join(os.tmpdir(), `matterbridge.${MATTER_STORAGE_DIR}.zip`), `matterbridge.${MATTER_STORAGE_DIR}.zip`, (error) => {
                 this.wssSendCloseSnackbarMessage('Creating matter storage backup...');
                 if (error) {
-                    this.log.error(`Error downloading the matter storage matterbridge.${MATTER_STORAGE_NAME}.zip: ${error instanceof Error ? error.message : error}`);
+                    this.log.error(`Error downloading the matter storage matterbridge.${MATTER_STORAGE_DIR}.zip: ${error instanceof Error ? error.message : error}`);
                     res.status(500).send('Error downloading the matter storage zip file');
                 }
                 else {
-                    this.log.debug(`Matter storage matterbridge.${MATTER_STORAGE_NAME}.zip downloaded successfully`);
+                    this.log.debug(`Matter storage matterbridge.${MATTER_STORAGE_DIR}.zip downloaded successfully`);
                 }
             });
         });
@@ -842,7 +853,7 @@ export class Frontend extends EventEmitter {
         }
         this.log.debug('Frontend stopped successfully');
     }
-    async getApiSettings() {
+    getApiSettings() {
         this.matterbridge.systemInformation.totalMemory = formatBytes(os.totalmem());
         this.matterbridge.systemInformation.freeMemory = formatBytes(os.freemem());
         this.matterbridge.systemInformation.systemUptime = formatUptime(os.uptime());
@@ -871,23 +882,23 @@ export class Frontend extends EventEmitter {
             restartMode: this.matterbridge.restartMode,
             virtualMode: this.matterbridge.virtualMode,
             profile: this.matterbridge.profile,
-            readOnly: this.matterbridge.readOnly,
-            shellyBoard: this.matterbridge.shellyBoard,
-            shellySysUpdate: this.matterbridge.shellySysUpdate,
-            shellyMainUpdate: this.matterbridge.shellyMainUpdate,
-            loggerLevel: await this.matterbridge.getLogLevel(),
+            loggerLevel: this.matterbridge.logLevel,
             fileLogger: this.matterbridge.fileLogger,
-            matterLoggerLevel: Logger.level,
+            matterLoggerLevel: this.matterbridge.matterLogLevel,
             matterFileLogger: this.matterbridge.matterFileLogger,
             matterMdnsInterface: this.matterbridge.mdnsInterface,
             matterIpv4Address: this.matterbridge.ipv4Address,
             matterIpv6Address: this.matterbridge.ipv6Address,
-            matterPort: (await this.matterbridge.nodeContext?.get('matterport', 5540)) ?? 5540,
-            matterDiscriminator: await this.matterbridge.nodeContext?.get('matterdiscriminator'),
-            matterPasscode: await this.matterbridge.nodeContext?.get('matterpasscode'),
-            restartRequired: this.matterbridge.restartRequired,
-            fixedRestartRequired: this.matterbridge.fixedRestartRequired,
-            updateRequired: this.matterbridge.updateRequired,
+            matterPort: this.matterbridge.port || 5540,
+            matterDiscriminator: this.matterbridge.discriminator,
+            matterPasscode: this.matterbridge.passcode,
+            readOnly: this.readOnly,
+            shellyBoard: this.shellyBoard,
+            shellySysUpdate: this.shellySysUpdate,
+            shellyMainUpdate: this.shellyMainUpdate,
+            restartRequired: this.restartRequired,
+            fixedRestartRequired: this.fixedRestartRequired,
+            updateRequired: this.updateRequired,
         };
         return { systemInformation: this.matterbridge.systemInformation, matterbridgeInformation: info };
     }
@@ -1065,7 +1076,7 @@ export class Frontend extends EventEmitter {
         });
         return attributes.trimStart().trimEnd();
     }
-    getPlugins() {
+    getApiPlugins() {
         if (this.matterbridge.hasCleanupStarted)
             return [];
         const plugins = [];
@@ -1100,7 +1111,7 @@ export class Frontend extends EventEmitter {
         }
         return plugins;
     }
-    getDevices(pluginName) {
+    getApiDevices(pluginName) {
         if (this.matterbridge.hasCleanupStarted)
             return [];
         const devices = [];
@@ -1488,7 +1499,7 @@ export class Frontend extends EventEmitter {
             else if (data.method === '/api/create-matter-storage-backup') {
                 this.wssSendSnackbarMessage('Creating matter storage backup...', 0);
                 this.log.notice(`Creating matter storage backup...`);
-                this.zip('zip', path.join(os.tmpdir(), `matterbridge.${MATTER_STORAGE_NAME}.zip`), [path.join(this.matterbridge.matterbridgeDirectory, MATTER_STORAGE_NAME)], '');
+                this.zip('zip', path.join(os.tmpdir(), `matterbridge.${MATTER_STORAGE_DIR}.zip`), [path.join(this.matterbridge.matterbridgeDirectory, MATTER_STORAGE_DIR)], '');
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/create-plugin-backup') {
@@ -1580,14 +1591,13 @@ export class Frontend extends EventEmitter {
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: matter });
             }
             else if (data.method === '/api/settings') {
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: await this.getApiSettings() });
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: this.getApiSettings() });
             }
             else if (data.method === '/api/plugins') {
-                const plugins = this.matterbridge.hasCleanupStarted ? [] : this.getPlugins();
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: plugins });
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: this.getApiPlugins() });
             }
             else if (data.method === '/api/devices') {
-                const devices = this.matterbridge.hasCleanupStarted ? [] : this.getDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined);
+                const devices = this.getApiDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined);
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: devices });
             }
             else if (data.method === '/api/clusters') {
@@ -2033,8 +2043,8 @@ export class Frontend extends EventEmitter {
         if (!this.listening || this.webSocketServer?.clients.size === 0)
             return;
         this.log.debug('Sending a restart required message to all connected clients');
-        this.matterbridge.restartRequired = true;
-        this.matterbridge.fixedRestartRequired = fixed;
+        this.restartRequired = true;
+        this.fixedRestartRequired = fixed;
         if (snackbar === true)
             this.wssSendSnackbarMessage(`Restart required`, 0);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', success: true, response: { fixed } });
@@ -2043,7 +2053,7 @@ export class Frontend extends EventEmitter {
         if (!this.listening || this.webSocketServer?.clients.size === 0)
             return;
         this.log.debug('Sending a restart not required message to all connected clients');
-        this.matterbridge.restartRequired = false;
+        this.restartRequired = false;
         if (snackbar === true)
             this.wssSendCloseSnackbarMessage(`Restart required`);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
@@ -2052,7 +2062,7 @@ export class Frontend extends EventEmitter {
         if (!this.listening || this.webSocketServer?.clients.size === 0)
             return;
         this.log.debug('Sending an update required message to all connected clients');
-        this.matterbridge.updateRequired = true;
+        this.updateRequired = true;
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'update_required', success: true, response: { devVersion } });
     }
     wssSendCpuUpdate(cpuUsage, processCpuUsage) {

package/dist/jestutils/jestHelpers.d.ts

@@ -83,7 +83,7 @@ export declare function createTestEnvironment(name: string, createOnly?: boolean
 export declare function destroyTestEnvironment(createOnly?: boolean): Promise<void>;
 export declare function flushAsync(ticks?: number, microTurns?: number, pause?: number): Promise<void>;
 export declare function logKeepAlives(log?: AnsiLogger): number;
-export declare function flushAllEndpointNumberPersistence(targetServer: ServerNode, rounds?: number): Promise<void>;
+export declare function flushAllEndpointNumberPersistence(targetServer: ServerNode, rounds?: number, pause?: number): Promise<void>;
 export declare function assertAllEndpointNumbersPersisted(targetServer: ServerNode): Promise<number>;
 export declare function closeServerNodeStores(targetServer?: ServerNode): Promise<void>;
 export declare function startServerNode(name: string, port: number, deviceType?: DeviceTypeId, createOnly?: boolean): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;