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

package/dist/utils/deepEqual.js

@@ -1,58 +0,0 @@
-export function deepEqual(a, b, excludeProperties = []) {
-    const debugLog = (...messages) => {
-    };
-    if (a === b) {
-        return true;
-    }
-    if (typeof a !== typeof b) {
-        debugLog(`deepEqual false for typeof a: ${typeof a} typeof b: ${typeof b}`);
-        return false;
-    }
-    if (a == null || b == null) {
-        debugLog('deepEqual false for == null');
-        return false;
-    }
-    if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime();
-    }
-    if (a instanceof RegExp && b instanceof RegExp) {
-        return a.source === b.source && a.flags === b.flags;
-    }
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length) {
-            debugLog(`deepEqual false for array a.length(${a.length}) !== b.length(${b.length})`);
-            return false;
-        }
-        for (let i = 0; i < a.length; i++) {
-            if (!deepEqual(a[i], b[i], excludeProperties)) {
-                debugLog('deepEqual false for array !deepEqual(a[i], b[i])');
-                debugLog(`- aProps.length(${a[i]}):`, a[i]);
-                debugLog(`- bProps.length(${b[i]}):`, b[i]);
-                return false;
-            }
-        }
-        return true;
-    }
-    if (typeof a === 'object' && typeof b === 'object') {
-        const aProps = Object.getOwnPropertyNames(a).filter((prop) => !excludeProperties.includes(prop));
-        const bProps = Object.getOwnPropertyNames(b).filter((prop) => !excludeProperties.includes(prop));
-        if (aProps.length !== bProps.length) {
-            debugLog(`deepEqual false for aProps.length(${aProps.length}) !== bProps.length(${bProps.length})`);
-            debugLog(`- aProps.length(${aProps.length}):`, aProps);
-            debugLog(`- bProps.length(${bProps.length}):`, bProps);
-            return false;
-        }
-        for (const prop of aProps) {
-            if (!Object.prototype.hasOwnProperty.call(b, prop)) {
-                debugLog(`deepEqual false for !b.hasOwnProperty(${prop})`);
-                return false;
-            }
-            if (!deepEqual(a[prop], b[prop], excludeProperties)) {
-                debugLog(`deepEqual false for !deepEqual(a[${prop}], b[${prop}])`);
-                return false;
-            }
-        }
-        return true;
-    }
-    return false;
-}

package/dist/utils/error.d.ts

@@ -1,3 +0,0 @@
-import { type AnsiLogger } from 'node-ansi-logger';
-export declare function logError(log: AnsiLogger, message: string, error: unknown): void;
-export declare function inspectError(log: AnsiLogger, message: string, error: unknown): string;

package/dist/utils/error.js

@@ -1,12 +0,0 @@
-import { inspect } from 'node:util';
-import { RESET } from 'node-ansi-logger';
-export function logError(log, message, error) {
-    log.error(`${message}: ${error instanceof Error ? error.message + ' \nStack: \n' + error.stack : error}`);
-}
-export function inspectError(log, message, error) {
-    const errorMessage = error instanceof Error ? `${error.message} \n` : '';
-    const inspectedError = inspect(error, { depth: 10, colors: true, showHidden: false });
-    const fullMessage = `${message}: ${errorMessage}${RESET}${inspectedError}`;
-    log.error(fullMessage);
-    return fullMessage;
-}

package/dist/utils/format.d.ts

@@ -1,4 +0,0 @@
-export declare function formatTimeStamp(timestamp: number): string;
-export declare function formatPercent(percent: number, digits?: number): string;
-export declare function formatBytes(bytes: number, digits?: number): string;
-export declare function formatUptime(seconds: number): string;

package/dist/utils/format.js

@@ -1,29 +0,0 @@
-export function formatTimeStamp(timestamp) {
-    return `${new Date(timestamp).toLocaleString()}`;
-}
-export function formatPercent(percent, digits = 2) {
-    return `${percent.toFixed(digits)} %`;
-}
-export function formatBytes(bytes, digits = 2) {
-    if (bytes === 0)
-        return `${bytes.toFixed(digits)} B`;
-    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-    const idx = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
-    const value = bytes / Math.pow(1024, idx);
-    return `${value.toFixed(digits)} ${units[idx]}`;
-}
-export function formatUptime(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' : ''}`;
-}

package/dist/utils/hex.d.ts

@@ -1,4 +0,0 @@
-export declare function bufferToHex(buffer: ArrayBufferLike): string;
-export declare function hexToBuffer(hex: string): Uint8Array;
-export declare function pemToBuffer(pem: string, validate?: boolean): Uint8Array;
-export declare function extractPrivateKeyRaw(pemPrivateKey: string): Uint8Array;

package/dist/utils/hex.js

@@ -1,118 +0,0 @@
-import { createPublicKey, createPrivateKey, X509Certificate } from 'node:crypto';
-export function bufferToHex(buffer) {
-    if (!(buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer))) {
-        throw new TypeError('Expected input to be an ArrayBuffer or ArrayBufferView');
-    }
-    const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-    return Array.from(bytes)
-        .map((byte) => byte.toString(16).padStart(2, '0'))
-        .join('');
-}
-export function hexToBuffer(hex) {
-    if (typeof hex !== 'string') {
-        throw new TypeError('Expected a string for hex input');
-    }
-    const cleaned = hex.trim();
-    if (cleaned.length % 2 !== 0) {
-        throw new Error('Invalid hex string length, must be even');
-    }
-    if (!/^[0-9a-fA-F]*$/.test(cleaned)) {
-        throw new Error('Invalid hex string, contains non-hex characters');
-    }
-    const length = cleaned.length / 2;
-    const result = new Uint8Array(length);
-    for (let i = 0; i < length; i++) {
-        result[i] = parseInt(cleaned.substr(i * 2, 2), 16);
-    }
-    return result;
-}
-export function pemToBuffer(pem, validate = false) {
-    if (typeof pem !== 'string') {
-        throw new TypeError('Expected a string for PEM input');
-    }
-    const cleaned = pem.trim();
-    if (!cleaned.includes('-----BEGIN') || !cleaned.includes('-----END')) {
-        throw new Error('Invalid PEM format: missing BEGIN/END markers');
-    }
-    const lines = cleaned.split('\n');
-    const base64Lines = [];
-    let inContent = false;
-    for (const line of lines) {
-        const trimmedLine = line.trim();
-        if (trimmedLine.startsWith('-----BEGIN')) {
-            inContent = true;
-            continue;
-        }
-        if (trimmedLine.startsWith('-----END')) {
-            inContent = false;
-            break;
-        }
-        if (inContent && trimmedLine.length > 0) {
-            base64Lines.push(trimmedLine);
-        }
-    }
-    if (base64Lines.length === 0) {
-        throw new Error('Invalid PEM format: no content found between BEGIN/END markers');
-    }
-    const base64String = base64Lines.join('');
-    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(base64String)) {
-        throw new Error('Invalid PEM format: contains invalid base64 characters');
-    }
-    try {
-        const buffer = Buffer.from(base64String, 'base64');
-        const result = new Uint8Array(buffer);
-        if (validate) {
-            try {
-                const pemType = cleaned.match(/-----BEGIN\s+([^-]+)-----/)?.[1]?.trim();
-                if (pemType?.includes('CERTIFICATE')) {
-                    const cert = new X509Certificate(pem);
-                    if (cert.validFrom && cert.validTo) {
-                        const now = Date.now();
-                        const from = Date.parse(cert.validFrom);
-                        const to = Date.parse(cert.validTo);
-                        if (now < from || now > to) {
-                            throw new Error('Certificate is not currently valid');
-                        }
-                    }
-                    if (!cert.subject || !cert.issuer) {
-                        throw new Error('Certificate missing subject or issuer');
-                    }
-                }
-                else if (pemType?.includes('PRIVATE KEY')) {
-                    createPrivateKey({ key: pem, format: 'pem' });
-                }
-                else if (pemType?.includes('PUBLIC KEY')) {
-                    createPublicKey({ key: pem, format: 'pem' });
-                }
-            }
-            catch (validationError) {
-                throw new Error(`PEM validation failed: ${validationError instanceof Error ? validationError.message : String(validationError)}`);
-            }
-        }
-        return result;
-    }
-    catch (error) {
-        throw new Error(`Failed to decode base64 content: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-export function extractPrivateKeyRaw(pemPrivateKey) {
-    if (typeof pemPrivateKey !== 'string') {
-        throw new TypeError('Expected a string for PEM private key input');
-    }
-    const keyBlock = /-----BEGIN (?:EC )?PRIVATE KEY-----[^-]+-----END (?:EC )?PRIVATE KEY-----/s.exec(pemPrivateKey);
-    if (!keyBlock) {
-        throw new Error('No EC PRIVATE KEY block found in the supplied PEM');
-    }
-    try {
-        const privateKey = createPrivateKey(keyBlock[0]);
-        const pkcs8Der = privateKey.export({ format: 'der', type: 'pkcs8' });
-        if (pkcs8Der.length < 32) {
-            throw new Error('Invalid private key: DER data too short');
-        }
-        const rawPrivateKey = pkcs8Der.subarray(pkcs8Der.length - 32);
-        return new Uint8Array(rawPrivateKey);
-    }
-    catch (error) {
-        throw new Error(`Failed to extract private key: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/dist/utils/inspector.d.ts

@@ -1,24 +0,0 @@
-import EventEmitter from 'node:events';
-interface InspectorEvents {
-    start: [];
-    stop: [];
-    snapshot: [];
-    snapshot_done: [];
-    gc: [type?: 'major' | 'minor', execution?: 'sync' | 'async'];
-    gc_done: [type: 'major' | 'minor', execution: 'sync' | 'async'];
-}
-export declare class Inspector extends EventEmitter<InspectorEvents> {
-    private readonly name;
-    private readonly debug;
-    private readonly verbose;
-    private session;
-    private snapshotInterval?;
-    private snapshotInProgress;
-    private log;
-    constructor(name?: string, debug?: boolean, verbose?: boolean);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    takeHeapSnapshot(): Promise<void>;
-    runGarbageCollector(type?: 'major' | 'minor', execution?: 'sync' | 'async'): void;
-}
-export {};

package/dist/utils/inspector.js

@@ -1,200 +0,0 @@
-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/dist/utils/isValid.d.ts

@@ -1,10 +0,0 @@
-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/dist/utils/isValid.js

@@ -1,69 +0,0 @@
-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/dist/utils/network.d.ts

@@ -1,25 +0,0 @@
-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>;
-export declare function getNpmPackageVersion(packageName: string, tag?: string, timeout?: number): Promise<string>;
-export type UpdateJson = {
-    latest: string;
-    latestDate: string;
-    dev: string;
-    devDate: string;
-    latestMessage: string;
-    latestMessageSeverity: 'info' | 'warning' | 'error' | 'success';
-    devMessage: string;
-    devMessageSeverity: 'info' | 'warning' | 'error' | 'success';
-};
-export declare function getGitHubUpdate(branch: 'main' | 'dev', file: string, timeout?: number): Promise<UpdateJson>;
-export declare function getGlobalNodeModules(): Promise<string>;