@matterbridge/thread 3.6.0 → 3.6.1-dev-20260309-6341dee

package/dist/broadcastServer.js

@@ -2,7 +2,8 @@ if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mBroadcastServer loaded.\u001B[40;0m');
 import { EventEmitter } from 'node:events';
 import { BroadcastChannel } from 'node:worker_threads';
-import { hasParameter, logError } from '@matterbridge/utils';
+import { hasParameter } from '@matterbridge/utils/cli';
+import { logError } from '@matterbridge/utils/error';
 import { CYAN, db, debugStringify, er } from 'node-ansi-logger';
 export class BroadcastServer extends EventEmitter {
     name;

package/dist/checkUpdates.js

@@ -1,5 +1,5 @@
 import { plg } from '@matterbridge/types';
-import { isValidString } from '@matterbridge/utils';
+import { isValidString } from '@matterbridge/utils/validate';
 import { AnsiLogger, db, debugStringify, nt, wr } from 'node-ansi-logger';
 import { BroadcastServer } from './broadcastServer.js';
 export async function checkUpdates(matterbridge) {
@@ -24,7 +24,7 @@ export async function checkUpdates(matterbridge) {
     server.close();
 }
 export async function checkUpdatesAndLog(matterbridge, log, server) {
-    const { getGitHubUpdate } = await import('@matterbridge/utils');
+    const { getGitHubUpdate } = await import('@matterbridge/utils/github-version');
     const branch = matterbridge.matterbridgeVersion.includes('-dev-') ? 'dev' : 'main';
     try {
         const updateJson = await getGitHubUpdate(branch, 'update.json', 5_000);
@@ -50,7 +50,7 @@ export async function checkUpdatesAndLog(matterbridge, log, server) {
     }
 }
 export async function getMatterbridgeLatestVersion(matterbridge, log, server) {
-    const { getNpmPackageVersion } = await import('@matterbridge/utils');
+    const { getNpmPackageVersion } = await import('@matterbridge/utils/npm-version');
     try {
         const version = await getNpmPackageVersion('matterbridge');
         server.request({ type: 'matterbridge_latest_version', src: server.name, dst: 'matterbridge', params: { version } });
@@ -75,7 +75,7 @@ export async function getMatterbridgeLatestVersion(matterbridge, log, server) {
     }
 }
 export async function getMatterbridgeDevVersion(matterbridge, log, server) {
-    const { getNpmPackageVersion } = await import('@matterbridge/utils');
+    const { getNpmPackageVersion } = await import('@matterbridge/utils/npm-version');
     try {
         const version = await getNpmPackageVersion('matterbridge', 'dev');
         server.request({ type: 'matterbridge_dev_version', src: server.name, dst: 'matterbridge', params: { version } });
@@ -100,7 +100,7 @@ export async function getMatterbridgeDevVersion(matterbridge, log, server) {
     }
 }
 export async function getPluginLatestVersion(log, server, plugin) {
-    const { getNpmPackageVersion } = await import('@matterbridge/utils');
+    const { getNpmPackageVersion } = await import('@matterbridge/utils/npm-version');
     try {
         const version = await getNpmPackageVersion(plugin.name);
         plugin.latestVersion = version;
@@ -119,7 +119,7 @@ export async function getPluginLatestVersion(log, server, plugin) {
     }
 }
 export async function getPluginDevVersion(log, server, plugin) {
-    const { getNpmPackageVersion } = await import('@matterbridge/utils');
+    const { getNpmPackageVersion } = await import('@matterbridge/utils/npm-version');
     try {
         const version = await getNpmPackageVersion(plugin.name, 'dev');
         plugin.devVersion = version;

package/dist/dockerVersion.js

@@ -1,4 +1,4 @@
-import { isValidString } from '@matterbridge/utils';
+import { isValidString } from '@matterbridge/utils/validate';
 async function httpsGetJson(url, headers, timeoutMs) {
     const https = await import('node:https');
     return new Promise((resolve, reject) => {
@@ -6,7 +6,7 @@ async function httpsGetJson(url, headers, timeoutMs) {
         const timeoutId = setTimeout(() => {
             controller.abort();
             reject(new Error(`Request timed out after ${timeoutMs / 1000} seconds`));
-        }, timeoutMs);
+        }, timeoutMs).unref();
         const req = https.get(url, { headers, signal: controller.signal }, (res) => {
             let data = '';
             const statusCode = res.statusCode ?? 0;

package/dist/export.d.ts

@@ -1,3 +1,3 @@
 export * from './broadcastServer.js';
-export * from './worker.js';
+export * from './threadsManager.js';
 export declare function systemCheck(): Promise<void>;

package/dist/export.js

@@ -1,5 +1,5 @@
 export * from './broadcastServer.js';
-export * from './worker.js';
+export * from './threadsManager.js';
 export async function systemCheck() {
     await import('./workerSystemCheck.js');
 }

package/dist/spawnCommand.d.ts

@@ -0,0 +1 @@
+export declare function spawnCommand(command: string, args: string[], packageCommand?: 'install' | 'uninstall', packageName?: string): Promise<boolean>;

package/dist/spawnCommand.js

@@ -0,0 +1,96 @@
+import { hasParameter } from '@matterbridge/utils/cli';
+import { AnsiLogger } from 'node-ansi-logger';
+import { BroadcastServer } from './broadcastServer.js';
+export async function spawnCommand(command, args, packageCommand, packageName) {
+    const { spawn } = await import('node:child_process');
+    const debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-spawn') || hasParameter('verbose-spawn');
+    const verbose = hasParameter('verbose') || hasParameter('verbose-spawn');
+    const log = new AnsiLogger({ logName: 'Spawn', logTimestampFormat: 4, logLevel: debug ? "debug" : "info" });
+    const server = new BroadcastServer('spawn', log);
+    const sendLog = (name, message) => {
+        try {
+            server.request({ type: 'frontend_logmessage', src: 'spawn', dst: 'frontend', params: { level: 'spawn', time: log.now(), name, message } });
+        }
+        catch (err) {
+            log.debug(`Failed to send log message to frontend: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    if (verbose)
+        log.debug(`Spawning command: ${command} with ${args.join(' ')} ${packageCommand} ${packageName}`);
+    const cmdLine = command + ' ' + args.join(' ');
+    if (process.platform === 'win32' && command === 'npm') {
+        const argstring = 'npm ' + args.join(' ');
+        args.splice(0, args.length, '/c', argstring);
+        command = 'cmd.exe';
+    }
+    if (hasParameter('sudo') ||
+        (process.platform !== 'win32' && command === 'npm' && !hasParameter('docker') && !hasParameter('nosudo') && !process.env.PATH?.includes('/.nvm/versions/node/'))) {
+        args.unshift(command);
+        command = 'sudo';
+    }
+    log.debug(`Spawn command ${command} with ${args.join(' ')}`);
+    const success = await new Promise((resolve) => {
+        if (packageCommand === 'install')
+            sendLog('Matterbridge:spawn-init', `Installing ${packageName}`);
+        else if (packageCommand === 'uninstall')
+            sendLog('Matterbridge:spawn-init', `Uninstalling ${packageName}`);
+        const childProcess = spawn(command, args, {
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        childProcess.on('error', (err) => {
+            log.error(`Failed to start child process "${cmdLine}": ${err.message}`);
+            sendLog('Matterbridge:spawn-exit-error', 'Spawn process error');
+            resolve(false);
+        });
+        childProcess.on('close', (code, signal) => {
+            if (code === 0) {
+                log.debug(`Child process "${cmdLine}" closed with code ${code} and signal ${signal}`);
+                sendLog('Matterbridge:spawn-exit-success', 'Child process closed');
+                resolve(true);
+            }
+            else {
+                log.error(`Child process "${cmdLine}" closed with code ${code} and signal ${signal}`);
+                sendLog('Matterbridge:spawn-exit-error', 'Child process closed');
+                resolve(false);
+            }
+        });
+        childProcess.on('exit', (code, signal) => {
+            if (code === 0) {
+                log.debug(`Child process "${cmdLine}" exited with code ${code} and signal ${signal}`);
+                sendLog('Matterbridge:spawn-exit-success', 'Child process exited');
+                resolve(true);
+            }
+            else {
+                log.error(`Child process "${cmdLine}" exited with code ${code} and signal ${signal}`);
+                sendLog('Matterbridge:spawn-exit-error', 'Child process exited');
+                resolve(false);
+            }
+        });
+        childProcess.on('disconnect', () => {
+            log.debug(`Child process "${cmdLine}" has been disconnected from the parent`);
+            resolve(true);
+        });
+        if (childProcess.stdout) {
+            childProcess.stdout.on('data', (data) => {
+                const message = data.toString().trim();
+                const lines = message.split('\n');
+                for (const line of lines) {
+                    log.debug(`Spawn output (stdout): ${line}`);
+                    sendLog('Matterbridge:spawn', line);
+                }
+            });
+        }
+        if (childProcess.stderr) {
+            childProcess.stderr.on('data', (data) => {
+                const message = data.toString().trim();
+                const lines = message.split('\n');
+                for (const line of lines) {
+                    log.debug(`Spawn verbose (stderr): ${line}`);
+                    sendLog('Matterbridge:spawn', line);
+                }
+            });
+        }
+    });
+    server.close();
+    return success;
+}

package/dist/threadsManager.d.ts

@@ -0,0 +1,20 @@
+import { Worker } from 'node:worker_threads';
+import { LogLevel } from 'node-ansi-logger';
+export declare class ThreadsManager {
+    private debug;
+    private verbose;
+    private log;
+    static logLevel: LogLevel;
+    private server;
+    private readonly boundMsgHandler;
+    private interval;
+    private intervalMs;
+    private threads;
+    constructor(intervalMs?: number);
+    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;
+    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

@@ -0,0 +1,170 @@
+if (process.argv.includes('--loader') || process.argv.includes('-loader'))
+    console.log('\u001B[32mThreadsManager loaded.\u001B[40;0m');
+import fs from 'node:fs';
+import path, { resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import { hasParameter } from '@matterbridge/utils/cli';
+import { AnsiLogger, CYAN, db, debugStringify, MAGENTA } from 'node-ansi-logger';
+import { BroadcastServer } from './broadcastServer.js';
+export class ThreadsManager {
+    debug;
+    verbose;
+    log;
+    static logLevel;
+    server;
+    boundMsgHandler = this.msgHandler.bind(this);
+    interval;
+    intervalMs;
+    threads = [
+        { name: 'CheckUpdates', path: 'workerCheckUpdates.js', type: 'worker' },
+        { name: 'SystemCheck', path: 'workerSystemCheck.js', type: 'worker' },
+        { name: 'GlobalPrefix', path: 'workerGlobalPrefix.js', type: 'worker' },
+        { name: 'SpawnCommand', path: 'workerSpawnCommand.js', type: 'worker' },
+    ];
+    constructor(intervalMs = 10_000) {
+        this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-threads') || hasParameter('verbose-threads');
+        this.verbose = hasParameter('verbose') || hasParameter('verbose-threads');
+        this.log = new AnsiLogger({
+            logName: 'ThreadsManager',
+            logNameColor: MAGENTA,
+            logTimestampFormat: 4,
+            logLevel: this.debug ? "debug" : "info",
+        });
+        ThreadsManager.logLevel = this.log.logLevel;
+        this.server = new BroadcastServer('manager', this.log);
+        this.server.on('broadcast_message', this.boundMsgHandler);
+        this.intervalMs = intervalMs;
+        this.interval = setInterval(this.intervalHandler.bind(this), this.intervalMs);
+        if (this.verbose)
+            this.log.notice(`ThreadsManager initialized. Listening for broadcast messages...`);
+    }
+    destroy() {
+        clearInterval(this.interval);
+        this.server.off('broadcast_message', this.boundMsgHandler);
+        this.server.close();
+        if (this.verbose)
+            this.log.notice(`ThreadsManager destroyed. Broadcast server closed.`);
+    }
+    async msgHandler(msg) {
+        if (this.server.isWorkerRequest(msg) && (msg.dst === 'all' || msg.dst === 'manager')) {
+            if (this.verbose)
+                this.log.debug(`Received broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
+            switch (msg.type) {
+                case 'get_log_level':
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
+                    break;
+                case 'set_log_level':
+                    if (!this.debug) {
+                        this.log.logLevel = msg.params.logLevel;
+                        ThreadsManager.logLevel = msg.params.logLevel;
+                    }
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
+                    break;
+                case 'manager_run':
+                    try {
+                        this.runThread(msg.params.name, msg.params.workerData, msg.params.argv, msg.params.env, msg.params.execArgv, msg.params.pipedOutput);
+                        this.server.respond({ ...msg, result: { success: true } });
+                    }
+                    catch (err) {
+                        this.log.error(`Failed to run thread ${CYAN}${msg.params.name}${db}: ${err.message}`);
+                        this.server.respond({ ...msg, result: { success: false } });
+                    }
+                    break;
+                default:
+                    if (this.verbose)
+                        this.log.debug(`Unknown broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}`);
+            }
+        }
+    }
+    intervalHandler() {
+        this.log.debug(`Threads status:\n${this.threads.map((t) => `${t.name} running: ${t.worker ? 'yes' : 'no'}, lastSeen: ${t.lastSeen ? new Date(t.lastSeen).toISOString() : 'never'}, runs: ${t.runCount ?? 0}, errors: ${t.errorCount ?? 0}`).join('\n')}`);
+        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 };
+                thread.worker.postMessage(msg);
+            }
+            if (thread.worker && Date.now() - (thread.lastSeen || 0) > this.intervalMs * 2) {
+                this.log.warn(`Thread ${CYAN}${thread.name}${db} has not been seen for more than ${this.intervalMs * 2} ms. It may be unresponsive.`);
+            }
+        }
+    }
+    runThread(name, workerData, argv, env, execArgv, pipedOutput = false) {
+        const threadInfo = this.threads.find((t) => t.name === name);
+        if (!threadInfo) {
+            throw new Error(`Thread ${name} not found`);
+        }
+        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}...`);
+        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);
+        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}`);
+        });
+        worker.once('exit', () => {
+            const stoppedAt = Date.now();
+            threadInfo.lastStopped = stoppedAt;
+            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`);
+        });
+        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 (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`);
+        });
+        worker.once('error', () => {
+            threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
+            const stoppedAt = Date.now();
+            threadInfo.lastStopped = stoppedAt;
+            threadInfo.lastDuration = Math.max(0, stoppedAt - (threadInfo.lastStarted ?? stoppedAt));
+            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}...`);
+        return threadInfo.worker;
+    }
+    resolvePath(fileName) {
+        const currentModuleDirectory = path.dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+            path.join(currentModuleDirectory, fileName),
+            path.join(currentModuleDirectory, '..', 'dist', fileName),
+        ];
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        return candidates[0];
+    }
+    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 },
+            type: 'module',
+            name,
+            argv: argv ?? process.argv.slice(2),
+            env: env ?? process.env,
+            execArgv,
+            stdout: pipedOutput,
+            stderr: pipedOutput,
+        };
+        if (this.verbose)
+            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,41 +1,18 @@
-import { isMainThread, parentPort, threadId, workerData } from 'node:worker_threads';
-import { hasParameter, inspectError } from '@matterbridge/utils';
-import { AnsiLogger, MAGENTA } from 'node-ansi-logger';
-import { BroadcastServer } from './broadcastServer.js';
+import { inspectError } from '@matterbridge/utils/error';
 import { checkUpdates } from './checkUpdates.js';
-import { logWorkerInfo, parentLog, parentPost, threadLogger } from './worker.js';
-const debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-worker') || hasParameter('verbose-worker');
-const verbose = hasParameter('verbose') || hasParameter('verbose-worker');
-const name = 'MatterbridgeCheckUpdates';
-if (!isMainThread && parentPort) {
-    parentPost({ type: 'init', threadId, threadName: workerData.threadName, success: true });
-    if (debug)
-        parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} initialized.`);
-}
-const log = new AnsiLogger({
-    logName: name,
-    logNameColor: MAGENTA,
-    logTimestampFormat: 4,
-    logLevel: debug ? "debug" : "info",
+import { WorkerWrapper } from './workerWrapper.js';
+new WorkerWrapper('GlobalPrefix', async (worker) => {
+    worker.logger("info", `Starting check updates...`);
+    let success = false;
+    try {
+        const shared = (await worker.server.fetch({ type: 'matterbridge_shared', src: `matterbridge`, dst: 'matterbridge' }, 5000)).result.data;
+        await checkUpdates(shared);
+        worker.logger("info", `Check updates succeeded`);
+        success = true;
+    }
+    catch (error) {
+        const errorMessage = inspectError(worker.log, `Failed to check updates`, error);
+        worker.logger("error", errorMessage);
+    }
+    return success;
 });
-const server = new BroadcastServer('matterbridge', log);
-if (verbose)
-    logWorkerInfo(log, verbose);
-threadLogger(name, "info", `Starting check updates...`);
-let success = false;
-try {
-    const shared = (await server.fetch({ type: 'matterbridge_shared', src: `matterbridge`, dst: 'matterbridge' }, 1000)).result.data;
-    await checkUpdates(shared);
-    threadLogger(name, "info", `Check updates succeeded`);
-    success = true;
-}
-catch (error) {
-    const errorMessage = inspectError(log, `Failed to check updates`, error);
-    threadLogger(name, "error", errorMessage);
-}
-server.close();
-if (!isMainThread && parentPort) {
-    parentPost({ type: 'exit', threadId, threadName: workerData.threadName, success });
-    if (debug)
-        parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} exiting with success: ${success}.`);
-}

package/dist/workerGlobalPrefix.js

@@ -1,41 +1,19 @@
-import { isMainThread, parentPort, threadId, workerData } from 'node:worker_threads';
-import { getGlobalNodeModules, hasParameter, inspectError } from '@matterbridge/utils';
-import { AnsiLogger, MAGENTA } from 'node-ansi-logger';
-import { BroadcastServer } from './broadcastServer.js';
-import { logWorkerInfo, parentLog, parentPost, threadLogger } from './worker.js';
-const debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-worker') || hasParameter('verbose-worker');
-const verbose = hasParameter('verbose') || hasParameter('verbose-worker');
-const name = 'MatterbridgeGlobalPrefix';
-if (!isMainThread && parentPort) {
-    parentPost({ type: 'init', threadId, threadName: workerData.threadName, success: true });
-    if (debug)
-        parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} initialized.`);
-}
-const log = new AnsiLogger({
-    logName: name,
-    logNameColor: MAGENTA,
-    logTimestampFormat: 4,
-    logLevel: debug ? "debug" : "info",
+import { inspectError } from '@matterbridge/utils/error';
+import { getGlobalNodeModules } from '@matterbridge/utils/npm-prefix';
+import { WorkerWrapper } from './workerWrapper.js';
+new WorkerWrapper('GlobalPrefix', async (worker) => {
+    let prefix;
+    worker.logger("info", `Starting global prefix check...`);
+    let success = false;
+    try {
+        prefix = await getGlobalNodeModules();
+        worker.server.request({ type: 'matterbridge_global_prefix', src: `matterbridge`, dst: 'matterbridge', params: { prefix } });
+        worker.logger("info", `Global node_modules directory: ${prefix}`);
+        success = true;
+    }
+    catch (error) {
+        const errorMessage = inspectError(worker.log, `Failed to get global node modules`, error);
+        worker.logger("error", errorMessage);
+    }
+    return success;
 });
-const server = new BroadcastServer('matterbridge', log);
-if (verbose)
-    logWorkerInfo(log, verbose);
-let prefix;
-threadLogger(name, "info", `Starting global prefix check...`);
-let success = false;
-try {
-    prefix = await getGlobalNodeModules();
-    server.request({ type: 'matterbridge_global_prefix', src: `matterbridge`, dst: 'matterbridge', params: { prefix } });
-    threadLogger(name, "info", `Global node_modules directory: ${prefix}`);
-    success = true;
-}
-catch (error) {
-    const errorMessage = inspectError(log, `Failed to get global node modules`, error);
-    threadLogger(name, "error", errorMessage);
-}
-server.close();
-if (!isMainThread && parentPort) {
-    parentPost({ type: 'exit', threadId, threadName: workerData.threadName, success });
-    if (debug)
-        parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} exiting with success: ${success}.`);
-}

package/dist/workerSpawnCommand.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workerSpawnCommand.js

@@ -0,0 +1,12 @@
+import { workerData } from 'node:worker_threads';
+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);
+    if (success)
+        worker.logger("info", `Spawn command ${workerData.command} with args ${workerData.args.join(' ')} executed successfully`);
+    else
+        worker.logger("error", `Spawn command ${workerData.command} with args ${workerData.args.join(' ')} failed`);
+    return success;
+});

package/dist/workerSystemCheck.js

@@ -1,84 +1,62 @@
 import os from 'node:os';
-import { isMainThread, parentPort, threadId, workerData } from 'node:worker_threads';
-import { excludedInterfaceNamePattern, hasParameter, inspectError } from '@matterbridge/utils';
-import { AnsiLogger, MAGENTA } from 'node-ansi-logger';
-import { BroadcastServer } from './broadcastServer.js';
-import { logWorkerInfo, parentLog, parentPost, threadLogger } from './worker.js';
-const debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-worker') || hasParameter('verbose-worker');
-const verbose = hasParameter('verbose') || hasParameter('verbose-worker');
-const name = 'MatterbridgeSystemCheck';
-if (!isMainThread && parentPort) {
-    parentPost({ type: 'init', threadId, threadName: workerData.threadName, success: true });
-    if (debug)
-        parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} initialized.`);
-}
-const log = new AnsiLogger({
-    logName: name,
-    logNameColor: MAGENTA,
-    logTimestampFormat: 4,
-    logLevel: debug ? "debug" : "info",
-});
-const server = new BroadcastServer('matterbridge', log);
-if (verbose)
-    logWorkerInfo(log, verbose);
-threadLogger(name, "info", `Starting system check...`);
-let success = false;
-try {
-    const shared = (await server.fetch({ type: 'matterbridge_shared', src: `matterbridge`, dst: 'matterbridge' }, 1000)).result.data;
-    if (process.env.NVM_BIN && process.env.NVM_DIR)
-        threadLogger(name, "error", `NVM is a development tool and is not supported in production. Please install node from https://github.com/nodesource/distributions.`);
-    const nodeVersion = process.versions.node;
-    const versionMajor = parseInt(nodeVersion.split('.')[0]);
-    const versionMinor = parseInt(nodeVersion.split('.')[1]);
-    const versionPatch = parseInt(nodeVersion.split('.')[2]);
-    threadLogger(name, "debug", `Node.js Version: ${versionMajor}.${versionMinor}.${versionPatch}`);
-    if (versionMajor === 20 && versionMinor < 19)
-        threadLogger(name, "error", `Node.js version < 20.19.0 is not supported. Please upgrade to Node.js LTS version (24.x).`);
-    if (versionMajor === 22 && versionMinor < 13)
-        threadLogger(name, "error", `Node.js version < 22.13.0 is not supported. Please upgrade to Node.js LTS version (24.x).`);
-    if (versionMajor === 21 || versionMajor === 23 || versionMajor === 25)
-        threadLogger(name, "error", `Node.js odd major versions are not supported. Please upgrade to Node.js LTS version (24.x).`);
-    if (versionMajor !== 24)
-        threadLogger(name, "notice", `You are running Node.js ${versionMajor}.${versionMinor}.${versionPatch}. Please consider upgrading to Node.js LTS version (24.x).`);
-    const networkInterfaces = os.networkInterfaces();
-    let foundInternal = false;
-    let foundExternal = false;
-    let foundIpv4 = false;
-    let foundIpv6 = false;
-    for (const [interfaceName, interfaceDetails] of Object.entries(networkInterfaces)) {
-        if (!shared.mdnsInterface && excludedInterfaceNamePattern.test(interfaceName))
-            threadLogger(name, "warn", `Found network interface '${interfaceName}'. Please use --mdnsinterface parameter to specify the correct local interface for mDNS.`);
-        if (excludedInterfaceNamePattern.test(interfaceName))
-            continue;
-        for (const detail of interfaceDetails || []) {
-            if (detail.internal)
-                foundInternal = true;
-            if (!detail.internal)
-                foundExternal = true;
-            if (detail.family === 'IPv4' && !detail.internal && foundIpv4 === false)
-                foundIpv4 = true;
-            if (detail.family === 'IPv6' && !detail.internal && foundIpv6 === false)
-                foundIpv6 = true;
+import { inspectError } from '@matterbridge/utils/error';
+import { excludedInterfaceNamePattern } from '@matterbridge/utils/network';
+import { WorkerWrapper } from './workerWrapper.js';
+new WorkerWrapper('SystemCheck', async (worker) => {
+    worker.logger("info", `Starting system check...`);
+    let success = false;
+    try {
+        const shared = (await worker.server.fetch({ type: 'matterbridge_shared', src: `matterbridge`, dst: 'matterbridge' }, 1000)).result.data;
+        if (process.env.NVM_BIN && process.env.NVM_DIR)
+            worker.logger("error", `NVM is a development tool and is not supported in production. Please install node from https://github.com/nodesource/distributions.`);
+        const nodeVersion = process.versions.node;
+        const versionMajor = parseInt(nodeVersion.split('.')[0]);
+        const versionMinor = parseInt(nodeVersion.split('.')[1]);
+        const versionPatch = parseInt(nodeVersion.split('.')[2]);
+        worker.logger("debug", `Node.js Version: ${versionMajor}.${versionMinor}.${versionPatch}`);
+        if (versionMajor === 20 && versionMinor < 19)
+            worker.logger("error", `Node.js version < 20.19.0 is not supported. Please upgrade to Node.js LTS version (24.x).`);
+        if (versionMajor === 22 && versionMinor < 13)
+            worker.logger("error", `Node.js version < 22.13.0 is not supported. Please upgrade to Node.js LTS version (24.x).`);
+        if (versionMajor === 21 || versionMajor === 23 || versionMajor === 25)
+            worker.logger("error", `Node.js odd major versions are not supported. Please upgrade to Node.js LTS version (24.x).`);
+        if (versionMajor !== 24)
+            worker.logger("notice", `You are running Node.js ${versionMajor}.${versionMinor}.${versionPatch}. Please consider upgrading to Node.js LTS version (24.x).`);
+        const networkInterfaces = os.networkInterfaces();
+        let foundInternal = false;
+        let foundExternal = false;
+        let foundIpv4 = false;
+        let foundIpv6 = false;
+        for (const [interfaceName, interfaceDetails] of Object.entries(networkInterfaces)) {
+            if (!shared.mdnsInterface && excludedInterfaceNamePattern.test(interfaceName))
+                worker.logger("warn", `Found network interface '${interfaceName}'. Please use --mdnsinterface parameter to specify the correct local interface for mDNS.`);
+            if (excludedInterfaceNamePattern.test(interfaceName))
+                continue;
+            for (const detail of interfaceDetails || []) {
+                if (detail.internal)
+                    foundInternal = true;
+                if (!detail.internal)
+                    foundExternal = true;
+                if (detail.family === 'IPv4' && !detail.internal && foundIpv4 === false)
+                    foundIpv4 = true;
+                if (detail.family === 'IPv6' && !detail.internal && foundIpv6 === false)
+                    foundIpv6 = true;
+            }
         }
+        if (!foundInternal)
+            worker.logger("error", `No internal network interface found. Check your network configuration.`);
+        if (!foundExternal)
+            worker.logger("error", `No external network interface found. Check your network configuration.`);
+        if (!foundIpv4)
+            worker.logger("error", `No IPv4 network interface found. Check your network configuration.`);
+        if (!foundIpv6)
+            worker.logger("error", `No IPv6 network interface found. Check your network configuration.`);
+        worker.logger("info", `System check succeeded`);
+        success = true;
+    }
+    catch (error) {
+        const errorMessage = inspectError(worker.log, `Failed to perform system check`, error);
+        worker.logger("error", errorMessage);
     }
-    if (!foundInternal)
-        threadLogger(name, "error", `No internal network interface found. Check your network configuration.`);
-    if (!foundExternal)
-        threadLogger(name, "error", `No external network interface found. Check your network configuration.`);
-    if (!foundIpv4)
-        threadLogger(name, "error", `No IPv4 network interface found. Check your network configuration.`);
-    if (!foundIpv6)
-        threadLogger(name, "error", `No IPv6 network interface found. Check your network configuration.`);
-    threadLogger(name, "info", `System check succeeded`);
-    success = true;
-}
-catch (error) {
-    const errorMessage = inspectError(log, `Failed to perform system check`, error);
-    threadLogger(name, "error", errorMessage);
-}
-server.close();
-if (!isMainThread && parentPort) {
-    parentPost({ type: 'exit', threadId, threadName: workerData.threadName, success });
-    if (debug)
-        parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} exiting with success: ${success}.`);
-}
+    return success;
+});

package/dist/workerWrapper.d.ts

@@ -0,0 +1,16 @@
+import type { ParentPortMessage } from '@matterbridge/types';
+import { AnsiLogger, LogLevel } from 'node-ansi-logger';
+import { BroadcastServer } from './broadcastServer.js';
+export declare class WorkerWrapper {
+    name: string;
+    debug: boolean;
+    verbose: boolean;
+    log: AnsiLogger;
+    server: BroadcastServer;
+    constructor(name: string, callback: (worker: WorkerWrapper) => Promise<boolean>);
+    destroy(success: boolean): void;
+    parentPost(message: ParentPortMessage): void;
+    parentLog(logName: string | undefined, logLevel: LogLevel, message: string): void;
+    logger(level: LogLevel, message: string): void;
+    logWorkerInfo(log: AnsiLogger, logEnv?: boolean): void;
+}

package/dist/workerWrapper.js

@@ -0,0 +1,91 @@
+import { inspect } from 'node:util';
+import { isMainThread, parentPort, threadId, workerData } from 'node:worker_threads';
+import { hasParameter } from '@matterbridge/utils/cli';
+import { AnsiLogger, debugStringify, MAGENTA } from 'node-ansi-logger';
+import { BroadcastServer } from './broadcastServer.js';
+import { ThreadsManager } from './threadsManager.js';
+export class WorkerWrapper {
+    name;
+    debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-threads') || hasParameter('verbose-threads');
+    verbose = hasParameter('verbose') || hasParameter('verbose-threads');
+    log;
+    server;
+    constructor(name, callback) {
+        this.name = name;
+        this.log = new AnsiLogger({
+            logName: name,
+            logNameColor: MAGENTA,
+            logTimestampFormat: 4,
+            logLevel: this.debug ? "debug" : "info",
+        });
+        this.server = new BroadcastServer('matterbridge', this.log);
+        if (!isMainThread && parentPort) {
+            parentPort.on('message', (message) => {
+                if (this.debug)
+                    this.log.debug(`Worker ${workerData.threadName}:${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)}`);
+                        break;
+                    case 'pong':
+                        this.parentLog(workerData.threadName, "debug", `Worker ${workerData.threadName}:${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)}`);
+                }
+            });
+        }
+        if (!isMainThread && parentPort && workerData) {
+            name = workerData.threadName;
+            this.parentPost({ type: 'init', threadId, threadName: workerData.threadName, success: true });
+            if (this.debug)
+                this.parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} initialized.`);
+        }
+        if (this.verbose)
+            this.logWorkerInfo(this.log, false);
+        setImmediate(async () => {
+            const success = await callback(this);
+            this.destroy(success);
+        });
+    }
+    destroy(success) {
+        this.server.close();
+        if (!isMainThread && parentPort && 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 });
+            parentPort.close();
+        }
+    }
+    parentPost(message) {
+        if (!parentPort)
+            throw new Error(`WorkerServer ${workerData.threadName}: parentPort is not available.`);
+        parentPort.postMessage(message);
+        if (this.debug)
+            this.log.debug(`Worker ${workerData.threadName}:${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 };
+        parentPort.postMessage(logMessage);
+        if (this.debug)
+            this.log.debug(`Worker ${workerData.threadName}:${threadId} sent log to parent: ${logName} ${logLevel} ${message}`);
+    }
+    logger(level, message) {
+        if (!isMainThread && parentPort)
+            this.parentLog(this.name, level, message);
+        else
+            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(`ParentPort: ${parentPort ? 'active' : 'not active'}`);
+        log.debug(`WorkerData: ${workerData ? debugStringify(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'}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/thread",
-  "version": "3.6.0",
+  "version": "3.6.1-dev-20260309-6341dee",
   "description": "Matterbridge thread library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -49,6 +49,14 @@
     ".": {
       "types": "./dist/export.d.ts",
       "import": "./dist/export.js"
+    },
+    "./server": {
+      "types": "./dist/broadcastServer.d.ts",
+      "import": "./dist/broadcastServer.js"
+    },
+    "./manager": {
+      "types": "./dist/threadsManager.d.ts",
+      "import": "./dist/threadsManager.js"
     }
   },
   "engines": {
@@ -61,8 +69,8 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@matterbridge/types": "3.6.0",
-    "@matterbridge/utils": "3.6.0",
+    "@matterbridge/types": "3.6.1-dev-20260309-6341dee",
+    "@matterbridge/utils": "3.6.1-dev-20260309-6341dee",
     "node-ansi-logger": "3.2.0"
   }
 }

package/dist/worker.d.ts

@@ -1,8 +0,0 @@
-import { Worker } from 'node:worker_threads';
-import type { ParentPortMessage } from '@matterbridge/types';
-import { AnsiLogger, LogLevel } from 'node-ansi-logger';
-export declare function parentPost(message: ParentPortMessage): void;
-export declare function parentLog(logName: string | undefined, logLevel: LogLevel, message: string): void;
-export declare function threadLogger(threadName: string, level: LogLevel, message: string): void;
-export declare function createESMWorker(name: string, relativePath: string, workerData?: Record<string, boolean | number | string | object>, argv?: string[], env?: NodeJS.ProcessEnv, execArgv?: string[], pipedOutput?: boolean): Worker;
-export declare function logWorkerInfo(log: AnsiLogger, logEnv?: boolean): void;

package/dist/worker.js

@@ -1,53 +0,0 @@
-import { resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { inspect } from 'node:util';
-import { isMainThread, parentPort, threadId, Worker, workerData } from 'node:worker_threads';
-import { hasParameter } from '@matterbridge/utils';
-import { AnsiLogger, debugStringify, MAGENTA } from 'node-ansi-logger';
-const debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-worker') || hasParameter('verbose-worker');
-const verbose = hasParameter('verbose') || hasParameter('verbose-worker');
-const log = new AnsiLogger({ logName: 'Worker', logNameColor: MAGENTA, logTimestampFormat: 4, logLevel: debug ? "debug" : "info" });
-export function parentPost(message) {
-    if (!parentPort)
-        throw new Error(`WorkerServer ${workerData.threadName}: parentPort is not available.`);
-    parentPort.postMessage(message);
-    if (debug)
-        log.debug(`Worker ${workerData.threadName}:${threadId} sent message to parent: ${debugStringify(message)}`);
-}
-export function 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 };
-    parentPort.postMessage(logMessage);
-    if (debug)
-        log.debug(`Worker ${workerData.threadName}:${threadId} sent log to parent: ${logName} ${logLevel} ${message}`);
-}
-export function threadLogger(threadName, level, message) {
-    AnsiLogger.create({ logName: threadName, logNameColor: MAGENTA, logTimestampFormat: 4, logLevel: level }).log(level, message);
-    if (!isMainThread && parentPort)
-        parentLog(threadName, level, message);
-}
-export function createESMWorker(name, relativePath, workerData, argv, env, execArgv, pipedOutput = false) {
-    const fileURL = pathToFileURL(resolve(relativePath));
-    const options = {
-        workerData: { ...workerData, threadName: name },
-        type: 'module',
-        name,
-        argv: argv ?? process.argv.slice(2),
-        env: env ?? process.env,
-        execArgv,
-        stdout: pipedOutput,
-        stderr: pipedOutput,
-    };
-    if (verbose)
-        log.debug(`Creating ESM Worker ${name} with file URL: ${fileURL.href} and options: ${debugStringify(options)}`);
-    return new Worker(fileURL, options);
-}
-export function logWorkerInfo(log, logEnv = false) {
-    log.debug(`${isMainThread ? 'Main thread' : 'Worker thread'}: ${workerData?.threadName}:${threadId} Pid: ${process.pid}`);
-    log.debug(`ParentPort: ${parentPort ? 'active' : 'not active'}`);
-    log.debug(`WorkerData: ${workerData ? inspect(workerData, true, 10, true) : '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'}`);
-}