matterbridge 3.3.1-dev-20251009-edb969d → 3.3.1-dev-20251011-c8b30f8

package/dist/cli.js

@@ -3,7 +3,7 @@ if (process.argv.includes('--loader') || process.argv.includes('-loader'))
 import os from 'node:os';
 import { inspect } from 'node:util';
 import { AnsiLogger, BRIGHT, CYAN, db, RED, YELLOW } from 'node-ansi-logger';
-import { cliEmitter, setLastCpuUsage, setLastProcessCpuUsage } from './cliEmitter.js';
+import { cliEmitter, setLastOsCpuUsage, setLastProcessCpuUsage } from './cliEmitter.js';
 import { history, historyIndex, historySize, setHistoryIndex } from './cliHistory.js';
 import { getIntParameter, hasParameter } from './utils/commandLine.js';
 import { Matterbridge } from './matterbridge.js';
@@ -21,6 +21,8 @@ let peakProcessCpu = 0;
 let peakRss = 0;
 let peakHeapUsed = 0;
 let peakHeapTotal = 0;
+let peakExternal = 0;
+let peakArrayBuffers = 0;
 const log = new AnsiLogger({ logName: 'Cli', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
 const formatCpuUsage = (percent) => {
     return `${percent.toFixed(2).padStart(5, ' ')} %`;
@@ -60,7 +62,7 @@ async function startCpuMemoryCheck() {
         const systemUptime = formatOsUpTime(Math.floor(os.uptime()));
         const processUptime = formatOsUpTime(Math.floor(process.uptime()));
         cliEmitter.emit('uptime', systemUptime, processUptime);
-        const totalMememory = formatMemoryUsage(os.totalmem());
+        const totalMemory = formatMemoryUsage(os.totalmem());
         const freeMemory = formatMemoryUsage(os.freemem());
         const memoryUsageRaw = process.memoryUsage();
         const rss = formatMemoryUsage(memoryUsageRaw.rss);
@@ -83,7 +85,17 @@ async function startCpuMemoryCheck() {
                 log.debug(`****${RED}${BRIGHT}HeapTotal peak detected.${db} Peak heapTotal from ${CYAN}${formatMemoryUsage(peakHeapTotal)}${db} to ${CYAN}${formatMemoryUsage(memoryUsageRaw.heapTotal)}${db}`);
             peakHeapTotal = memoryUsageRaw.heapTotal;
         }
-        cliEmitter.emit('memory', totalMememory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers);
+        if (memoryUsageRaw.external > peakExternal) {
+            if (peakExternal && trace)
+                log.debug(`****${RED}${BRIGHT}External peak detected.${db} Peak external from ${CYAN}${formatMemoryUsage(peakExternal)}${db} to ${CYAN}${formatMemoryUsage(memoryUsageRaw.external)}${db}`);
+            peakExternal = memoryUsageRaw.external;
+        }
+        if (memoryUsageRaw.arrayBuffers > peakArrayBuffers) {
+            if (peakArrayBuffers && trace)
+                log.debug(`****${RED}${BRIGHT}ArrayBuffers peak detected.${db} Peak arrayBuffers from ${CYAN}${formatMemoryUsage(peakArrayBuffers)}${db} to ${CYAN}${formatMemoryUsage(memoryUsageRaw.arrayBuffers)}${db}`);
+            peakArrayBuffers = memoryUsageRaw.arrayBuffers;
+        }
+        cliEmitter.emit('memory', totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers);
         const currCpus = os.cpus();
         if (currCpus.length !== prevCpus.length) {
             prevCpus = currCpus;
@@ -98,16 +110,16 @@ async function startCpuMemoryCheck() {
             totalIdle += idleDiff;
             totalTick += totalDiff;
         });
-        const cpuUsage = 100 - (totalIdle / totalTick) * 100;
-        if (totalTick === 0 || isNaN(cpuUsage) || !isFinite(cpuUsage) || cpuUsage <= 0) {
+        const osCpuUsage = 100 - (totalIdle / totalTick) * 100;
+        if (totalTick === 0 || isNaN(osCpuUsage) || !isFinite(osCpuUsage) || osCpuUsage <= 0) {
             log.debug(`Cpu check failed, using previous cpus`);
         }
         else {
-            setLastCpuUsage(cpuUsage);
-            if (cpuUsage > peakCpu) {
-                peakCpu = cpuUsage;
+            setLastOsCpuUsage(osCpuUsage);
+            if (osCpuUsage > peakCpu) {
+                peakCpu = osCpuUsage;
                 if (peakCpu && trace)
-                    log.debug(`****${RED}${BRIGHT}Cpu peak detected.${db} Peak cpu from ${CYAN}${formatCpuUsage(peakCpu)}${db} to ${CYAN}${formatCpuUsage(cpuUsage)}${db}`);
+                    log.debug(`****${RED}${BRIGHT}Cpu peak detected.${db} Peak cpu from ${CYAN}${formatCpuUsage(peakCpu)}${db} to ${CYAN}${formatCpuUsage(osCpuUsage)}${db}`);
             }
         }
         prevCpus = currCpus;
@@ -115,7 +127,7 @@ async function startCpuMemoryCheck() {
         const userMs = diff.user / 1000;
         const systemMs = diff.system / 1000;
         const totalMs = userMs + systemMs;
-        const processCpuUsage = Number(((totalMs / memoryCheckIntervalMs) * 100).toFixed(2));
+        const processCpuUsage = Number((((totalMs / memoryCheckIntervalMs) * 100) / currCpus.length).toFixed(2));
         if (processCpuUsage > peakProcessCpu) {
             peakProcessCpu = processCpuUsage;
             if (peakProcessCpu && trace)
@@ -123,9 +135,10 @@ async function startCpuMemoryCheck() {
         }
         prevProcessCpu = process.cpuUsage();
         setLastProcessCpuUsage(processCpuUsage);
-        cliEmitter.emit('cpu', cpuUsage, processCpuUsage);
+        cliEmitter.emit('cpu', osCpuUsage, processCpuUsage);
         const entry = history[historyIndex];
-        entry.cpu = cpuUsage;
+        entry.timestamp = Date.now();
+        entry.cpu = osCpuUsage;
         entry.peakCpu = peakCpu;
         entry.processCpu = processCpuUsage;
         entry.peakProcessCpu = peakProcessCpu;
@@ -135,16 +148,25 @@ async function startCpuMemoryCheck() {
         entry.peakHeapUsed = peakHeapUsed;
         entry.heapTotal = memoryUsageRaw.heapTotal;
         entry.peakHeapTotal = peakHeapTotal;
-        entry.timestamp = Date.now();
         setHistoryIndex((historyIndex + 1) % historySize);
         if (trace)
-            log.debug(`***${YELLOW}${BRIGHT}Host cpu:${db} ${CYAN}${formatCpuUsage(cpuUsage)}${db} (peak ${formatCpuUsage(peakCpu)}) ${YELLOW}${BRIGHT}Process cpu:${db} ${CYAN}${formatCpuUsage(processCpuUsage)}${db} (peak ${formatCpuUsage(peakProcessCpu)}) ${YELLOW}${BRIGHT}Process memory:${db} rss ${CYAN}${rss}${db} (peak ${formatMemoryUsage(peakRss)}) heapUsed ${CYAN}${heapUsed}${db} (peak ${formatMemoryUsage(peakHeapUsed)}) heapTotal ${CYAN}${heapTotal}${db} (peak ${formatMemoryUsage(peakHeapTotal)}) external ${external} arrayBuffers ${arrayBuffers}`);
+            log.debug(`***${YELLOW}${BRIGHT}Host cpu:${db} ` +
+                `${CYAN}${formatCpuUsage(osCpuUsage)}${db} (peak ${formatCpuUsage(peakCpu)}) ` +
+                `${YELLOW}${BRIGHT}Process cpu:${db} ` +
+                `${CYAN}${formatCpuUsage(processCpuUsage)}${db} (peak ${formatCpuUsage(peakProcessCpu)}) ` +
+                `${YELLOW}${BRIGHT}Process memory:${db} ` +
+                `rss ${CYAN}${rss}${db} (peak ${formatMemoryUsage(peakRss)}) ` +
+                `heapUsed ${CYAN}${heapUsed}${db} (peak ${formatMemoryUsage(peakHeapUsed)}) ` +
+                `heapTotal ${CYAN}${heapTotal}${db} (peak ${formatMemoryUsage(peakHeapTotal)}) ` +
+                `external ${CYAN}${external}${db} (peak ${formatMemoryUsage(peakExternal)}) ` +
+                `arrayBuffers ${CYAN}${arrayBuffers}${db} (peak ${formatMemoryUsage(peakArrayBuffers)})`);
     };
     clearInterval(memoryCheckInterval);
     memoryCheckInterval = setInterval(interval, memoryCheckIntervalMs).unref();
     clearTimeout(memoryPeakResetTimeout);
     memoryPeakResetTimeout = setTimeout(() => {
-        log.debug(`****${RED}${BRIGHT}Cpu and memory peaks reset after first 5 minutes.${db}`);
+        if (trace)
+            log.debug(`****${RED}${BRIGHT}Cpu and memory peaks reset after first 5 minutes.${db}`);
         peakCpu = 0;
         peakProcessCpu = 0;
         peakRss = 0;
@@ -154,7 +176,13 @@ async function startCpuMemoryCheck() {
 }
 async function stopCpuMemoryCheck() {
     if (trace) {
-        log.debug(`***Cpu memory check stopped. Peak cpu: ${CYAN}${peakCpu.toFixed(2)} %${db}. Peak rss: ${CYAN}${formatMemoryUsage(peakRss)}${db}. Peak heapUsed: ${CYAN}${formatMemoryUsage(peakHeapUsed)}${db}. Peak heapTotal: ${CYAN}${formatMemoryUsage(peakHeapTotal)}${db}`);
+        log.debug(`***Cpu memory check stopped. ` +
+            `Peak cpu: ${CYAN}${peakCpu.toFixed(2)} %${db}. ` +
+            `Peak rss: ${CYAN}${formatMemoryUsage(peakRss)}${db}. ` +
+            `Peak heapUsed: ${CYAN}${formatMemoryUsage(peakHeapUsed)}${db}. ` +
+            `Peak heapTotal: ${CYAN}${formatMemoryUsage(peakHeapTotal)}${db}. ` +
+            `Peak external: ${CYAN}${formatMemoryUsage(peakExternal)}${db}. ` +
+            `Peak arrayBuffers: ${CYAN}${formatMemoryUsage(peakArrayBuffers)}${db}.`);
     }
     clearInterval(memoryCheckInterval);
     clearTimeout(memoryPeakResetTimeout);

package/dist/cliEmitter.js

@@ -2,10 +2,10 @@ if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mCli emitter loaded.\u001B[40;0m');
 import { EventEmitter } from 'node:events';
 export const cliEmitter = new EventEmitter();
-export let lastCpuUsage = 0;
+export let lastOsCpuUsage = 0;
 export let lastProcessCpuUsage = 0;
-export function setLastCpuUsage(val) {
-    lastCpuUsage = val;
+export function setLastOsCpuUsage(val) {
+    lastOsCpuUsage = val;
 }
 export function setLastProcessCpuUsage(val) {
     lastProcessCpuUsage = val;

package/dist/cliHistory.js

@@ -14,6 +14,7 @@ export function setHistoryIndex(index) {
     historyIndex = index;
 }
 export const history = Array.from({ length: historySize }, () => ({
+    timestamp: 0,
     cpu: 0,
     peakCpu: 0,
     processCpu: 0,
@@ -24,7 +25,10 @@ export const history = Array.from({ length: historySize }, () => ({
     peakHeapUsed: 0,
     heapTotal: 0,
     peakHeapTotal: 0,
-    timestamp: 0,
+    external: 0,
+    peakExternal: 0,
+    arrayBuffers: 0,
+    peakArrayBuffers: 0,
 }));
 export function generateHistoryPage(options = {}) {
     const pageTitle = options.pageTitle ?? 'Matterbridge CPU & Memory History';

package/dist/frontend.js

@@ -3,20 +3,21 @@ if (process.argv.includes('--loader') || process.argv.includes('-loader'))
 import os from 'node:os';
 import path from 'node:path';
 import EventEmitter from 'node:events';
-import express from 'express';
-import WebSocket, { WebSocketServer } from 'ws';
-import multer from 'multer';
 import { AnsiLogger, stringify, debugStringify, CYAN, db, er, nf, rs, UNDERLINE, UNDERLINEOFF, YELLOW, nt, wr } from 'node-ansi-logger';
 import { Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, Lifecycle, LogDestination, Diagnostic, Time, FabricIndex } from '@matter/main';
 import { BridgedDeviceBasicInformation } from '@matter/main/clusters/bridged-device-basic-information';
 import { PowerSource } from '@matter/main/clusters/power-source';
 import { DeviceAdvertiser, DeviceCommissioner, FabricManager } from '@matter/main/protocol';
 import { CommissioningOptions } from '@matter/main/types';
-import { MATTER_LOGGER_FILE, MATTER_STORAGE_NAME, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg } from './matterbridgeTypes.js';
-import { createZip, isValidArray, isValidNumber, isValidObject, isValidString, isValidBoolean, withTimeout, hasParameter, wait, inspectError } from './utils/export.js';
+import { MATTER_LOGGER_FILE, MATTER_STORAGE_NAME, MATTERBRIDGE_DIAGNOSTIC_FILE, MATTERBRIDGE_HISTORY_FILE, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg } from './matterbridgeTypes.js';
+import { isValidArray, isValidNumber, isValidObject, isValidString, isValidBoolean } from './utils/isvalid.js';
+import { createZip } from './utils/createZip.js';
+import { hasParameter } from './utils/commandLine.js';
+import { withTimeout, wait } from './utils/wait.js';
+import { inspectError } from './utils/error.js';
 import { formatMemoryUsage, formatOsUpTime } from './utils/network.js';
 import { capitalizeFirstLetter, getAttribute } from './matterbridgeEndpointHelpers.js';
-import { cliEmitter, lastCpuUsage, lastProcessCpuUsage } from './cliEmitter.js';
+import { cliEmitter, lastOsCpuUsage, lastProcessCpuUsage } from './cliEmitter.js';
 import { generateHistoryPage } from './cliHistory.js';
 import { BroadcastServer } from './broadcastServer.js';
 export class Frontend extends EventEmitter {
@@ -94,9 +95,11 @@ export class Frontend extends EventEmitter {
     async start(port = 8283) {
         this.port = port;
         this.log.debug(`Initializing the frontend ${hasParameter('ssl') ? 'https' : 'http'} server on port ${YELLOW}${this.port}${db}`);
+        const multer = await import('multer');
         const uploadDir = path.join(this.matterbridge.matterbridgeDirectory, 'uploads');
-        const upload = multer({ dest: uploadDir });
-        this.expressApp = express();
+        const upload = multer.default({ dest: uploadDir });
+        const express = await import('express');
+        this.expressApp = express.default();
         this.expressApp.use(express.static(path.join(this.matterbridge.rootDirectory, 'frontend/build')));
         if (!hasParameter('ssl')) {
             const http = await import('node:http');
@@ -245,8 +248,9 @@ export class Frontend extends EventEmitter {
                 return;
             });
         }
+        const ws = await import('ws');
         this.log.debug(`Creating WebSocketServer...`);
-        this.webSocketServer = new WebSocketServer(hasParameter('ssl') ? { server: this.httpsServer } : { server: this.httpServer });
+        this.webSocketServer = new ws.WebSocketServer(hasParameter('ssl') ? { server: this.httpsServer } : { server: this.httpServer });
         this.webSocketServer.on('connection', (ws, request) => {
             const clientIp = request.socket.remoteAddress;
             let callbackLogLevel = "notice";
@@ -419,11 +423,11 @@ export class Frontend extends EventEmitter {
                     serverNodes.push(device.serverNode);
             }
             const fs = await import('node:fs');
-            if (fs.existsSync(path.join(this.matterbridge.matterbridgeDirectory, 'diagnostic.log')))
-                fs.unlinkSync(path.join(this.matterbridge.matterbridgeDirectory, 'diagnostic.log'));
+            if (fs.existsSync(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE)))
+                fs.unlinkSync(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE));
             const diagnosticDestination = LogDestination({ name: 'diagnostic', level: MatterLogLevel.INFO, format: MatterLogFormat.formats.plain });
             diagnosticDestination.write = async (text, _message) => {
-                await fs.promises.appendFile(path.join(this.matterbridge.matterbridgeDirectory, 'diagnostic.log'), text + '\n', { encoding: 'utf8' });
+                await fs.promises.appendFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE), text + '\n', { encoding: 'utf8' });
             };
             Logger.destinations.diagnostic = diagnosticDestination;
             if (!diagnosticDestination.context) {
@@ -440,15 +444,28 @@ export class Frontend extends EventEmitter {
             await wait(500);
             try {
                 const fs = await import('node:fs');
-                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, 'diagnostic.log'), 'utf8');
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE), 'utf8');
                 res.type('text/plain');
                 res.send(data.slice(29));
             }
             catch (error) {
-                this.log.error(`Error reading diagnostic log file ${MATTER_LOGGER_FILE}: ${error instanceof Error ? error.message : error}`);
+                this.log.error(`Error reading diagnostic log file ${MATTERBRIDGE_DIAGNOSTIC_FILE}: ${error instanceof Error ? error.message : error}`);
                 res.status(500).send('Error reading diagnostic log file.');
             }
         });
+        this.expressApp.get('/api/viewhistory', async (req, res) => {
+            this.log.debug('The frontend sent /api/viewhistory');
+            try {
+                const fs = await import('node:fs');
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_HISTORY_FILE), 'utf8');
+                res.type('text/html');
+                res.send(data);
+            }
+            catch (error) {
+                this.log.error(`Error reading history log file ${MATTERBRIDGE_HISTORY_FILE}: ${error instanceof Error ? error.message : error}`);
+                res.status(500).send('Error reading history log file. Please create the history log before loading it.');
+            }
+        });
         this.expressApp.get('/api/shellyviewsystemlog', async (req, res) => {
             this.log.debug('The frontend sent /api/shellyviewsystemlog');
             try {
@@ -612,6 +629,7 @@ export class Frontend extends EventEmitter {
     }
     async stop() {
         this.log.debug('Stopping the frontend...');
+        const ws = await import('ws');
         if (this.expressApp) {
             this.expressApp.removeAllListeners();
             this.expressApp = undefined;
@@ -620,7 +638,7 @@ export class Frontend extends EventEmitter {
         if (this.webSocketServer) {
             this.log.debug('Closing WebSocket server...');
             this.webSocketServer.clients.forEach((client) => {
-                if (client.readyState === WebSocket.OPEN) {
+                if (client.readyState === ws.WebSocket.OPEN) {
                     client.close();
                 }
             });
@@ -666,7 +684,7 @@ export class Frontend extends EventEmitter {
         this.matterbridge.systemInformation.freeMemory = formatMemoryUsage(os.freemem());
         this.matterbridge.systemInformation.systemUptime = formatOsUpTime(os.uptime());
         this.matterbridge.systemInformation.processUptime = formatOsUpTime(Math.floor(process.uptime()));
-        this.matterbridge.systemInformation.cpuUsage = lastCpuUsage.toFixed(2) + ' %';
+        this.matterbridge.systemInformation.cpuUsage = lastOsCpuUsage.toFixed(2) + ' %';
         this.matterbridge.systemInformation.processCpuUsage = lastProcessCpuUsage.toFixed(2) + ' %';
         this.matterbridge.systemInformation.rss = formatMemoryUsage(process.memoryUsage().rss);
         this.matterbridge.systemInformation.heapTotal = formatMemoryUsage(process.memoryUsage().heapTotal);
@@ -986,7 +1004,7 @@ export class Frontend extends EventEmitter {
     async wsMessageHandler(client, message) {
         let data;
         const sendResponse = (data) => {
-            if (client.readyState === WebSocket.OPEN) {
+            if (client.readyState === client.OPEN) {
                 if ('response' in data) {
                     const { response, ...rest } = data;
                     this.log.debug(`Sending api response message: ${debugStringify(rest)}`);
@@ -1271,7 +1289,7 @@ export class Frontend extends EventEmitter {
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/generatehistorypage') {
-                generateHistoryPage({ outputPath: path.join(this.matterbridge.rootDirectory, 'frontend/build', 'history.html'), pageTitle: `Matterbridge on ${this.matterbridge.systemInformation.hostname} Cpu & Memory History` });
+                generateHistoryPage({ outputPath: path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_HISTORY_FILE), pageTitle: `Matterbridge on ${this.matterbridge.systemInformation.hostname} Cpu & Memory History` });
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/matter') {
@@ -1708,6 +1726,8 @@ export class Frontend extends EventEmitter {
         }
     }
     wssSendLogMessage(level, time, name, message) {
+        if (!this.listening || this.webSocketServer?.clients.size === 0)
+            return;
         if (!level || !time || !name || !message)
             return;
         message = message.replace(/\x1B\[[0-9;]*[m|s|u|K]/g, '');
@@ -1732,10 +1752,14 @@ export class Frontend extends EventEmitter {
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'log', success: true, response: { level, time, name, message } });
     }
     wssSendRefreshRequired(changed, params) {
+        if (!this.listening || this.webSocketServer?.clients.size === 0)
+            return;
         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, ...params } });
     }
     wssSendRestartRequired(snackbar = true, fixed = false) {
+        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;
@@ -1744,6 +1768,8 @@ export class Frontend extends EventEmitter {
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', success: true, response: { fixed } });
     }
     wssSendRestartNotRequired(snackbar = true) {
+        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;
         if (snackbar === true)
@@ -1751,43 +1777,59 @@ export class Frontend extends EventEmitter {
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
     }
     wssSendUpdateRequired(devVersion = false) {
+        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.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'update_required', success: true, response: { devVersion } });
     }
     wssSendCpuUpdate(cpuUsage, processCpuUsage) {
+        if (!this.listening || this.webSocketServer?.clients.size === 0)
+            return;
         if (hasParameter('debug'))
             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.listening || this.webSocketServer?.clients.size === 0)
+            return;
         if (hasParameter('debug'))
             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.listening || this.webSocketServer?.clients.size === 0)
+            return;
         if (hasParameter('debug'))
             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.listening || this.webSocketServer?.clients.size === 0)
+            return;
         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.listening || this.webSocketServer?.clients.size === 0)
+            return;
         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.listening || this.webSocketServer?.clients.size === 0)
+            return;
         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 } });
     }
     wssBroadcastMessage(msg) {
+        if (!this.listening || this.webSocketServer?.clients.size === 0)
+            return;
         const stringifiedMsg = JSON.stringify(msg);
         if (msg.method !== 'log')
             this.log.debug(`Sending a broadcast message: ${debugStringify(msg)}`);
         this.webSocketServer?.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
+            if (client.readyState === client.OPEN) {
                 client.send(stringifiedMsg);
             }
         });

package/dist/matterbridge.js

@@ -871,26 +871,23 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`Command Line Arguments: ${cmdArgs}`);
     }
     async setLogLevel(logLevel) {
-        if (this.log)
-            this.log.logLevel = logLevel;
+        this.log.logLevel = logLevel;
         this.frontend.logLevel = logLevel;
         MatterbridgeEndpoint.logLevel = logLevel;
-        if (this.devices)
-            this.devices.logLevel = logLevel;
-        if (this.plugins)
-            this.plugins.logLevel = logLevel;
+        this.devices.logLevel = logLevel;
+        this.plugins.logLevel = logLevel;
         for (const plugin of this.plugins) {
             if (!plugin.platform || !plugin.platform.log || !plugin.platform.config)
                 continue;
-            plugin.platform.log.logLevel = plugin.platform.config.debug === true ? "debug" : this.log.logLevel;
-            await plugin.platform.onChangeLoggerLevel(plugin.platform.config.debug === true ? "debug" : this.log.logLevel);
+            plugin.platform.log.logLevel = plugin.platform.config.debug === true ? "debug" : logLevel;
+            await plugin.platform.onChangeLoggerLevel(plugin.platform.config.debug === true ? "debug" : logLevel);
         }
         let callbackLogLevel = "notice";
-        if (this.log.logLevel === "info" || Logger.level === MatterLogLevel.INFO)
+        if (logLevel === "info" || Logger.level === MatterLogLevel.INFO)
             callbackLogLevel = "info";
-        if (this.log.logLevel === "debug" || Logger.level === MatterLogLevel.DEBUG)
+        if (logLevel === "debug" || Logger.level === MatterLogLevel.DEBUG)
             callbackLogLevel = "debug";
-        AnsiLogger.setGlobalCallback(this.frontend.wssSendLogMessage.bind(this.frontend), callbackLogLevel);
+        AnsiLogger.setGlobalCallbackLevel(callbackLogLevel);
         this.log.debug(`WebSocketServer logger global callback set to ${callbackLogLevel}`);
     }
     getLogLevel() {

package/dist/matterbridgeTypes.js

@@ -5,3 +5,5 @@ export const MATTERBRIDGE_LOGGER_FILE = 'matterbridge.log';
 export const MATTER_LOGGER_FILE = 'matter.log';
 export const NODE_STORAGE_DIR = 'storage';
 export const MATTER_STORAGE_NAME = 'matterstorage';
+export const MATTERBRIDGE_DIAGNOSTIC_FILE = 'diagnostic.log';
+export const MATTERBRIDGE_HISTORY_FILE = 'history.html';