matterbridge 3.4.7-dev-20260104-6b10cee → 3.4.7-dev-20260112-bd9e311

package/packages/utils/dist/commandLine.js

@@ -0,0 +1,63 @@
+import { isValidNumber } from './isValid.js';
+export function hasParameter(name) {
+    const commandArguments = process.argv.slice(2);
+    let markerIncluded = commandArguments.includes(`-${name}`);
+    if (!markerIncluded)
+        markerIncluded = commandArguments.includes(`--${name}`);
+    return markerIncluded;
+}
+export function hasAnyParameter(...params) {
+    return params.some((param) => {
+        return hasParameter(param);
+    });
+}
+export function getParameter(name) {
+    const commandArguments = process.argv.slice(2);
+    let markerIndex = commandArguments.indexOf(`-${name}`);
+    if (markerIndex === -1)
+        markerIndex = commandArguments.indexOf(`--${name}`);
+    if (markerIndex === -1 || markerIndex + 1 === commandArguments.length || commandArguments[markerIndex + 1].startsWith('-'))
+        return undefined;
+    return commandArguments[markerIndex + 1];
+}
+export function getIntParameter(name) {
+    const value = getParameter(name);
+    if (value === undefined)
+        return undefined;
+    const intValue = parseInt(value, 10);
+    if (!isValidNumber(intValue))
+        return undefined;
+    return intValue;
+}
+export function getIntArrayParameter(name) {
+    const commandArguments = process.argv.slice(2);
+    let markerIndex = commandArguments.indexOf(`--${name}`);
+    if (markerIndex < 0)
+        markerIndex = commandArguments.indexOf(`-${name}`);
+    if (markerIndex < 0)
+        return undefined;
+    const intValues = [];
+    for (let i = markerIndex + 1; i < commandArguments.length && !commandArguments[i].startsWith('-'); i++) {
+        const intValue = parseInt(commandArguments[i], 10);
+        if (isValidNumber(intValue))
+            intValues.push(intValue);
+    }
+    if (intValues.length === 0)
+        return undefined;
+    return intValues;
+}
+export function getStringArrayParameter(name) {
+    const commandArguments = process.argv.slice(2);
+    let markerIndex = commandArguments.indexOf(`--${name}`);
+    if (markerIndex < 0)
+        markerIndex = commandArguments.indexOf(`-${name}`);
+    if (markerIndex < 0)
+        return undefined;
+    const values = [];
+    for (let i = markerIndex + 1; i < commandArguments.length && !commandArguments[i].startsWith('-'); i++) {
+        values.push(commandArguments[i]);
+    }
+    if (values.length === 0)
+        return undefined;
+    return values;
+}

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

@@ -0,0 +1,2 @@
+import { AnsiLogger } from 'node-ansi-logger';
+export declare function copyDirectory(srcDir: string, destDir: string, log?: AnsiLogger): Promise<boolean>;

package/packages/utils/dist/copyDirectory.js

@@ -0,0 +1,39 @@
+export async function copyDirectory(srcDir, destDir, log) {
+    if (srcDir === '') {
+        throw new Error('Source directory must be specified.');
+    }
+    if (destDir === '') {
+        throw new Error('Destination directory must be specified.');
+    }
+    if (!srcDir) {
+        throw new Error('Source directory must be specified.');
+    }
+    if (!destDir) {
+        throw new Error('Destination directory must be specified.');
+    }
+    if (srcDir === destDir) {
+        throw new Error('Source and destination directories must be different.');
+    }
+    const fs = await import('node:fs').then((mod) => mod.promises);
+    const path = await import('node:path');
+    log?.debug(`copyDirectory: copying directory from ${srcDir} to ${destDir}`);
+    try {
+        await fs.mkdir(destDir, { recursive: true });
+        const entries = await fs.readdir(srcDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(srcDir, entry.name);
+            const destPath = path.join(destDir, entry.name);
+            if (entry.isDirectory()) {
+                await copyDirectory(srcPath, destPath);
+            }
+            else if (entry.isFile()) {
+                await fs.copyFile(srcPath, destPath);
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        log?.error(`copyDirectory error copying from ${srcDir} to ${destDir}: ${error instanceof Error ? error.message : error}`);
+        return false;
+    }
+}

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

@@ -0,0 +1,2 @@
+import { AnsiLogger } from 'node-ansi-logger';
+export declare function createDirectory(path: string, name: string, log: AnsiLogger): Promise<void>;

package/packages/utils/dist/createDirectory.js

@@ -0,0 +1,21 @@
+import { promises as fs } from 'node:fs';
+export async function createDirectory(path, name, log) {
+    try {
+        await fs.access(path);
+        log.debug(`Directory ${name} already exists at path: ${path}`);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            try {
+                await fs.mkdir(path, { recursive: true });
+                log.info(`Created ${name}: ${path}`);
+            }
+            catch (err) {
+                log.error(`Error creating dir ${name} path ${path}: ${err}`);
+            }
+        }
+        else {
+            log.error(`Error accessing dir ${name} path ${path}: ${err}`);
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export declare function createZip(outputPath: string, ...sourcePaths: string[]): Promise<number>;

package/packages/utils/dist/createZip.js

@@ -0,0 +1,69 @@
+import { AnsiLogger } from 'node-ansi-logger';
+export async function createZip(outputPath, ...sourcePaths) {
+    const log = new AnsiLogger({ logName: 'Archive', logTimestampFormat: 4, logLevel: "info" });
+    const { default: archiver } = await import('archiver');
+    const { glob } = await import('glob');
+    const { createWriteStream, statSync } = await import('node:fs');
+    const path = await import('node:path');
+    log.debug(`creating archive ${outputPath} from ${sourcePaths.join(', ')} ...`);
+    return new Promise((resolve, reject) => {
+        const output = createWriteStream(outputPath);
+        const archive = archiver('zip', {
+            zlib: { level: 9 },
+        });
+        output.on('close', () => {
+            log.debug(`archive ${outputPath} closed with ${archive.pointer()} total bytes`);
+            resolve(archive.pointer());
+        });
+        output.on('end', () => {
+            log.debug(`archive ${outputPath} data has been drained ${archive.pointer()} total bytes`);
+        });
+        archive.on('error', (error) => {
+            log.error(`archive error: ${error.message}`);
+            reject(error);
+        });
+        archive.on('warning', (error) => {
+            if (error.code === 'ENOENT') {
+                log.warn(`archive warning: ${error.message}`);
+            }
+            else {
+                log.error(`archive warning: ${error.message}`);
+                reject(error);
+            }
+        });
+        archive.on('entry', (entry) => {
+            log.debug(`- archive entry: ${entry.name}`);
+        });
+        archive.pipe(output);
+        for (const sourcePath of sourcePaths) {
+            let stats;
+            try {
+                stats = statSync(sourcePath);
+            }
+            catch (error) {
+                if (sourcePath.includes('*')) {
+                    const files = glob.sync(sourcePath.replace(/\\/g, '/'));
+                    log.debug(`adding files matching glob pattern: ${sourcePath}`);
+                    for (const file of files) {
+                        log.debug(`- glob file: ${file}`);
+                        archive.file(file, { name: file });
+                    }
+                }
+                else {
+                    log.error(`no files or directory found for pattern ${sourcePath}: ${error}`);
+                }
+                continue;
+            }
+            if (stats.isFile()) {
+                log.debug(`adding file: ${sourcePath}`);
+                archive.file(sourcePath, { name: path.basename(sourcePath) });
+            }
+            else if (stats.isDirectory()) {
+                log.debug(`adding directory: ${sourcePath}`);
+                archive.directory(sourcePath, path.basename(sourcePath));
+            }
+        }
+        log.debug(`finalizing archive ${outputPath}...`);
+        archive.finalize().catch(reject);
+    });
+}

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

@@ -0,0 +1 @@
+export declare function deepCopy<T>(value: T): T;

package/packages/utils/dist/deepCopy.js

@@ -0,0 +1,40 @@
+export function deepCopy(value) {
+    if (typeof value !== 'object' || value === null) {
+        return value;
+    }
+    else if (Array.isArray(value)) {
+        return value.map((item) => deepCopy(item));
+    }
+    else if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    else if (value instanceof RegExp) {
+        return new RegExp(value.source, value.flags);
+    }
+    else if (value instanceof Map) {
+        const mapCopy = new Map();
+        for (const [origKey, origVal] of value.entries()) {
+            const clonedKey = deepCopy(origKey);
+            const clonedVal = deepCopy(origVal);
+            mapCopy.set(clonedKey, clonedVal);
+        }
+        return mapCopy;
+    }
+    else if (value instanceof Set) {
+        const setCopy = new Set();
+        value.forEach((item) => {
+            setCopy.add(deepCopy(item));
+        });
+        return setCopy;
+    }
+    else {
+        const proto = Object.getPrototypeOf(value);
+        const copy = Object.create(proto);
+        for (const key in value) {
+            if (Object.prototype.hasOwnProperty.call(value, key)) {
+                copy[key] = deepCopy(value[key]);
+            }
+        }
+        return copy;
+    }
+}

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

@@ -0,0 +1 @@
+export declare function deepEqual(a: any, b: any, excludeProperties?: string[]): boolean;

package/packages/utils/dist/deepEqual.js

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

@@ -0,0 +1,3 @@
+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/packages/utils/dist/error.js

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

@@ -0,0 +1,15 @@
+export * from './colorUtils.js';
+export * from './commandLine.js';
+export * from './copyDirectory.js';
+export * from './createDirectory.js';
+export * from './createZip.js';
+export * from './deepCopy.js';
+export * from './deepEqual.js';
+export * from './error.js';
+export * from './format.js';
+export * from './hex.js';
+export * from './inspector.js';
+export * from './isValid.js';
+export * from './network.js';
+export * from './tracker.js';
+export * from './wait.js';

package/packages/utils/dist/export.js

@@ -0,0 +1,15 @@
+export * from './colorUtils.js';
+export * from './commandLine.js';
+export * from './copyDirectory.js';
+export * from './createDirectory.js';
+export * from './createZip.js';
+export * from './deepCopy.js';
+export * from './deepEqual.js';
+export * from './error.js';
+export * from './format.js';
+export * from './hex.js';
+export * from './inspector.js';
+export * from './isValid.js';
+export * from './network.js';
+export * from './tracker.js';
+export * from './wait.js';

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

@@ -0,0 +1,4 @@
+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/packages/utils/dist/format.js

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

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

package/packages/utils/dist/githubVersion.js

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

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

@@ -0,0 +1,4 @@
+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/packages/utils/dist/hex.js

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

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