@matterbridge/thread 3.9.3-dev-20260628-8ac730c → 3.9.3-dev-20260629-7c47082

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.js

@@ -145,22 +145,26 @@ export class ThreadsManager {
             else if (message.type === 'exit') {
                 threadInfo.lastStopped = now;
                 threadInfo.lastDuration = Math.max(0, now - (threadInfo.lastStarted ?? now));
+                if (!message.success) {
+                    threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
+                }
                 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`);
             }
         });
         worker.on('messageerror', () => {
             const now = Date.now();
+            threadInfo.lastSeen = now;
             threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
             this.log.error(`Thread ${threadInfo.name} encountered a message error at ${new Date(now).toISOString()}`);
         });
         worker.once('error', (error) => {
             const now = Date.now();
-            threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
+            threadInfo.lastSeen = now;
             threadInfo.lastStopped = now;
             threadInfo.lastDuration = Math.max(0, now - (threadInfo.lastStarted ?? now));
+            threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
             threadInfo.worker = undefined;
-            threadInfo.lastSeen = now;
             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.d.ts

@@ -12,8 +12,14 @@ export declare class WorkerWrapper {
     server: BroadcastServer;
     workerData: WorkerData | null;
     tracker: Tracker | undefined;
+    private destroyed;
+    private readonly boundUnhandledRejectionHandler;
+    private readonly boundUncaughtExceptionHandler;
     constructor(name: ThreadNames, callback: (worker: WorkerWrapper) => Promise<boolean>);
     destroy(success: boolean): void;
+    private handleUnhandledRejection;
+    private handleUncaughtException;
+    private safeParentLog;
     parentPost(message: ParentPortMessage): void;
     parentLog(logName: string | undefined, logLevel: LogLevel, message: string): void;
     logger(level: LogLevel, message: string): void;

package/dist/workerWrapper.js

@@ -17,6 +17,13 @@ export class WorkerWrapper {
     server;
     workerData = workerData;
     tracker;
+    destroyed = false;
+    boundUnhandledRejectionHandler = (reason) => {
+        this.handleUnhandledRejection(reason);
+    };
+    boundUncaughtExceptionHandler = (error) => {
+        this.handleUncaughtException(error);
+    };
     constructor(name, callback) {
         this.name = name;
         this.callback = callback;
@@ -45,6 +52,10 @@ export class WorkerWrapper {
             logLevel: this.debug ? "debug" : "info",
         });
         this.server = new BroadcastServer('matterbridge', this.log);
+        if (!isMainThread) {
+            process.on('unhandledRejection', this.boundUnhandledRejectionHandler);
+            process.on('uncaughtException', this.boundUncaughtExceptionHandler);
+        }
         if (!isMainThread && parentPort && this.workerData) {
             parentPort.on('message', (message) => {
                 if (this.debug)
@@ -92,20 +103,58 @@ export class WorkerWrapper {
         }
     }
     destroy(success) {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        if (!isMainThread) {
+            process.off('unhandledRejection', this.boundUnhandledRejectionHandler);
+            process.off('uncaughtException', this.boundUncaughtExceptionHandler);
+        }
         if (this.tracker)
             this.tracker.stop();
         this.server.close();
         if (!isMainThread && parentPort && this.workerData) {
             if (this.debug)
                 this.parentLog(this.name, "info", `Worker ${this.name}:${threadId} exiting with success: ${success}.`);
-            this.parentPost({ type: 'exit', threadId, threadName: this.name, memoryUsage: process.memoryUsage(), success });
-            parentPort.close();
+            try {
+                this.parentPost({ type: 'exit', threadId, threadName: this.name, memoryUsage: process.memoryUsage(), success });
+            }
+            catch (error) {
+                this.log.error(`Worker ${this.name}:${threadId} failed to send exit message to parent: ${getErrorMessage(error)}`);
+            }
+            try {
+                parentPort.close();
+                process.exit(success ? 0 : 1);
+            }
+            catch (error) {
+                this.log.error(`Worker ${this.name}:${threadId} failed to close parentPort: ${getErrorMessage(error)}`);
+            }
         }
         else {
             if (this.debug)
                 this.log.debug(`Worker ${this.name}:${threadId} exiting with success in main thread: ${success}.`);
         }
     }
+    handleUnhandledRejection(reason) {
+        const errorMessage = inspectError(this.log, `Worker ${this.name} unhandled rejection`, reason);
+        this.safeParentLog("error", errorMessage);
+        this.destroy(false);
+    }
+    handleUncaughtException(error) {
+        const errorMessage = inspectError(this.log, `Worker ${this.name} uncaught exception`, error);
+        this.safeParentLog("error", errorMessage);
+        this.destroy(false);
+    }
+    safeParentLog(level, message) {
+        if (this.destroyed)
+            return;
+        try {
+            this.logger(level, message);
+        }
+        catch (error) {
+            this.log.error(`Worker ${this.name} failed to send error log to parent: ${getErrorMessage(error)}`);
+        }
+    }
     parentPost(message) {
         if (!parentPort)
             throw new Error(`WorkerServer ${this.name}: parentPort is not available.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/thread",
-  "version": "3.9.3-dev-20260628-8ac730c",
+  "version": "3.9.3-dev-20260629-7c47082",
   "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-8ac730c",
-    "@matterbridge/utils": "3.9.3-dev-20260628-8ac730c",
+    "@matterbridge/types": "3.9.3-dev-20260629-7c47082",
+    "@matterbridge/utils": "3.9.3-dev-20260629-7c47082",
     "@zip.js/zip.js": "2.8.26",
     "node-ansi-logger": "3.3.0"
   }