matterbridge 3.4.7-dev-20260103-3152357 → 3.4.7-dev-20260112-a00b2bf

package/packages/utils/dist/inspector.js

@@ -0,0 +1,200 @@
+if (process.argv.includes('--loader') || process.argv.includes('-loader'))
+    console.log('\u001B[32mInspector loaded.\u001B[40;0m');
+import EventEmitter from 'node:events';
+import { AnsiLogger, BRIGHT, CYAN, RESET, YELLOW, db } from 'node-ansi-logger';
+export class Inspector extends EventEmitter {
+    name;
+    debug;
+    verbose;
+    session;
+    snapshotInterval;
+    snapshotInProgress = false;
+    log;
+    constructor(name = 'Inspector', debug = false, verbose = false) {
+        super();
+        this.name = name;
+        this.debug = debug;
+        this.verbose = verbose;
+        if (process.argv.includes('--debug') || process.argv.includes('-debug')) {
+            this.debug = true;
+        }
+        if (process.argv.includes('--verbose') || process.argv.includes('-verbose')) {
+            this.verbose = true;
+        }
+        this.log = new AnsiLogger({ logName: this.name, logTimestampFormat: 4, logLevel: this.debug ? "debug" : "info" });
+        this.log.logNameColor = YELLOW;
+        this.on('start', () => {
+            this.start();
+        });
+        this.on('stop', () => {
+            this.stop();
+        });
+        this.on('snapshot', () => {
+            this.takeHeapSnapshot();
+        });
+        this.on('gc', () => {
+            this.runGarbageCollector();
+        });
+    }
+    async start() {
+        if (this.session) {
+            this.log.warn('Inspector session already active.');
+            return;
+        }
+        const { Session } = await import('node:inspector');
+        const { mkdirSync } = await import('node:fs');
+        this.log.debug(`Starting heap sampling...`);
+        mkdirSync('heap_profiles', { recursive: true });
+        mkdirSync('heap_snapshots', { recursive: true });
+        try {
+            this.session = new Session();
+            this.session.connect();
+            await new Promise((resolve, reject) => {
+                this.session?.post('HeapProfiler.startSampling', (err) => (err ? reject(err) : resolve()));
+            });
+            this.log.debug(`Started heap sampling`);
+            const { getIntParameter } = await import('./commandLine.js');
+            const interval = getIntParameter('snapshotinterval');
+            if (interval && interval >= 30000) {
+                this.log.debug(`Started heap snapshot interval of ${CYAN}${interval}${db} ms`);
+                clearInterval(this.snapshotInterval);
+                this.snapshotInterval = setInterval(async () => {
+                    try {
+                        if (this.snapshotInProgress) {
+                            if (this.debug)
+                                this.log.debug(`Skip heap snapshot: previous snapshot still in progress`);
+                            return;
+                        }
+                        this.log.debug(`Run heap snapshot interval`);
+                        await this.takeHeapSnapshot();
+                    }
+                    catch (err) {
+                        this.log.error(`Error during scheduled heap snapshot: ${err instanceof Error ? err.message : err}`);
+                    }
+                }, interval).unref();
+            }
+        }
+        catch (err) {
+            this.log.error(`Failed to start heap sampling: ${err instanceof Error ? err.message : err}`);
+            this.session?.disconnect();
+            this.session = undefined;
+            return;
+        }
+    }
+    async stop() {
+        if (!this.session) {
+            this.log.warn('No active inspector session.');
+            return;
+        }
+        const { writeFileSync } = await import('node:fs');
+        const path = await import('node:path');
+        this.log.debug(`Stopping heap sampling...`);
+        if (this.snapshotInterval) {
+            this.log.debug(`Clearing heap snapshot interval...`);
+            clearInterval(this.snapshotInterval);
+            await this.takeHeapSnapshot();
+        }
+        try {
+            const result = await new Promise((resolve, reject) => {
+                this.session?.post('HeapProfiler.stopSampling', (err, result) => (err ? reject(err) : resolve(result)));
+            });
+            const profile = JSON.stringify(result.profile);
+            const safeTimestamp = new Date().toISOString().replace(/[<>:"/\\|?*]/g, '-');
+            const filename = path.join('heap_profiles', `${safeTimestamp}.heapprofile`);
+            writeFileSync(filename, profile);
+            this.log.debug(`Heap sampling profile saved to ${CYAN}${filename}${db}`);
+        }
+        catch (err) {
+            this.log.error(`Failed to stop heap sampling: ${err instanceof Error ? err.message : err}`);
+        }
+        finally {
+            this.session.disconnect();
+            this.session = undefined;
+            this.log.debug(`Stopped heap sampling`);
+        }
+    }
+    async takeHeapSnapshot() {
+        if (!this.session) {
+            this.log.warn('No active inspector session.');
+            return;
+        }
+        if (this.snapshotInProgress) {
+            if (this.debug)
+                this.log.debug('Heap snapshot already in progress, skipping.');
+            return;
+        }
+        this.snapshotInProgress = true;
+        const { createWriteStream } = await import('node:fs');
+        const path = await import('node:path');
+        const safeTimestamp = new Date().toISOString().replace(/[<>:"/\\|?*]/g, '-');
+        const filename = path.join('heap_snapshots', `${safeTimestamp}.heapsnapshot`);
+        this.runGarbageCollector('minor', 'async');
+        this.runGarbageCollector('major', 'async');
+        if (this.debug)
+            this.log.debug(`Taking heap snapshot to ${CYAN}${filename}${db}...`);
+        const stream = createWriteStream(filename, { flags: 'w' });
+        let streamErrored = false;
+        const onStreamError = (err) => {
+            streamErrored = true;
+            this.log.error(`Heap snapshot stream error: ${err instanceof Error ? err.message : err}`);
+        };
+        stream.once('error', onStreamError);
+        const chunksListener = (notification) => {
+            if (!stream.write(notification.params.chunk)) {
+            }
+        };
+        this.session.on('HeapProfiler.addHeapSnapshotChunk', chunksListener);
+        try {
+            await new Promise((resolve) => {
+                this.session?.post('HeapProfiler.takeHeapSnapshot', (err) => {
+                    this.session?.off('HeapProfiler.addHeapSnapshotChunk', chunksListener);
+                    const finalize = () => {
+                        if (!err && !streamErrored) {
+                            if (this.debug)
+                                this.log.debug(`Heap sampling snapshot saved to ${CYAN}${filename}${db}`);
+                            this.runGarbageCollector('minor', 'async');
+                            this.runGarbageCollector('major', 'async');
+                            this.emit('snapshot_done');
+                        }
+                        else if (err) {
+                            this.log.error(`Failed to take heap snapshot: ${err instanceof Error ? err.message : err}`);
+                            this.runGarbageCollector('minor', 'async');
+                            this.runGarbageCollector('major', 'async');
+                        }
+                        resolve();
+                    };
+                    try {
+                        stream.end(() => finalize());
+                    }
+                    catch (e) {
+                        this.log.error(`Error finalizing heap snapshot stream: ${e instanceof Error ? e.message : e}`);
+                        finalize();
+                    }
+                });
+            });
+        }
+        finally {
+            this.snapshotInProgress = false;
+        }
+    }
+    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}`);
+        }
+    }
+}

package/packages/utils/dist/isValid.d.ts

@@ -0,0 +1,10 @@
+export declare function isValidIpv4Address(ipv4Address: string): boolean;
+export declare function isValidNumber(value: unknown, min?: number, max?: number): value is number;
+export declare function isValidBoolean(value: unknown): value is boolean;
+export declare function isValidString(value: unknown, minLength?: number, maxLength?: number): value is string;
+export declare function isValidRegExp(value: unknown): value is RegExp;
+export declare function isValidObject(value: unknown, minLength?: number, maxLength?: number): value is object;
+export declare function isValidArray(value: unknown, minLength?: number, maxLength?: number): value is unknown[];
+export declare function isValidNull(value: unknown): value is null;
+export declare function isValidUndefined(value: unknown): value is undefined;
+export declare function parseVersionString(versionString: string): number | undefined;

package/packages/utils/dist/isValid.js

@@ -0,0 +1,69 @@
+export function isValidIpv4Address(ipv4Address) {
+    const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+    return ipv4Regex.test(ipv4Address);
+}
+export function isValidNumber(value, min, max) {
+    if (value === undefined || value === null || typeof value !== 'number' || Number.isNaN(value) || !Number.isFinite(value))
+        return false;
+    if (min !== undefined && value < min)
+        return false;
+    if (max !== undefined && value > max)
+        return false;
+    return true;
+}
+export function isValidBoolean(value) {
+    return value !== undefined && value !== null && typeof value === 'boolean';
+}
+export function isValidString(value, minLength, maxLength) {
+    if (value === undefined || value === null || typeof value !== 'string')
+        return false;
+    if (minLength !== undefined && value.length < minLength)
+        return false;
+    if (maxLength !== undefined && value.length > maxLength)
+        return false;
+    return true;
+}
+export function isValidRegExp(value) {
+    return value !== undefined && value !== null && value instanceof RegExp;
+}
+export function isValidObject(value, minLength, maxLength) {
+    if (value === undefined || value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const keys = Object.keys(value);
+    if (minLength !== undefined && keys.length < minLength)
+        return false;
+    if (maxLength !== undefined && keys.length > maxLength)
+        return false;
+    return true;
+}
+export function isValidArray(value, minLength, maxLength) {
+    if (value === undefined || value === null || !Array.isArray(value))
+        return false;
+    if (minLength !== undefined && value.length < minLength)
+        return false;
+    if (maxLength !== undefined && value.length > maxLength)
+        return false;
+    return true;
+}
+export function isValidNull(value) {
+    return value === null;
+}
+export function isValidUndefined(value) {
+    return value === undefined;
+}
+export function parseVersionString(versionString) {
+    if (!isValidString(versionString))
+        return undefined;
+    versionString = versionString.trim();
+    const match = versionString.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return undefined;
+    const [, majorStr, minorStr, patchStr] = match;
+    const major = parseInt(majorStr, 10);
+    const minor = parseInt(minorStr, 10);
+    const patch = parseInt(patchStr, 10);
+    if ([major, minor, patch].some((n) => !Number.isFinite(n)) || major > 99 || minor > 99 || patch > 99) {
+        return undefined;
+    }
+    return major * 10000 + minor * 100 + patch;
+}

package/packages/utils/dist/network.d.ts

@@ -0,0 +1,12 @@
+export declare function getInterfaceDetails(): {
+    interfaceName: string;
+    ipv4Address: string | undefined;
+    ipv6Address: string | undefined;
+    macAddress: string | undefined;
+} | undefined;
+export declare function getInterfaceName(): string | undefined;
+export declare function getIpv4InterfaceAddress(): string | undefined;
+export declare function getIpv6InterfaceAddress(scope?: boolean): string | undefined;
+export declare function getMacAddress(): string | undefined;
+export declare function logInterfaces(): void;
+export declare function resolveHostname(hostname: string, family?: 0 | 4 | 6): Promise<string | null>;

package/packages/utils/dist/network.js

@@ -0,0 +1,105 @@
+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;
+    }
+}

package/packages/utils/dist/npmRoot.d.ts

@@ -0,0 +1 @@
+export declare function getGlobalNodeModules(): Promise<string>;

package/packages/utils/dist/npmRoot.js

@@ -0,0 +1,13 @@
+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/packages/utils/dist/npmVersion.d.ts

@@ -0,0 +1 @@
+export declare function getNpmPackageVersion(packageName: string, tag?: string, timeout?: number): Promise<string>;

package/packages/utils/dist/npmVersion.js

@@ -0,0 +1,43 @@
+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}`));
+        });
+    });
+}

package/packages/utils/dist/tracker.d.ts

@@ -0,0 +1,52 @@
+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 {};