matterbridge 2.1.6-dev.3 → 2.1.6-dev.5

package/CHANGELOG.md

@@ -33,19 +33,23 @@ matterbridge-zigbee2mqtt v. 2.4.4
 matterbridge-somfy-tahoma v. 1.2.3
 matterbridge-hass v. 0.0.8
 
-## [2.1.6] - 2025-02-13
+## [2.1.6] - 2025-02-15
 
 ### Added
 
-- [docker]: Added health check directly inside the docker image. No need to change configuration.
+- [docker]: Added health check directly in the docker image. No need to change configuration.
 - [platform]: Saving in the storage the selects for faster loading of plugins.
 - [icon]: Added matterbridge svg icon (thanks: https://github.com/robvanoostenrijk https://github.com/stuntguy3000).
+- [frontend]: Added processUptime.
 - [frontend]: Frontend v.2.4.2.
+- [PluginManager]: Refactor PluginManager to optimize memory and load time.
 
 ### Changed
 
 - [package]: Update matter.js to 0.12.4-alpha.0-20250212-b2729c9eb
 - [package]: Update matter.js to 0.12.4-alpha.0-20250213-1187f81eb
+- [package]: Update matter.js to 0.12.4-alpha.0-20250215-5af08a8d6
+- [package]: Update matter.js to 0.12.4-alpha.0-20250217-b0bba5179
 
 <a href="https://www.buymeacoffee.com/luligugithub">
   <img src="./yellow-button.png" alt="Buy me a coffee" width="120">

package/dist/cli.js

@@ -1,50 +1,69 @@
 #!/usr/bin/env node
 import { Matterbridge } from './matterbridge.js';
-let instance;
+import { getIntParameter, hasParameter } from './utils/export.js';
+import { AnsiLogger, BRIGHT, CYAN, db, YELLOW } from './logger/export.js';
+import { EventEmitter } from 'node:events';
+export const cliEmitter = new EventEmitter();
+export let instance;
 let session;
 let memoryCheckInterval;
 let prevCpus;
-let lastCpuUsage = 0;
-const cli = '\u001B[32m';
-const er = '\u001B[38;5;9m';
-const rs = '\u001B[40;0m';
-const db = '\u001B[38;5;245m';
-const CYAN = '\u001B[36m';
-const YELLOW = '\u001B[33m';
-const BRIGHT = '\u001B[1m';
-async function main() {
-    if (process.argv.includes('-memorycheck'))
-        await startMemoryCheck();
-    if (process.argv.includes('-inspector'))
-        await startInspector();
-    if (process.argv.includes('-debug'))
-        console.log(cli + `CLI: ${process.argv.includes('-edge') ? 'MatterbridgeEdge' : 'Matterbridge'}.loadInstance() called` + rs);
-    instance = await Matterbridge.loadInstance(true);
-    registerHandlers();
-    if (process.argv.includes('-debug'))
-        console.log(cli + `CLI: ${process.argv.includes('-edge') ? 'MatterbridgeEdge' : 'Matterbridge'}.loadInstance() exited` + rs);
-}
-async function startMemoryCheck() {
+export let lastCpuUsage = 0;
+let peakCpu = 0;
+let peakRss = 0;
+const log = new AnsiLogger({ logName: 'Cli', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
+const formatMemoryUsage = (bytes) => {
+    if (bytes >= 1024 ** 3) {
+        return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
+    }
+    else if (bytes >= 1024 ** 2) {
+        return `${(bytes / 1024 ** 2).toFixed(2)} MB`;
+    }
+    else {
+        return `${(bytes / 1024).toFixed(2)} KB`;
+    }
+};
+const formatOsUpTime = (seconds) => {
+    if (seconds >= 86400) {
+        const days = Math.floor(seconds / 86400);
+        return `${days} day${days !== 1 ? 's' : ''}`;
+    }
+    if (seconds >= 3600) {
+        const hours = Math.floor(seconds / 3600);
+        return `${hours} hour${hours !== 1 ? 's' : ''}`;
+    }
+    if (seconds >= 60) {
+        const minutes = Math.floor(seconds / 60);
+        return `${minutes} minute${minutes !== 1 ? 's' : ''}`;
+    }
+    return `${seconds} second${seconds !== 1 ? 's' : ''}`;
+};
+async function startCpuMemoryCheck() {
     const os = await import('node:os');
-    console.log(cli + `CLI: Memory check started` + rs);
+    log.debug(`Cpu memory check started`);
     prevCpus = os.cpus();
-    const formatMemoryUsage = (bytes) => {
-        if (bytes >= 1024 ** 3) {
-            return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
-        }
-        else if (bytes >= 1024 ** 2) {
-            return `${(bytes / 1024 ** 2).toFixed(2)} MB`;
-        }
-        else {
-            return `${(bytes / 1024).toFixed(2)} KB`;
-        }
-    };
+    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 freeMemory = formatMemoryUsage(os.freemem());
+        const memoryUsageRaw = process.memoryUsage();
+        const rss = formatMemoryUsage(memoryUsageRaw.rss);
+        const heapTotal = formatMemoryUsage(memoryUsageRaw.heapTotal);
+        const heapUsed = formatMemoryUsage(memoryUsageRaw.heapUsed);
+        const external = formatMemoryUsage(memoryUsageRaw.external);
+        const arrayBuffers = formatMemoryUsage(memoryUsageRaw.arrayBuffers);
+        if (memoryUsageRaw.rss > peakRss)
+            peakRss = memoryUsageRaw.rss;
+        cliEmitter.emit('memory', totalMememory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers);
         const currCpus = os.cpus();
         let cpuUsageLog;
         if (currCpus.length !== prevCpus.length) {
             prevCpus = currCpus;
-            cpuUsageLog = lastCpuUsage.toFixed(2);
+            log.debug(`Cpu check length failed, resetting previous cpus`);
+            return;
         }
         let totalIdle = 0, totalTick = 0;
         prevCpus.forEach((prevCpu, i) => {
@@ -56,91 +75,116 @@ async function startMemoryCheck() {
         });
         const cpuUsage = 100 - (totalIdle / totalTick) * 100;
         if (totalTick === 0 || isNaN(cpuUsage) || !isFinite(cpuUsage) || cpuUsage <= 0) {
+            if (lastCpuUsage != 0)
+                log.debug(`Cpu check failed, using previous cpus`);
             cpuUsageLog = lastCpuUsage.toFixed(2);
         }
+        else {
+            cpuUsageLog = cpuUsage.toFixed(2);
+            lastCpuUsage = cpuUsage;
+            if (lastCpuUsage > peakCpu)
+                peakCpu = lastCpuUsage;
+            cliEmitter.emit('cpu', lastCpuUsage);
+        }
         prevCpus = currCpus;
-        lastCpuUsage = cpuUsage;
-        cpuUsageLog = cpuUsage.toFixed(2);
-        const memoryUsageRaw = process.memoryUsage();
-        const memoryUsage = {
-            rss: formatMemoryUsage(memoryUsageRaw.rss),
-            heapTotal: formatMemoryUsage(memoryUsageRaw.heapTotal),
-            heapUsed: formatMemoryUsage(memoryUsageRaw.heapUsed),
-            external: formatMemoryUsage(memoryUsageRaw.external),
-            arrayBuffers: formatMemoryUsage(memoryUsageRaw.arrayBuffers),
-        };
-        console.log(`${YELLOW}${BRIGHT}Cpu usage:${db} ${CYAN}${cpuUsageLog.padStart(6, ' ')} %${db} ${YELLOW}${BRIGHT}Memory usage:${db} rss ${CYAN}${memoryUsage.rss}${db} heapTotal ${CYAN}${memoryUsage.heapTotal}${db} heapUsed ${CYAN}${memoryUsage.heapUsed}${db} external ${memoryUsage.external} arrayBuffers ${memoryUsage.arrayBuffers}` +
-            rs);
+        log.debug(`***${YELLOW}${BRIGHT}Cpu usage:${db} ${CYAN}${cpuUsageLog.padStart(6, ' ')} %${db} ${YELLOW}${BRIGHT}Memory usage:${db} rss ${CYAN}${rss}${db} heapTotal ${CYAN}${heapTotal}${db} heapUsed ${CYAN}${heapUsed}${db} external ${external} arrayBuffers ${arrayBuffers}`);
     };
     interval();
-    memoryCheckInterval = setInterval(interval, 1000);
+    memoryCheckInterval = setInterval(interval, getIntParameter('memoryinterval') ?? 10 * 1000);
 }
-async function stopMemoryCheck() {
-    console.log(cli + `CLI: Stopping memory check in 5 minute` + rs);
-    instance = undefined;
-    setTimeout(() => {
-        console.log(cli + `CLI: Memory check stopped` + rs);
-        clearInterval(memoryCheckInterval);
-        process.exit(0);
-    }, 5 * 60 * 1000);
+async function stopCpuMemoryCheck() {
+    log.debug(`***Cpu memory check stopped. Peak cpu: ${CYAN}${peakCpu.toFixed(2)} %${db}. Peak rss: ${CYAN}${formatMemoryUsage(peakRss)}${db}.`);
+    clearInterval(memoryCheckInterval);
 }
 async function startInspector() {
     const { Session } = await import('node:inspector');
+    log.debug(`Starting heap sampling...`);
     session = new Session();
     session.connect();
-    session.post('HeapProfiler.startSampling', {}, (err) => {
-        if (err)
-            console.error(err);
-        else
-            console.log(cli + `CLI: Heap sampling started` + rs);
+    await new Promise((resolve, reject) => {
+        session?.post('HeapProfiler.startSampling', {}, (err) => (err ? reject(err) : resolve()));
     });
+    log.debug(`Started heap sampling`);
 }
 async function stopInspector() {
     const { writeFileSync } = await import('node:fs');
-    session.post('HeapProfiler.stopSampling', (err, result) => {
-        if (err) {
-            console.error(err);
-        }
-        else {
-            const profile = JSON.stringify(result.profile, null, 2);
-            writeFileSync('heap-sampling-profile.heapsampling.json', profile);
-            console.log(cli + `CLI: Heap sampling profile saved to heap-sampling-profile.heapsnapshot` + rs);
-        }
-    });
+    log.debug(`Stopping heap sampling...`);
+    if (!session) {
+        log.error('No active inspector session.');
+        return;
+    }
+    try {
+        const result = await new Promise((resolve, reject) => {
+            session?.post('HeapProfiler.stopSampling', (err, result) => (err ? reject(err) : resolve(result)));
+        });
+        const profile = JSON.stringify(result.profile);
+        writeFileSync('Heap-sampling-profile.heapprofile', profile);
+        log.debug('Heap sampling profile saved to Heap-sampling-profile.heapprofile');
+    }
+    catch (err) {
+        log.error(`Failed to stop heap sampling: ${err instanceof Error ? err.message : err}`);
+    }
+    finally {
+        session.disconnect();
+        session = undefined;
+        log.debug(`Stopped heap sampling`);
+    }
 }
 function registerHandlers() {
+    log.debug('Registering event handlers...');
     if (instance)
         instance.on('shutdown', async () => shutdown());
     if (instance)
         instance.on('restart', async () => restart());
     if (instance)
         instance.on('update', async () => update());
+    if (instance)
+        instance.on('startmemorycheck', async () => start());
+    if (instance)
+        instance.on('stopmemorycheck', async () => stop());
+    log.debug('Registered event handlers');
 }
 async function shutdown() {
-    if (process.argv.includes('-debug'))
-        console.log(cli + 'CLI: received shutdown event, exiting...' + rs);
-    if (process.argv.includes('-inspector'))
+    log.debug('Received shutdown event, exiting...');
+    if (hasParameter('inspect'))
         await stopInspector();
-    if (process.argv.includes('-memorycheck')) {
-        await stopMemoryCheck();
-    }
-    else {
-        process.exit(0);
-    }
+    await stopCpuMemoryCheck();
+    process.exit(0);
 }
 async function restart() {
-    if (process.argv.includes('-debug'))
-        console.log(cli + 'CLI: received restart event, loading...' + rs);
+    log.debug('Received restart event, loading...');
     instance = await Matterbridge.loadInstance(true);
     registerHandlers();
 }
 async function update() {
-    if (process.argv.includes('-debug'))
-        console.log(cli + 'CLI: received update event, updating...' + rs);
+    log.debug('Received update event, updating...');
     instance = await Matterbridge.loadInstance(true);
     registerHandlers();
 }
+async function start() {
+    log.debug('Received start memory check event');
+    startCpuMemoryCheck();
+}
+async function stop() {
+    log.debug('Received stop memory check event');
+    stopCpuMemoryCheck();
+}
+async function main() {
+    log.debug(`Cli main() started`);
+    await startCpuMemoryCheck();
+    if (hasParameter('inspect'))
+        await startInspector();
+    log.debug(`***Matterbridge.loadInstance(true) called`);
+    instance = await Matterbridge.loadInstance(true);
+    log.debug(`***Matterbridge.loadInstance(true) exited`);
+    if (instance.shutdown) {
+        shutdown();
+    }
+    else {
+        registerHandlers();
+    }
+}
 process.title = 'matterbridge';
 main().catch((error) => {
-    console.error(er + `CLI: Matterbridge.loadInstance() failed with error: ${error}` + rs);
+    log.error(`Matterbridge.loadInstance() failed with error: ${error instanceof Error ? error.message : error}`);
 });

package/dist/frontend.js

@@ -1,20 +1,22 @@
 import { EndpointServer, Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat } from '@matter/main';
-import { createServer } from 'http';
+import { createServer } from 'node:http';
 import https from 'https';
 import express from 'express';
 import WebSocket, { WebSocketServer } from 'ws';
-import os from 'os';
-import path from 'path';
-import { promises as fs } from 'fs';
-import { AnsiLogger, CYAN, db, debugStringify, er, nf, rs, stringify, UNDERLINE, UNDERLINEOFF, wr, YELLOW } from './logger/export.js';
-import { createZip, deepCopy, getIntParameter, hasParameter, isValidNumber, isValidObject, isValidString } from './utils/utils.js';
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { AnsiLogger, stringify, debugStringify, CYAN, db, er, nf, rs, UNDERLINE, UNDERLINEOFF, wr, YELLOW } from './logger/export.js';
+import { createZip, deepCopy, isValidNumber, isValidObject, isValidString } from './utils/export.js';
 import { plg } from './matterbridgeTypes.js';
+import { hasParameter } from './utils/export.js';
 export const WS_ID_LOG = 0;
 export const WS_ID_REFRESH_NEEDED = 1;
 export const WS_ID_RESTART_NEEDED = 2;
 export const WS_ID_CPU_UPDATE = 3;
 export const WS_ID_MEMORY_UPDATE = 4;
-export const WS_ID_SNACKBAR = 5;
+export const WS_ID_UPTIME_UPDATE = 5;
+export const WS_ID_SNACKBAR = 6;
 export class Frontend {
     matterbridge;
     log;
@@ -171,9 +173,16 @@ export class Frontend {
         this.webSocketServer.on('error', (ws, error) => {
             this.log.error(`WebSocketServer error: ${error}`);
         });
-        if (hasParameter('memorydump')) {
-            this.startCpuMemoryDump();
-        }
+        const { cliEmitter } = await import('./cli.js');
+        cliEmitter.on('uptime', (systemUptime, processUptime) => {
+            this.wssSendUptimeUpdate(systemUptime, processUptime);
+        });
+        cliEmitter.on('memory', (totalMememory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers) => {
+            this.wssSendMemoryUpdate(totalMememory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers);
+        });
+        cliEmitter.on('cpu', (cpuUsage) => {
+            this.wssSendCpuUpdate(cpuUsage);
+        });
         this.expressApp.post('/api/login', express.json(), async (req, res) => {
             const { password } = req.body;
             this.log.debug('The frontend sent /api/login', password);
@@ -228,7 +237,7 @@ export class Frontend {
                 space_available_size: this.formatMemoryUsage(space.space_available_size),
                 physical_space_size: this.formatMemoryUsage(space.physical_space_size),
             }));
-            const { default: module } = await import('module');
+            const { default: module } = await import('node:module');
             const loadedModules = module._cache ? Object.keys(module._cache).sort() : [];
             const memoryReport = {
                 memoryUsage,
@@ -785,9 +794,6 @@ export class Frontend {
             });
             this.webSocketServer = undefined;
         }
-        if (hasParameter('memorydump')) {
-            this.stopCpuMemoryDump();
-        }
     }
     formatMemoryUsage = (bytes) => {
         if (bytes >= 1024 ** 3) {
@@ -800,8 +806,7 @@ export class Frontend {
             return `${(bytes / 1024).toFixed(2)} KB`;
         }
     };
-    formatOsUpTime = () => {
-        const seconds = os.uptime();
+    formatOsUpTime = (seconds) => {
         if (seconds >= 86400) {
             const days = Math.floor(seconds / 86400);
             return `${days} day${days !== 1 ? 's' : ''}`;
@@ -816,84 +821,13 @@ export class Frontend {
         }
         return `${seconds} second${seconds !== 1 ? 's' : ''}`;
     };
-    getCpuUsage = () => {
-        const currCpus = os.cpus();
-        if (currCpus.length !== this.prevCpus.length) {
-            this.prevCpus = deepCopy(currCpus);
-            this.log.debug(`***Cpu usage reset. Current cpus: ${currCpus.length}. Previous cpus: ${this.prevCpus.length}.`);
-            return this.lastCpuUsage.toFixed(2);
-        }
-        let totalIdle = 0, totalTick = 0;
-        this.prevCpus.forEach((prevCpu, i) => {
-            const currCpu = currCpus[i];
-            const idleDiff = currCpu.times.idle - prevCpu.times.idle;
-            const totalDiff = Object.keys(currCpu.times).reduce((acc, key) => acc + (currCpu.times[key] - prevCpu.times[key]), 0);
-            totalIdle += idleDiff;
-            totalTick += totalDiff;
-        });
-        const cpuUsage = 100 - (totalIdle / totalTick) * 100;
-        if (totalTick === 0 || isNaN(cpuUsage) || !isFinite(cpuUsage) || cpuUsage <= 0) {
-            this.log.debug('***Invalid cpu usage. Returning the previous one.');
-            return this.lastCpuUsage.toFixed(2);
-        }
-        this.prevCpus = deepCopy(currCpus);
-        this.lastCpuUsage = cpuUsage;
-        return cpuUsage.toFixed(2);
-    };
-    startCpuMemoryDump() {
-        clearInterval(this.memoryInterval);
-        clearTimeout(this.memoryTimeout);
-        const interval = () => {
-            const cpuUsage = this.getCpuUsage();
-            const memoryUsageRaw = process.memoryUsage();
-            this.memoryData.push({ ...memoryUsageRaw, cpu: cpuUsage });
-            const memoryUsage = {
-                rss: this.formatMemoryUsage(memoryUsageRaw.rss),
-                heapTotal: this.formatMemoryUsage(memoryUsageRaw.heapTotal),
-                heapUsed: this.formatMemoryUsage(memoryUsageRaw.heapUsed),
-                external: this.formatMemoryUsage(memoryUsageRaw.external),
-                arrayBuffers: this.formatMemoryUsage(memoryUsageRaw.arrayBuffers),
-            };
-            this.log.debug(`***Cpu usage: ${CYAN}${cpuUsage.padStart(6, ' ')} %${db} - Memory usage: rss ${CYAN}${memoryUsage.rss}${db} heapTotal ${CYAN}${memoryUsage.heapTotal}${db} heapUsed ${CYAN}${memoryUsage.heapUsed}${db} external ${memoryUsage.external} arrayBuffers ${memoryUsage.arrayBuffers}`);
-            this.matterbridge.systemInformation.freeMemory = this.formatMemoryUsage(os.freemem());
-            this.matterbridge.systemInformation.totalMemory = this.formatMemoryUsage(os.totalmem());
-            this.matterbridge.systemInformation.systemUptime = this.formatOsUpTime();
-            this.matterbridge.systemInformation.cpuUsed = cpuUsage;
-            this.matterbridge.systemInformation.rss = this.formatMemoryUsage(process.memoryUsage().rss);
-            this.matterbridge.systemInformation.heapTotal = this.formatMemoryUsage(process.memoryUsage().heapTotal);
-            this.matterbridge.systemInformation.heapUsed = this.formatMemoryUsage(process.memoryUsage().heapUsed);
-            this.wssSendCpuUpdate(this.matterbridge.systemInformation.cpuUsed);
-            this.wssSendMemoryUpdate(this.matterbridge.systemInformation.freeMemory, this.matterbridge.systemInformation.totalMemory, this.matterbridge.systemInformation.systemUptime, this.matterbridge.systemInformation.rss, this.matterbridge.systemInformation.heapUsed, this.matterbridge.systemInformation.heapTotal);
-        };
-        interval();
-        this.memoryInterval = setInterval(interval, getIntParameter('memoryinterval') ?? 1000).unref();
-        this.memoryTimeout = setTimeout(() => {
-            this.stopCpuMemoryDump();
-        }, getIntParameter('memorytimeout') ?? 600000).unref();
-    }
-    stopCpuMemoryDump() {
-        clearInterval(this.memoryInterval);
-        this.memoryInterval = undefined;
-        clearTimeout(this.memoryTimeout);
-        this.memoryTimeout = undefined;
-        for (const memory of this.memoryData) {
-            const memoryUsage = {
-                rss: this.formatMemoryUsage(memory.rss),
-                heapTotal: this.formatMemoryUsage(memory.heapTotal),
-                heapUsed: this.formatMemoryUsage(memory.heapUsed),
-                external: this.formatMemoryUsage(memory.external),
-                arrayBuffers: this.formatMemoryUsage(memory.arrayBuffers),
-            };
-            console.log(`${YELLOW}Cpu usage:${db} ${CYAN}${memory.cpu.padStart(6, ' ')} %${db} - ${YELLOW}Memory usage:${db} rss ${CYAN}${memoryUsage.rss}${db} heapTotal ${CYAN}${memoryUsage.heapTotal}${db} heapUsed ${CYAN}${memoryUsage.heapUsed}${db} external ${memoryUsage.external} arrayBuffers ${memoryUsage.arrayBuffers}${rs}`);
-        }
-        this.memoryData = [];
-        this.prevCpus = [];
-    }
     async getApiSettings() {
+        const { lastCpuUsage } = await import('./cli.js');
         this.matterbridge.systemInformation.totalMemory = this.formatMemoryUsage(os.totalmem());
         this.matterbridge.systemInformation.freeMemory = this.formatMemoryUsage(os.freemem());
-        this.matterbridge.systemInformation.systemUptime = this.formatOsUpTime();
-        this.matterbridge.systemInformation.cpuUsed = this.getCpuUsage();
+        this.matterbridge.systemInformation.systemUptime = this.formatOsUpTime(os.uptime());
+        this.matterbridge.systemInformation.processUptime = this.formatOsUpTime(Math.floor(process.uptime()));
+        this.matterbridge.systemInformation.cpuUsage = lastCpuUsage.toFixed(2) + ' %';
         this.matterbridge.systemInformation.rss = this.formatMemoryUsage(process.memoryUsage().rss);
         this.matterbridge.systemInformation.heapTotal = this.formatMemoryUsage(process.memoryUsage().heapTotal);
         this.matterbridge.systemInformation.heapUsed = this.formatMemoryUsage(process.memoryUsage().heapUsed);
@@ -1378,21 +1312,27 @@ export class Frontend {
             }
         });
     }
-    wssSendCpuUpdate(cpuUsed) {
+    wssSendCpuUpdate(cpuUsage) {
+        this.log.debug('Sending a cpu update message to all connected clients');
+        this.webSocketServer?.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(JSON.stringify({ id: WS_ID_CPU_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'cpu_update', params: { cpuUsage } }));
+            }
+        });
+    }
+    wssSendMemoryUpdate(totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers) {
         this.log.debug('Sending a memory update message to all connected clients');
-        this.matterbridge.matterbridgeInformation.restartRequired = true;
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_CPU_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'cpu_update', params: { cpuUsed } }));
+                client.send(JSON.stringify({ id: WS_ID_MEMORY_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'memory_update', params: { totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers } }));
             }
         });
     }
-    wssSendMemoryUpdate(freeMemory, totalMemory, systemUptime, rss, heapUsed, heapTotal) {
-        this.log.debug('Sending a cpu update message to all connected clients');
-        this.matterbridge.matterbridgeInformation.restartRequired = true;
+    wssSendUptimeUpdate(systemUptime, processUptime) {
+        this.log.debug('Sending a uptime update message to all connected clients');
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_MEMORY_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'memory_update', params: { freeMemory, totalMemory, systemUptime, rss, heapUsed, heapTotal } }));
+                client.send(JSON.stringify({ id: WS_ID_UPTIME_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'uptime_update', params: { systemUptime, processUptime } }));
             }
         });
     }

package/dist/index.js

@@ -1,4 +1,6 @@
 import { Matterbridge } from './matterbridge.js';
+import { hasParameter } from './utils/export.js';
+import { AnsiLogger } from './logger/export.js';
 export { SemanticNamespace, ClosureTag, CompassDirectionTag, CompassLocationTag, DirectionTag, ElectricalMeasurementTag, LaundryTag, LevelTag, LocationTag, NumberTag, PositionTag, PowerSourceTag, RefrigeratorTag, RoomAirConditionerTag, SwitchesTag, } from '@matter/main';
 export * from '@matter/main/clusters';
 export * from '@matter/main/types';
@@ -11,16 +13,12 @@ export * from './matterbridgeDeviceTypes.js';
 export * from './matterbridgePlatform.js';
 export * from './matterbridgeAccessoryPlatform.js';
 export * from './matterbridgeDynamicPlatform.js';
-const cli = '\u001B[32m';
-const er = '\u001B[38;5;9m';
-const rs = '\u001B[40;0m';
+const log = new AnsiLogger({ logName: 'Main', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
 async function main() {
-    if (process.argv.includes('-debug'))
-        console.log(cli + 'MAIN: Matterbridge.loadInstance() called' + rs);
+    log.debug('***Matterbridge.loadInstance() called');
     await Matterbridge.loadInstance();
-    if (process.argv.includes('-debug'))
-        console.log(cli + 'MAIN: Matterbridge.loadInstance() exited' + rs);
+    log.debug('***Matterbridge.loadInstance() exited');
 }
 main().catch((error) => {
-    console.error(er + `MAIN: Matterbridge.loadInstance() failed with error: ${error}` + rs);
+    log.error(`Matterbridge.loadInstance() failed with error: ${error instanceof Error ? error.message : error}`);
 });