@matterbridge/utils 3.9.3-dev-20260628-fa05360 → 3.9.3-dev-20260630-684e0d2

package/dist/export.d.ts

@@ -1,4 +1,3 @@
-export * from './bunPrefix.js';
 export * from './colorUtils.js';
 export * from './commandLine.js';
 export * from './copyDirectory.js';
@@ -15,6 +14,7 @@ export * from './loader.js';
 export * from './network.js';
 export * from './npmPrefix.js';
 export * from './npmVersion.js';
+export * from './runtimeBun.js';
 export * from './tracker.js';
 export * from './validate.js';
 export * from './wait.js';

package/dist/export.js

@@ -1,4 +1,3 @@
-export * from './bunPrefix.js';
 export * from './colorUtils.js';
 export * from './commandLine.js';
 export * from './copyDirectory.js';
@@ -15,6 +14,7 @@ export * from './loader.js';
 export * from './network.js';
 export * from './npmPrefix.js';
 export * from './npmVersion.js';
+export * from './runtimeBun.js';
 export * from './tracker.js';
 export * from './validate.js';
 export * from './wait.js';

package/dist/githubVersion.js

@@ -3,33 +3,17 @@ 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}`;
-        let settled = false;
-        let req;
-        let timeoutId;
-        const rejectOnce = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeoutId);
-            reject(error);
-        };
-        const resolveOnce = (updateJson) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeoutId);
-            resolve(updateJson);
-        };
-        const timeoutError = new Error(`Request timed out after ${timeout / 1000} seconds`);
-        timeoutId = setTimeout(() => {
-            req?.destroy?.(timeoutError);
-            rejectOnce(timeoutError);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            controller.abort();
+            reject(new Error(`Request timed out after ${timeout / 1000} seconds`));
         }, timeout).unref();
-        req = https.get(url, {}, (res) => {
+        const req = https.get(url, { signal: controller.signal }, (res) => {
             let data = '';
             if (res.statusCode !== 200) {
+                clearTimeout(timeoutId);
                 res.resume();
-                rejectOnce(new Error(`Failed to fetch data. Status code: ${res.statusCode}`));
+                reject(new Error(`Failed to fetch data. Status code: ${res.statusCode}`));
                 return;
             }
             res.on('data', (chunk) => {
@@ -38,15 +22,18 @@ export async function getGitHubUpdate(branch, file, timeout = 10000) {
             res.on('end', () => {
                 try {
                     const jsonData = JSON.parse(data);
-                    resolveOnce(jsonData);
+                    clearTimeout(timeoutId);
+                    resolve(jsonData);
                 }
                 catch (error) {
-                    rejectOnce(new Error(`Failed to parse response JSON: ${getErrorMessage(error)}`));
+                    clearTimeout(timeoutId);
+                    reject(new Error(`Failed to parse response JSON: ${getErrorMessage(error)}`));
                 }
             });
         });
         req.on('error', (error) => {
-            rejectOnce(new Error(`Request failed: ${getErrorMessage(error)}`));
+            clearTimeout(timeoutId);
+            reject(new Error(`Request failed: ${getErrorMessage(error)}`));
         });
     });
 }

package/dist/npmPrefix.js

@@ -1,5 +1,5 @@
-import { getGlobalBunModules, isBun } from './bunPrefix.js';
 import { logModuleLoaded } from './loader.js';
+import { getGlobalBunModules, isBun } from './runtimeBun.js';
 logModuleLoaded('NpmPrefix');
 export async function getGlobalNodeModules() {
     if (isBun())

package/dist/npmVersion.js

@@ -3,33 +3,17 @@ export async function getNpmPackageVersion(packageName, tag = 'latest', timeout
     const https = await import('node:https');
     return new Promise((resolve, reject) => {
         const url = `https://registry.npmjs.org/${packageName}`;
-        let settled = false;
-        let req;
-        let timeoutId;
-        const rejectOnce = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeoutId);
-            reject(error);
-        };
-        const resolveOnce = (version) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeoutId);
-            resolve(version);
-        };
-        const timeoutError = new Error(`Request timed out after ${timeout / 1000} seconds`);
-        timeoutId = setTimeout(() => {
-            req?.destroy?.(timeoutError);
-            rejectOnce(timeoutError);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            controller.abort();
+            reject(new Error(`Request timed out after ${timeout / 1000} seconds`));
         }, timeout).unref();
-        req = https.get(url, {}, (res) => {
+        const req = https.get(url, { signal: controller.signal }, (res) => {
             let data = '';
             if (res.statusCode !== 200) {
+                clearTimeout(timeoutId);
                 res.resume();
-                rejectOnce(new Error(`Failed to fetch data. Status code: ${res.statusCode}`));
+                reject(new Error(`Failed to fetch data. Status code: ${res.statusCode}`));
                 return;
             }
             res.on('data', (chunk) => {
@@ -40,19 +24,23 @@ export async function getNpmPackageVersion(packageName, tag = 'latest', timeout
                     const jsonData = JSON.parse(data);
                     const version = jsonData['dist-tags']?.[tag];
                     if (version) {
-                        resolveOnce(version);
+                        clearTimeout(timeoutId);
+                        resolve(version);
                     }
                     else {
-                        rejectOnce(new Error(`Tag "${tag}" not found for package "${packageName}"`));
+                        clearTimeout(timeoutId);
+                        reject(new Error(`Tag "${tag}" not found for package "${packageName}"`));
                     }
                 }
                 catch (error) {
-                    rejectOnce(new Error(`Failed to parse response JSON: ${getErrorMessage(error)}`));
+                    clearTimeout(timeoutId);
+                    reject(new Error(`Failed to parse response JSON: ${getErrorMessage(error)}`));
                 }
             });
         });
         req.on('error', (error) => {
-            rejectOnce(new Error(`Request failed: ${getErrorMessage(error)}`));
+            clearTimeout(timeoutId);
+            reject(new Error(`Request failed: ${getErrorMessage(error)}`));
         });
     });
 }

package/dist/runtimeBun.d.ts

@@ -0,0 +1,22 @@
+export declare function isBun(): boolean;
+export declare function getBunVersion(): string | undefined;
+export declare function getBunRevision(): string | undefined;
+export declare function getNodeCompatVersion(): string | undefined;
+export declare function getBun(): typeof Bun | undefined;
+export declare function getGlobalBunModules(): string;
+export declare function nanoseconds(): number;
+export declare function sleep(ms: number): Promise<void>;
+export declare function which(command: string): string | null;
+export declare function gc(force?: boolean): void;
+export declare function setGcLevel(level?: 0 | 1 | 2): 0 | 1 | 2 | undefined;
+export interface BunRuntimeInfo {
+    isBun: boolean;
+    version?: string;
+    revision?: string;
+    nodeCompat?: string;
+    execPath: string;
+    main?: string;
+    arch: string;
+    platform: string;
+}
+export declare function getBunRuntimeInfo(): BunRuntimeInfo;

package/dist/runtimeBun.js

@@ -0,0 +1,63 @@
+import os from 'node:os';
+import path from 'node:path';
+import { logModuleLoaded } from './loader.js';
+logModuleLoaded('RuntimeBun');
+const HAS_BUN_GLOBAL = typeof Bun !== 'undefined';
+export function isBun() {
+    return HAS_BUN_GLOBAL || typeof process?.versions?.bun === 'string';
+}
+export function getBunVersion() {
+    if (HAS_BUN_GLOBAL)
+        return Bun.version;
+    return process?.versions?.bun;
+}
+export function getBunRevision() {
+    return HAS_BUN_GLOBAL ? Bun.revision : undefined;
+}
+export function getNodeCompatVersion() {
+    return process?.versions?.node;
+}
+export function getBun() {
+    return HAS_BUN_GLOBAL ? Bun : undefined;
+}
+export function getGlobalBunModules() {
+    if (!isBun()) {
+        throw new Error('getGlobalBunModules can only be called in a Bun environment.');
+    }
+    const bunInstall = process.env.BUN_INSTALL ?? path.join(os.homedir(), '.bun');
+    return path.join(bunInstall, 'install', 'global', 'node_modules');
+}
+export function nanoseconds() {
+    if (HAS_BUN_GLOBAL)
+        return Bun.nanoseconds();
+    return Number(process.hrtime.bigint());
+}
+export async function sleep(ms) {
+    if (HAS_BUN_GLOBAL)
+        return Bun.sleep(ms);
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function which(command) {
+    return HAS_BUN_GLOBAL ? Bun.which(command) : null;
+}
+export function gc(force = true) {
+    if (HAS_BUN_GLOBAL) {
+        Bun.gc(force);
+    }
+}
+export function setGcLevel(level) {
+    return HAS_BUN_GLOBAL ? Bun.unsafe.gcAggressionLevel(level) : undefined;
+}
+export function getBunRuntimeInfo() {
+    const bun = getBun();
+    return {
+        isBun: isBun(),
+        version: getBunVersion(),
+        revision: getBunRevision(),
+        nodeCompat: getNodeCompatVersion(),
+        execPath: process.execPath,
+        main: bun?.main ?? process.argv[1],
+        arch: process.arch,
+        platform: process.platform,
+    };
+}

package/dist/tracker.d.ts

@@ -36,6 +36,8 @@ export declare class Tracker extends EventEmitter<TrackerEvents> {
     private readonly name;
     private readonly debug;
     private readonly verbose;
+    private readonly tracker;
+    private readonly forceGc;
     private trackerInterval?;
     static historyIndex: number;
     static readonly historySize = 2880;
@@ -43,7 +45,7 @@ export declare class Tracker extends EventEmitter<TrackerEvents> {
     private prevCpus;
     private prevCpuUsage;
     private log;
-    constructor(name?: string, debug?: boolean, verbose?: boolean);
+    constructor(name?: string, debug?: boolean, verbose?: boolean, tracker?: boolean, forceGc?: boolean);
     start(sampleIntervalMs?: number): void;
     resetPeaks(): void;
     runGarbageCollector(type?: 'major' | 'minor', execution?: 'sync' | 'async'): void;

package/dist/tracker.js

@@ -3,11 +3,14 @@ import os from 'node:os';
 import { AnsiLogger, BRIGHT, CYAN, db, RED, RESET, YELLOW } from 'node-ansi-logger';
 import { formatBytes, formatPercent, formatTimeStamp } from './format.js';
 import { logModuleLoaded } from './loader.js';
+import { isBun, gc, setGcLevel } from './runtimeBun.js';
 logModuleLoaded('Tracker');
 export class Tracker extends EventEmitter {
     name;
     debug;
     verbose;
+    tracker;
+    forceGc;
     trackerInterval;
     static historyIndex = 0;
     static historySize = 2880;
@@ -35,18 +38,26 @@ export class Tracker extends EventEmitter {
     prevCpus = os.cpus();
     prevCpuUsage = process.cpuUsage();
     log;
-    constructor(name = 'Tracker', debug = false, verbose = false) {
+    constructor(name = 'Tracker', debug = false, verbose = false, tracker = false, forceGc = false) {
         super();
         this.name = name;
         this.debug = debug;
         this.verbose = verbose;
-        if (process.argv.includes('--debug') || process.argv.includes('-debug') || process.argv.includes('--verbose') || process.argv.includes('-verbose')) {
+        this.tracker = tracker;
+        this.forceGc = forceGc;
+        if (process.argv.includes('--debug') || process.argv.includes('--verbose') || process.argv.includes('--tracker')) {
             this.debug = true;
         }
-        if (process.argv.includes('--verbose') || process.argv.includes('-verbose')) {
+        if (process.argv.includes('--verbose')) {
             this.verbose = true;
         }
-        this.log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: this.debug ? "debug" : "info" });
+        if (process.argv.includes('--tracker')) {
+            this.tracker = true;
+        }
+        if (process.argv.includes('--force-gc')) {
+            this.forceGc = true;
+        }
+        this.log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: this.debug || this.tracker ? "debug" : "info" });
         this.log.logNameColor = YELLOW;
         if (this.verbose) {
             this.log.debug(`os.cpus():\n${RESET}`, os.cpus());
@@ -75,7 +86,7 @@ export class Tracker extends EventEmitter {
         this.prevCpuUsage = process.cpuUsage();
         this.trackerInterval = setInterval(() => {
             tryGcCount += sampleIntervalMs / 1000;
-            if (tryGcCount > 60 * 60) {
+            if (tryGcCount > 60 * 60 || this.forceGc) {
                 this.runGarbageCollector();
                 tryGcCount = 0;
             }
@@ -153,7 +164,8 @@ export class Tracker extends EventEmitter {
         this.emit('reset_peaks_done');
     }
     runGarbageCollector(type = 'major', execution = 'async') {
-        if (global.gc && typeof global.gc === 'function') {
+        const bun = isBun();
+        if (!bun && global.gc && typeof global.gc === 'function') {
             try {
                 global.gc({ type, execution });
                 if (this.debug)
@@ -167,6 +179,19 @@ export class Tracker extends EventEmitter {
                 this.emit('gc_done', 'minor', 'async');
             }
         }
+        else if (bun && typeof gc === 'function' && typeof setGcLevel === 'function') {
+            try {
+                setGcLevel(2);
+                gc(execution === 'sync');
+                if (this.debug)
+                    this.log.debug(`${CYAN}${BRIGHT}Bun garbage collection triggered at ${new Date(Date.now()).toLocaleString()}.${RESET}${db}`);
+                this.emit('gc_done', type, execution);
+            }
+            catch {
+                if (this.debug)
+                    this.log.debug(`${CYAN}${BRIGHT}Bun garbage collection failed triggered at ${new Date(Date.now()).toLocaleString()}.${RESET}${db}`);
+            }
+        }
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/utils",
-  "version": "3.9.3-dev-20260628-fa05360",
+  "version": "3.9.3-dev-20260630-684e0d2",
   "description": "Matterbridge utils library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -51,8 +51,8 @@
       "import": "./dist/export.js"
     },
     "./bun": {
-      "types": "./dist/bunPrefix.d.ts",
-      "import": "./dist/bunPrefix.js"
+      "types": "./dist/runtimeBun.d.ts",
+      "import": "./dist/runtimeBun.js"
     },
     "./cli": {
       "types": "./dist/commandLine.d.ts",

package/dist/bunPrefix.d.ts

@@ -1,2 +0,0 @@
-export declare function isBun(): boolean;
-export declare function getGlobalBunModules(): string;

package/dist/bunPrefix.js

@@ -1,14 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import { logModuleLoaded } from './loader.js';
-logModuleLoaded('BunPrefix');
-export function isBun() {
-    return typeof process !== 'undefined' && process.versions?.bun !== undefined;
-}
-export function getGlobalBunModules() {
-    if (!isBun()) {
-        throw new Error('getGlobalBunModules can only be called in a Bun environment.');
-    }
-    const bunInstall = process.env.BUN_INSTALL ?? path.join(os.homedir(), '.bun');
-    return path.join(bunInstall, 'install', 'global', 'node_modules');
-}