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

package/dist/dockerVersion.js

@@ -11,36 +11,18 @@ export function takeDockerVersionWarning() {
 async function httpsGetJson(url, headers, timeoutMs) {
     const https = await import('node:https');
     return new Promise((resolve, reject) => {
-        let settled = false;
-        let req;
-        let timeoutId;
-        const rejectOnce = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeoutId);
-            reject(error);
-        };
-        const resolveOnce = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeoutId);
-            resolve(value);
-        };
-        const timeoutError = new Error(`Request timed out after ${timeoutMs / 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 ${timeoutMs / 1000} seconds`));
         }, timeoutMs).unref();
-        req = https.get(url, { headers }, (res) => {
+        const req = https.get(url, { headers, signal: controller.signal }, (res) => {
             let data = '';
             const statusCode = res.statusCode ?? 0;
             if (statusCode >= 300 && statusCode < 400) {
                 const locationHeader = Array.isArray(res.headers.location) ? res.headers.location[0] : res.headers.location;
                 if (locationHeader) {
                     clearTimeout(timeoutId);
-                    settled = true;
                     res.resume();
                     const redirectedUrl = new URL(locationHeader, url).toString();
                     let redirectedHeaders = headers;
@@ -59,8 +41,9 @@ async function httpsGetJson(url, headers, timeoutMs) {
                 }
             }
             if (statusCode < 200 || statusCode >= 300) {
+                clearTimeout(timeoutId);
                 res.resume();
-                rejectOnce(new Error(`Failed to fetch data. Status code: ${statusCode}`));
+                reject(new Error(`Failed to fetch data. Status code: ${statusCode}`));
                 return;
             }
             res.on('data', (chunk) => {
@@ -68,15 +51,18 @@ async function httpsGetJson(url, headers, timeoutMs) {
             });
             res.on('end', () => {
                 try {
-                    resolveOnce(JSON.parse(data));
+                    clearTimeout(timeoutId);
+                    resolve(JSON.parse(data));
                 }
                 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/threadsManager.d.ts

@@ -12,9 +12,11 @@ export declare class ThreadsManager {
     private interval;
     private intervalMs;
     private threads;
+    private terminateWorkers;
     constructor(intervalMs?: number);
     destroy(): void;
     private msgHandler;
+    private terminateExitedWorkers;
     private intervalHandler;
     runThread(name: string, workerData?: WorkerData, argv?: string[], env?: NodeJS.ProcessEnv, execArgv?: string[], pipedOutput?: boolean): Worker;
     runInMainThread(name: string, workerData?: WorkerData | null): Promise<boolean>;

package/dist/threadsManager.js

@@ -5,6 +5,7 @@ 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 { fireAndForget } from '@matterbridge/utils/wait';
 import { AnsiLogger, CYAN, db, debugStringify, ft, MAGENTA, wr } from 'node-ansi-logger';
 import { BroadcastServer } from './broadcastServer.js';
 logModuleLoaded('ThreadsManager');
@@ -26,6 +27,7 @@ export class ThreadsManager {
         { name: 'ArchiveCommand', path: 'workerArchiveCommand.js', type: 'worker' },
         { name: 'DockerVersion', path: 'workerDockerVersion.js', type: 'worker' },
     ];
+    terminateWorkers = new Set();
     constructor(intervalMs = 60_000) {
         this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-threads') || hasParameter('verbose-threads');
         this.verbose = hasParameter('verbose') || hasParameter('verbose-threads');
@@ -47,6 +49,7 @@ export class ThreadsManager {
     }
     destroy() {
         clearInterval(this.interval);
+        this.terminateExitedWorkers();
         this.server.off('broadcast_message', this.boundMsgHandler);
         this.server.close();
         if (this.verbose)
@@ -83,10 +86,26 @@ export class ThreadsManager {
             }
         }
     }
+    terminateExitedWorkers() {
+        if (this.terminateWorkers.size > 0) {
+            this.log.debug(`Terminating ${this.terminateWorkers.size} workers that have exited...`);
+            for (const worker of this.terminateWorkers) {
+                try {
+                    this.log.debug(`Terminating worker with thread id ${worker.threadId}...`);
+                    fireAndForget(worker.terminate(), this.log, `Failed to terminate worker with thread id ${worker.threadId}`);
+                }
+                catch (error) {
+                    this.log.error(`Failed to terminate worker with thread id ${worker.threadId}: ${getErrorMessage(error)}`);
+                }
+            }
+            this.terminateWorkers.clear();
+        }
+    }
     intervalHandler() {
         for (const thread of this.threads) {
             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}`);
         }
+        this.terminateExitedWorkers();
         for (const thread of this.threads) {
             if (thread.worker && Date.now() - (thread.lastSeen ?? 0) > this.intervalMs) {
                 const msg = { type: 'ping', threadId: thread.worker.threadId, threadName: thread.name };
@@ -128,6 +147,7 @@ export class ThreadsManager {
                 threadInfo.worker = undefined;
             }
             this.log.debug(`Thread ${threadInfo.name} has exited at ${new Date(now).toISOString()}`);
+            this.terminateWorkers.delete(worker);
         });
         worker.on('message', (message) => {
             const now = Date.now();
@@ -148,6 +168,7 @@ export class ThreadsManager {
                 if (!message.success) {
                     threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
                 }
+                this.terminateWorkers.add(worker);
                 threadInfo.worker = undefined;
                 this.log.debug(`Thread ${threadInfo.name} has exited at ${new Date(now).toISOString()} with thread id ${worker.threadId} after running for ${threadInfo.lastDuration} ms`);
             }
@@ -165,6 +186,7 @@ export class ThreadsManager {
             threadInfo.lastDuration = Math.max(0, now - (threadInfo.lastStarted ?? now));
             threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
             threadInfo.worker = undefined;
+            this.terminateWorkers.add(worker);
             this.log.error(`Thread ${threadInfo.name} encountered an error at ${new Date(now).toISOString()} after running for ${threadInfo.lastDuration} ms: ${getErrorMessage(error)}`);
         });
         this.log.debug(`Started thread ${threadInfo.name} from path ${path} type ${threadInfo.type} with thread id ${worker.threadId}`);

package/dist/workerWrapper.js

@@ -145,6 +145,7 @@ export class WorkerWrapper {
         this.destroy(false);
     }
     safeParentLog(level, message) {
+        this.log.error(`Worker ${this.name}: ${message}`);
         if (this.destroyed)
             return;
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/thread",
-  "version": "3.9.3-dev-20260628-fa05360",
+  "version": "3.9.3-dev-20260630-684e0d2",
   "description": "Matterbridge thread library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -69,8 +69,8 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@matterbridge/types": "3.9.3-dev-20260628-fa05360",
-    "@matterbridge/utils": "3.9.3-dev-20260628-fa05360",
+    "@matterbridge/types": "3.9.3-dev-20260630-684e0d2",
+    "@matterbridge/utils": "3.9.3-dev-20260630-684e0d2",
     "@zip.js/zip.js": "2.8.26",
     "node-ansi-logger": "3.3.0"
   }