matterbridge 2.1.6-dev.2 → 2.1.6-dev.4

package/CHANGELOG.md

@@ -33,18 +33,22 @@ matterbridge-zigbee2mqtt v. 2.4.4
 matterbridge-somfy-tahoma v. 1.2.3
 matterbridge-hass v. 0.0.8
 
-## [2.1.6] - 2025-02-12
+## [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
 
 <a href="https://www.buymeacoffee.com/luligugithub">
   <img src="./yellow-button.png" alt="Buy me a coffee" width="120">

package/dist/cli.js

@@ -1,16 +1,144 @@
 #!/usr/bin/env node
 import { Matterbridge } from './matterbridge.js';
-let instance;
+import { EventEmitter } from 'events';
+export const cliEmitter = new EventEmitter();
+export let instance;
+let session;
+let memoryCheckInterval;
+let prevCpus;
+export 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() {
+    await startCpuMemoryCheck();
+    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);
+        console.log(cli + `CLI: 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);
+        console.log(cli + `CLI: Matterbridge.loadInstance() exited` + rs);
+}
+async function startCpuMemoryCheck() {
+    const os = await import('node:os');
+    if (process.argv.includes('-debug'))
+        console.log(cli + `CLI: Cpu memory check started` + rs);
+    prevCpus = os.cpus();
+    clearInterval(memoryCheckInterval);
+    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' : ''}`;
+    };
+    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);
+        cliEmitter.emit('memory', totalMememory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers);
+        const currCpus = os.cpus();
+        let cpuUsageLog;
+        if (currCpus.length !== prevCpus.length) {
+            prevCpus = currCpus;
+            if (process.argv.includes('-debug'))
+                console.log(cli + `CLI: Cpu check length failed, resetting previous cpus` + rs);
+            return;
+        }
+        let totalIdle = 0, totalTick = 0;
+        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) {
+            if (process.argv.includes('-debug') && lastCpuUsage != 0)
+                console.log(cli + `CLI: Cpu check failed, using previous cpus` + rs);
+            cpuUsageLog = lastCpuUsage.toFixed(2);
+        }
+        else {
+            cpuUsageLog = cpuUsage.toFixed(2);
+            lastCpuUsage = cpuUsage;
+            cliEmitter.emit('cpu', lastCpuUsage);
+        }
+        prevCpus = currCpus;
+        if (process.argv.includes('-debug'))
+            console.log(`${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}` +
+                rs);
+    };
+    interval();
+    memoryCheckInterval = setInterval(interval, 10 * 1000);
+}
+async function stopCpuMemoryCheck() {
+    if (process.argv.includes('-debug'))
+        console.log(cli + `CLI: Cpu memory check stopped` + rs);
+    clearInterval(memoryCheckInterval);
+}
+async function startInspector() {
+    const { Session } = await import('node:inspector');
+    if (process.argv.includes('-debug'))
+        console.log(cli + `CLI: Starting heap sampling...` + rs);
+    session = new Session();
+    session.connect();
+    session.post('HeapProfiler.startSampling', {}, (err) => {
+        if (err)
+            console.error(err);
+        else
+            console.log(cli + `CLI: Heap sampling started` + rs);
+    });
+}
+async function stopInspector() {
+    const { writeFileSync } = await import('node:fs');
+    if (process.argv.includes('-debug'))
+        console.log(cli + `CLI: Stopping heap sampling...` + rs);
+    session?.post('HeapProfiler.stopSampling', (err, result) => {
+        if (err) {
+            console.error(err);
+        }
+        else {
+            const profile = JSON.stringify(result.profile, null, 2);
+            writeFileSync('heap-sampling-profile.heapsnapshot', profile);
+            console.log(cli + `CLI: Heap sampling profile saved to heap-sampling-profile.heapsnapshot` + rs);
+        }
+        session?.disconnect();
+        session = undefined;
+    });
 }
 function registerHandlers() {
     if (instance)
@@ -19,10 +147,17 @@ function registerHandlers() {
         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());
 }
 async function shutdown() {
     if (process.argv.includes('-debug'))
         console.log(cli + 'CLI: received shutdown event, exiting...' + rs);
+    if (process.argv.includes('-inspector'))
+        await stopInspector();
+    await stopCpuMemoryCheck();
     process.exit(0);
 }
 async function restart() {
@@ -37,6 +172,16 @@ async function update() {
     instance = await Matterbridge.loadInstance(true);
     registerHandlers();
 }
+async function start() {
+    if (process.argv.includes('-debug'))
+        console.log(cli + 'CLI: received start memory check event' + rs);
+    startCpuMemoryCheck();
+}
+async function stop() {
+    if (process.argv.includes('-debug'))
+        console.log(cli + 'CLI: received stop memory check event' + rs);
+    stopCpuMemoryCheck();
+}
 process.title = 'matterbridge';
 main().catch((error) => {
     console.error(er + `CLI: Matterbridge.loadInstance() failed with error: ${error}` + rs);

package/dist/frontend.js

@@ -6,15 +6,16 @@ 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 { AnsiLogger, stringify, debugStringify, CYAN, db, er, nf, rs, UNDERLINE, UNDERLINEOFF, wr, YELLOW } from './logger/export.js';
+import { createZip, deepCopy, hasParameter, isValidNumber, isValidObject, isValidString } from './utils/utils.js';
 import { plg } from './matterbridgeTypes.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 +172,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);
@@ -752,17 +760,6 @@ export class Frontend {
         this.log.debug(`Frontend initialized on port ${YELLOW}${this.port}${db} static ${UNDERLINE}${path.join(this.matterbridge.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
     }
     async stop() {
-        if (hasParameter('memorycheck')) {
-            this.wssSendSnackbarMessage('Memory check started', getIntParameter('memorycheck') ?? 5 * 60 * 1000);
-            await new Promise((resolve) => {
-                this.log.debug(`***Memory check started for ${getIntParameter('memorycheck') ?? 5 * 60 * 1000} ms`);
-                setTimeout(() => {
-                    this.wssSendSnackbarMessage('Memory check stopped', 10);
-                    this.log.debug(`***Memory check stopped after ${getIntParameter('memorycheck') ?? 5 * 60 * 1000} ms`);
-                    resolve();
-                }, getIntParameter('memorycheck') ?? 5 * 60 * 1000);
-            });
-        }
         if (this.httpServer) {
             this.httpServer.close();
             this.httpServer.removeAllListeners();
@@ -796,9 +793,6 @@ export class Frontend {
             });
             this.webSocketServer = undefined;
         }
-        if (hasParameter('memorydump')) {
-            this.stopCpuMemoryDump();
-        }
     }
     formatMemoryUsage = (bytes) => {
         if (bytes >= 1024 ** 3) {
@@ -811,8 +805,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' : ''}`;
@@ -827,86 +820,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);
-        this.memoryInterval.unref();
-        this.memoryTimeout = setTimeout(() => {
-            this.stopCpuMemoryDump();
-        }, getIntParameter('memorytimeout') ?? 600000);
-        this.memoryTimeout.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);
@@ -1391,21 +1311,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/matter/export.js

@@ -1,4 +1,4 @@
 export * from '@matter/main';
 export { SemanticNamespace, ClosureTag, CompassDirectionTag, CompassLocationTag, DirectionTag, ElectricalMeasurementTag, LaundryTag, LevelTag, LocationTag, NumberTag, PositionTag, PowerSourceTag, RefrigeratorTag, RoomAirConditionerTag, SwitchesTag, } from '@matter/main';
 export { AttributeElement, ClusterElement, ClusterModel, CommandElement, EventElement, FieldElement } from '@matter/main/model';
-export { logEndpoint, MdnsService } from '@matter/main/protocol';
+export { logEndpoint, MdnsService, Val } from '@matter/main/protocol';

package/dist/matterbridge.js

@@ -35,7 +35,8 @@ export class Matterbridge extends EventEmitter {
         totalMemory: '',
         freeMemory: '',
         systemUptime: '',
-        cpuUsed: '',
+        processUptime: '',
+        cpuUsage: '',
         rss: '',
         heapTotal: '',
         heapUsed: '',
@@ -126,6 +127,12 @@ export class Matterbridge extends EventEmitter {
     constructor() {
         super();
     }
+    emit(eventName, ...args) {
+        return super.emit(eventName, ...args);
+    }
+    on(eventName, listener) {
+        return super.on(eventName, listener);
+    }
     getDevices() {
         return this.devices.array();
     }
@@ -1443,6 +1450,7 @@ export class Matterbridge extends EventEmitter {
                 sanitizeFabrics(serverNode.state.commissioning.fabrics, true);
             }
             this.frontend.wssSendRefreshRequired();
+            this.frontend.wssSendSnackbarMessage(`${storeId} is online`);
         });
         serverNode.lifecycle.offline.on(() => {
             this.log.notice(`Server node for ${storeId} is offline`);