@matterbridge/thread 3.9.3-dev-20260628-8ac730c → 3.9.3-dev-20260628-fa05360

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,57 @@ 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();
+            }
+            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-20260628-fa05360",
   "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-20260628-fa05360",
+    "@matterbridge/utils": "3.9.3-dev-20260628-fa05360",
     "@zip.js/zip.js": "2.8.26",
     "node-ansi-logger": "3.3.0"
   }