matterbridge 3.3.8 → 3.3.9-dev-20251118-930cfdb

package/dist/utils/hex.js

@@ -1,114 +1,39 @@
-/**
- * This file contains the hex functions.
- *
- * @file hex.ts
- * @author Luca Liguori
- * @created 2025-05-06
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { createPublicKey, createPrivateKey, X509Certificate } from 'node:crypto';
-/**
- * Converts an ArrayBuffer or Uint8Array to a hexadecimal string.
- *
- * Accepts any {ArrayBufferLike} input: a raw ArrayBuffer (binary data storage) or
- * a Uint8Array (TypedArray view over an ArrayBuffer). While an ArrayBuffer holds
- * the raw memory, a Uint8Array is a typed view into that memory, letting you access
- * its bytes directly. This function normalizes both by creating a Uint8Array view
- * before conversion.
- *
- * @param {ArrayBufferLike} buffer - The buffer or typed-array view to convert.
- * @returns {string} A lowercase hex string representation of the buffer's bytes.
- *
- * @throws {TypeError} If the input is not an ArrayBuffer or ArrayBufferView.
- */
 export function bufferToHex(buffer) {
-    // Check if the input is an ArrayBuffer or ArrayBufferView
     if (!(buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer))) {
         throw new TypeError('Expected input to be an ArrayBuffer or ArrayBufferView');
     }
-    // Create a Uint8Array view over the buffer
     const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-    // Convert each byte to 2-digit hex
     return Array.from(bytes)
         .map((byte) => byte.toString(16).padStart(2, '0'))
         .join('');
 }
-/**
- * Converts a hexadecimal string to a Uint8Array.
- *
- * @param {string} hex - The hex string to convert. Can include uppercase or lowercase characters.
- * @returns {Uint8Array} A Uint8Array representing the corresponding binary data.
- *
- * @throws {TypeError} If the input is not a string.
- * @throws {Error} If the input length is odd or contains non-hex characters.
- */
 export function hexToBuffer(hex) {
-    // Ensure the input is a string
     if (typeof hex !== 'string') {
         throw new TypeError('Expected a string for hex input');
     }
-    // Trim any whitespace from the input string
     const cleaned = hex.trim();
-    // Check if the length of the hex string is even
     if (cleaned.length % 2 !== 0) {
         throw new Error('Invalid hex string length, must be even');
     }
-    // Validate that the string contains only valid hex characters
     if (!/^[0-9a-fA-F]*$/.test(cleaned)) {
         throw new Error('Invalid hex string, contains non-hex characters');
     }
-    // Calculate the length of the resulting Uint8Array
     const length = cleaned.length / 2;
-    // Create a Uint8Array to hold the binary data
     const result = new Uint8Array(length);
-    // Convert each pair of hex characters into a byte
     for (let i = 0; i < length; i++) {
         result[i] = parseInt(cleaned.substr(i * 2, 2), 16);
     }
-    // Return the resulting Uint8Array
     return result;
 }
-/**
- * Converts a PEM (Privacy-Enhanced Mail) formatted string to a Uint8Array.
- *
- * PEM format is a base64-encoded format commonly used for cryptographic keys and certificates,
- * wrapped with header and footer lines like "-----BEGIN CERTIFICATE-----" and "-----END CERTIFICATE-----".
- * This function extracts the base64 content and converts it to binary data using Node.js Buffer API.
- *
- * @param {string} pem - The PEM formatted string to convert.
- * @param {boolean} validate - Whether to validate the PEM content using Node.js crypto module. Default is false.
- * @returns {Uint8Array} A Uint8Array representing the decoded binary data.
- *
- * @throws {TypeError} If the input is not a string.
- * @throws {Error} If the PEM format is invalid, contains invalid base64 characters, or validation fails.
- */
 export function pemToBuffer(pem, validate = false) {
-    // Ensure the input is a string
     if (typeof pem !== 'string') {
         throw new TypeError('Expected a string for PEM input');
     }
-    // Trim whitespace from the input
     const cleaned = pem.trim();
-    // Check if the string appears to be in PEM format
     if (!cleaned.includes('-----BEGIN') || !cleaned.includes('-----END')) {
         throw new Error('Invalid PEM format: missing BEGIN/END markers');
     }
-    // Extract the base64 content between the header and footer
     const lines = cleaned.split('\n');
     const base64Lines = [];
     let inContent = false;
@@ -129,114 +54,65 @@ export function pemToBuffer(pem, validate = false) {
     if (base64Lines.length === 0) {
         throw new Error('Invalid PEM format: no content found between BEGIN/END markers');
     }
-    // Join all base64 lines together
     const base64String = base64Lines.join('');
-    // Validate base64 string format
     if (!/^[A-Za-z0-9+/]*={0,2}$/.test(base64String)) {
         throw new Error('Invalid PEM format: contains invalid base64 characters');
     }
     try {
-        // Use Node.js Buffer API instead of legacy atob()
         const buffer = Buffer.from(base64String, 'base64');
-        // Convert Buffer to Uint8Array
         const result = new Uint8Array(buffer);
-        // Validate PEM content using Node.js crypto module if requested
         if (validate) {
             try {
-                // Determine PEM type from the header and validate accordingly
                 const pemType = cleaned.match(/-----BEGIN\s+([^-]+)-----/)?.[1]?.trim();
                 if (pemType?.includes('CERTIFICATE')) {
-                    // Use X509Certificate for robust certificate validation
                     const cert = new X509Certificate(pem);
-                    // Check validity period
                     if (cert.validFrom && cert.validTo) {
                         const now = Date.now();
                         const from = Date.parse(cert.validFrom);
                         const to = Date.parse(cert.validTo);
-                        // istanbul ignore next if
                         if (now < from || now > to) {
                             throw new Error('Certificate is not currently valid');
                         }
                     }
-                    // Check subject/issuer fields
-                    // istanbul ignore next if
                     if (!cert.subject || !cert.issuer) {
                         throw new Error('Certificate missing subject or issuer');
                     }
-                    // Optionally check signature (not possible without CA chain)
                 }
                 else if (pemType?.includes('PRIVATE KEY')) {
-                    // For private keys, try to create a private key
                     createPrivateKey({ key: pem, format: 'pem' });
                 }
                 else if (pemType?.includes('PUBLIC KEY')) {
-                    // For public keys, try to create a public key
                     createPublicKey({ key: pem, format: 'pem' });
                 }
-                // If no specific type is detected, skip validation
             }
             catch (validationError) {
-                // istanbul ignore next
                 throw new Error(`PEM validation failed: ${validationError instanceof Error ? validationError.message : String(validationError)}`);
             }
         }
         return result;
     }
     catch (error) {
-        // istanbul ignore next
         throw new Error(`Failed to decode base64 content: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-/**
- * Extracts the raw 32-byte private key scalar from an EC private key PEM.
- *
- * This function parses an EC private key in PEM format and extracts the raw
- * 32-byte private scalar (the "d" value) used in elliptic curve cryptography.
- * This is the actual secret key material.
- *
- * @param {string} pemPrivateKey - The EC private key in PEM format
- * @returns {Uint8Array} The raw 32-byte private key scalar
- * @throws {Error} If the input is not a valid EC private key PEM
- *
- * @example
- * ```typescript
- * const pemKey = `-----BEGIN EC PRIVATE KEY-----
- * MHcCAQEEIFBxqFkUxMoN2JkUXLFeiZnLNUpftjLi0sKMbZ6uajHXoAoGCCqGSM49
- * AwEHoUQDQgAEcJ3eH/rG3zf9WmqMjh5eBSkeXz3Cb4Fig1rTosfHmgyjx/WnLPEe
- * BF4SHvLo0G2COJEHa/VDE5EiKWO9ZR6AOQ==
- * -----END EC PRIVATE KEY-----`;
- *
- * const rawKey = extractPrivateKeyRaw(pemKey);
- * console.log(rawKey.length); // 32
- * console.log(bufferToHex(rawKey)); // hex representation of the private scalar
- * ```
- */
 export function extractPrivateKeyRaw(pemPrivateKey) {
     if (typeof pemPrivateKey !== 'string') {
         throw new TypeError('Expected a string for PEM private key input');
     }
-    // Extract the private key block
     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 {
-        // Create a private key object
         const privateKey = createPrivateKey(keyBlock[0]);
-        // Export as PKCS#8 DER format
         const pkcs8Der = privateKey.export({ format: 'der', type: 'pkcs8' });
-        // For P-256 curves, the private scalar is the last 32 bytes of the PKCS#8 DER
-        // istanbul ignore next
         if (pkcs8Der.length < 32) {
             throw new Error('Invalid private key: DER data too short');
         }
-        // Extract the last 32 bytes which contain the raw private scalar
         const rawPrivateKey = pkcs8Der.subarray(pkcs8Der.length - 32);
         return new Uint8Array(rawPrivateKey);
     }
     catch (error) {
-        // istanbul ignore next
         throw new Error(`Failed to extract private key: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-//# sourceMappingURL=hex.js.map

package/dist/utils/inspector.js

@@ -1,27 +1,3 @@
-/**
- * This file contains the Inspector class.
- *
- * @file inspector.ts
- * @author Luca Liguori
- * @created 2025-10-12
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/* eslint-disable no-console */
 if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mInspector loaded.\u001B[40;0m');
 import EventEmitter from 'node:events';
@@ -45,7 +21,7 @@ export class Inspector extends EventEmitter {
         if (process.argv.includes('--verbose') || process.argv.includes('-verbose')) {
             this.verbose = true;
         }
-        this.log = new AnsiLogger({ logName: this.name, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: this.debug ? "debug" /* LogLevel.DEBUG */ : "info" /* LogLevel.INFO */ });
+        this.log = new AnsiLogger({ logName: this.name, logTimestampFormat: 4, logLevel: this.debug ? "debug" : "info" });
         this.log.logNameColor = YELLOW;
         this.on('start', () => {
             this.start();
@@ -60,15 +36,6 @@ export class Inspector extends EventEmitter {
             this.runGarbageCollector();
         });
     }
-    /**
-     * Starts the inspector for heap sampling.
-     *
-     * This function is called when the -inspect parameter is passed to matterbridge.
-     *
-     * The -snapshotinterval parameter can be used to set the heap snapshot interval. Default is undefined. Minimum is 30000 ms.
-     * The snapshot is saved in the heap_profiles directory that is created in the current working directory.
-     * The snapshot can be analyzed using vscode or Chrome DevTools or other tools that support heap snapshots.
-     */
     async start() {
         if (this.session) {
             this.log.warn('Inspector session already active.');
@@ -77,9 +44,7 @@ export class Inspector extends EventEmitter {
         const { Session } = await import('node:inspector');
         const { mkdirSync } = await import('node:fs');
         this.log.debug(`Starting heap sampling...`);
-        // Create the heap profiles directory if it doesn't exist
         mkdirSync('heap_profiles', { recursive: true });
-        // Create the heap snapshots directory if it doesn't exist
         mkdirSync('heap_snapshots', { recursive: true });
         try {
             this.session = new Session();
@@ -88,7 +53,6 @@ export class Inspector extends EventEmitter {
                 this.session?.post('HeapProfiler.startSampling', (err) => (err ? reject(err) : resolve()));
             });
             this.log.debug(`Started heap sampling`);
-            // Set an interval to take heap snapshots
             const { getIntParameter } = await import('./commandLine.js');
             const interval = getIntParameter('snapshotinterval');
             if (interval && interval >= 30000) {
@@ -117,10 +81,6 @@ export class Inspector extends EventEmitter {
             return;
         }
     }
-    /**
-     * Stops the heap sampling and saves the profile to a file in the heap_profiles directory.
-     * This function is called when the inspector is stopped.
-     */
     async stop() {
         if (!this.session) {
             this.log.warn('No active inspector session.');
@@ -131,9 +91,7 @@ export class Inspector extends EventEmitter {
         this.log.debug(`Stopping heap sampling...`);
         if (this.snapshotInterval) {
             this.log.debug(`Clearing heap snapshot interval...`);
-            // Clear the snapshot interval if it exists
             clearInterval(this.snapshotInterval);
-            // Take a final heap snapshot before stopping
             await this.takeHeapSnapshot();
         }
         try {
@@ -155,15 +113,6 @@ export class Inspector extends EventEmitter {
             this.log.debug(`Stopped heap sampling`);
         }
     }
-    /**
-     * Takes a heap snapshot and saves it to the file name 'heap_snapshots/<timestamp>.heapsnapshot'.
-     * If triggers a full garbage collection before and after taking the snapshot to reduce noise.
-     *
-     * This function is called periodically based on the -snapshotinterval parameter.
-     * The -snapshotinterval parameter must at least 30000 ms.
-     * The snapshot is saved in the heap_snapshots directory that is created in the current working directory.
-     * The snapshot can be analyzed using vscode or Chrome DevTools or other tools that support heap snapshots.
-     */
     async takeHeapSnapshot() {
         if (!this.session) {
             this.log.warn('No active inspector session.');
@@ -179,7 +128,6 @@ export class Inspector extends EventEmitter {
         const path = await import('node:path');
         const safeTimestamp = new Date().toISOString().replace(/[<>:"/\\|?*]/g, '-');
         const filename = path.join('heap_snapshots', `${safeTimestamp}.heapsnapshot`);
-        // Trigger a garbage collection before taking the snapshot to reduce noise
         this.runGarbageCollector('minor', 'async');
         this.runGarbageCollector('major', 'async');
         if (this.debug)
@@ -192,16 +140,13 @@ export class Inspector extends EventEmitter {
         };
         stream.once('error', onStreamError);
         const chunksListener = (notification) => {
-            // notification.params.chunk is a string; write directly to the stream
             if (!stream.write(notification.params.chunk)) {
-                // If backpressure engages, it's fine; the stream will buffer internally. We don't block the inspector.
             }
         };
         this.session.on('HeapProfiler.addHeapSnapshotChunk', chunksListener);
         try {
             await new Promise((resolve) => {
                 this.session?.post('HeapProfiler.takeHeapSnapshot', (err) => {
-                    // Detach chunk listener and close the stream, then perform post-actions
                     this.session?.off('HeapProfiler.addHeapSnapshotChunk', chunksListener);
                     const finalize = () => {
                         if (!err && !streamErrored) {
@@ -218,7 +163,6 @@ export class Inspector extends EventEmitter {
                         }
                         resolve();
                     };
-                    // End stream and wait for finish or error
                     try {
                         stream.end(() => finalize());
                     }
@@ -233,17 +177,6 @@ export class Inspector extends EventEmitter {
             this.snapshotInProgress = false;
         }
     }
-    /**
-     * Manually trigger garbage collection to free memory (if exposed with --expose-gc)
-     *
-     * @param {'major' | 'minor'} type - The type of garbage collection to perform ('major' or 'minor'). Default is 'major'.
-     * @param {'sync' | 'async'} execution - The execution mode of garbage collection ('sync' or 'async'). Default is 'async'.
-     *
-     * @remarks
-     * - major collection refers to old-generation mark-sweep/mark-compact cycles.
-     * - minor collection refers to young-generation collections (scavenges).
-     * - sync execution blocks the main thread until GC is complete, which can cause pauses.
-     */
     runGarbageCollector(type = 'major', execution = 'async') {
         if (global.gc && typeof global.gc === 'function') {
             try {
@@ -265,4 +198,3 @@ export class Inspector extends EventEmitter {
         }
     }
 }
-//# sourceMappingURL=inspector.js.map

package/dist/utils/isvalid.js

@@ -1,45 +1,7 @@
-/**
- * This file contains the validation functions.
- *
- * @file isvalid.ts
- * @author Luca Liguori
- * @created 2025-02-16
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Checks if a given string is a valid IPv4 address.
- *
- * @param {string} ipv4Address - The string to be checked.
- * @returns {boolean} - Returns true if the string is a valid IPv4 address, otherwise returns false.
- */
 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);
 }
-/**
- * Checks if a value is a valid number within the specified range.
- *
- * @param {any} value - The value to be checked.
- * @param {number} min - The minimum value allowed (optional).
- * @param {number} max - The maximum value allowed (optional).
- * @returns {value is number} Returns true if the value is a valid number within the specified range, otherwise false.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidNumber(value, min, max) {
     if (value === undefined || value === null || typeof value !== 'number' || Number.isNaN(value) || !Number.isFinite(value))
         return false;
@@ -49,25 +11,9 @@ export function isValidNumber(value, min, max) {
         return false;
     return true;
 }
-/**
- * Checks if a value is a valid boolean.
- *
- * @param {any} value - The value to be checked.
- * @returns {value is boolean} `true` if the value is a valid boolean, `false` otherwise.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidBoolean(value) {
     return value !== undefined && value !== null && typeof value === 'boolean';
 }
-/**
- * Checks if a value is a valid string.
- *
- * @param {any} value - The value to be checked.
- * @param {number} minLength - The min string length (optional).
- * @param {number} maxLength - The max string length (optional).
- * @returns {value is string} A boolean indicating whether the value is a valid string.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidString(value, minLength, maxLength) {
     if (value === undefined || value === null || typeof value !== 'string')
         return false;
@@ -77,25 +23,9 @@ export function isValidString(value, minLength, maxLength) {
         return false;
     return true;
 }
-/**
- * Checks if a value is a valid RegExp.
- *
- * @param {any} value - The value to be checked.
- * @returns {value is RegExp} A boolean indicating whether the value is a valid RegExp.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidRegExp(value) {
     return value !== undefined && value !== null && value instanceof RegExp;
 }
-/**
- * Checks if a value is a valid object.
- *
- * @param {any} value - The value to be checked.
- * @param {number} minLength - The min number of keys (optional).
- * @param {number} maxLength - The max number of keys (optional).
- * @returns {value is object} A boolean indicating whether the value is a valid object.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidObject(value, minLength, maxLength) {
     if (value === undefined || value === null || typeof value !== 'object' || Array.isArray(value))
         return false;
@@ -106,15 +36,6 @@ export function isValidObject(value, minLength, maxLength) {
         return false;
     return true;
 }
-/**
- * Checks if a value is a valid array.
- *
- * @param {any} value - The value to be checked.
- * @param {number} minLength - The min number of elements (optional).
- * @param {number} maxLength - The max number of elements (optional).
- * @returns {value is unknown[]} A boolean indicating whether the value is a valid array.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidArray(value, minLength, maxLength) {
     if (value === undefined || value === null || !Array.isArray(value))
         return false;
@@ -124,33 +45,12 @@ export function isValidArray(value, minLength, maxLength) {
         return false;
     return true;
 }
-/**
- * Checks if the given value is null.
- *
- * @param {any} value - The value to check.
- * @returns {value is null} `true` if the value is null, `false` otherwise.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidNull(value) {
     return value === null;
 }
-/**
- * Checks if a value is undefined.
- *
- * @param {any} value - The value to check.
- * @returns {value is undefined} `true` if the value is undefined, `false` otherwise.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isValidUndefined(value) {
     return value === undefined;
 }
-/**
- * Converts a semantic version string like "6.11.0-1011-raspi" to a numeric version code like 61100.
- * Format: major * 10000 + minor * 100 + patch
- *
- * @param {string} versionString The version string to parse
- * @returns {number | undefined} A numeric version code or undefined if parsing fails
- */
 export function parseVersionString(versionString) {
     if (!isValidString(versionString))
         return undefined;
@@ -167,4 +67,3 @@ export function parseVersionString(versionString) {
     }
     return major * 10000 + minor * 100 + patch;
 }
-//# sourceMappingURL=isvalid.js.map