@matterbridge/core 3.8.0-dev-20260527-b4148f4 → 3.8.0-dev-20260528-1971f9d

package/dist/backend.d.ts

@@ -0,0 +1,37 @@
+import EventEmitter from 'node:events';
+import type { ApiDevice, ApiPlugin, ApiSettings, SharedMatterbridge } from '@matterbridge/types';
+import type { BackendExpress } from './backendExpress.js';
+import type { BackendWsServer } from './backendWsServer.js';
+interface BackendEvents {
+    server_listening: [protocol: string, port: number, address?: string];
+    server_error: [error: unknown];
+    server_stopped: [];
+    websocket_server_listening: [protocol: string];
+    websocket_server_stopped: [];
+}
+export declare class Backend extends EventEmitter<BackendEvents> {
+    private debug;
+    private verbose;
+    private log;
+    private matterbridge;
+    private readonly server;
+    private port;
+    private listening;
+    private httpServer;
+    private httpsServer;
+    backendExpress: BackendExpress | undefined;
+    backendWsServer: BackendWsServer | undefined;
+    storedPassword: string | undefined;
+    authClients: Set<string>;
+    authClientsTimeout: NodeJS.Timeout | undefined;
+    constructor(matterbridge: SharedMatterbridge);
+    destroy(): void;
+    private broadcastMsgHandler;
+    start(port?: number): Promise<void>;
+    stop(): Promise<void>;
+    getApiSettings(): ApiSettings;
+    getApiPlugins(): ApiPlugin[];
+    getApiDevices(_pluginName?: string): ApiDevice[];
+    generateDiagnostic(): Promise<void>;
+}
+export {};

package/dist/backend.js

@@ -0,0 +1,294 @@
+import EventEmitter from 'node:events';
+import path from 'node:path';
+import { BroadcastServer } from '@matterbridge/thread';
+import { getParameter, hasParameter } from '@matterbridge/utils/cli';
+import { getErrorMessage, inspectError, logError } from '@matterbridge/utils/error';
+import { AnsiLogger, rs, UNDERLINE, UNDERLINEOFF } from 'node-ansi-logger';
+if (hasParameter('loader'))
+    console.log('\u001B[32mBackend loaded.\u001B[40;0m');
+export class Backend extends EventEmitter {
+    debug;
+    verbose;
+    log;
+    matterbridge;
+    server;
+    port = 8283;
+    listening = false;
+    httpServer;
+    httpsServer;
+    backendExpress;
+    backendWsServer;
+    storedPassword = undefined;
+    authClients = new Set();
+    authClientsTimeout = undefined;
+    constructor(matterbridge) {
+        super();
+        this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-frontend') || hasParameter('verbose-frontend');
+        this.verbose = hasParameter('verbose') || hasParameter('verbose-frontend');
+        this.matterbridge = matterbridge;
+        this.log = new AnsiLogger({
+            logName: 'Backend',
+            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(port = 8283) {
+        this.log.debug('Starting backend...');
+        this.port = port;
+        const { BackendExpress } = await import('./backendExpress.js');
+        const { BackendWsServer } = await import('./backendWsServer.js');
+        this.backendExpress = new BackendExpress(this.matterbridge, this);
+        this.backendWsServer = new BackendWsServer(this.matterbridge, this);
+        if (!hasParameter('ssl')) {
+            const http = await import('node:http');
+            try {
+                this.log.debug(`Creating HTTP server...`);
+                this.httpServer = http.createServer(this.backendExpress.expressApp);
+            }
+            catch (error) {
+                logError(this.log, `Failed to create HTTP server`, error);
+                this.emit('server_error', error);
+                return;
+            }
+            this.httpServer.listen(this.port, getParameter('bind'), () => {
+                const addr = this.httpServer?.address();
+                if (addr && typeof addr !== 'string') {
+                    this.log.info(`The frontend http server is bound to ${addr.family} ${addr.address}:${addr.port}`);
+                }
+                if (this.matterbridge.systemInformation.ipv4Address !== '' && !getParameter('bind'))
+                    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 !== '' && !getParameter('bind'))
+                    this.log.info(`The frontend http server is listening on ${UNDERLINE}http://[${this.matterbridge.systemInformation.ipv6Address}]:${this.port}${UNDERLINEOFF}${rs}`);
+                this.listening = true;
+                this.emit('server_listening', 'http', this.port);
+            });
+            this.httpServer.on('upgrade', (req, socket, head) => {
+                try {
+                    if ((req.headers.upgrade || '').toLowerCase() !== 'websocket') {
+                        this.log.error(`WebSocket upgrade error: Invalid upgrade header ${req.headers.upgrade}`);
+                        socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+                        return socket.destroy();
+                    }
+                    const url = new URL(req.url ?? '/', `http://${req.headers.host || 'localhost'}`);
+                    const password = url.searchParams.get('password') ?? '';
+                    if (password !== this.storedPassword) {
+                        this.log.error(`WebSocket upgrade error: Invalid password ${password ? '[redacted]' : '(empty)'}`);
+                        socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
+                        return socket.destroy();
+                    }
+                    this.log.debug(`WebSocket upgrade success host ${url.host} password ${password ? '[redacted]' : '(empty)'}`);
+                    if (req.socket.remoteAddress)
+                        this.authClients.add(req.socket.remoteAddress);
+                    this.backendWsServer?.webSocketServer?.handleUpgrade(req, socket, head, (ws) => {
+                        this.backendWsServer?.webSocketServer?.emit('connection', ws, req);
+                    });
+                }
+                catch (err) {
+                    {
+                        inspectError(this.log, 'WebSocket upgrade error:', err);
+                        socket.write('HTTP/1.1 500 Internal Server Error\r\nConnection: close\r\n\r\n');
+                        socket.destroy();
+                    }
+                }
+                return undefined;
+            });
+            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.emit('server_error', error);
+                return;
+            });
+        }
+        else {
+            let cert;
+            let key;
+            let ca;
+            let fullChain;
+            let pfx;
+            let passphrase;
+            let httpsServerOptions;
+            const fs = await import('node:fs');
+            if (fs.existsSync(path.join(this.matterbridge.matterbridgeDirectory, 'certs', 'cert.p12'))) {
+                try {
+                    pfx = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, 'certs', 'cert.p12'));
+                    this.log.info(`Loaded p12 certificate file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs', 'cert.p12')}`);
+                }
+                catch (error) {
+                    logError(this.log, `Error reading p12 certificate file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs', 'cert.p12')}`, error);
+                    this.emit('server_error', error);
+                    return;
+                }
+                try {
+                    passphrase = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, 'certs', 'cert.pass'), 'utf8');
+                    passphrase = passphrase.trim();
+                    this.log.info(`Loaded p12 passphrase file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs', 'cert.pass')}`);
+                }
+                catch (error) {
+                    logError(this.log, `Error reading p12 passphrase file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs', 'cert.pass')}`, error);
+                    this.emit('server_error', error);
+                    return;
+                }
+                httpsServerOptions = { pfx, passphrase };
+            }
+            else {
+                try {
+                    cert = await fs.promises.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) {
+                    logError(this.log, `Error reading certificate file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs', 'cert.pem')}`, error);
+                    this.emit('server_error', error);
+                    return;
+                }
+                try {
+                    key = await fs.promises.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) {
+                    logError(this.log, `Error reading key file ${path.join(this.matterbridge.matterbridgeDirectory, 'certs', 'key.pem')}`, error);
+                    this.emit('server_error', error);
+                    return;
+                }
+                try {
+                    ca = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, 'certs', 'ca.pem'), 'utf8');
+                    fullChain = `${cert}\n${ca}`;
+                    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: ${getErrorMessage(error)}`);
+                }
+                httpsServerOptions = { cert: fullChain ?? cert, key, ca };
+            }
+            if (hasParameter('mtls')) {
+                httpsServerOptions.requestCert = true;
+                httpsServerOptions.rejectUnauthorized = true;
+            }
+            const https = await import('node:https');
+            try {
+                this.log.debug(`Creating HTTPS server...`);
+                this.httpsServer = https.createServer(httpsServerOptions, this.backendExpress.expressApp);
+            }
+            catch (error) {
+                logError(this.log, `Failed to create HTTPS server`, error);
+                this.emit('server_error', error);
+                return;
+            }
+            this.httpsServer.listen(this.port, getParameter('bind'), () => {
+                const addr = this.httpsServer?.address();
+                if (addr && typeof addr !== 'string') {
+                    this.log.info(`The frontend https server is bound to ${addr.family} ${addr.address}:${addr.port}`);
+                }
+                if (this.matterbridge.systemInformation.ipv4Address !== '' && !getParameter('bind'))
+                    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 !== '' && !getParameter('bind'))
+                    this.log.info(`The frontend https server is listening on ${UNDERLINE}https://[${this.matterbridge.systemInformation.ipv6Address}]:${this.port}${UNDERLINEOFF}${rs}`);
+                this.listening = true;
+                this.emit('server_listening', 'https', this.port);
+            });
+            this.httpsServer.on('upgrade', (req, socket, head) => {
+                try {
+                    if ((req.headers.upgrade || '').toLowerCase() !== 'websocket') {
+                        socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+                        return socket.destroy();
+                    }
+                    const url = new URL(req.url ?? '/', `https://${req.headers.host || 'localhost'}`);
+                    const password = url.searchParams.get('password') ?? '';
+                    if (password !== this.storedPassword) {
+                        this.log.error(`WebSocket upgrade error: Invalid password ${password ? '[redacted]' : '(empty)'}`);
+                        socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
+                        return socket.destroy();
+                    }
+                    this.log.debug(`WebSocket upgrade success host ${url.host} password ${password ? '[redacted]' : '(empty)'}`);
+                    if (req.socket.remoteAddress)
+                        this.authClients.add(req.socket.remoteAddress);
+                    this.backendWsServer?.webSocketServer?.handleUpgrade(req, socket, head, (ws) => {
+                        this.backendWsServer?.webSocketServer?.emit('connection', ws, req);
+                    });
+                }
+                catch (err) {
+                    {
+                        inspectError(this.log, 'WebSocket upgrade error:', err);
+                        socket.write('HTTP/1.1 500 Internal Server Error\r\nConnection: close\r\n\r\n');
+                        socket.destroy();
+                    }
+                }
+                return undefined;
+            });
+            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.emit('server_error', error);
+                return;
+            });
+        }
+        this.log.debug('Backend started');
+    }
+    async stop() {
+        this.log.debug('Stopping backend...');
+        if (this.httpServer) {
+            this.log.debug('Closing http server...');
+            this.httpServer.close();
+            this.log.debug('Http server closed successfully');
+            this.listening = false;
+            this.emit('server_stopped');
+            this.httpServer.removeAllListeners();
+            this.httpServer = undefined;
+            this.log.debug('Backend http server closed successfully');
+        }
+        if (this.httpsServer) {
+            this.log.debug('Closing https server...');
+            this.httpsServer.close();
+            this.log.debug('Https server closed successfully');
+            this.listening = false;
+            this.emit('server_stopped');
+            this.httpsServer.removeAllListeners();
+            this.httpsServer = undefined;
+            this.log.debug('Backend https server closed successfully');
+        }
+        this.log.debug('Backend stopped');
+    }
+    getApiSettings() {
+        return {};
+    }
+    getApiPlugins() {
+        return [];
+    }
+    getApiDevices(_pluginName) {
+        return [];
+    }
+    async generateDiagnostic() { }
+}

package/dist/backendExpress.d.ts

@@ -1,16 +1,16 @@
 import { type SharedMatterbridge } from '@matterbridge/types';
 import express from 'express';
-import type { Frontend } from './frontend.js';
+import { Backend } from './backend.js';
 export declare class BackendExpress {
     private debug;
     private verbose;
-    private expressApp;
     private log;
     private backend;
     private matterbridge;
     private readonly server;
     private fileLimiter;
-    constructor(matterbridge: SharedMatterbridge, backend: Frontend);
+    expressApp: express.Application | undefined;
+    constructor(matterbridge: SharedMatterbridge, backend: Backend);
     destroy(): void;
     private broadcastMsgHandler;
     private validateReq;

package/dist/backendExpress.js

@@ -15,7 +15,6 @@ if (hasParameter('loader'))
 export class BackendExpress {
     debug;
     verbose;
-    expressApp;
     log;
     backend;
     matterbridge;
@@ -24,6 +23,7 @@ export class BackendExpress {
         windowMs: 60 * 1000,
         max: 20,
     });
+    expressApp;
     constructor(matterbridge, backend) {
         this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-frontend') || hasParameter('verbose-frontend');
         this.verbose = hasParameter('verbose') || hasParameter('verbose-frontend');
@@ -111,7 +111,7 @@ export class BackendExpress {
             const { default: v8 } = await import('node:v8');
             const heapStatsRaw = v8.getHeapStatistics();
             const heapSpacesRaw = v8.getHeapSpaceStatistics();
-            const heapStats = Object.fromEntries(Object.entries(heapStatsRaw).map(([key, value]) => [key, formatBytes(value)]));
+            const heapStats = Object.fromEntries(Object.entries(heapStatsRaw).map(([key, value]) => [key, typeof value === 'number' ? formatBytes(value) : value]));
             const heapSpaces = heapSpacesRaw.map((space) => ({
                 ...space,
                 space_size: formatBytes(space.space_size),
@@ -314,7 +314,7 @@ export class BackendExpress {
             if (!this.validateReq(req, res))
                 return;
             res.download(path.join(os.tmpdir(), MATTERBRIDGE_BACKUP_FILE), MATTERBRIDGE_BACKUP_FILE, (error) => {
-                this.backend.wssSendCloseSnackbarMessage('Creating matterbridge backup...');
+                this.backend.backendWsServer?.wssSendCloseSnackbarMessage('Creating matterbridge backup...');
                 if (error) {
                     this.log.error(`Error downloading file ${MATTERBRIDGE_BACKUP_FILE}: ${getErrorMessage(error)}`);
                     res.status(500).send(`Error downloading the matterbridge backup file.`);
@@ -329,9 +329,9 @@ export class BackendExpress {
             if (!this.validateReq(req, res))
                 return;
             res.download(path.join(os.tmpdir(), `matterbridge.${NODE_STORAGE_DIR}.zip`), `matterbridge.${NODE_STORAGE_DIR}.zip`, (error) => {
-                this.backend.wssSendCloseSnackbarMessage('Creating matterbridge storage backup...');
+                this.backend.backendWsServer?.wssSendCloseSnackbarMessage('Creating matterbridge storage backup...');
                 if (error) {
-                    this.log.error(`Error downloading file ${`matterbridge.${NODE_STORAGE_DIR}.zip`}: ${getErrorMessage(error)}`);
+                    this.log.error(`Error downloading file matterbridge.${NODE_STORAGE_DIR}.zip: ${getErrorMessage(error)}`);
                     res.status(500).send('Error downloading the matterbridge storage file');
                 }
                 else {
@@ -344,7 +344,7 @@ export class BackendExpress {
             if (!this.validateReq(req, res))
                 return;
             res.download(path.join(os.tmpdir(), `matterbridge.${MATTER_STORAGE_DIR}.zip`), `matterbridge.${MATTER_STORAGE_DIR}.zip`, (error) => {
-                this.backend.wssSendCloseSnackbarMessage('Creating matter storage backup...');
+                this.backend.backendWsServer?.wssSendCloseSnackbarMessage('Creating matter storage backup...');
                 if (error) {
                     this.log.error(`Error downloading the matter storage matterbridge.${MATTER_STORAGE_DIR}.zip: ${getErrorMessage(error)}`);
                     res.status(500).send('Error downloading the matter storage file');
@@ -359,7 +359,7 @@ export class BackendExpress {
             if (!this.validateReq(req, res))
                 return;
             res.download(path.join(os.tmpdir(), MATTERBRIDGE_PLUGIN_STORAGE_FILE), MATTERBRIDGE_PLUGIN_STORAGE_FILE, (error) => {
-                this.backend.wssSendCloseSnackbarMessage('Creating plugin backup...');
+                this.backend.backendWsServer?.wssSendCloseSnackbarMessage('Creating plugin backup...');
                 if (error) {
                     this.log.error(`Error downloading file ${MATTERBRIDGE_PLUGIN_STORAGE_FILE}: ${getErrorMessage(error)}`);
                     res.status(500).send('Error downloading the matterbridge plugin storage file');
@@ -374,7 +374,7 @@ export class BackendExpress {
             if (!this.validateReq(req, res))
                 return;
             res.download(path.join(os.tmpdir(), MATTERBRIDGE_PLUGIN_CONFIG_FILE), MATTERBRIDGE_PLUGIN_CONFIG_FILE, (error) => {
-                this.backend.wssSendCloseSnackbarMessage('Creating config backup...');
+                this.backend.backendWsServer?.wssSendCloseSnackbarMessage('Creating config backup...');
                 if (error) {
                     this.log.error(`Error downloading file ${MATTERBRIDGE_PLUGIN_CONFIG_FILE}: ${getErrorMessage(error)}`);
                     res.status(500).send('Error downloading the matterbridge plugin config file');
@@ -395,7 +395,7 @@ export class BackendExpress {
                 res.status(400).send('Invalid request: file and filename are required');
                 return;
             }
-            this.backend.wssSendSnackbarMessage(`Installing package ${filename}...`, 0);
+            this.backend.backendWsServer?.wssSendSnackbarMessage(`Installing package ${filename}...`, 0);
             const filePath = path.join(this.matterbridge.matterbridgeDirectory, 'uploads', filename);
             try {
                 const fs = await import('node:fs');
@@ -422,8 +422,8 @@ export class BackendExpress {
             }
             catch (err) {
                 this.log.error(`Error uploading or installing plugin package file ${plg}${filename}${er}:`, err);
-                this.backend.wssSendCloseSnackbarMessage(`Installing package ${filename}...`);
-                this.backend.wssSendSnackbarMessage(`Error uploading or installing plugin package ${filename}`, 10, 'error');
+                this.backend.backendWsServer?.wssSendCloseSnackbarMessage(`Installing package ${filename}...`);
+                this.backend.backendWsServer?.wssSendSnackbarMessage(`Error uploading or installing plugin package ${filename}`, 10, 'error');
                 res.status(500).send(`Error uploading or installing plugin package ${escapeHtml(filename)}`);
             }
         });

package/dist/backendWsServer.d.ts

@@ -1,16 +1,16 @@
 import type { EndpointNumber } from '@matter/types/datatype';
 import type { ApiMatter, RefreshRequiredChanged, SharedMatterbridge, WsMessageBroadcast } from '@matterbridge/types';
 import { WebSocketServer } from 'ws';
-import type { Frontend } from './frontend.js';
-export declare class BackendsWsServer {
+import { Backend } from './backend.js';
+export declare class BackendWsServer {
     private debug;
     private verbose;
-    private webSocketServer;
     private log;
     private backend;
     private matterbridge;
     private readonly server;
-    constructor(matterbridge: SharedMatterbridge, backend: Frontend);
+    webSocketServer: WebSocketServer | undefined;
+    constructor(matterbridge: SharedMatterbridge, backend: Backend);
     destroy(): void;
     private broadcastMsgHandler;
     start(): Promise<WebSocketServer | undefined>;

package/dist/backendWsServer.js

@@ -8,14 +8,14 @@ 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 {
+export class BackendWsServer {
     debug;
     verbose;
-    webSocketServer;
     log;
     backend;
     matterbridge;
     server;
+    webSocketServer;
     constructor(matterbridge, backend) {
         this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-frontend') || hasParameter('verbose-frontend');
         this.verbose = hasParameter('verbose') || hasParameter('verbose-frontend');
@@ -149,7 +149,8 @@ export class BackendsWsServer {
             }
         };
         try {
-            data = JSON.parse(rawData.toString());
+            const raw = Array.isArray(rawData) ? Buffer.concat(rawData) : rawData instanceof ArrayBuffer ? Buffer.from(rawData) : rawData;
+            data = JSON.parse(raw.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' });
@@ -217,9 +218,7 @@ export class BackendsWsServer {
             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)
+        if (snackbar)
             this.wssSendSnackbarMessage(`Restart required`, 0);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', success: true, response: { fixed } });
     }
@@ -228,8 +227,7 @@ export class BackendsWsServer {
             return;
         if (this.verbose)
             this.log.debug('Sending a restart not required message to all connected clients');
-        this.backend.restartRequired = false;
-        if (snackbar === true)
+        if (snackbar)
             this.wssSendCloseSnackbarMessage(`Restart required`);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
     }
@@ -238,7 +236,6 @@ export class BackendsWsServer {
             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) {

package/dist/behaviors/activatedCarbonFilterMonitoringServer.d.ts

@@ -1,9 +1,9 @@
 import { ActivatedCarbonFilterMonitoringServer } from '@matter/node/behaviors/activated-carbon-filter-monitoring';
 import { ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
 declare const MatterbridgeActivatedCarbonFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof ActivatedCarbonFilterMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<ActivatedCarbonFilterMonitoring, {
+    warning: false;
     condition: true;
     replacementProductList: false;
-    warning: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "activatedCarbonFilterMonitoring">;
 export declare class MatterbridgeActivatedCarbonFilterMonitoringServer extends MatterbridgeActivatedCarbonFilterMonitoringServer_base {
     resetCondition(): Promise<void>;

package/dist/behaviors/hepaFilterMonitoringServer.d.ts

@@ -1,9 +1,9 @@
 import { HepaFilterMonitoringServer } from '@matter/node/behaviors/hepa-filter-monitoring';
 import { HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
 declare const MatterbridgeHepaFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof HepaFilterMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<HepaFilterMonitoring, {
+    warning: false;
     condition: true;
     replacementProductList: false;
-    warning: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "hepaFilterMonitoring">;
 export declare class MatterbridgeHepaFilterMonitoringServer extends MatterbridgeHepaFilterMonitoringServer_base {
     resetCondition(): Promise<void>;

package/dist/matterNode.js

@@ -22,6 +22,7 @@ import { toBaseDevice } from './deviceManager.js';
 import { addVirtualDevice } from './helpers.js';
 import { bridge } from './matterbridgeDeviceTypes.js';
 import { PluginManager } from './pluginManager.js';
+import { getErrorMessage } from './utils/export.js';
 export class MatterNode extends EventEmitter {
     matterbridge;
     pluginName;
@@ -515,7 +516,7 @@ export class MatterNode extends EventEmitter {
             this.log.notice(`Started ${this.serverNode.id} server node`);
         }
         catch (error) {
-            this.log.error(`Failed to start ${this.serverNode.id} server node: ${error instanceof Error ? error.message : error}`);
+            this.log.error(`Failed to start ${this.serverNode.id} server node: ${getErrorMessage(error)}`);
         }
     }
     async stopServerNode(timeout = 30000) {
@@ -528,7 +529,7 @@ export class MatterNode extends EventEmitter {
             this.log.info(`Closed ${this.serverNode.id} server node`);
         }
         catch (error) {
-            this.log.error(`Failed to close ${this.serverNode.id} server node: ${error instanceof Error ? error.message : error}`);
+            this.log.error(`Failed to close ${this.serverNode.id} server node: ${getErrorMessage(error)}`);
         }
     }
     async createAggregatorNode() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.8.0-dev-20260527-b4148f4",
+  "version": "3.8.0-dev-20260528-1971f9d",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -130,10 +130,10 @@
   ],
   "dependencies": {
     "@matter/main": "0.17.0",
-    "@matterbridge/dgram": "3.8.0-dev-20260527-b4148f4",
-    "@matterbridge/thread": "3.8.0-dev-20260527-b4148f4",
-    "@matterbridge/types": "3.8.0-dev-20260527-b4148f4",
-    "@matterbridge/utils": "3.8.0-dev-20260527-b4148f4",
+    "@matterbridge/dgram": "3.8.0-dev-20260528-1971f9d",
+    "@matterbridge/thread": "3.8.0-dev-20260528-1971f9d",
+    "@matterbridge/types": "3.8.0-dev-20260528-1971f9d",
+    "@matterbridge/utils": "3.8.0-dev-20260528-1971f9d",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.5.2",