@matterbridge/thread 3.9.1-dev-20260614-18d1a2e → 3.9.1-dev-20260617-b1e1b99

package/README.md

@@ -6,10 +6,12 @@
 [![Docker Pulls](https://img.shields.io/docker/pulls/luligu/matterbridge?label=docker%20pulls)](https://hub.docker.com/r/luligu/matterbridge)
 ![Node.js CI](https://github.com/Luligu/matterbridge/actions/workflows/build.yml/badge.svg)
 ![CodeQL](https://github.com/Luligu/matterbridge/actions/workflows/codeql.yml/badge.svg)
-[![codecov](https://codecov.io/gh/Luligu/matterbridge/branch/main/graph/badge.svg)](https://codecov.io/gh/Luligu/matterbridge)
-[![styled with prettier](https://img.shields.io/badge/styled_with-Prettier-f8bc45.svg?logo=prettier)](https://prettier.io/)
-[![linted with eslint](https://img.shields.io/badge/linted_with-ES_Lint-4B32C3.svg?logo=eslint)](https://eslint.org/)
+[![Codecov](https://codecov.io/gh/Luligu/matterbridge/branch/main/graph/badge.svg)](https://codecov.io/gh/Luligu/matterbridge)
+[![tested with Vitest](https://img.shields.io/badge/tested_with-Vitest-6E9F18.svg?logo=vitest&logoColor=white)](https://vitest.dev)
+[![styled with Oxc](https://img.shields.io/badge/styled_with-Oxc-9BE4E0.svg?logo=oxc&logoColor=white)](https://oxc.rs/docs/guide/usage/formatter.html)
+[![linted with Oxc](https://img.shields.io/badge/linted_with-Oxc-9BE4E0.svg?logo=oxc&logoColor=white)](https://oxc.rs/docs/guide/usage/linter.html)
 [![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![TypeScript Native](https://img.shields.io/badge/TypeScript_Native-3178C6?logo=typescript&logoColor=white)](https://github.com/microsoft/typescript-go)
 [![ESM](https://img.shields.io/badge/ESM-Node.js-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
 [![matterbridge.io](https://img.shields.io/badge/matterbridge.io-online-brightgreen)](https://matterbridge.io)
 

package/dist/broadcastServer.js

@@ -1,10 +1,10 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] BroadcastServer loaded.\u001B[40;0m');
 import { EventEmitter } from 'node:events';
 import { BroadcastChannel } from 'node:worker_threads';
 import { hasParameter } from '@matterbridge/utils/cli';
 import { logError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { CYAN, db, debugStringify, er } from 'node-ansi-logger';
+logModuleLoaded('BroadcastServer');
 export class BroadcastServer extends EventEmitter {
     name;
     log;
@@ -88,20 +88,19 @@ export class BroadcastServer extends EventEmitter {
             this.log.error('Broadcast channel is closed');
             return;
         }
-        if (message.id === undefined) {
-            message.id = this.getUniqueId();
-        }
-        if (message.timestamp === undefined) {
-            message.timestamp = Date.now();
-        }
-        message.src = this.name;
+        const broadcastMessage = {
+            ...message,
+            id: message.id ?? this.getUniqueId(),
+            timestamp: message.timestamp ?? Date.now(),
+            src: this.name,
+        };
         if (this.verbose)
-            this.log.debug(`Broadcasting message: ${debugStringify(message)}`);
+            this.log.debug(`Broadcasting message: ${debugStringify(broadcastMessage)}`);
         try {
-            this.broadcastChannel.postMessage(message);
+            this.broadcastChannel.postMessage(broadcastMessage);
         }
         catch (error) {
-            logError(this.log, `Failed to broadcast message ${debugStringify(message)}${er}`, error);
+            logError(this.log, `Failed to broadcast message ${debugStringify(broadcastMessage)}${er}`, error);
         }
     }
     request(message) {
@@ -109,24 +108,23 @@ export class BroadcastServer extends EventEmitter {
             this.log.error('Broadcast channel is closed');
             return;
         }
-        if (message.id === undefined) {
-            message.id = this.getUniqueId();
-        }
-        if (message.timestamp === undefined) {
-            message.timestamp = Date.now();
-        }
-        message.src = this.name;
-        if (!this.isWorkerRequest(message)) {
-            this.log.error(`Invalid request message format: ${debugStringify(message)}`);
+        const requestMessage = {
+            ...message,
+            id: message.id ?? this.getUniqueId(),
+            timestamp: message.timestamp ?? Date.now(),
+            src: this.name,
+        };
+        if (!this.isWorkerRequest(requestMessage)) {
+            this.log.error(`Invalid request message format: ${debugStringify(requestMessage)}`);
             return;
         }
         if (this.verbose)
-            this.log.debug(`Broadcasting request message: ${debugStringify(message)}`);
+            this.log.debug(`Broadcasting request message: ${debugStringify(requestMessage)}`);
         try {
-            this.broadcastChannel.postMessage(message);
+            this.broadcastChannel.postMessage(requestMessage);
         }
         catch (error) {
-            logError(this.log, `Failed to broadcast request message ${debugStringify(message)}${er}`, error);
+            logError(this.log, `Failed to broadcast request message ${debugStringify(requestMessage)}${er}`, error);
         }
     }
     respond(message) {
@@ -134,65 +132,64 @@ export class BroadcastServer extends EventEmitter {
             this.log.error('Broadcast channel is closed');
             return;
         }
-        if (typeof message.timestamp === 'number') {
-            message.elapsed = Date.now() - message.timestamp;
-        }
-        if (message.timestamp === undefined) {
-            message.timestamp = Date.now();
-        }
-        if (message.dst === this.name) {
-            message.dst = message.src;
-        }
-        message.src = this.name;
-        if (!this.isWorkerResponse(message)) {
-            this.log.error(`Invalid response message format: ${debugStringify(message)}`);
+        const now = Date.now();
+        const responseMessage = {
+            ...message,
+            ...(typeof message.timestamp === 'number' ? { elapsed: now - message.timestamp } : {}),
+            timestamp: message.timestamp ?? now,
+            dst: message.dst === this.name ? message.src : message.dst,
+            src: this.name,
+        };
+        if (!this.isWorkerResponse(responseMessage)) {
+            this.log.error(`Invalid response message format: ${debugStringify(responseMessage)}`);
             return;
         }
         if (this.verbose)
-            this.log.debug(`Broadcasting response message: ${debugStringify(message)}`);
+            this.log.debug(`Broadcasting response message: ${debugStringify(responseMessage)}`);
         try {
-            this.broadcastChannel.postMessage(message);
+            this.broadcastChannel.postMessage(responseMessage);
         }
         catch (error) {
-            logError(this.log, `Failed to broadcast response message ${debugStringify(message)}${er}`, error);
+            logError(this.log, `Failed to broadcast response message ${debugStringify(responseMessage)}${er}`, error);
         }
     }
     async fetch(message, timeout = 250) {
         if (this.closed) {
             return Promise.reject(new Error('Broadcast channel is closed'));
         }
-        if (message.id === undefined) {
-            message.id = this.getUniqueId();
-        }
-        if (message.timestamp === undefined) {
-            message.timestamp = Date.now();
-        }
+        let timeoutId;
+        const requestMessage = {
+            ...message,
+            id: message.id ?? this.getUniqueId(),
+            timestamp: message.timestamp ?? Date.now(),
+            src: this.name,
+        };
         if (this.verbose)
-            this.log.debug(`Fetching message: ${debugStringify(message)}`);
+            this.log.debug(`Fetching message: ${debugStringify(requestMessage)}`);
         return new Promise((resolve, reject) => {
             const responseHandler = (msg) => {
-                if (this.isWorkerResponseOfType(msg, message.type) && msg.id === message.id) {
+                if (this.isWorkerResponseOfType(msg, requestMessage.type) && msg.id === requestMessage.id) {
                     clearTimeout(timeoutId);
                     this.off('broadcast_message', responseHandler);
                     if (this.verbose)
                         this.log.debug(`Fetch response: ${debugStringify(msg)}`);
                     if ('error' in msg && typeof msg.error === 'string') {
-                        reject(new Error(`Fetch received error response ${msg.error} to message type ${message.type} id ${message.id} from ${message.src} to ${message.dst}`));
+                        reject(new Error(`Fetch received error response ${msg.error} to message type ${requestMessage.type} id ${requestMessage.id} from ${requestMessage.src} to ${requestMessage.dst}`));
                     }
                     else if ('result' in msg) {
                         resolve(msg);
                     }
                     else {
-                        reject(new Error(`Fetch received malformed response for message type ${message.type} id ${message.id} from ${message.src} to ${message.dst}`));
+                        reject(new Error(`Fetch received malformed response for message type ${requestMessage.type} id ${requestMessage.id} from ${requestMessage.src} to ${requestMessage.dst}`));
                     }
                     return;
                 }
             };
             this.on('broadcast_message', responseHandler);
-            this.request(message);
-            const timeoutId = setTimeout(() => {
+            this.request(requestMessage);
+            timeoutId = setTimeout(() => {
                 this.off('broadcast_message', responseHandler);
-                reject(new Error(`Fetch timeout after ${timeout}ms for message type ${message.type} id ${message.id} from ${message.src} to ${message.dst}`));
+                reject(new Error(`Fetch timeout after ${timeout}ms for message type ${requestMessage.type} id ${requestMessage.id} from ${requestMessage.src} to ${requestMessage.dst}`));
             }, timeout);
         });
     }

package/dist/checkUpdates.js

@@ -1,8 +1,13 @@
 import { createHash } from 'node:crypto';
 import { plg } from '@matterbridge/types';
+import { getErrorMessage } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { isValidString } from '@matterbridge/utils/validate';
 import { AnsiLogger, db, debugStringify, nt, wr } from 'node-ansi-logger';
 import { BroadcastServer } from './broadcastServer.js';
+logModuleLoaded('CheckUpdates');
+let refreshSettingsRequired = false;
+let refreshPluginsRequired = false;
 export async function checkUpdates(matterbridge) {
     const log = new AnsiLogger({ logName: 'MatterbridgeUpdates', logTimestampFormat: 4, logLevel: matterbridge.logLevel });
     const server = new BroadcastServer('updates', log);
@@ -19,9 +24,15 @@ export async function checkUpdates(matterbridge) {
         }
     }
     catch (error) {
-        log.debug(`Error fetching plugins for update check: ${error instanceof Error ? error.message : error}`);
+        log.debug(`Error fetching plugins for update check: ${getErrorMessage(error)}`);
     }
     await Promise.all([checkUpdatePromise, latestVersionPromise, devVersionPromise, ...pluginsVersionPromises, ...pluginsDevVersionPromises]);
+    if (refreshSettingsRequired)
+        server.request({ type: 'frontend_refreshrequired', src: server.name, dst: 'frontend', params: { changed: 'settings' } });
+    if (refreshPluginsRequired)
+        server.request({ type: 'frontend_refreshrequired', src: server.name, dst: 'frontend', params: { changed: 'plugins' } });
+    refreshSettingsRequired = false;
+    refreshPluginsRequired = false;
     server.close();
 }
 export async function checkUpdatesAndLog(matterbridge, log, server) {
@@ -54,7 +65,7 @@ export async function checkUpdatesAndLog(matterbridge, log, server) {
         }
     }
     catch (error) {
-        log.debug(`Error checking GitHub ${branch} updates: ${error instanceof Error ? error.message : error}`);
+        log.debug(`Error checking GitHub ${branch} updates: ${getErrorMessage(error)}`);
     }
 }
 export async function getMatterbridgeLatestVersion(matterbridge, log, server) {
@@ -62,7 +73,10 @@ export async function getMatterbridgeLatestVersion(matterbridge, log, server) {
     try {
         const version = await getNpmPackageVersion('matterbridge');
         server.request({ type: 'matterbridge_latest_version', src: server.name, dst: 'matterbridge', params: { version } });
-        if (matterbridge.matterbridgeVersion !== version) {
+        if (matterbridge.matterbridgeVersion === version) {
+            log.debug(`Matterbridge is up to date. Current version: ${matterbridge.matterbridgeVersion}. Latest version: ${version}.`);
+        }
+        else {
             log.notice(`Matterbridge is out of date. Current version: ${matterbridge.matterbridgeVersion}. Latest version: ${version}.`);
             server.request({
                 type: 'frontend_snackbarmessage',
@@ -71,15 +85,13 @@ export async function getMatterbridgeLatestVersion(matterbridge, log, server) {
                 params: { message: 'Matterbridge latest update available', timeout: 0, severity: 'info' },
             });
             server.request({ type: 'frontend_updaterequired', src: server.name, dst: 'frontend', params: { devVersion: false } });
-            server.request({ type: 'frontend_refreshrequired', src: server.name, dst: 'frontend', params: { changed: 'settings' } });
-        }
-        else {
-            log.debug(`Matterbridge is up to date. Current version: ${matterbridge.matterbridgeVersion}. Latest version: ${version}.`);
+            refreshSettingsRequired = true;
         }
         return version;
     }
     catch (error) {
-        log.warn(`Error getting Matterbridge latest version: ${error instanceof Error ? error.message : error}`);
+        log.warn(`Error getting Matterbridge latest version: ${getErrorMessage(error)}`);
+        return undefined;
     }
 }
 export async function getMatterbridgeDevVersion(matterbridge, log, server) {
@@ -96,7 +108,7 @@ export async function getMatterbridgeDevVersion(matterbridge, log, server) {
                 params: { message: 'Matterbridge dev update available', timeout: 0, severity: 'info' },
             });
             server.request({ type: 'frontend_updaterequired', src: server.name, dst: 'frontend', params: { devVersion: true } });
-            server.request({ type: 'frontend_refreshrequired', src: server.name, dst: 'frontend', params: { changed: 'settings' } });
+            refreshSettingsRequired = true;
         }
         else if ((matterbridge.matterbridgeVersion.includes('-dev-') || matterbridge.matterbridgeVersion.includes('-git-')) && matterbridge.matterbridgeVersion === version) {
             log.debug(`Matterbridge@dev is up to date. Current version: ${matterbridge.matterbridgeVersion}. Latest dev version: ${version}.`);
@@ -104,7 +116,8 @@ export async function getMatterbridgeDevVersion(matterbridge, log, server) {
         return version;
     }
     catch (error) {
-        log.warn(`Error getting Matterbridge latest dev version: ${error instanceof Error ? error.message : error}`);
+        log.warn(`Error getting Matterbridge latest dev version: ${getErrorMessage(error)}`);
+        return undefined;
     }
 }
 export async function getPluginLatestVersion(log, server, plugin) {
@@ -113,17 +126,18 @@ export async function getPluginLatestVersion(log, server, plugin) {
         const version = await getNpmPackageVersion(plugin.name);
         plugin.latestVersion = version;
         server.request({ type: 'plugins_set_latest_version', src: server.name, dst: 'plugins', params: { plugin, version } });
-        if (plugin.version !== plugin.latestVersion) {
-            log.notice(`The plugin ${plg}${plugin.name}${nt} is out of date. Current version: ${plugin.version}. Latest version: ${plugin.latestVersion}.`);
-            server.request({ type: 'frontend_refreshrequired', src: server.name, dst: 'frontend', params: { changed: 'plugins' } });
+        if (plugin.version === plugin.latestVersion) {
+            log.debug(`The plugin ${plg}${plugin.name}${db} is up to date. Current version: ${plugin.version}. Latest version: ${plugin.latestVersion}.`);
         }
         else {
-            log.debug(`The plugin ${plg}${plugin.name}${db} is up to date. Current version: ${plugin.version}. Latest version: ${plugin.latestVersion}.`);
+            log.notice(`The plugin ${plg}${plugin.name}${nt} is out of date. Current version: ${plugin.version}. Latest version: ${plugin.latestVersion}.`);
+            refreshPluginsRequired = true;
         }
         return version;
     }
     catch (error) {
-        log.warn(`Error getting plugin ${plg}${plugin.name}${wr} latest version: ${error instanceof Error ? error.message : error}`);
+        log.warn(`Error getting plugin ${plg}${plugin.name}${wr} latest version: ${getErrorMessage(error)}`);
+        return undefined;
     }
 }
 export async function getPluginDevVersion(log, server, plugin) {
@@ -134,7 +148,7 @@ export async function getPluginDevVersion(log, server, plugin) {
         server.request({ type: 'plugins_set_dev_version', src: server.name, dst: 'plugins', params: { plugin, version } });
         if ((plugin.version.includes('-dev-') || plugin.version.includes('-git-')) && plugin.version !== plugin.devVersion) {
             log.notice(`The plugin ${plg}${plugin.name}${nt} is out of date. Current version: ${plugin.version}. Latest dev version: ${plugin.devVersion}.`);
-            server.request({ type: 'frontend_refreshrequired', src: server.name, dst: 'frontend', params: { changed: 'plugins' } });
+            refreshPluginsRequired = true;
         }
         else if (plugin.version.includes('-dev-') && plugin.version === plugin.devVersion) {
             log.debug(`The plugin ${plg}${plugin.name}${db} is up to date. Current version: ${plugin.version}. Latest dev version: ${plugin.devVersion}.`);
@@ -142,6 +156,7 @@ export async function getPluginDevVersion(log, server, plugin) {
         return version;
     }
     catch (error) {
-        log.debug(`Error getting plugin ${plg}${plugin.name}${db} latest dev version: ${error instanceof Error ? error.message : error}`);
+        log.debug(`Error getting plugin ${plg}${plugin.name}${db} latest dev version: ${getErrorMessage(error)}`);
+        return undefined;
     }
 }

package/dist/dockerVersion.js

@@ -1,4 +1,7 @@
+import { getErrorMessage } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { isValidString } from '@matterbridge/utils/validate';
+logModuleLoaded('DockerVersion');
 async function httpsGetJson(url, headers, timeoutMs) {
     const https = await import('node:https');
     return new Promise((resolve, reject) => {
@@ -46,13 +49,13 @@ async function httpsGetJson(url, headers, timeoutMs) {
                     resolve(JSON.parse(data));
                 }
                 catch (error) {
-                    reject(new Error(`Failed to parse response JSON: ${error instanceof Error ? error.message : error}`));
+                    reject(new Error(`Failed to parse response JSON: ${getErrorMessage(error)}`));
                 }
             });
         });
         req.on('error', (error) => {
             clearTimeout(timeoutId);
-            reject(new Error(`Request failed: ${error instanceof Error ? error.message : error}`));
+            reject(new Error(`Request failed: ${getErrorMessage(error)}`));
         });
     });
 }

package/dist/spawnCommand.js

@@ -1,6 +1,9 @@
 import { hasParameter } from '@matterbridge/utils/cli';
+import { getErrorMessage } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { AnsiLogger } from 'node-ansi-logger';
 import { BroadcastServer } from './broadcastServer.js';
+logModuleLoaded('SpawnCommand');
 export async function spawnCommand(command, args, packageCommand, packageName) {
     const { spawn } = await import('node:child_process');
     const debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-spawn') || hasParameter('verbose-spawn');
@@ -12,7 +15,7 @@ export async function spawnCommand(command, args, packageCommand, packageName) {
             server.request({ type: 'frontend_logmessage', src: 'spawn', dst: 'frontend', params: { level: 'spawn', time: log.now(), name, message } });
         }
         catch (err) {
-            log.debug(`Failed to send log message to frontend: ${err instanceof Error ? err.message : String(err)}`);
+            log.debug(`Failed to send log message to frontend: ${getErrorMessage(err)}`);
         }
     };
     if (verbose)
@@ -38,7 +41,7 @@ export async function spawnCommand(command, args, packageCommand, packageName) {
             stdio: ['inherit', 'pipe', 'pipe'],
         });
         childProcess.on('error', (err) => {
-            log.error(`Failed to start child process "${cmdLine}": ${err.message}`);
+            log.error(`Failed to start child process "${cmdLine}": ${getErrorMessage(err)}`);
             sendLog('Matterbridge:spawn-exit-error', 'Spawn process error');
             resolve(false);
         });

package/dist/threadsManager.js

@@ -1,12 +1,13 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] ThreadsManager loaded.\u001B[40;0m');
 import fs from 'node:fs';
-import path, { resolve } from 'node:path';
+import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { Worker } from 'node:worker_threads';
 import { hasParameter } from '@matterbridge/utils/cli';
+import { getErrorMessage } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { AnsiLogger, CYAN, db, debugStringify, MAGENTA, wr } from 'node-ansi-logger';
 import { BroadcastServer } from './broadcastServer.js';
+logModuleLoaded('ThreadsManager');
 export class ThreadsManager {
     debug;
     verbose;
@@ -51,7 +52,7 @@ export class ThreadsManager {
         if (this.verbose)
             this.log.notice(`ThreadsManager destroyed. Broadcast server closed.`);
     }
-    async msgHandler(msg) {
+    msgHandler(msg) {
         if (this.server.isWorkerRequest(msg) && (msg.dst === 'all' || msg.dst === 'manager')) {
             if (this.verbose)
                 this.log.debug(`Received broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
@@ -72,7 +73,7 @@ export class ThreadsManager {
                         this.server.respond({ ...msg, result: { success: true } });
                     }
                     catch (err) {
-                        this.log.warn(`Failed to run thread ${CYAN}${msg.params.name}${wr}: ${err.message}`);
+                        this.log.warn(`Failed to run thread ${CYAN}${msg.params.name}${wr}: ${getErrorMessage(err)}`);
                         this.server.respond({ ...msg, result: { success: false } });
                     }
                     break;
@@ -87,11 +88,11 @@ export class ThreadsManager {
             this.log.debug(`Thread ${thread.name} running: ${thread.worker ? 'yes' : 'no'}, lastSeen: ${thread.lastSeen ? new Date(thread.lastSeen).toISOString() : 'never'}, runs: ${thread.runCount ?? 0}, errors: ${thread.errorCount ?? 0}`);
         }
         for (const thread of this.threads) {
-            if (thread.worker && Date.now() - (thread.lastSeen || 0) > this.intervalMs) {
+            if (thread.worker && Date.now() - (thread.lastSeen ?? 0) > this.intervalMs) {
                 const msg = { type: 'ping', threadId: thread.worker.threadId, threadName: thread.name };
                 thread.worker.postMessage(msg);
             }
-            if (thread.worker && Date.now() - (thread.lastSeen || 0) > this.intervalMs * 2) {
+            if (thread.worker && Date.now() - (thread.lastSeen ?? 0) > this.intervalMs * 2) {
                 this.log.warn(`Thread ${CYAN}${thread.name}${db} has not been seen for more than ${this.intervalMs * 2} ms. It may be unresponsive.`);
             }
         }
@@ -177,7 +178,7 @@ export class ThreadsManager {
         return candidates[0];
     }
     createESMWorker(name, relativePath, workerData, argv, env, execArgv, pipedOutput = false) {
-        const fileURL = pathToFileURL(resolve(relativePath));
+        const fileURL = pathToFileURL(path.resolve(relativePath));
         const options = {
             workerData: { ...workerData, threadName: name, debug: this.debug, verbose: this.verbose, logLevel: this.log.logLevel, tracker: this.tracker },
             type: 'module',

package/dist/workerArchiveCommand.js

@@ -1,8 +1,8 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[35m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] ArchiveCommand loaded.\u001B[40;0m');
 import { isArchiveWorkerData } from '@matterbridge/types';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { WorkerWrapper } from './workerWrapper.js';
 import { createZip, readZip, unZip } from './zipjs.js';
+logModuleLoaded('ArchiveCommand', '\u001B[35m');
 export default new WorkerWrapper('ArchiveCommand', async (worker) => {
     if (!isArchiveWorkerData(worker.workerData)) {
         worker.logger("error", `ArchiveCommand invalid parameters`);

package/dist/workerCheckUpdates.js

@@ -1,8 +1,8 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[35m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] CheckUpdates loaded.\u001B[40;0m');
 import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { checkUpdates } from './checkUpdates.js';
 import { WorkerWrapper } from './workerWrapper.js';
+logModuleLoaded('CheckUpdates', '\u001B[35m');
 export default new WorkerWrapper('CheckUpdates', async (worker) => {
     worker.logger("info", `Starting check updates...`);
     let success = false;

package/dist/workerDockerVersion.js

@@ -1,10 +1,10 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[35m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] DockerVersion loaded.\u001B[40;0m');
 import { readFileSync } from 'node:fs';
 import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { debugStringify } from 'node-ansi-logger';
 import { getDockerVersion } from './dockerVersion.js';
 import { WorkerWrapper } from './workerWrapper.js';
+logModuleLoaded('DockerVersion', '\u001B[35m');
 export default new WorkerWrapper('DockerVersion', async (worker) => {
     worker.logger("info", `Starting docker version check...`);
     let success = false;

package/dist/workerGlobalPrefix.js

@@ -1,8 +1,8 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[35m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] GlobalPrefix loaded.\u001B[40;0m');
 import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { getGlobalNodeModules } from '@matterbridge/utils/npm-prefix';
 import { WorkerWrapper } from './workerWrapper.js';
+logModuleLoaded('GlobalPrefix', '\u001B[35m');
 export default new WorkerWrapper('GlobalPrefix', async (worker) => {
     let prefix;
     worker.logger("info", `Starting global prefix check...`);

package/dist/workerSpawnCommand.js

@@ -1,8 +1,8 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[35m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] SpawnCommand loaded.\u001B[40;0m');
 import { isSpawnWorkerData } from '@matterbridge/types';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { spawnCommand } from './spawnCommand.js';
 import { WorkerWrapper } from './workerWrapper.js';
+logModuleLoaded('SpawnCommand', '\u001B[35m');
 export default new WorkerWrapper('SpawnCommand', async (worker) => {
     if (!isSpawnWorkerData(worker.workerData)) {
         worker.logger("error", `SpawnCommand invalid parameters`);

package/dist/workerSystemCheck.js

@@ -1,9 +1,9 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[35m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] SystemCheck loaded.\u001B[40;0m');
 import os from 'node:os';
 import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { excludedInterfaceNamePattern } from '@matterbridge/utils/network';
 import { WorkerWrapper } from './workerWrapper.js';
+logModuleLoaded('SystemCheck', '\u001B[35m');
 export default new WorkerWrapper('SystemCheck', async (worker) => {
     worker.logger("info", `Starting system check...`);
     let success = false;
@@ -39,7 +39,7 @@ export default new WorkerWrapper('SystemCheck', async (worker) => {
             }
             if (excludedInterfaceNamePattern.test(interfaceName))
                 continue;
-            for (const detail of interfaceDetails || []) {
+            for (const detail of interfaceDetails ?? []) {
                 if (detail.internal)
                     foundInternal = true;
                 if (!detail.internal)

package/dist/workerWrapper.js

@@ -1,12 +1,12 @@
-if (process.argv.includes('--loader'))
-    console.log('\u001B[32m[' + new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3 }) + '] WorkerWrapper loaded.\u001B[40;0m');
 import { isMainThread, parentPort, threadId, workerData } from 'node:worker_threads';
-import { inspectError } from '@matterbridge/utils';
+import { getErrorMessage, inspectError } from '@matterbridge/utils';
 import { hasParameter } from '@matterbridge/utils/cli';
 import { formatBytes } from '@matterbridge/utils/format';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { AnsiLogger, debugStringify, MAGENTA } from 'node-ansi-logger';
 import { BroadcastServer } from './broadcastServer.js';
 import { ThreadsManager } from './threadsManager.js';
+logModuleLoaded('WorkerWrapper');
 export class WorkerWrapper {
     name;
     callback;
@@ -21,9 +21,9 @@ export class WorkerWrapper {
         this.name = name;
         this.callback = callback;
         if (this.workerData) {
-            this.debug = this.workerData.debug || this.debug;
-            this.verbose = this.workerData.verbose || this.verbose;
-            this.useTracker = this.workerData.tracker || this.useTracker;
+            this.debug = this.workerData.debug ?? this.debug;
+            this.verbose = this.workerData.verbose ?? this.verbose;
+            this.useTracker = this.workerData.tracker ?? this.useTracker;
         }
         if (this.useTracker) {
             void import('@matterbridge/utils/tracker')
@@ -34,7 +34,7 @@ export class WorkerWrapper {
             })
                 .catch((err) => {
                 if (this.debug)
-                    console.error(`WorkerWrapper ${this.name}: failed to load Tracker`, err);
+                    console.error(`WorkerWrapper ${this.name}: failed to load Tracker ${getErrorMessage(err)}`);
                 return;
             });
         }
@@ -75,17 +75,19 @@ export class WorkerWrapper {
         if (this.verbose)
             this.logWorkerInfo(this.log, false);
         if (!isMainThread) {
-            setImmediate(async () => {
-                let success = false;
-                try {
-                    success = await callback(this);
-                }
-                catch (err) {
-                    inspectError(this.log, `Worker ${this.name} callback failed`, err);
-                }
-                finally {
-                    this.destroy(success);
-                }
+            setImmediate(() => {
+                void (async () => {
+                    let success = false;
+                    try {
+                        success = await callback(this);
+                    }
+                    catch (err) {
+                        inspectError(this.log, `Worker ${this.name} callback failed`, err);
+                    }
+                    finally {
+                        this.destroy(success);
+                    }
+                })();
             });
         }
     }

package/dist/zipjs.js

@@ -1,5 +1,5 @@
 import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
-import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import path from 'node:path';
 import { Uint8ArrayReader, Uint8ArrayWriter, ZipReader, ZipWriter } from '@zip.js/zip.js';
 import { AnsiLogger } from 'node-ansi-logger';
 export async function createZip(zipPath, sourcePaths) {
@@ -9,11 +9,11 @@ export async function createZip(zipPath, sourcePaths) {
     const writer = new ZipWriter(new Uint8ArrayWriter());
     let entryCount = 0;
     for (const sourcePath of sourcePaths) {
-        const resolvedSourcePath = resolve(sourcePath);
-        entryCount += await addZipEntry(writer, resolvedSourcePath, basename(resolvedSourcePath), log);
+        const resolvedSourcePath = path.resolve(sourcePath);
+        entryCount += await addZipEntry(writer, resolvedSourcePath, path.basename(resolvedSourcePath), log);
     }
     const zipData = await writer.close();
-    await mkdir(dirname(zipPath), { recursive: true });
+    await mkdir(path.dirname(zipPath), { recursive: true });
     await writeFile(zipPath, zipData);
     log.info(`Created zip ${zipPath} with ${entryCount} entries (${zipData.byteLength} bytes).`);
     return zipData.byteLength;
@@ -58,7 +58,7 @@ export async function unZip(zipPath, destinationPath = getDefaultDestinationPath
                 extractedEntries++;
                 continue;
             }
-            await mkdir(dirname(entryPath), { recursive: true });
+            await mkdir(path.dirname(entryPath), { recursive: true });
             const fileData = await entry.getData(new Uint8ArrayWriter());
             await writeFile(entryPath, fileData);
             extractedEntries++;
@@ -83,7 +83,7 @@ async function addZipEntry(writer, sourcePath, entryName, log) {
         children.sort((left, right) => left.name.localeCompare(right.name));
         let childEntries = 1;
         for (const child of children) {
-            childEntries += await addZipEntry(writer, join(sourcePath, child.name), `${directoryEntryName}${child.name}`, log);
+            childEntries += await addZipEntry(writer, path.join(sourcePath, child.name), `${directoryEntryName}${child.name}`, log);
         }
         log.debug(`Added directory ${directoryEntryName}`);
         return childEntries;
@@ -96,18 +96,18 @@ async function addZipEntry(writer, sourcePath, entryName, log) {
     throw new Error(`Unsupported source path type: ${sourcePath}`);
 }
 function getDefaultDestinationPath(zipPath) {
-    const zipExtension = extname(zipPath);
-    const zipName = basename(zipPath, zipExtension);
-    return join(dirname(zipPath), zipName);
+    const zipExtension = path.extname(zipPath);
+    const zipName = path.basename(zipPath, zipExtension);
+    return path.join(path.dirname(zipPath), zipName);
 }
 function normalizeEntryName(entryName) {
     return entryName.replace(/\\/g, '/');
 }
 function resolveEntryPath(destinationPath, entryName) {
-    const resolvedDestinationPath = resolve(destinationPath);
-    const resolvedEntryPath = resolve(resolvedDestinationPath, normalizeEntryName(entryName));
-    const relativeEntryPath = relative(resolvedDestinationPath, resolvedEntryPath);
-    if (isAbsolute(relativeEntryPath) || relativeEntryPath.startsWith('..')) {
+    const resolvedDestinationPath = path.resolve(destinationPath);
+    const resolvedEntryPath = path.resolve(resolvedDestinationPath, normalizeEntryName(entryName));
+    const relativeEntryPath = path.relative(resolvedDestinationPath, resolvedEntryPath);
+    if (path.isAbsolute(relativeEntryPath) || relativeEntryPath.startsWith('..')) {
         throw new Error(`Refusing to extract zip entry outside destination: ${entryName}`);
     }
     return resolvedEntryPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/thread",
-  "version": "3.9.1-dev-20260614-18d1a2e",
+  "version": "3.9.1-dev-20260617-b1e1b99",
   "description": "Matterbridge thread library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -69,8 +69,8 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@matterbridge/types": "3.9.1-dev-20260614-18d1a2e",
-    "@matterbridge/utils": "3.9.1-dev-20260614-18d1a2e",
+    "@matterbridge/types": "3.9.1-dev-20260617-b1e1b99",
+    "@matterbridge/utils": "3.9.1-dev-20260617-b1e1b99",
     "@zip.js/zip.js": "2.8.26",
     "node-ansi-logger": "3.3.0-dev-20260607-585945a"
   }