@matterbridge/thread 3.9.3-dev-20260629-7c47082 → 3.9.3-dev-20260630-9b4b673

package/dist/checkUpdates.d.ts

@@ -1,7 +1,7 @@
 import type { ApiPlugin, SharedMatterbridge } from '@matterbridge/types';
 import { AnsiLogger } from 'node-ansi-logger';
-import { BroadcastServer } from './broadcastServer.js';
-export declare function checkUpdates(matterbridge: SharedMatterbridge): Promise<void>;
+import type { BroadcastServer } from './broadcastServer.js';
+export declare function checkUpdates(matterbridge: SharedMatterbridge, server: BroadcastServer): Promise<void>;
 export declare function checkUpdatesAndLog(matterbridge: SharedMatterbridge, log: AnsiLogger, server: BroadcastServer): Promise<void>;
 export declare function getMatterbridgeLatestVersion(matterbridge: SharedMatterbridge, log: AnsiLogger, server: BroadcastServer): Promise<string | undefined>;
 export declare function getMatterbridgeDevVersion(matterbridge: SharedMatterbridge, log: AnsiLogger, server: BroadcastServer): Promise<string | undefined>;

package/dist/checkUpdates.js

@@ -4,33 +4,28 @@ 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 noUpdatesAvailable = true;
-export async function checkUpdates(matterbridge) {
+export async function checkUpdates(matterbridge, server) {
     const log = new AnsiLogger({ logName: 'MatterbridgeUpdates', logTimestampFormat: 4, logLevel: matterbridge.logLevel });
-    const server = new BroadcastServer('updates', log);
     noUpdatesAvailable = true;
-    const checkUpdatePromise = checkUpdatesAndLog(matterbridge, log, server);
-    const latestVersionPromise = getMatterbridgeLatestVersion(matterbridge, log, server);
-    const devVersionPromise = getMatterbridgeDevVersion(matterbridge, log, server);
-    const pluginsVersionPromises = [];
-    const pluginsDevVersionPromises = [];
+    let plugins = [];
     try {
-        const plugins = (await server.fetch({ type: 'plugins_apipluginarray', src: server.name, dst: 'plugins' }, 1000)).result.plugins;
-        for (const plugin of plugins) {
-            pluginsVersionPromises.push(getPluginLatestVersion(log, server, plugin));
-            pluginsDevVersionPromises.push(getPluginDevVersion(log, server, plugin));
-        }
+        plugins = (await server.fetch({ type: 'plugins_apipluginarray', src: server.name, dst: 'plugins' }, 1000)).result.plugins;
     }
     catch (error) {
         log.debug(`Error fetching plugins for update check: ${getErrorMessage(error)}`);
     }
-    await Promise.all([checkUpdatePromise, latestVersionPromise, devVersionPromise, ...pluginsVersionPromises, ...pluginsDevVersionPromises]);
+    await checkUpdatesAndLog(matterbridge, log, server);
+    await getMatterbridgeLatestVersion(matterbridge, log, server);
+    await getMatterbridgeDevVersion(matterbridge, log, server);
+    for (const plugin of plugins) {
+        await getPluginLatestVersion(log, server, plugin);
+        await getPluginDevVersion(log, server, plugin);
+    }
     if (noUpdatesAvailable) {
         server.request({ type: 'frontend_snackbarmessage', src: server.name, dst: 'frontend', params: { message: 'No updates available', timeout: 5, severity: 'info' } });
     }
-    server.close();
 }
 export async function checkUpdatesAndLog(matterbridge, log, server) {
     const { getGitHubUpdate } = await import('@matterbridge/utils/github-version');

package/dist/spawnCommand.js

@@ -32,6 +32,7 @@ export async function spawnCommand(command, args, packageCommand, packageName) {
             (command === 'npm' || command === 'bun') &&
             !hasParameter('docker') &&
             !hasParameter('nosudo') &&
+            !isBun() &&
             !process.env.PATH?.includes('/.nvm/versions/node/'))) {
         args.unshift(command === 'npm' && isBun() ? 'bun' : command);
         command = 'sudo';

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}`);
@@ -191,6 +213,7 @@ export class ThreadsManager {
         const candidates = [
             path.join(currentModuleDirectory, fileName),
             path.join(currentModuleDirectory, '..', 'dist', fileName),
+            path.join(currentModuleDirectory, '..', 'src', fileName.replace(/\.js$/, '.ts')),
             path.join(currentModuleDirectory, 'workers', fileName),
         ];
         for (const candidate of candidates) {

package/dist/workerCheckUpdates.js

@@ -8,7 +8,7 @@ export default new WorkerWrapper('CheckUpdates', async (worker) => {
     let success = false;
     try {
         const shared = (await worker.server.fetch({ type: 'matterbridge_shared', src: `matterbridge`, dst: 'matterbridge' }, 5000)).result.data;
-        await checkUpdates(shared);
+        await checkUpdates(shared, worker.server);
         worker.logger("info", `Check updates succeeded`);
         success = true;
     }

package/dist/workerWrapper.js

@@ -124,7 +124,6 @@ export class WorkerWrapper {
             }
             try {
                 parentPort.close();
-                process.exit(success ? 0 : 1);
             }
             catch (error) {
                 this.log.error(`Worker ${this.name}:${threadId} failed to close parentPort: ${getErrorMessage(error)}`);
@@ -146,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-20260629-7c47082",
+  "version": "3.9.3-dev-20260630-9b4b673",
   "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-20260629-7c47082",
-    "@matterbridge/utils": "3.9.3-dev-20260629-7c47082",
+    "@matterbridge/types": "3.9.3-dev-20260630-9b4b673",
+    "@matterbridge/utils": "3.9.3-dev-20260630-9b4b673",
     "@zip.js/zip.js": "2.8.26",
     "node-ansi-logger": "3.3.0"
   }