matterbridge 3.3.1-dev-20251009-008da25 → 3.3.1-dev-20251012-b3546f8

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, ' ')} %`;
@@ -55,12 +57,11 @@ async function startCpuMemoryCheck() {
     log.debug(`Cpu memory check started`);
     prevCpus = os.cpus();
     prevProcessCpu = process.cpuUsage();
-    clearInterval(memoryCheckInterval);
     const interval = () => {
         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 +84,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 +109,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 +126,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 +134,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 +147,29 @@ async function startCpuMemoryCheck() {
         entry.peakHeapUsed = peakHeapUsed;
         entry.heapTotal = memoryUsageRaw.heapTotal;
         entry.peakHeapTotal = peakHeapTotal;
-        entry.timestamp = Date.now();
+        entry.external = memoryUsageRaw.external;
+        entry.peakExternal = peakExternal;
+        entry.arrayBuffers = memoryUsageRaw.arrayBuffers;
+        entry.peakArrayBuffers = peakArrayBuffers;
         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 +179,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

@@ -2,7 +2,7 @@ if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mCli history loaded.\u001B[40;0m');
 import { writeFileSync } from 'node:fs';
 import path from 'node:path';
-export const historySize = 2160;
+export const historySize = 4320;
 export let historyIndex = 0;
 export function setHistoryIndex(index) {
     if (!Number.isFinite(index) || !Number.isSafeInteger(index)) {
@@ -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';
@@ -50,9 +54,10 @@ export function generateHistoryPage(options = {}) {
     const peakRss = Math.max(...normalizedHistory.map((entry) => entry.peakRss ?? entry.rss));
     const peakHeapUsed = Math.max(...normalizedHistory.map((entry) => entry.peakHeapUsed ?? entry.heapUsed));
     const peakHeapTotal = Math.max(...normalizedHistory.map((entry) => entry.peakHeapTotal ?? entry.heapTotal));
+    const peakExternal = Math.max(...normalizedHistory.map((entry) => entry.peakExternal ?? entry.external));
+    const peakArrayBuffers = Math.max(...normalizedHistory.map((entry) => entry.peakArrayBuffers ?? entry.arrayBuffers));
     const firstTimestamp = normalizedHistory[0]?.timestamp ?? Date.now();
     const lastTimestamp = normalizedHistory[normalizedHistory.length - 1]?.timestamp ?? Date.now();
-    const historySanitised = JSON.stringify(normalizedHistory).replace(/</g, '\\u003c').replace(/>/g, '\\u003e');
     const summary = {
         entries: normalizedHistory.length,
         timeRange: `${new Date(firstTimestamp).toLocaleString()} → ${new Date(lastTimestamp).toLocaleString()}`,
@@ -61,8 +66,9 @@ export function generateHistoryPage(options = {}) {
         peakRss,
         peakHeapUsed,
         peakHeapTotal,
+        peakExternal,
+        peakArrayBuffers,
     };
-    const summarySanitised = JSON.stringify(summary).replace(/</g, '\\u003c').replace(/>/g, '\\u003e');
     const html = `<!DOCTYPE html>
 <html lang="en">
   <head>
@@ -271,8 +277,8 @@ export function generateHistoryPage(options = {}) {
     </div>
 
     <script type="module">
-      const HISTORY_DATA = ${historySanitised};
-      const SUMMARY_DATA = ${summarySanitised};
+      const HISTORY_DATA = ${JSON.stringify(normalizedHistory)};
+      const SUMMARY_DATA = ${JSON.stringify(summary)};
       let cleanup = () => {};
 
       const summaryContainer = document.getElementById('summary');
@@ -283,7 +289,9 @@ export function generateHistoryPage(options = {}) {
         { label: 'Process CPU Peak', value: SUMMARY_DATA.peakProcessCpu.toFixed(2) + ' %' },
         { label: 'RSS Peak', value: formatBytes(SUMMARY_DATA.peakRss) },
         { label: 'Heap Used Peak', value: formatBytes(SUMMARY_DATA.peakHeapUsed) },
-        { label: 'Heap Total Peak', value: formatBytes(SUMMARY_DATA.peakHeapTotal) }
+        { label: 'Heap Total Peak', value: formatBytes(SUMMARY_DATA.peakHeapTotal) },
+        { label: 'External Peak', value: formatBytes(SUMMARY_DATA.peakExternal) },
+        { label: 'Array Buffers Peak', value: formatBytes(SUMMARY_DATA.peakArrayBuffers) }
       ];
 
       summaryEntries.forEach(function (itemData) {
@@ -326,7 +334,7 @@ export function generateHistoryPage(options = {}) {
       const cpuPeakValue = HISTORY_DATA.reduce(function (acc, entry) {
         return Math.max(acc, Number.isFinite(entry.peakCpu) ? entry.peakCpu : 0, Number.isFinite(entry.cpu) ? entry.cpu : 0);
       }, 0);
-      const cpuPadding = cpuPeakValue <= 10 ? 2 : cpuPeakValue * 0.1;
+      const cpuMaxYAxis = cpuPeakValue > 0 ? cpuPeakValue * 1.05 : undefined;
 
       const processCpuPeakValue = HISTORY_DATA.reduce(function (acc, entry) {
         return Math.max(
@@ -335,7 +343,33 @@ export function generateHistoryPage(options = {}) {
           Number.isFinite(entry.processCpu) ? entry.processCpu : 0
         );
       }, 0);
-      const processCpuPadding = processCpuPeakValue <= 10 ? 2 : processCpuPeakValue * 0.1;
+      const processCpuMaxYAxis = processCpuPeakValue > 0 ? processCpuPeakValue * 1.05 : undefined;
+      const useProcessCpuDecimals = (processCpuMaxYAxis ?? 0) <= 3;
+
+      // Compute memory chart dynamic minimum Y as (min observed MB) - 10%
+      const memoryMinMb = HISTORY_DATA.reduce(function (acc, entry) {
+        const values = [entry.rss, entry.heapTotal, entry.heapUsed].map(bytesToMb);
+        const finiteValues = values.filter(function (v) { return Number.isFinite(v); });
+        const minEntry = finiteValues.length ? Math.min.apply(Math, finiteValues) : acc;
+        return Math.min(acc, minEntry);
+      }, Number.POSITIVE_INFINITY);
+      const memoryMinYAxis = Number.isFinite(memoryMinMb) && memoryMinMb > 0 ? Math.max(0, memoryMinMb - memoryMinMb * 0.1) : 0;
+
+      // Compute memory chart dynamic maximum Y as (max observed MB including peaks) + 5%
+      const memoryMaxMb = HISTORY_DATA.reduce(function (acc, entry) {
+        const values = [
+          entry.rss,
+          entry.heapTotal,
+          entry.heapUsed,
+          entry.peakRss,
+          entry.peakHeapTotal,
+          entry.peakHeapUsed
+        ].map(bytesToMb);
+        const finiteValues = values.filter(function (v) { return Number.isFinite(v); });
+        const maxEntry = finiteValues.length ? Math.max.apply(Math, finiteValues) : acc;
+        return Math.max(acc, maxEntry);
+      }, 0);
+      const memoryMaxYAxis = Number.isFinite(memoryMaxMb) && memoryMaxMb > 0 ? memoryMaxMb * 1.05 : undefined;
 
         renderCharts();
 
@@ -364,7 +398,7 @@ export function generateHistoryPage(options = {}) {
               }
             ],
             minY: 0,
-            maxY: cpuPeakValue + cpuPadding,
+            maxY: cpuMaxYAxis,
             yFormatter: function (value) {
               return value.toFixed(0) + ' %';
             }
@@ -397,9 +431,9 @@ export function generateHistoryPage(options = {}) {
               }
             ],
             minY: 0,
-            maxY: processCpuPeakValue + processCpuPadding,
+            maxY: processCpuMaxYAxis,
             yFormatter: function (value) {
-              return value.toFixed(0) + ' %';
+              return value.toFixed(useProcessCpuDecimals ? 1 : 0) + ' %';
             }
           });
 
@@ -423,7 +457,8 @@ export function generateHistoryPage(options = {}) {
                 color: '#f472b6'
               }
             ],
-            minY: 0,
+            minY: memoryMinYAxis,
+            maxY: memoryMaxYAxis,
             yFormatter: function (value) {
               return value.toFixed(0) + ' MB';
             }

package/dist/frontend.js

@@ -3,9 +3,6 @@ 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';
@@ -13,10 +10,14 @@ 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_DIAGNOSTIC_FILE, MATTERBRIDGE_HISTORY_FILE, 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 { 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";
@@ -625,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;
@@ -633,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();
                 }
             });
@@ -679,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);
@@ -999,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)}`);
@@ -1721,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, '');
@@ -1745,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;
@@ -1757,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)
@@ -1764,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/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.3.1-dev-20251009-008da25",
+  "version": "3.3.1-dev-20251012-b3546f8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.3.1-dev-20251009-008da25",
+      "version": "3.3.1-dev-20251012-b3546f8",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.15.5",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.3.1-dev-20251009-008da25",
+  "version": "3.3.1-dev-20251012-b3546f8",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",