matterbridge 3.5.0-dev-20260119-f9ea00e → 3.5.1-dev-20260121-22e98b4

package/dist/utils/network.js

@@ -1,193 +0,0 @@
-import os from 'node:os';
-import { AnsiLogger, BLUE, CYAN, nf } from 'node-ansi-logger';
-export function getInterfaceDetails() {
-    const result = { interfaceName: '', ipv4Address: undefined, ipv6Address: undefined, macAddress: undefined };
-    for (const [interfaceName, interfaceDetails] of Object.entries(os.networkInterfaces())) {
-        if (!interfaceName || !interfaceDetails || interfaceDetails.length === 0)
-            continue;
-        for (const detail of interfaceDetails) {
-            if (detail.internal)
-                continue;
-            if (!result.interfaceName)
-                result.interfaceName = interfaceName;
-            if (interfaceName === result.interfaceName && !result.ipv4Address && detail.family === 'IPv4')
-                result.ipv4Address = detail.address;
-            if (interfaceName === result.interfaceName && !result.ipv6Address && detail.family === 'IPv6')
-                result.ipv6Address = detail.address;
-            if (interfaceName === result.interfaceName && !result.macAddress)
-                result.macAddress = detail.mac;
-        }
-    }
-    if (result.interfaceName)
-        return result;
-}
-export function getInterfaceName() {
-    for (const [interfaceName, interfaceDetails] of Object.entries(os.networkInterfaces())) {
-        if (!interfaceName || !interfaceDetails || interfaceDetails.length === 0)
-            continue;
-        for (const detail of interfaceDetails) {
-            if (!detail.internal)
-                return interfaceName;
-        }
-    }
-}
-export function getIpv4InterfaceAddress() {
-    for (const [interfaceName, interfaceDetails] of Object.entries(os.networkInterfaces())) {
-        if (!interfaceName || !interfaceDetails || interfaceDetails.length === 0)
-            continue;
-        for (const detail of interfaceDetails) {
-            if (detail.family === 'IPv4' && !detail.internal)
-                return detail.address;
-        }
-    }
-}
-export function getIpv6InterfaceAddress(scope = false) {
-    for (const [interfaceName, interfaceDetails] of Object.entries(os.networkInterfaces())) {
-        if (!interfaceName || !interfaceDetails || interfaceDetails.length === 0)
-            continue;
-        for (const detail of interfaceDetails) {
-            if (detail.family === 'IPv6' && !detail.internal) {
-                const address = detail.address;
-                if (!scope)
-                    return address;
-                if (address.includes('%'))
-                    return address;
-                const isWindows = os.platform() === 'win32';
-                const zoneId = isWindows ? detail.scopeid : interfaceName;
-                if (zoneId !== undefined && zoneId !== null && `${zoneId}`.length > 0) {
-                    return `${address}%${zoneId}`;
-                }
-                return address;
-            }
-        }
-    }
-}
-export function getMacAddress() {
-    for (const [interfaceName, interfaceDetails] of Object.entries(os.networkInterfaces())) {
-        if (!interfaceName || !interfaceDetails || interfaceDetails.length === 0)
-            continue;
-        for (const detail of interfaceDetails) {
-            if (!detail.internal)
-                return detail.mac;
-        }
-    }
-}
-export function logInterfaces() {
-    const log = new AnsiLogger({ logName: 'MatterbridgeUtils', logTimestampFormat: 4, logLevel: "info" });
-    log.logLevel = "info";
-    log.logName = 'LogInterfaces';
-    log.info('Available Network Interfaces:');
-    const availableAddresses = Object.entries(os.networkInterfaces());
-    for (const [ifaceName, ifaces] of availableAddresses) {
-        if (ifaces && ifaces.length > 0) {
-            log.info(`Network interface ${BLUE}${ifaceName}${nf}:`);
-            ifaces.forEach((iface) => {
-                log.info(`- ${CYAN}${iface.family}${nf} address ${CYAN}${iface.address}${nf} netmask ${CYAN}${iface.netmask}${nf} mac ${CYAN}${iface.mac}${nf}` +
-                    `${iface.scopeid ? ` scopeid ${CYAN}${iface.scopeid}${nf}` : ''}${iface.cidr ? ` cidr ${CYAN}${iface.cidr}${nf}` : ''} ${CYAN}${iface.internal ? 'internal' : 'external'}${nf}`);
-            });
-        }
-    }
-}
-export async function resolveHostname(hostname, family = 4) {
-    const dns = await import('node:dns');
-    try {
-        const addresses = await dns.promises.lookup(hostname.toLowerCase(), { family });
-        return addresses.address;
-    }
-    catch (_error) {
-        return null;
-    }
-}
-export async function getNpmPackageVersion(packageName, tag = 'latest', timeout = 10000) {
-    const https = await import('node:https');
-    return new Promise((resolve, reject) => {
-        const url = `https://registry.npmjs.org/${packageName}`;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => {
-            controller.abort();
-            reject(new Error(`Request timed out after ${timeout / 1000} seconds`));
-        }, timeout);
-        const req = https.get(url, { signal: controller.signal }, (res) => {
-            let data = '';
-            if (res.statusCode !== 200) {
-                clearTimeout(timeoutId);
-                res.resume();
-                reject(new Error(`Failed to fetch data. Status code: ${res.statusCode}`));
-                return;
-            }
-            res.on('data', (chunk) => {
-                data += chunk;
-            });
-            res.on('end', () => {
-                clearTimeout(timeoutId);
-                try {
-                    const jsonData = JSON.parse(data);
-                    const version = jsonData['dist-tags']?.[tag];
-                    if (version) {
-                        resolve(version);
-                    }
-                    else {
-                        reject(new Error(`Tag "${tag}" not found for package "${packageName}"`));
-                    }
-                }
-                catch (error) {
-                    reject(new Error(`Failed to parse response JSON: ${error instanceof Error ? error.message : error}`));
-                }
-            });
-        });
-        req.on('error', (error) => {
-            clearTimeout(timeoutId);
-            reject(new Error(`Request failed: ${error instanceof Error ? error.message : error}`));
-        });
-    });
-}
-export async function getGitHubUpdate(branch, file, timeout = 10000) {
-    const https = await import('node:https');
-    return new Promise((resolve, reject) => {
-        const url = `https://matterbridge.io/${branch}_${file}`;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => {
-            controller.abort();
-            reject(new Error(`Request timed out after ${timeout / 1000} seconds`));
-        }, timeout);
-        const req = https.get(url, { signal: controller.signal }, (res) => {
-            let data = '';
-            if (res.statusCode !== 200) {
-                clearTimeout(timeoutId);
-                res.resume();
-                reject(new Error(`Failed to fetch data. Status code: ${res.statusCode}`));
-                return;
-            }
-            res.on('data', (chunk) => {
-                data += chunk;
-            });
-            res.on('end', () => {
-                clearTimeout(timeoutId);
-                try {
-                    const jsonData = JSON.parse(data);
-                    resolve(jsonData);
-                }
-                catch (error) {
-                    reject(new Error(`Failed to parse response JSON: ${error instanceof Error ? error.message : error}`));
-                }
-            });
-        });
-        req.on('error', (error) => {
-            clearTimeout(timeoutId);
-            reject(new Error(`Request failed: ${error instanceof Error ? error.message : error}`));
-        });
-    });
-}
-export async function getGlobalNodeModules() {
-    const { exec } = await import('node:child_process');
-    return new Promise((resolve, reject) => {
-        exec('npm root -g', (error, stdout) => {
-            if (error) {
-                reject(error);
-            }
-            else {
-                resolve(stdout.trim());
-            }
-        });
-    });
-}

package/dist/utils/tracker.d.ts

@@ -1,52 +0,0 @@
-import EventEmitter from 'node:events';
-export type TrackerSnapshot = {
-    timestamp: number;
-    freeMemory: number;
-    peakFreeMemory: number;
-    totalMemory: number;
-    peakTotalMemory: number;
-    osCpu: number;
-    peakOsCpu: number;
-    processCpu: number;
-    peakProcessCpu: number;
-    rss: number;
-    peakRss: number;
-    heapUsed: number;
-    peakHeapUsed: number;
-    heapTotal: number;
-    peakHeapTotal: number;
-    external: number;
-    peakExternal: number;
-    arrayBuffers: number;
-    peakArrayBuffers: number;
-};
-interface TrackerEvents {
-    start: [];
-    stop: [];
-    uptime: [os: number, process: number];
-    cpu: [os: number, process: number];
-    memory: [free: number, total: number, rss: number, heapUsed: number, heapTotal: number, external: number, arrayBuffers: number];
-    snapshot: [snapshot: TrackerSnapshot];
-    reset_peaks: [];
-    reset_peaks_done: [];
-    gc: [];
-    gc_done: [type: 'major' | 'minor', execution: 'sync' | 'async'];
-}
-export declare class Tracker extends EventEmitter<TrackerEvents> {
-    private readonly name;
-    private readonly debug;
-    private readonly verbose;
-    private trackerInterval?;
-    static historyIndex: number;
-    static readonly historySize = 2880;
-    static readonly history: TrackerSnapshot[];
-    private prevCpus;
-    private prevCpuUsage;
-    private log;
-    constructor(name?: string, debug?: boolean, verbose?: boolean);
-    start(sampleIntervalMs?: number): void;
-    resetPeaks(): void;
-    runGarbageCollector(type?: 'major' | 'minor', execution?: 'sync' | 'async'): void;
-    stop(): void;
-}
-export {};

package/dist/utils/tracker.js

@@ -1,201 +0,0 @@
-if (process.argv.includes('--loader') || process.argv.includes('-loader'))
-    console.log('\u001B[32mTracker loaded.\u001B[40;0m');
-import os from 'node:os';
-import EventEmitter from 'node:events';
-import { AnsiLogger, BRIGHT, CYAN, RESET, YELLOW, db, RED } from 'node-ansi-logger';
-import { formatPercent, formatBytes, formatTimeStamp } from './format.js';
-export class Tracker extends EventEmitter {
-    name;
-    debug;
-    verbose;
-    trackerInterval;
-    static historyIndex = 0;
-    static historySize = 2880;
-    static history = Array.from({ length: this.historySize }, () => ({
-        timestamp: 0,
-        freeMemory: 0,
-        peakFreeMemory: 0,
-        totalMemory: 0,
-        peakTotalMemory: 0,
-        osCpu: 0,
-        peakOsCpu: 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,
-    }));
-    prevCpus = os.cpus();
-    prevCpuUsage = process.cpuUsage();
-    log;
-    constructor(name = 'Tracker', debug = false, verbose = false) {
-        super();
-        this.name = name;
-        this.debug = debug;
-        this.verbose = verbose;
-        if (process.argv.includes('--debug') || process.argv.includes('-debug') || process.argv.includes('--verbose') || process.argv.includes('-verbose')) {
-            this.debug = true;
-        }
-        if (process.argv.includes('--verbose') || process.argv.includes('-verbose')) {
-            this.verbose = true;
-        }
-        this.log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: this.debug ? "debug" : "info" });
-        this.log.logNameColor = YELLOW;
-        if (this.verbose) {
-            this.log.debug(`os.cpus():\n${RESET}`, os.cpus());
-            this.log.debug(`process.cpuUsage():\n${RESET}`, process.cpuUsage());
-            this.log.debug(`process.memoryUsage():\n${RESET}`, process.memoryUsage());
-        }
-        this.on('start', () => {
-            this.start();
-        });
-        this.on('stop', () => {
-            this.stop();
-        });
-        this.on('reset_peaks', () => {
-            this.resetPeaks();
-        });
-        this.on('gc', () => {
-            this.runGarbageCollector();
-        });
-    }
-    start(sampleIntervalMs = 10000) {
-        if (this.trackerInterval)
-            return;
-        this.log.debug(`Tracker starting...`);
-        let tryGcCount = 0;
-        this.prevCpus = os.cpus();
-        this.prevCpuUsage = process.cpuUsage();
-        this.trackerInterval = setInterval(() => {
-            tryGcCount += sampleIntervalMs / 1000;
-            if (tryGcCount > 60 * 60) {
-                this.runGarbageCollector();
-                tryGcCount = 0;
-            }
-            const entry = Tracker.history[Tracker.historyIndex];
-            const prevEntry = Tracker.history[(Tracker.historyIndex + Tracker.historySize - 1) % Tracker.historySize];
-            entry.timestamp = Date.now();
-            this.emit('uptime', os.uptime(), process.uptime());
-            const currentCpus = os.cpus();
-            const loads = currentCpus.map((cpu, idx) => {
-                const prev = this.prevCpus[idx]?.times;
-                if (!prev)
-                    return 0;
-                const cur = cpu.times;
-                const idleDelta = cur.idle - prev.idle;
-                const busyDelta = cur.user - prev.user + (cur.nice - prev.nice) + (cur.sys - prev.sys) + (cur.irq - prev.irq);
-                const totalDelta = busyDelta + idleDelta;
-                if (totalDelta <= 0)
-                    return 0;
-                return busyDelta / totalDelta;
-            });
-            this.prevCpus = currentCpus;
-            const avgLoad = loads.length === 0 ? 0 : loads.reduce((sum, value) => sum + value, 0) / loads.length;
-            const osCpu = Number((avgLoad * 100).toFixed(2));
-            entry.osCpu = osCpu;
-            entry.peakOsCpu = Math.max(prevEntry.peakOsCpu, osCpu);
-            const diff = process.cpuUsage(this.prevCpuUsage);
-            this.prevCpuUsage = process.cpuUsage();
-            const totalMs = (diff.user + diff.system) / 1000;
-            const processCpu = Number((((totalMs / sampleIntervalMs) * 100) / currentCpus.length).toFixed(2));
-            entry.processCpu = processCpu;
-            entry.peakProcessCpu = Math.max(prevEntry.peakProcessCpu, processCpu);
-            this.emit('cpu', entry.osCpu, entry.processCpu);
-            entry.freeMemory = os.freemem();
-            entry.peakFreeMemory = Math.max(prevEntry.peakFreeMemory, entry.freeMemory);
-            entry.totalMemory = os.totalmem();
-            entry.peakTotalMemory = Math.max(prevEntry.peakTotalMemory, entry.totalMemory);
-            const mem = process.memoryUsage();
-            entry.rss = mem.rss;
-            entry.peakRss = Math.max(prevEntry.peakRss, mem.rss);
-            entry.heapUsed = mem.heapUsed;
-            entry.peakHeapUsed = Math.max(prevEntry.peakHeapUsed, mem.heapUsed);
-            entry.heapTotal = mem.heapTotal;
-            entry.peakHeapTotal = Math.max(prevEntry.peakHeapTotal, mem.heapTotal);
-            entry.external = mem.external;
-            entry.peakExternal = Math.max(prevEntry.peakExternal, mem.external);
-            entry.arrayBuffers = mem.arrayBuffers;
-            entry.peakArrayBuffers = Math.max(prevEntry.peakArrayBuffers, mem.arrayBuffers);
-            this.emit('memory', entry.freeMemory, entry.totalMemory, entry.rss, entry.heapUsed, entry.heapTotal, entry.external, entry.arrayBuffers);
-            this.emit('snapshot', entry);
-            if (this.debug) {
-                this.log.debug(`Time: ${formatTimeStamp(entry.timestamp)} ` +
-                    `os ${CYAN}${BRIGHT}${formatPercent(entry.osCpu)}${RESET}${db} (${entry.peakOsCpu > prevEntry.peakOsCpu ? RED : ''}${formatPercent(entry.peakOsCpu)}${db}) ` +
-                    `process ${CYAN}${BRIGHT}${formatPercent(entry.processCpu)}${RESET}${db} (${entry.peakProcessCpu > prevEntry.peakProcessCpu ? RED : ''}${formatPercent(entry.peakProcessCpu)}${db}) ` +
-                    `rss: ${CYAN}${BRIGHT}${formatBytes(entry.rss)}${RESET}${db} (${entry.peakRss > prevEntry.peakRss ? RED : ''}${formatBytes(entry.peakRss)}${db}) ` +
-                    `heapUsed: ${CYAN}${BRIGHT}${formatBytes(entry.heapUsed)}${RESET}${db} (${entry.peakHeapUsed > prevEntry.peakHeapUsed ? RED : ''}${formatBytes(entry.peakHeapUsed)}${db}) ` +
-                    `heapTotal: ${CYAN}${BRIGHT}${formatBytes(entry.heapTotal)}${RESET}${db} (${entry.peakHeapTotal > prevEntry.peakHeapTotal ? RED : ''}${formatBytes(entry.peakHeapTotal)}${db}) ` +
-                    `external: ${CYAN}${BRIGHT}${formatBytes(entry.external)}${RESET}${db} (${entry.peakExternal > prevEntry.peakExternal ? RED : ''}${formatBytes(entry.peakExternal)}${db}) ` +
-                    `arrayBuffers: ${CYAN}${BRIGHT}${formatBytes(entry.arrayBuffers)}${RESET}${db} (${entry.peakArrayBuffers > prevEntry.peakArrayBuffers ? RED : ''}${formatBytes(entry.peakArrayBuffers)}${db})`);
-            }
-            Tracker.historyIndex = (Tracker.historyIndex + 1) % Tracker.historySize;
-        }, sampleIntervalMs);
-        this.log.debug(`Tracker started`);
-    }
-    resetPeaks() {
-        const prevHistoryIndex = (Tracker.historyIndex + Tracker.historySize - 1) % Tracker.historySize;
-        Tracker.history[prevHistoryIndex].peakOsCpu = 0;
-        Tracker.history[prevHistoryIndex].peakProcessCpu = 0;
-        Tracker.history[prevHistoryIndex].peakRss = 0;
-        Tracker.history[prevHistoryIndex].peakHeapUsed = 0;
-        Tracker.history[prevHistoryIndex].peakHeapTotal = 0;
-        Tracker.history[prevHistoryIndex].peakExternal = 0;
-        Tracker.history[prevHistoryIndex].peakArrayBuffers = 0;
-        if (this.debug)
-            this.log.debug(`${CYAN}${BRIGHT}Peaks reset at ${new Date(Date.now()).toLocaleString()}.${RESET}${db}`);
-        this.emit('reset_peaks_done');
-    }
-    runGarbageCollector(type = 'major', execution = 'async') {
-        if (global.gc && typeof global.gc === 'function') {
-            try {
-                global.gc({ type, execution });
-                if (this.debug)
-                    this.log.debug(`${CYAN}${BRIGHT}Garbage collection (${type}-${execution}) triggered at ${new Date(Date.now()).toLocaleString()}.${RESET}${db}`);
-                this.emit('gc_done', type, execution);
-            }
-            catch {
-                global.gc();
-                if (this.debug)
-                    this.log.debug(`${CYAN}${BRIGHT}Garbage collection (minor-async) triggered at ${new Date(Date.now()).toLocaleString()}.${RESET}${db}`);
-                this.emit('gc_done', 'minor', 'async');
-            }
-        }
-        else {
-            if (this.debug)
-                this.log.debug(`${CYAN}${BRIGHT}Garbage collection not exposed. Start Node.js with --expose-gc to enable manual garbage collection.${RESET}${db}`);
-        }
-    }
-    stop() {
-        this.log.debug(`Tracker stopping...`);
-        if (this.trackerInterval) {
-            clearInterval(this.trackerInterval);
-            this.trackerInterval = undefined;
-        }
-        if (this.debug) {
-            this.log.debug(`Tracker history for ${YELLOW}${BRIGHT}${this.name}:${RESET}`);
-            this.log.debug('Timestamp            Host cpu            Process cpu         Rss                   Heap Used             Heap Total            External              ArrayBuffers');
-            for (let i = 0; i < Tracker.historySize; i++) {
-                const index = (Tracker.historyIndex + i) % Tracker.historySize;
-                const entry = Tracker.history[index];
-                if (entry.timestamp === 0)
-                    continue;
-                this.log.debug(`${formatTimeStamp(entry.timestamp)} ` +
-                    `${CYAN}${BRIGHT}${formatPercent(entry.osCpu).padStart(8)}${RESET} (${formatPercent(entry.peakOsCpu).padStart(8)}) ` +
-                    `${CYAN}${BRIGHT}${formatPercent(entry.processCpu).padStart(8)}${RESET} (${formatPercent(entry.peakProcessCpu).padStart(8)}) ` +
-                    `${CYAN}${BRIGHT}${formatBytes(entry.rss).padStart(9)}${RESET} (${formatBytes(entry.peakRss).padStart(9)}) ` +
-                    `${CYAN}${BRIGHT}${formatBytes(entry.heapUsed).padStart(9)}${RESET} (${formatBytes(entry.peakHeapUsed).padStart(9)}) ` +
-                    `${CYAN}${BRIGHT}${formatBytes(entry.heapTotal).padStart(9)}${RESET} (${formatBytes(entry.peakHeapTotal).padStart(9)}) ` +
-                    `${CYAN}${BRIGHT}${formatBytes(entry.external).padStart(9)}${RESET} (${formatBytes(entry.peakExternal).padStart(9)}) ` +
-                    `${CYAN}${BRIGHT}${formatBytes(entry.arrayBuffers).padStart(9)}${RESET} (${formatBytes(entry.peakArrayBuffers).padStart(9)})`);
-            }
-        }
-        this.log.debug(`Tracker stopped`);
-    }
-}

package/dist/utils/wait.d.ts

@@ -1,3 +0,0 @@
-export declare function waiter(name: string, check: () => boolean, exitWithReject?: boolean, resolveTimeout?: number, resolveInterval?: number, debug?: boolean): Promise<boolean>;
-export declare function wait(timeout?: number, name?: string, debug?: boolean): Promise<void>;
-export declare function withTimeout<T>(promise: Promise<T>, timeoutMillisecs?: number, reThrow?: boolean): Promise<T>;

package/dist/utils/wait.js

@@ -1,73 +0,0 @@
-import { AnsiLogger } from 'node-ansi-logger';
-export async function waiter(name, check, exitWithReject = false, resolveTimeout = 5000, resolveInterval = 500, debug = false) {
-    const log = new AnsiLogger({ logName: 'Waiter', logTimestampFormat: 4, logLevel: "debug" });
-    if (check()) {
-        if (debug)
-            log.debug(`Waiter "${name}" already true`);
-        return true;
-    }
-    if (debug)
-        log.debug(`Waiter "${name}" started...`);
-    return new Promise((resolve, reject) => {
-        const timeoutId = setTimeout(() => {
-            if (debug)
-                log.debug(`Waiter "${name}" finished for timeout...`);
-            clearTimeout(timeoutId);
-            clearInterval(intervalId);
-            if (exitWithReject)
-                reject(new Error(`Waiter "${name}" finished due to timeout`));
-            else
-                resolve(false);
-        }, resolveTimeout).unref();
-        const intervalId = setInterval(async () => {
-            if (check()) {
-                if (debug)
-                    log.debug(`Waiter "${name}" finished for true condition...`);
-                clearTimeout(timeoutId);
-                clearInterval(intervalId);
-                resolve(true);
-            }
-            await Promise.resolve();
-        }, resolveInterval).unref();
-    });
-}
-export async function wait(timeout = 1000, name, debug = false) {
-    const log = new AnsiLogger({ logName: 'Wait', logTimestampFormat: 4, logLevel: "debug" });
-    if (debug)
-        log.debug(`Wait "${name}" started...`);
-    return new Promise((resolve) => {
-        const timeoutId = setTimeout(() => {
-            if (debug)
-                log.debug(`Wait "${name}" finished...`);
-            clearTimeout(timeoutId);
-            resolve();
-        }, timeout).unref();
-    });
-}
-export function withTimeout(promise, timeoutMillisecs = 10000, reThrow = true) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            if (reThrow) {
-                reject(new Error('Operation timed out'));
-            }
-            else {
-                resolve(undefined);
-            }
-        }, timeoutMillisecs).unref();
-        promise
-            .then((result) => {
-            clearTimeout(timer);
-            resolve(result);
-            return result;
-        })
-            .catch((error) => {
-            clearTimeout(timer);
-            if (reThrow) {
-                reject(error);
-            }
-            else {
-                resolve(undefined);
-            }
-        });
-    });
-}