matterbridge 2.1.5-dev.1 → 2.1.5-dev.3

package/CHANGELOG.md

@@ -33,13 +33,18 @@ matterbridge-zigbee2mqtt v. 2.4.4
 matterbridge-somfy-tahoma v. 1.2.3
 matterbridge-hass v. 0.0.8
 
-## [2.1.5] - 2025-02-08
+## [2.1.5] - 2025-02-09
 
 ### Added
 
+- [frontend]: Frontend v.2.4.1.
+- [frontend]: Optimized rendering of all pages.
+- [frontend]: Added cpuUsed, rss and heapUsed to SystemInformation.
+
 ### Changed
 
 - [matterbridge]: Calls getNpmPackageVersion() instead of npm to get latest version.
+- [matterbridge]: Memory optimization on MatterbridgeEndpoint.
 
 ### Fixed
 

package/dist/frontend.js

@@ -7,12 +7,14 @@ 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, getIntParameter, hasParameter, isValidNumber, isValidObject, isValidString } from './utils/utils.js';
+import { createZip, deepCopy, getIntParameter, hasParameter, isValidNumber, isValidObject, isValidString } from './utils/utils.js';
 import { plg } from './matterbridgeTypes.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.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 class Frontend {
     matterbridge;
     log;
@@ -22,7 +24,8 @@ export class Frontend {
     httpServer;
     httpsServer;
     webSocketServer;
-    prevCpus = os.cpus();
+    prevCpus = deepCopy(os.cpus());
+    lastCpuUsage = 0;
     memoryData = [];
     memoryInterval;
     memoryTimeout;
@@ -792,28 +795,61 @@ export class Frontend {
         }
     }
     formatMemoryUsage = (bytes) => {
-        const kb = bytes / 1024;
-        const mb = kb / 1024;
-        return mb >= 1 ? `${mb.toFixed(2)} MB` : `${kb.toFixed(2)} KB`;
+        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`;
+        }
+    };
+    formatOsUpTime = () => {
+        const seconds = os.uptime();
+        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' : ''}`;
+    };
+    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 currCpus = os.cpus();
-            if (currCpus.length !== this.prevCpus.length) {
-                this.prevCpus = currCpus;
-            }
-            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).toFixed(2);
-            this.prevCpus = currCpus;
+            const cpuUsage = this.getCpuUsage();
             const memoryUsageRaw = process.memoryUsage();
             this.memoryData.push({ ...memoryUsageRaw, cpu: cpuUsage });
             const memoryUsage = {
@@ -824,6 +860,15 @@ export class Frontend {
                 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);
@@ -852,8 +897,13 @@ export class Frontend {
         this.prevCpus = [];
     }
     async getApiSettings() {
+        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.rss = this.formatMemoryUsage(process.memoryUsage().rss);
-        this.matterbridge.systemInformation.heap = this.formatMemoryUsage(process.memoryUsage().heapUsed) + ' / ' + this.formatMemoryUsage(process.memoryUsage().heapTotal);
+        this.matterbridge.systemInformation.heapTotal = this.formatMemoryUsage(process.memoryUsage().heapTotal);
+        this.matterbridge.systemInformation.heapUsed = this.formatMemoryUsage(process.memoryUsage().heapUsed);
         this.matterbridge.matterbridgeInformation.bridgeMode = this.matterbridge.bridgeMode;
         this.matterbridge.matterbridgeInformation.restartMode = this.matterbridge.restartMode;
         this.matterbridge.matterbridgeInformation.loggerLevel = this.matterbridge.log.logLevel;
@@ -1316,4 +1366,22 @@ export class Frontend {
             }
         });
     }
+    wssSendCpuUpdate(cpuUsed) {
+        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 } }));
+            }
+        });
+    }
+    wssSendMemoryUpdate(freeMemory, totalMemory, systemUptime, rss, heapUsed, heapTotal) {
+        this.log.debug('Sending a cpu 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_MEMORY_UPDATE, src: 'Matterbridge', dst: 'Frontend', method: 'memory_update', params: { freeMemory, totalMemory, systemUptime, rss, heapUsed, heapTotal } }));
+            }
+        });
+    }
 }

package/dist/matterbridge.js

@@ -35,8 +35,10 @@ export class Matterbridge extends EventEmitter {
         totalMemory: '',
         freeMemory: '',
         systemUptime: '',
+        cpuUsed: '',
         rss: '',
-        heap: '',
+        heapTotal: '',
+        heapUsed: '',
     };
     matterbridgeInformation = {
         homeDirectory: '',

package/dist/matterbridgeEndpoint.js

@@ -2,7 +2,7 @@ import { AnsiLogger, BLUE, CYAN, YELLOW, db, debugStringify, er, hk, or, zb } fr
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
 import { isValidNumber, isValidObject } from './utils/utils.js';
 import { MatterbridgeBehavior, MatterbridgeBehaviorDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, } from './matterbridgeBehaviors.js';
-import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, capitalizeFirstLetter, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, } from './matterbridgeEndpointHelpers.js';
+import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, capitalizeFirstLetter, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, } from './matterbridgeEndpointHelpers.js';
 import { Endpoint, Lifecycle, MutableEndpoint, NamedHandler, SupportedBehaviors, VendorId } from '@matter/main';
 import { getClusterNameById, MeasurementType } from '@matter/main/types';
 import { Descriptor } from '@matter/main/clusters/descriptor';
@@ -130,7 +130,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         }
         else
             this.deviceTypes.set(firstDefinition.code, firstDefinition);
-        this.log = new AnsiLogger({ logName: 'MatterbridgeEndpoint', logTimestampFormat: 4, logLevel: debug === true ? "debug" : MatterbridgeEndpoint.logLevel });
+        this.log = new AnsiLogger({ logName: options.uniqueStorageKey ?? 'MatterbridgeEndpoint', logTimestampFormat: 4, logLevel: debug === true ? "debug" : MatterbridgeEndpoint.logLevel });
         this.log.debug(`${YELLOW}new${db} MatterbridgeEndpoint: ${zb}${'0x' + firstDefinition.code.toString(16).padStart(4, '0')}${db}-${zb}${firstDefinition.name}${db} ` +
             `id: ${CYAN}${options.uniqueStorageKey}${db} number: ${CYAN}${options.endpointId}${db} taglist: ${CYAN}${options.tagList ? debugStringify(options.tagList) : 'undefined'}${db}`);
         this.behaviors.require(MatterbridgeBehavior, { deviceCommand: new MatterbridgeBehaviorDevice(this.log, this.commandHandler, undefined) });
@@ -171,24 +171,8 @@ export class MatterbridgeEndpoint extends Endpoint {
     async updateAttribute(cluster, attribute, value, log) {
         return await updateAttribute(this, cluster, attribute, value, log);
     }
-    async subscribeAttribute(clusterId, attribute, listener, log) {
-        const clusterName = lowercaseFirstLetter(getClusterNameById(clusterId));
-        if (this.construction.status !== Lifecycle.Status.Active) {
-            await this.construction.ready;
-        }
-        const events = this.events;
-        if (!(clusterName in events)) {
-            this.log.error(`subscribeAttribute ${hk}${attribute}${er} error: Cluster ${'0x' + clusterId.toString(16).padStart(4, '0')}:${clusterName} not found on endpoint ${or}${this.maybeId}${er}:${or}${this.maybeNumber}${er}`);
-            return false;
-        }
-        attribute = lowercaseFirstLetter(attribute) + '$Changed';
-        if (!(attribute in events[clusterName])) {
-            this.log.error(`subscribeAttribute error: Attribute ${hk}${attribute}${er} not found on Cluster ${'0x' + clusterId.toString(16).padStart(4, '0')}:${clusterName} on endpoint ${or}${this.maybeId}${er}:${or}${this.maybeNumber}${er}`);
-            return false;
-        }
-        events[clusterName][attribute].on(listener);
-        log?.info(`${db}Subscribed endpoint ${or}${this.id}${db}:${or}${this.number}${db} attribute ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${attribute}${db}`);
-        return true;
+    async subscribeAttribute(cluster, attribute, listener, log) {
+        return await subscribeAttribute(this, cluster, attribute, listener, log);
     }
     async triggerEvent(clusterId, event, payload, log) {
         const clusterName = lowercaseFirstLetter(getClusterNameById(clusterId));
@@ -207,6 +191,7 @@ export class MatterbridgeEndpoint extends Endpoint {
     }
     addClusterServers(serverList) {
         addClusterServers(this, serverList);
+        return this;
     }
     async addFixedLabel(label, value) {
         await addFixedLabel(this, label, value);

package/dist/matterbridgeEndpointHelpers.js

@@ -479,6 +479,26 @@ export async function updateAttribute(endpoint, cluster, attribute, value, log)
         `to ${YELLOW}${value !== null && typeof value === 'object' ? debugStringify(value) : value}${db}`);
     return true;
 }
+export async function subscribeAttribute(endpoint, cluster, attribute, listener, log) {
+    const clusterName = getBehavior(endpoint, cluster)?.id;
+    if (!clusterName) {
+        endpoint.log.error(`subscribeAttribute ${hk}${attribute}${er} error: cluster not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
+        return false;
+    }
+    if (endpoint.construction.status !== Lifecycle.Status.Active) {
+        endpoint.log.debug(`subscribeAttribute ${hk}${clusterName}.${attribute}${db}: Endpoint ${or}${endpoint.maybeId}${db}:${or}${endpoint.maybeNumber}${db} is in the ${BLUE}${endpoint.construction.status}${db} state`);
+        await endpoint.construction.ready;
+    }
+    const events = endpoint.events;
+    attribute = lowercaseFirstLetter(attribute) + '$Changed';
+    if (!(clusterName in events) || !(attribute in events[clusterName])) {
+        endpoint.log.error(`subscribeAttribute error: Attribute ${hk}${attribute.replace('$Changed', '')}${er} not found on Cluster ${'0x' + getClusterId(endpoint, clusterName)?.toString(16).padStart(4, '0')}:${clusterName} on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
+        return false;
+    }
+    events[clusterName][attribute].on(listener);
+    log?.info(`${db}Subscribed endpoint ${or}${endpoint.id}${db}:${or}${endpoint.number}${db} attribute ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${attribute}${db}`);
+    return true;
+}
 export function getDefaultTemperatureMeasurementClusterServer(measuredValue = 0) {
     return optionsFor(TemperatureMeasurementServer, {
         measuredValue,

package/dist/utils/utils.js

@@ -1,8 +1,5 @@
 import os from 'os';
 import path from 'path';
-import { createWriteStream, statSync } from 'fs';
-import { promises as fs } from 'fs';
-import * as dns from 'dns';
 import { AnsiLogger, idn, rs } from 'node-ansi-logger';
 const log = new AnsiLogger({ logName: 'MatterbridgeUtils', logTimestampFormat: 4, logLevel: "info" });
 export function deepEqual(a, b, excludeProperties = []) {
@@ -263,6 +260,7 @@ export async function wait(timeout = 1000, name, debug = false) {
 export async function createZip(outputPath, ...sourcePaths) {
     const { default: archiver } = await import('archiver');
     const { glob } = await import('glob');
+    const { createWriteStream, statSync } = await import('fs');
     log.logLevel = "info";
     log.logName = 'Archive';
     log.debug(`creating archive ${outputPath} from ${sourcePaths.join(', ')} ...`);
@@ -328,6 +326,7 @@ export async function createZip(outputPath, ...sourcePaths) {
     });
 }
 export async function copyDirectory(srcDir, destDir) {
+    const fs = await import('fs').then((mod) => mod.promises);
     log.debug(`copyDirectory: copying directory from ${srcDir} to ${destDir}`);
     try {
         await fs.mkdir(destDir, { recursive: true });
@@ -350,6 +349,7 @@ export async function copyDirectory(srcDir, destDir) {
     }
 }
 export async function resolveHostname(hostname, family = 4) {
+    const dns = await import('dns');
     try {
         const addresses = await dns.promises.lookup(hostname.toLowerCase(), { family });
         return addresses.address;

package/frontend/build/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
     "main.css": "./static/css/main.cf25d33e.css",
-    "main.js": "./static/js/main.26dbf9b9.js",
+    "main.js": "./static/js/main.1c3bc5a8.js",
     "static/js/453.abd36b29.chunk.js": "./static/js/453.abd36b29.chunk.js",
     "static/media/roboto-latin-700-normal.woff2": "./static/media/roboto-latin-700-normal.4535474e1cf8598695ad.woff2",
     "static/media/roboto-latin-500-normal.woff2": "./static/media/roboto-latin-500-normal.7077203b1982951ecf76.woff2",
@@ -61,11 +61,11 @@
     "static/media/roboto-greek-ext-400-normal.woff": "./static/media/roboto-greek-ext-400-normal.16eb83b4a3b1ea994243.woff",
     "index.html": "./index.html",
     "main.cf25d33e.css.map": "./static/css/main.cf25d33e.css.map",
-    "main.26dbf9b9.js.map": "./static/js/main.26dbf9b9.js.map",
+    "main.1c3bc5a8.js.map": "./static/js/main.1c3bc5a8.js.map",
     "453.abd36b29.chunk.js.map": "./static/js/453.abd36b29.chunk.js.map"
   },
   "entrypoints": [
     "static/css/main.cf25d33e.css",
-    "static/js/main.26dbf9b9.js"
+    "static/js/main.1c3bc5a8.js"
   ]
 }

package/frontend/build/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><base href="./"><link rel="icon" href="./matterbridge 32x32.png"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><title>Matterbridge</title><link rel="manifest" href="./manifest.json"/><script defer="defer" src="./static/js/main.26dbf9b9.js"></script><link href="./static/css/main.cf25d33e.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><base href="./"><link rel="icon" href="./matterbridge 32x32.png"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><title>Matterbridge</title><link rel="manifest" href="./manifest.json"/><script defer="defer" src="./static/js/main.1c3bc5a8.js"></script><link href="./static/css/main.cf25d33e.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>