@matterbridge/thread 3.6.1-dev-20260310-6341dee → 3.6.1-dev-20260311-7da5ff8

package/dist/broadcastServer.js

@@ -140,7 +140,7 @@ export class BroadcastServer extends EventEmitter {
         if (message.timestamp === undefined) {
             message.timestamp = Date.now();
         }
-        if (message.dst === this.name || message.dst === 'all') {
+        if (message.dst === this.name) {
             message.dst = message.src;
         }
         message.src = this.name;

package/dist/threadsManager.d.ts

@@ -1,8 +1,10 @@
 import { Worker } from 'node:worker_threads';
+import type { WorkerData } from '@matterbridge/types';
 import { LogLevel } from 'node-ansi-logger';
 export declare class ThreadsManager {
     private debug;
     private verbose;
+    private tracker;
     private log;
     static logLevel: LogLevel;
     private server;
@@ -14,7 +16,7 @@ export declare class ThreadsManager {
     destroy(): void;
     private msgHandler;
     private intervalHandler;
-    runThread(name: string, workerData?: Record<string, boolean | number | string | object>, argv?: string[], env?: NodeJS.ProcessEnv, execArgv?: string[], pipedOutput?: boolean): Worker;
+    runThread(name: string, workerData?: WorkerData, argv?: string[], env?: NodeJS.ProcessEnv, execArgv?: string[], pipedOutput?: boolean): Worker;
     resolvePath(fileName: string): string;
     createESMWorker(name: string, relativePath: string, workerData?: Record<string, boolean | number | string | object>, argv?: string[], env?: NodeJS.ProcessEnv, execArgv?: string[], pipedOutput?: boolean): Worker;
 }

package/dist/threadsManager.js

@@ -10,6 +10,7 @@ import { BroadcastServer } from './broadcastServer.js';
 export class ThreadsManager {
     debug;
     verbose;
+    tracker;
     log;
     static logLevel;
     server;
@@ -25,6 +26,7 @@ export class ThreadsManager {
     constructor(intervalMs = 10_000) {
         this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-threads') || hasParameter('verbose-threads');
         this.verbose = hasParameter('verbose') || hasParameter('verbose-threads');
+        this.tracker = hasParameter('tracker') || hasParameter('tracker-threads');
         this.log = new AnsiLogger({
             logName: 'ThreadsManager',
             logNameColor: MAGENTA,
@@ -97,17 +99,18 @@ export class ThreadsManager {
         if (threadInfo.worker) {
             throw new Error(`Thread ${name} is already running with thread ID ${threadInfo.worker.threadId}`);
         }
-        this.log.info(`Starting thread ${threadInfo.name} from path: ${threadInfo.path} type ${threadInfo.type}...`);
+        const path = this.resolvePath(threadInfo.path);
+        this.log.debug(`Starting thread ${threadInfo.name} from path ${path} type ${threadInfo.type}...`);
         threadInfo.lastStarted = undefined;
         threadInfo.lastStopped = undefined;
         threadInfo.lastDuration = undefined;
-        threadInfo.worker = this.createESMWorker(threadInfo.name, this.resolvePath(threadInfo.path), { ...workerData, debug: this.debug, verbose: this.verbose, logLevel: this.log.logLevel }, argv, env, execArgv, pipedOutput);
+        threadInfo.worker = this.createESMWorker(threadInfo.name, path, { ...workerData, debug: this.debug, verbose: this.verbose, logLevel: this.log.logLevel }, argv, env, execArgv, pipedOutput);
         const worker = threadInfo.worker;
         worker.once('online', () => {
             threadInfo.runCount = (threadInfo.runCount ?? 0) + 1;
             threadInfo.lastStarted = Date.now();
             threadInfo.lastSeen = Date.now();
-            this.log.info(`Thread ${threadInfo.name} is online started at ${new Date(threadInfo.lastStarted).toISOString()} with thread ID ${worker.threadId}`);
+            this.log.debug(`Thread ${threadInfo.name} is online started at ${new Date(threadInfo.lastStarted).toISOString()} with thread id ${worker.threadId}`);
         });
         worker.once('exit', () => {
             const stoppedAt = Date.now();
@@ -115,18 +118,19 @@ export class ThreadsManager {
             threadInfo.lastDuration = Math.max(0, stoppedAt - (threadInfo.lastStarted ?? stoppedAt));
             threadInfo.worker = undefined;
             threadInfo.lastSeen = Date.now();
-            this.log.info(`Thread ${threadInfo.name} has exited at ${new Date(threadInfo.lastStopped).toISOString()} after running for ${threadInfo.lastDuration} ms`);
+            this.log.debug(`Thread ${threadInfo.name} has exited at ${new Date(threadInfo.lastStopped).toISOString()} after running for ${threadInfo.lastDuration} ms`);
         });
         worker.on('message', (message) => {
             threadInfo.lastSeen = Date.now();
-            this.log.info(`Thread ${threadInfo.name} sent a message at ${new Date().toISOString()} after running for ${threadInfo.lastDuration} ms: ${debugStringify(message)}`);
+            if (this.verbose)
+                this.log.debug(`Thread ${threadInfo.name} sent a message at ${new Date().toISOString()}: ${debugStringify(message)}`);
             if (message.type === 'log') {
                 AnsiLogger.create({ logName: threadInfo.name, logNameColor: MAGENTA, logTimestampFormat: 4, logLevel: this.log.logLevel }).log(message.logLevel, message.message);
             }
         });
         worker.on('messageerror', () => {
             threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
-            this.log.error(`Thread ${threadInfo.name} encountered a message error at ${new Date().toISOString()} after running for ${threadInfo.lastDuration} ms`);
+            this.log.error(`Thread ${threadInfo.name} encountered a message error at ${new Date().toISOString()}`);
         });
         worker.once('error', () => {
             threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
@@ -136,7 +140,7 @@ export class ThreadsManager {
             threadInfo.worker = undefined;
             this.log.error(`Thread ${threadInfo.name} encountered an error at ${new Date(threadInfo.lastStopped).toISOString()} after running for ${threadInfo.lastDuration} ms`);
         });
-        this.log.info(`Started thread ${threadInfo.name} from path: ${threadInfo.path} type ${threadInfo.type}...`);
+        this.log.debug(`Started thread ${threadInfo.name} from path ${path} type ${threadInfo.type} with thread id ${worker.threadId}`);
         return threadInfo.worker;
     }
     resolvePath(fileName) {
@@ -154,7 +158,7 @@ export class ThreadsManager {
     createESMWorker(name, relativePath, workerData, argv, env, execArgv, pipedOutput = false) {
         const fileURL = pathToFileURL(resolve(relativePath));
         const options = {
-            workerData: { ...workerData, threadName: name, debug: this.debug, verbose: this.verbose, logLevel: this.log.logLevel },
+            workerData: { ...workerData, threadName: name, debug: this.debug, verbose: this.verbose, logLevel: this.log.logLevel, tracker: this.tracker },
             type: 'module',
             name,
             argv: argv ?? process.argv.slice(2),
@@ -164,7 +168,7 @@ export class ThreadsManager {
             stderr: pipedOutput,
         };
         if (this.verbose)
-            this.log.debug(`Creating ESM Worker ${name} with file URL: ${fileURL.href} and options: ${debugStringify(options)}`);
+            this.log.debug(`Creating ESM Worker ${name} with file URL ${fileURL.href} and options ${debugStringify(options)}`);
         return new Worker(fileURL, options);
     }
 }

package/dist/workerCheckUpdates.js

@@ -1,7 +1,7 @@
 import { inspectError } from '@matterbridge/utils/error';
 import { checkUpdates } from './checkUpdates.js';
 import { WorkerWrapper } from './workerWrapper.js';
-new WorkerWrapper('GlobalPrefix', async (worker) => {
+new WorkerWrapper('CheckUpdates', async (worker) => {
     worker.logger("info", `Starting check updates...`);
     let success = false;
     try {

package/dist/workerSpawnCommand.js

@@ -1,12 +1,29 @@
-import { workerData } from 'node:worker_threads';
+import { isSpawnWorkerData } from '@matterbridge/types';
 import { spawnCommand } from './spawnCommand.js';
 import { WorkerWrapper } from './workerWrapper.js';
-new WorkerWrapper('GlobalPrefix', async (worker) => {
-    worker.logger("info", `Starting spawn command ${workerData.command} with args ${workerData.args.join(' ')} and package command ${workerData.packageCommand} for package ${workerData.packageName}...`);
-    const success = await spawnCommand(workerData.command, workerData.args, workerData.packageCommand, workerData.packageName);
+new WorkerWrapper('SpawnCommand', async (worker) => {
+    if (!isSpawnWorkerData(worker.workerData)) {
+        worker.logger("error", `SpawnCommand invalid parameters`);
+        return false;
+    }
+    worker.logger("info", `Starting spawn command ${worker.workerData.command} with args ${worker.workerData.args.join(' ')} and package command ${worker.workerData.packageCommand} for package ${worker.workerData.packageName}...`);
+    const success = await spawnCommand(worker.workerData.command, worker.workerData.args, worker.workerData.packageCommand, worker.workerData.packageName);
     if (success)
-        worker.logger("info", `Spawn command ${workerData.command} with args ${workerData.args.join(' ')} executed successfully`);
+        worker.logger("info", `Spawn command ${worker.workerData.command} with args ${worker.workerData.args.join(' ')} executed successfully`);
     else
-        worker.logger("error", `Spawn command ${workerData.command} with args ${workerData.args.join(' ')} failed`);
+        worker.logger("error", `Spawn command ${worker.workerData.command} with args ${worker.workerData.args.join(' ')} failed`);
+    worker.server.respond({
+        type: 'manager_spawn_response',
+        src: `manager`,
+        dst: 'all',
+        id: worker.server.getUniqueId(),
+        result: {
+            command: worker.workerData.command,
+            args: worker.workerData.args,
+            packageCommand: worker.workerData.packageCommand,
+            packageName: worker.workerData.packageName,
+            success,
+        },
+    });
     return success;
 });

package/dist/workerWrapper.d.ts

@@ -1,13 +1,17 @@
-import type { ParentPortMessage } from '@matterbridge/types';
+import type { ParentPortMessage, ThreadNames, WorkerData } from '@matterbridge/types';
+import type { Tracker } from '@matterbridge/utils/tracker';
 import { AnsiLogger, LogLevel } from 'node-ansi-logger';
 import { BroadcastServer } from './broadcastServer.js';
 export declare class WorkerWrapper {
-    name: string;
+    name: ThreadNames;
     debug: boolean;
     verbose: boolean;
+    useTracker: boolean;
     log: AnsiLogger;
     server: BroadcastServer;
-    constructor(name: string, callback: (worker: WorkerWrapper) => Promise<boolean>);
+    workerData: WorkerData | null;
+    tracker: Tracker | undefined;
+    constructor(name: ThreadNames, callback: (worker: WorkerWrapper) => Promise<boolean>);
     destroy(success: boolean): void;
     parentPost(message: ParentPortMessage): void;
     parentLog(logName: string | undefined, logLevel: LogLevel, message: string): void;

package/dist/workerWrapper.js

@@ -1,6 +1,8 @@
-import { inspect } from 'node:util';
+if (process.argv.includes('--loader') || process.argv.includes('-loader'))
+    console.log('\u001B[32mWorkerWrapper loaded.\u001B[40;0m');
 import { isMainThread, parentPort, threadId, workerData } from 'node:worker_threads';
 import { hasParameter } from '@matterbridge/utils/cli';
+import { formatBytes } from '@matterbridge/utils/format';
 import { AnsiLogger, debugStringify, MAGENTA } from 'node-ansi-logger';
 import { BroadcastServer } from './broadcastServer.js';
 import { ThreadsManager } from './threadsManager.js';
@@ -8,40 +10,60 @@ export class WorkerWrapper {
     name;
     debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-threads') || hasParameter('verbose-threads');
     verbose = hasParameter('verbose') || hasParameter('verbose-threads');
+    useTracker = hasParameter('tracker') || hasParameter('tracker-threads');
     log;
     server;
+    workerData = workerData;
+    tracker;
     constructor(name, callback) {
         this.name = name;
+        if (this.workerData) {
+            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')
+                .then(({ Tracker }) => {
+                this.tracker = new Tracker(`Thread${this.name}`, this.debug, this.verbose);
+                this.tracker.start();
+                return undefined;
+            })
+                .catch((err) => {
+                if (this.debug)
+                    console.error(`WorkerWrapper ${this.name}: failed to load Tracker`, err);
+                return undefined;
+            });
+        }
         this.log = new AnsiLogger({
-            logName: name,
+            logName: this.name,
             logNameColor: MAGENTA,
             logTimestampFormat: 4,
             logLevel: this.debug ? "debug" : "info",
         });
         this.server = new BroadcastServer('matterbridge', this.log);
-        if (!isMainThread && parentPort) {
+        if (!isMainThread && parentPort && this.workerData) {
             parentPort.on('message', (message) => {
                 if (this.debug)
-                    this.log.debug(`Worker ${workerData.threadName}:${threadId} received message from parent: ${debugStringify(message)}`);
+                    this.log.debug(`Worker ${this.name}:${threadId} received message from parent: ${debugStringify(message)}`);
                 switch (message.type) {
                     case 'ping':
-                        this.parentLog(workerData.threadName, "debug", `Worker ${workerData.threadName}:${threadId} received ping message type from parent: ${debugStringify(message)}`);
-                        this.parentPost({ type: 'pong', threadId, threadName: workerData.threadName });
-                        this.parentLog(workerData.threadName, "debug", `Worker ${workerData.threadName}:${threadId} sent pong message type to parent: ${debugStringify(message)}`);
+                        this.parentLog(this.name, "debug", `Worker ${this.name}:${threadId} received ping message type from parent: ${debugStringify(message)}`);
+                        this.parentPost({ type: 'pong', threadId, threadName: this.name });
+                        this.parentLog(this.name, "debug", `Worker ${this.name}:${threadId} sent pong message type to parent: ${debugStringify(message)}`);
                         break;
                     case 'pong':
-                        this.parentLog(workerData.threadName, "debug", `Worker ${workerData.threadName}:${threadId} received pong message type from parent: ${debugStringify(message)}`);
+                        this.parentLog(this.name, "debug", `Worker ${this.name}:${threadId} received pong message type from parent: ${debugStringify(message)}`);
                         break;
                     default:
-                        this.parentLog(workerData.threadName, "warn", `Worker ${workerData.threadName}:${threadId} received unknown message type from parent: ${debugStringify(message)}`);
+                        this.parentLog(this.name, "warn", `Worker ${this.name}:${threadId} received unknown message type from parent: ${debugStringify(message)}`);
                 }
             });
         }
-        if (!isMainThread && parentPort && workerData) {
-            name = workerData.threadName;
-            this.parentPost({ type: 'init', threadId, threadName: workerData.threadName, success: true });
+        if (!isMainThread && parentPort && this.workerData) {
+            this.parentPost({ type: 'init', threadId, threadName: this.name, memoryUsage: process.memoryUsage(), success: true });
             if (this.debug)
-                this.parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} initialized.`);
+                this.parentLog(this.name, "info", `Worker ${this.name}:${threadId} initialized.`);
         }
         if (this.verbose)
             this.logWorkerInfo(this.log, false);
@@ -51,28 +73,30 @@ export class WorkerWrapper {
         });
     }
     destroy(success) {
+        if (this.tracker)
+            this.tracker.stop();
         this.server.close();
-        if (!isMainThread && parentPort && workerData) {
+        if (!isMainThread && parentPort && this.workerData) {
             if (this.debug)
-                this.parentLog(this.name, "info", `Worker ${workerData.threadName}:${threadId} exiting with success: ${success}.`);
-            this.parentPost({ type: 'exit', threadId, threadName: workerData.threadName, success });
+                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();
         }
     }
     parentPost(message) {
         if (!parentPort)
-            throw new Error(`WorkerServer ${workerData.threadName}: parentPort is not available.`);
+            throw new Error(`WorkerServer ${this.name}: parentPort is not available.`);
         parentPort.postMessage(message);
         if (this.debug)
-            this.log.debug(`Worker ${workerData.threadName}:${threadId} sent message to parent: ${debugStringify(message)}`);
+            this.log.debug(`Worker ${this.name}:${threadId} sent message to parent: ${debugStringify(message)}`);
     }
     parentLog(logName, logLevel, message) {
         if (!parentPort)
-            throw new Error(`WorkerServer ${workerData.threadName}: parentPort is not available.`);
-        const logMessage = { type: 'log', threadId, threadName: workerData.threadName, logName, logLevel, message };
+            throw new Error(`WorkerServer ${this.name}: parentPort is not available.`);
+        const logMessage = { type: 'log', threadId, threadName: this.name, logName, logLevel, message };
         parentPort.postMessage(logMessage);
         if (this.debug)
-            this.log.debug(`Worker ${workerData.threadName}:${threadId} sent log to parent: ${logName} ${logLevel} ${message}`);
+            this.log.debug(`Worker ${this.name}:${threadId} sent log to parent: ${logName} ${logLevel} ${message}`);
     }
     logger(level, message) {
         if (!isMainThread && parentPort)
@@ -81,11 +105,12 @@ export class WorkerWrapper {
             AnsiLogger.create({ logName: this.name, logNameColor: MAGENTA, logTimestampFormat: 4, logLevel: ThreadsManager.logLevel }).log(level, message);
     }
     logWorkerInfo(log, logEnv = false) {
-        log.debug(`${isMainThread ? 'Main thread' : 'Worker thread'}: ${workerData?.threadName}:${threadId} Pid: ${process.pid}`);
+        log.debug(`${isMainThread ? 'Main thread' : 'Worker thread'}: ${this.name}:${threadId} Pid: ${process.pid}`);
         log.debug(`ParentPort: ${parentPort ? 'active' : 'not active'}`);
-        log.debug(`WorkerData: ${workerData ? debugStringify(workerData) : 'none'}`);
+        log.debug(`WorkerData: ${this.workerData ? debugStringify(this.workerData) : 'none'}`);
         const argv = process.argv.slice(2);
         log.debug(`Argv: ${argv.length ? argv.join(' ') : 'none'}`);
-        log.debug(`Env: ${logEnv ? inspect(process.env, true, 10, true) : 'not logged'}`);
+        log.debug(`Env: ${logEnv ? debugStringify(process.env) : 'not logged'}`);
+        log.debug(`Memory: ${formatBytes(process.memoryUsage().heapTotal)} total, ${formatBytes(process.memoryUsage().heapUsed)} used`);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/thread",
-  "version": "3.6.1-dev-20260310-6341dee",
+  "version": "3.6.1-dev-20260311-7da5ff8",
   "description": "Matterbridge thread library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -69,8 +69,8 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@matterbridge/types": "3.6.1-dev-20260310-6341dee",
-    "@matterbridge/utils": "3.6.1-dev-20260310-6341dee",
+    "@matterbridge/types": "3.6.1-dev-20260311-7da5ff8",
+    "@matterbridge/utils": "3.6.1-dev-20260311-7da5ff8",
     "node-ansi-logger": "3.2.0"
   }
 }