matterbridge 3.3.3-dev-20251019-a73923c → 3.3.4-dev-20251020-4d2dd49

package/CHANGELOG.md

@@ -23,6 +23,27 @@ Advantages:
 - isolation between threads;
 - individual plugin isolation in childbridge mode;
 
+## [3.3.4] - Not released
+
+### Breaking Changes
+
+- [nodejs]: Matterbridge will not start if the Node.js version is less then 20.x.x.
+
+### Added
+
+- [frontend]: Added debounce to MatterSettings.
+- [cli]: Bumped `cli` version to 3.0.0 with backport of Traker and Inspector from thread module.
+
+### Changed
+
+- [package]: Updated dependencies.
+- [matter]: Bumped `matter.js` version to 0.15.6. Thanks matter.js!
+- [frontend]: Bumped `frontend` version to 3.2.3.
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
 ## [3.3.3] - 2025-10-18
 
 ### Added

package/dist/cli.js

@@ -1,331 +1,66 @@
 if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mCLI loaded.\u001B[40;0m');
-import os from 'node:os';
-import { inspect } from 'node:util';
-import { AnsiLogger, BRIGHT, CYAN, db, RED, YELLOW } from 'node-ansi-logger';
-import { cliEmitter, setLastOsCpuUsage, setLastProcessCpuUsage } from './cliEmitter.js';
-import { history, historyIndex, historySize, setHistoryIndex } from './cliHistory.js';
-import { getIntParameter, hasParameter } from './utils/commandLine.js';
+import { AnsiLogger } from 'node-ansi-logger';
+import { cliEmitter } from './cliEmitter.js';
+import { hasParameter, hasAnyParameter } from './utils/commandLine.js';
 import { Matterbridge } from './matterbridge.js';
+import { inspectError } from './utils/error.js';
+import { Tracker } from './utils/tracker.js';
+import { Inspector } from './utils/inspector.js';
 export let instance;
-let session;
-let snapshotInterval;
-const trace = hasParameter('trace');
-let memoryCheckInterval;
-const memoryCheckIntervalMs = getIntParameter('memoryinterval') ?? 10 * 1000;
-let memoryPeakResetTimeout;
-let prevCpus;
-let prevProcessCpu;
-let peakCpu = 0;
-let peakProcessCpu = 0;
-let peakRss = 0;
-let peakHeapUsed = 0;
-let peakHeapTotal = 0;
-let peakExternal = 0;
-let peakArrayBuffers = 0;
+export const tracker = new Tracker('Cli', true, true);
+export const inspector = new Inspector('Cli', true, true);
 const log = new AnsiLogger({ logName: 'Cli', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
-const formatCpuUsage = (percent) => {
-    return `${percent.toFixed(2).padStart(5, ' ')} %`;
-};
-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() {
+function startCpuMemoryCheck() {
+    log.debug(`Cpu memory check starting...`);
+    tracker.start();
+    tracker.on('uptime', (os, process) => {
+        cliEmitter.emit('uptime', tracker.formatOsUpTime(Math.floor(os)), tracker.formatOsUpTime(Math.floor(process)));
+    });
+    tracker.on('snapshot', (snapshot) => {
+        cliEmitter.emit('memory', tracker.formatBytes(snapshot.totalMemory), tracker.formatBytes(snapshot.freeMemory), tracker.formatBytes(snapshot.rss), tracker.formatBytes(snapshot.heapTotal), tracker.formatBytes(snapshot.heapUsed), tracker.formatBytes(snapshot.external), tracker.formatBytes(snapshot.arrayBuffers));
+        cliEmitter.emit('cpu', snapshot.osCpu, snapshot.processCpu);
+    });
     log.debug(`Cpu memory check started`);
-    prevCpus = os.cpus();
-    prevProcessCpu = process.cpuUsage();
-    const interval = () => {
-        const systemUptime = formatOsUpTime(Math.floor(os.uptime()));
-        const processUptime = formatOsUpTime(Math.floor(process.uptime()));
-        cliEmitter.emit('uptime', systemUptime, processUptime);
-        const totalMemory = 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) {
-            if (peakRss && trace)
-                log.debug(`****${RED}${BRIGHT}Rss peak detected.${db} Peak rss from ${CYAN}${formatMemoryUsage(peakRss)}${db} to ${CYAN}${formatMemoryUsage(memoryUsageRaw.rss)}${db}`);
-            peakRss = memoryUsageRaw.rss;
-        }
-        if (memoryUsageRaw.heapUsed > peakHeapUsed) {
-            if (peakHeapUsed && trace)
-                log.debug(`****${RED}${BRIGHT}HeapUsed peak detected.${db} Peak heapUsed from ${CYAN}${formatMemoryUsage(peakHeapUsed)}${db} to ${CYAN}${formatMemoryUsage(memoryUsageRaw.heapUsed)}${db}`);
-            peakHeapUsed = memoryUsageRaw.heapUsed;
-        }
-        if (memoryUsageRaw.heapTotal > peakHeapTotal) {
-            if (peakHeapTotal && trace)
-                log.debug(`****${RED}${BRIGHT}HeapTotal peak detected.${db} Peak heapTotal from ${CYAN}${formatMemoryUsage(peakHeapTotal)}${db} to ${CYAN}${formatMemoryUsage(memoryUsageRaw.heapTotal)}${db}`);
-            peakHeapTotal = memoryUsageRaw.heapTotal;
-        }
-        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;
-            log.debug(`Cpu check length failed, resetting previous cpus`);
-            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 osCpuUsage = 100 - (totalIdle / totalTick) * 100;
-        if (totalTick === 0 || isNaN(osCpuUsage) || !isFinite(osCpuUsage) || osCpuUsage <= 0) {
-            log.debug(`Cpu check failed, using previous cpus`);
-        }
-        else {
-            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(osCpuUsage)}${db}`);
-            }
-        }
-        prevCpus = currCpus;
-        const diff = process.cpuUsage(prevProcessCpu);
-        const userMs = diff.user / 1000;
-        const systemMs = diff.system / 1000;
-        const totalMs = userMs + systemMs;
-        const processCpuUsage = Number((((totalMs / memoryCheckIntervalMs) * 100) / currCpus.length).toFixed(2));
-        if (processCpuUsage > peakProcessCpu) {
-            peakProcessCpu = processCpuUsage;
-            if (peakProcessCpu && trace)
-                log.debug(`****${RED}${BRIGHT}Process cpu peak detected.${db} Peak process cpu from ${CYAN}${formatCpuUsage(peakProcessCpu)}${db} to ${CYAN}${formatCpuUsage(processCpuUsage)}${db}`);
-        }
-        prevProcessCpu = process.cpuUsage();
-        setLastProcessCpuUsage(processCpuUsage);
-        cliEmitter.emit('cpu', osCpuUsage, processCpuUsage);
-        const entry = history[historyIndex];
-        entry.timestamp = Date.now();
-        entry.cpu = osCpuUsage;
-        entry.peakCpu = peakCpu;
-        entry.processCpu = processCpuUsage;
-        entry.peakProcessCpu = peakProcessCpu;
-        entry.rss = memoryUsageRaw.rss;
-        entry.peakRss = peakRss;
-        entry.heapUsed = memoryUsageRaw.heapUsed;
-        entry.peakHeapUsed = peakHeapUsed;
-        entry.heapTotal = memoryUsageRaw.heapTotal;
-        entry.peakHeapTotal = peakHeapTotal;
-        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(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(() => {
-        if (trace)
-            log.debug(`****${RED}${BRIGHT}Cpu and memory peaks reset after first 5 minutes.${db}`);
-        peakCpu = 0;
-        peakProcessCpu = 0;
-        peakRss = 0;
-        peakHeapUsed = 0;
-        peakHeapTotal = 0;
-    }, 5 * 60 * 1000).unref();
 }
-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}. ` +
-            `Peak external: ${CYAN}${formatMemoryUsage(peakExternal)}${db}. ` +
-            `Peak arrayBuffers: ${CYAN}${formatMemoryUsage(peakArrayBuffers)}${db}.`);
-    }
-    clearInterval(memoryCheckInterval);
-    clearTimeout(memoryPeakResetTimeout);
+function stopCpuMemoryCheck() {
+    log.debug(`Cpu memory check stopping...`);
+    tracker.stop();
+    tracker.removeAllListeners();
+    log.debug(`Cpu memory check stopped`);
 }
 async function startInspector() {
-    const { Session } = await import('node:inspector');
-    const { mkdirSync } = await import('node:fs');
-    log.debug(`***Starting heap sampling...`);
-    mkdirSync('heap_profile', { recursive: true });
-    try {
-        session = new Session();
-        session.connect();
-        await new Promise((resolve, reject) => {
-            session?.post('HeapProfiler.startSampling', (err) => (err ? reject(err) : resolve()));
-        });
-        log.debug(`***Started heap sampling`);
-        const interval = getIntParameter('snapshotinterval');
-        if (interval && interval >= 30000) {
-            log.debug(`***Started heap snapshot interval of ${CYAN}${interval}${db} ms`);
-            clearInterval(snapshotInterval);
-            snapshotInterval = setInterval(async () => {
-                log.debug(`Run heap snapshot interval`);
-                await takeHeapSnapshot();
-            }, interval).unref();
-        }
-    }
-    catch (err) {
-        log.error(`***Failed to start heap sampling: ${err instanceof Error ? err.message : err}`);
-        session?.disconnect();
-        session = undefined;
-        return;
-    }
+    await inspector.start();
 }
 async function stopInspector() {
-    const { writeFileSync } = await import('node:fs');
-    const path = await import('node:path');
-    log.debug(`***Stopping heap sampling...`);
-    if (snapshotInterval) {
-        log.debug(`***Clearing heap snapshot interval...`);
-        clearInterval(snapshotInterval);
-        await takeHeapSnapshot();
-    }
-    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);
-        const filename = path.join('heap_profile', `Heap-profile-${new Date().toISOString().replace(/[:]/g, '-')}.heapprofile`);
-        writeFileSync(filename, profile);
-        log.debug(`***Heap sampling profile saved to ${CYAN}${filename}${db}`);
-    }
-    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`);
-    }
+    await inspector.stop();
 }
 async function takeHeapSnapshot() {
-    const { writeFileSync } = await import('node:fs');
-    const path = await import('node:path');
-    const filename = path.join('heap_profile', `Heap-snapshot-${new Date().toISOString().replace(/[:]/g, '-')}.heapsnapshot`);
-    if (!session) {
-        log.error('No active inspector session.');
-        return;
-    }
-    triggerGarbageCollection();
-    log.debug(`Taking heap snapshot...`);
-    const chunks = [];
-    const chunksListener = (notification) => {
-        chunks.push(Buffer.from(notification.params.chunk));
-    };
-    session.on('HeapProfiler.addHeapSnapshotChunk', chunksListener);
-    await new Promise((resolve) => {
-        session?.post('HeapProfiler.takeHeapSnapshot', (err) => {
-            if (!err) {
-                session?.off('HeapProfiler.addHeapSnapshotChunk', chunksListener);
-                writeFileSync(filename, Buffer.concat(chunks));
-                chunks.length = 0;
-                log.debug(`***Heap sampling snapshot saved to ${CYAN}${filename}${db}`);
-                triggerGarbageCollection();
-                resolve();
-            }
-            else {
-                session?.off('HeapProfiler.addHeapSnapshotChunk', chunksListener);
-                chunks.length = 0;
-                log.error(`***Failed to take heap snapshot: ${err instanceof Error ? err.message : err}`);
-                triggerGarbageCollection();
-                resolve();
-            }
-        });
-    });
+    await inspector.takeHeapSnapshot();
 }
 function triggerGarbageCollection() {
-    if (global.gc && typeof global.gc === 'function') {
-        try {
-            global.gc({ type: 'major', execution: 'sync' });
-        }
-        catch {
-            global.gc();
-        }
-        log.debug('Manual garbage collection triggered via global.gc().');
-    }
-    else {
-        log.debug('Garbage collection is not exposed. Start Node.js with --expose-gc to enable manual GC.');
-    }
+    inspector.runGarbageCollector();
 }
 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());
-    if (instance)
-        instance.on('startinspector', async () => startInspector());
-    if (instance)
-        instance.on('stopinspector', async () => stopInspector());
-    if (instance)
-        instance.on('takeheapsnapshot', async () => takeHeapSnapshot());
-    if (instance)
-        instance.on('triggergarbagecollection', async () => triggerGarbageCollection());
+    if (!instance)
+        return;
+    instance.on('shutdown', () => shutdown());
+    instance.on('restart', () => restart());
+    instance.on('update', () => update());
+    instance.on('startmemorycheck', () => start());
+    instance.on('stopmemorycheck', () => stop());
+    instance.on('startinspector', () => startInspector());
+    instance.on('stopinspector', () => stopInspector());
+    instance.on('takeheapsnapshot', () => takeHeapSnapshot());
+    instance.on('triggergarbagecollection', () => triggerGarbageCollection());
     log.debug('Registered event handlers');
 }
 async function shutdown() {
     log.debug('Received shutdown event, exiting...');
     if (hasParameter('inspect'))
         await stopInspector();
-    await stopCpuMemoryCheck();
+    stopCpuMemoryCheck();
     cliEmitter.emit('shutdown');
     process.exit(0);
 }
@@ -339,17 +74,17 @@ async function update() {
     instance = await Matterbridge.loadInstance(true);
     registerHandlers();
 }
-async function start() {
+function start() {
     log.debug('Received start memory check event');
-    await startCpuMemoryCheck();
+    startCpuMemoryCheck();
 }
-async function stop() {
+function stop() {
     log.debug('Received stop memory check event');
-    await stopCpuMemoryCheck();
+    stopCpuMemoryCheck();
 }
 async function main() {
     log.debug(`Cli main() started`);
-    await startCpuMemoryCheck();
+    startCpuMemoryCheck();
     if (hasParameter('inspect'))
         await startInspector();
     log.debug(`***Matterbridge.loadInstance(true) called`);
@@ -361,11 +96,72 @@ async function main() {
     else {
         registerHandlers();
         cliEmitter.emit('ready');
+        log.debug(`Cli main() ready`);
     }
 }
-process.title = 'matterbridge';
+if (hasAnyParameter('help', 'h'))
+    help();
+if (hasAnyParameter('version', 'v'))
+    await version();
 main().catch((error) => {
-    const errorMessage = error instanceof Error ? error.message : error;
-    const errorInspect = inspect(error, { depth: 10 });
-    log.error(`Matterbridge.loadInstance() failed with error: ${errorMessage}\nstack: ${errorInspect}`);
+    inspectError(log, 'Matterbridge.loadInstance() failed with error', error);
+    shutdown();
 });
+async function version() {
+    const { default: pkg } = await import('../package.json', { with: { type: 'json' } });
+    console.log(`Matterbridge version ${pkg.version}`);
+    process.exit(0);
+}
+function help() {
+    console.log(`
+  Usage: matterbridge [options] [command] 
+
+    Commands:
+      --help:                  show the help
+      --version:               show the version
+      --add [plugin path]:     register the plugin from the given absolute or relative path
+      --add [plugin name]:     register the globally installed plugin with the given name
+      --remove [plugin path]:  remove the plugin from the given absolute or relative path
+      --remove [plugin name]:  remove the globally installed plugin with the given name
+      --enable [plugin path]:  enable the plugin from the given absolute or relative path
+      --enable [plugin name]:  enable the globally installed plugin with the given name
+      --disable [plugin path]: disable the plugin from the given absolute or relative path
+      --disable [plugin name]: disable the globally installed plugin with the given name
+
+    Reset Commands:
+      --reset:                 remove the commissioning for Matterbridge (bridge mode and childbridge mode). Shutdown Matterbridge before using it!
+      --reset [plugin path]:   remove the commissioning for the plugin from the given absolute or relative path (childbridge mode). Shutdown Matterbridge before using it!
+      --reset [plugin name]:   remove the commissioning for the globally installed plugin (childbridge mode). Shutdown Matterbridge before using it!
+      --factoryreset:          remove all commissioning information and reset all internal storages. Shutdown Matterbridge before using it!
+
+    Options:
+      --bridge:                start Matterbridge in bridge mode
+      --childbridge:           start Matterbridge in childbridge mode
+      --port [port]:           start the matter commissioning server on the given port (default 5540)
+      --mdnsinterface [name]:  set the interface to use for the matter server mdnsInterface (default all interfaces)
+      --ipv4address [address]: set the ipv4 interface address to use for the matter server listener (default all addresses)
+      --ipv6address [address]: set the ipv6 interface address to use for the matter server listener (default all addresses)
+      --frontend [port]:       start the frontend on the given port (default 8283)
+      --logger:                set the matterbridge logger level: debug | info | notice | warn | error | fatal (default info)
+      --filelogger:            enable the matterbridge file logger (matterbridge.log)
+      --matterlogger:          set the matter.js logger level: debug | info | notice | warn | error | fatal (default info)
+      --matterfilelogger:      enable the matter.js file logger (matter.log)
+      --list:                  list the registered plugins
+      --loginterfaces:         log the network interfaces (usefull for finding the name of the interface to use with -mdnsinterface option)
+      --logstorage:            log the node storage
+      --sudo:                  force the use of sudo to install or update packages if the internal logic fails
+      --nosudo:                force not to use sudo to install or update packages if the internal logic fails
+      --norestore:             force not to automatically restore the matterbridge node storage and the matter storage from backup if it is corrupted
+      --novirtual:             disable the creation of the virtual devices Restart, Update and Reboot Matterbridge
+      --ssl:                   enable SSL for the frontend and the WebSocketServer (the server will use the certificates and switch to https)
+      --mtls:                  enable mTLS for the frontend and the WebSocketServer (both server and client will use and require the certificates and switch to https)
+      --vendorId:              override the default vendorId 0xfff1
+      --vendorName:            override the default vendorName "Matterbridge"
+      --productId:             override the default productId 0x8000
+      --productName:           override the default productName "Matterbridge aggregator"
+      --service:               enable the service mode (used in the linux systemctl configuration file and macOS launchctl plist)
+      --docker:                enable the docker mode (used in the docker image)
+      --homedir:               override the home directory (default the os homedir)
+  `);
+    process.exit(0);
+}

package/dist/cliHistory.js

@@ -3,47 +3,15 @@ if (process.argv.includes('--loader') || process.argv.includes('-loader'))
 import { writeFileSync } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-export const historySize = 2880;
-export let historyIndex = 0;
-export function setHistoryIndex(index) {
-    if (!Number.isFinite(index) || !Number.isSafeInteger(index)) {
-        throw new TypeError('historyIndex must be a finite, safe integer.');
-    }
-    if (index < 0 || index >= historySize) {
-        throw new RangeError(`historyIndex must be between 0 and ${historySize - 1}.`);
-    }
-    historyIndex = index;
-}
-export const history = Array.from({ length: historySize }, () => ({
-    timestamp: 0,
-    cpu: 0,
-    peakCpu: 0,
-    processCpu: 0,
-    peakProcessCpu: 0,
-    rss: 0,
-    peakRss: 0,
-    heapUsed: 0,
-    peakHeapUsed: 0,
-    heapTotal: 0,
-    peakHeapTotal: 0,
-    external: 0,
-    peakExternal: 0,
-    arrayBuffers: 0,
-    peakArrayBuffers: 0,
-}));
+import { Tracker } from './utils/tracker.js';
 export function generateHistoryPage(options = {}) {
     const pageTitle = options.pageTitle ?? 'Matterbridge CPU & Memory History';
     const hostname = options.hostname ?? os.hostname();
     const outputPath = path.resolve(options.outputPath ?? path.join(process.cwd(), 'history.html'));
-    const bufferLength = history.length;
-    if (bufferLength === 0) {
-        return undefined;
-    }
-    const startIndex = ((Math.trunc(historyIndex) % bufferLength) + bufferLength) % bufferLength;
     const normalizedHistory = [];
-    for (let offset = 0; offset < bufferLength; offset += 1) {
-        const index = (startIndex + offset) % bufferLength;
-        const entry = history[index];
+    for (let offset = 0; offset < Tracker.historySize; offset += 1) {
+        const index = (Tracker.historyIndex + offset) % Tracker.historySize;
+        const entry = Tracker.history[index];
         if (!entry || entry.timestamp === 0)
             continue;
         normalizedHistory.push(entry);
@@ -51,7 +19,7 @@ export function generateHistoryPage(options = {}) {
     if (normalizedHistory.length === 0) {
         return undefined;
     }
-    const peakCpu = Math.max(...normalizedHistory.map((entry) => entry.peakCpu ?? entry.cpu));
+    const peakOsCpu = Math.max(...normalizedHistory.map((entry) => entry.peakOsCpu ?? entry.osCpu));
     const peakProcessCpu = Math.max(...normalizedHistory.map((entry) => entry.peakProcessCpu ?? entry.processCpu));
     const peakRss = Math.max(...normalizedHistory.map((entry) => entry.peakRss ?? entry.rss));
     const peakHeapUsed = Math.max(...normalizedHistory.map((entry) => entry.peakHeapUsed ?? entry.heapUsed));
@@ -63,7 +31,7 @@ export function generateHistoryPage(options = {}) {
     const summary = {
         entries: normalizedHistory.length,
         timeRange: `${new Date(firstTimestamp).toLocaleString()} → ${new Date(lastTimestamp).toLocaleString()}`,
-        peakCpu,
+        peakOsCpu,
         peakProcessCpu,
         peakRss,
         peakHeapUsed,
@@ -295,7 +263,7 @@ export function generateHistoryPage(options = {}) {
       const summaryEntries = [
         { label: 'Samples', value: SUMMARY_DATA.entries.toLocaleString() },
         { label: 'Time Range', value: SUMMARY_DATA.timeRange },
-        { label: 'Host CPU Peak', value: SUMMARY_DATA.peakCpu.toFixed(2) + ' %' },
+        { label: 'Host CPU Peak', value: SUMMARY_DATA.peakOsCpu.toFixed(2) + ' %' },
         { 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) },
@@ -316,8 +284,8 @@ export function generateHistoryPage(options = {}) {
         const row = document.createElement('tr');
         const cells = [
           new Date(entry.timestamp).toLocaleString(),
-          entry.cpu.toFixed(2),
-          entry.peakCpu.toFixed(2),
+          entry.osCpu.toFixed(2),
+          entry.peakOsCpu.toFixed(2),
           (Number.isFinite(entry.processCpu) ? entry.processCpu : 0).toFixed(2),
           (
             Number.isFinite(entry.peakProcessCpu)
@@ -342,16 +310,12 @@ 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);
+        return Math.max(acc, Number.isFinite(entry.peakOsCpu) ? entry.peakOsCpu : 0, Number.isFinite(entry.osCpu) ? entry.osCpu : 0);
       }, 0);
       const cpuMaxYAxis = cpuPeakValue > 0 ? cpuPeakValue * 1.05 : undefined;
 
       const processCpuPeakValue = HISTORY_DATA.reduce(function (acc, entry) {
-        return Math.max(
-          acc,
-          Number.isFinite(entry.peakProcessCpu) ? entry.peakProcessCpu : 0,
-          Number.isFinite(entry.processCpu) ? entry.processCpu : 0
-        );
+        return Math.max(acc, Number.isFinite(entry.peakProcessCpu) ? entry.peakProcessCpu : 0, Number.isFinite(entry.processCpu) ? entry.processCpu : 0);
       }, 0);
       const processCpuMaxYAxis = processCpuPeakValue > 0 ? processCpuPeakValue * 1.05 : undefined;
       const useProcessCpuDecimals = (processCpuMaxYAxis ?? 0) <= 3;
@@ -418,14 +382,14 @@ export function generateHistoryPage(options = {}) {
               {
                 label: 'Host CPU %',
                 values: HISTORY_DATA.map(function (entry) {
-                  return Number.isFinite(entry.cpu) ? Number(entry.cpu.toFixed(2)) : 0;
+                  return Number.isFinite(entry.osCpu) ? Number(entry.osCpu.toFixed(2)) : 0;
                 }),
                 color: '#38bdf8',
                 fill: 'rgba(56, 189, 248, 0.18)',
                 markPeaks: true,
                 markerPeakValues: HISTORY_DATA.map(function (entry) {
-                  if (Number.isFinite(entry.peakCpu)) return entry.peakCpu;
-                  if (Number.isFinite(entry.cpu)) return entry.cpu;
+                  if (Number.isFinite(entry.peakOsCpu)) return entry.peakOsCpu;
+                  if (Number.isFinite(entry.osCpu)) return entry.osCpu;
                   return Number.NEGATIVE_INFINITY;
                 }),
                 markerRadius: 2.5
@@ -433,7 +397,7 @@ export function generateHistoryPage(options = {}) {
               {
                 label: 'Host Peak CPU %',
                 values: HISTORY_DATA.map(function (entry) {
-                  return Number.isFinite(entry.peakCpu) ? Number(entry.peakCpu.toFixed(2)) : 0;
+                  return Number.isFinite(entry.peakOsCpu) ? Number(entry.peakOsCpu.toFixed(2)) : 0;
                 }),
                 color: '#facc15',
                 dashed: [6, 4]