@matterbridge/thread 3.10.13-dev-20261007-320f739 → 3.10.13-dev-20261008-55d98fb

package/dist/threadsManager.d.ts

@@ -11,11 +11,13 @@ export declare class ThreadsManager {
     private readonly boundMsgHandler;
     private interval;
     private intervalMs;
+    private readonly coreDirectory;
     private threads;
     private terminateWorkers;
-    constructor(intervalMs?: number);
+    constructor(coreDirectory: string, intervalMs?: number);
     destroy(): void;
     private msgHandler;
+    private sendShutdown;
     private terminateExitedWorkers;
     private intervalHandler;
     runThread(name: string, workerData?: WorkerData, argv?: string[], env?: NodeJS.ProcessEnv, execArgv?: string[], pipedOutput?: boolean): Worker;

package/dist/threadsManager.js

@@ -19,6 +19,7 @@ export class ThreadsManager {
     boundMsgHandler = this.msgHandler.bind(this);
     interval;
     intervalMs;
+    coreDirectory;
     threads = [
         { name: 'CheckUpdates', path: 'workerCheckUpdates.js', type: 'worker' },
         { name: 'SystemCheck', path: 'workerSystemCheck.js', type: 'worker' },
@@ -27,9 +28,11 @@ export class ThreadsManager {
         { name: 'ArchiveCommand', path: 'workerArchiveCommand.js', type: 'worker' },
         { name: 'DockerVersion', path: 'workerDockerVersion.js', type: 'worker' },
         { name: 'Backend', path: 'threadBackend.js', type: 'thread' },
+        { name: 'RootNode', path: 'threadRootNode.js', type: 'thread', multiple: true },
+        { name: 'Tracker', path: 'threadTracker.js', type: 'thread', multiple: true, startup: true, shutdown: true },
     ];
     terminateWorkers = new Set();
-    constructor(intervalMs = 60_000) {
+    constructor(coreDirectory, intervalMs = 60_000) {
         this.debug = hasAnyParameter('debug', 'verbose', 'debug-threads', 'verbose-threads');
         this.verbose = hasAnyParameter('verbose', 'verbose-threads');
         this.tracker = hasAnyParameter('tracker', 'tracker-threads');
@@ -44,6 +47,7 @@ export class ThreadsManager {
         this.server = new BroadcastServer('manager', this.log);
         this.server.on('broadcast_message', this.boundMsgHandler);
         this.intervalMs = intervalMs;
+        this.coreDirectory = coreDirectory;
         this.interval = setInterval(this.intervalHandler.bind(this), this.intervalMs);
         if (this.verbose)
             this.log.notice(`ThreadsManager initialized. Listening for broadcast messages...`);
@@ -51,6 +55,7 @@ export class ThreadsManager {
     destroy() {
         clearInterval(this.interval);
         this.terminateExitedWorkers();
+        this.sendShutdown(this.threads.filter((t) => t.shutdown));
         this.server.off('broadcast_message', this.boundMsgHandler);
         this.server.close();
         if (this.verbose)
@@ -81,12 +86,31 @@ export class ThreadsManager {
                         this.server.respond({ ...msg, result: { success: false } });
                     }
                     break;
+                case 'manager_shutdown': {
+                    const threads = msg.params.thread === undefined ? this.threads : this.threads.filter((t) => t.name === msg.params.thread);
+                    if (threads.length === 0)
+                        this.log.warn(`Failed to shut down thread ${CYAN}${msg.params.thread}${wr}: thread not found`);
+                    this.sendShutdown(threads);
+                    this.server.respond({ ...msg, result: { success: threads.length > 0 } });
+                    break;
+                }
                 default:
                     if (this.verbose)
                         this.log.debug(`Unknown broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}`);
             }
         }
     }
+    sendShutdown(threads) {
+        for (const thread of threads) {
+            for (const info of [thread, ...(thread.instances ?? [])]) {
+                if (!info.worker)
+                    continue;
+                const shutdownMessage = { type: 'shutdown', threadName: thread.name, threadId: info.worker.threadId };
+                info.worker.postMessage(shutdownMessage);
+                this.log.debug(`Thread ${thread.name} sent shutdown message to thread id ${info.worker.threadId}`);
+            }
+        }
+    }
     terminateExitedWorkers() {
         if (this.terminateWorkers.size > 0) {
             this.log.debug(`Terminating ${this.terminateWorkers.size} workers that have exited...`);
@@ -104,16 +128,26 @@ export class ThreadsManager {
     }
     intervalHandler() {
         for (const thread of this.threads) {
-            this.log.debug(`Thread ${thread.name} running: ${thread.worker ? 'yes' : 'no'}, threadId: ${thread.worker?.threadId ?? 'none'}, lastSeen: ${thread.lastSeen ? new Date(thread.lastSeen).toISOString() : 'never'}, runs: ${thread.runCount ?? 0}, errors: ${thread.errorCount ?? 0}`);
+            if (!thread.multiple) {
+                this.log.debug(`Thread ${thread.name} running: ${thread.worker ? 'yes' : 'no'}, threadId: ${thread.worker?.threadId ?? 'none'}, lastSeen: ${thread.lastSeen ? new Date(thread.lastSeen).toISOString() : 'never'}, runs: ${thread.runCount ?? 0}, errors: ${thread.errorCount ?? 0}`);
+                continue;
+            }
+            const instances = thread.instances ?? [];
+            this.log.debug(`Thread ${thread.name} instances: ${instances.length}, running: ${instances.filter((instance) => instance.worker).length}, runs: ${thread.runCount ?? 0}, errors: ${thread.errorCount ?? 0}`);
+            instances.forEach((instance, index) => {
+                this.log.debug(`- instance ${index} running: ${instance.worker ? 'yes' : 'no'}, threadId: ${instance.worker?.threadId ?? 'none'}, lastSeen: ${instance.lastSeen ? new Date(instance.lastSeen).toISOString() : 'never'}, lastStarted: ${instance.lastStarted ? new Date(instance.lastStarted).toISOString() : 'never'}, lastStopped: ${instance.lastStopped ? new Date(instance.lastStopped).toISOString() : 'never'}, lastDuration: ${instance.lastDuration ?? 'none'} ms`);
+            });
         }
         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 };
-                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.`);
+            for (const info of [thread, ...(thread.instances ?? [])]) {
+                if (info.worker && Date.now() - (info.lastSeen ?? 0) > this.intervalMs) {
+                    const msg = { type: 'ping', threadId: info.worker.threadId, threadName: thread.name };
+                    info.worker.postMessage(msg);
+                }
+                if (info.worker && Date.now() - (info.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.`);
+                }
             }
         }
     }
@@ -122,76 +156,100 @@ export class ThreadsManager {
         if (!threadInfo) {
             throw new Error(`Thread ${name} not found`);
         }
-        if (threadInfo.worker) {
+        if (threadInfo.worker && !threadInfo.multiple) {
             throw new Error(`Thread ${name} is already running with thread ID ${threadInfo.worker.threadId}`);
         }
         const path = this.resolvePath(threadInfo.path);
         if (!fs.existsSync(path)) {
             throw new Error(`Thread ${name} file not found at path ${path}`);
         }
-        this.log.debug(`Starting thread ${threadInfo.name} from path ${path} type ${threadInfo.type}...`);
+        this.log.debug(`Starting thread ${threadInfo.name} from path ${path} type ${threadInfo.type}${threadInfo.multiple ? ` instances: ${threadInfo.instances?.length}` : ''}...`);
         threadInfo.lastStarted = undefined;
         threadInfo.lastStopped = undefined;
         threadInfo.lastDuration = undefined;
-        threadInfo.worker = this.createESMWorker(threadInfo.name, path, { ...workerData, type: threadInfo.type, debug: this.debug, verbose: this.verbose, logLevel: this.log.logLevel }, argv, env, execArgv, pipedOutput);
-        const worker = threadInfo.worker;
+        const worker = this.createESMWorker(threadInfo.name, path, { ...workerData, type: threadInfo.type, debug: this.debug, verbose: this.verbose, tracker: this.tracker, logLevel: this.log.logLevel }, argv, env, execArgv, pipedOutput);
+        if (threadInfo.multiple) {
+            threadInfo.instances ??= [];
+            threadInfo.instances.push({ worker });
+        }
+        else
+            threadInfo.worker = worker;
         worker.once('online', () => {
             const now = Date.now();
+            const info = [threadInfo, ...(threadInfo.instances ?? [])].find((info) => info.worker === worker);
+            if (info) {
+                info.lastSeen = now;
+                info.lastStarted = now;
+            }
             this.log.debug(`Thread ${threadInfo.name} is online at ${new Date(now).toISOString()}`);
         });
         worker.once('exit', () => {
             const now = Date.now();
-            if (threadInfo.worker === worker) {
-                threadInfo.lastSeen = now;
-                threadInfo.lastStopped = now;
-                threadInfo.lastDuration = Math.max(0, now - (threadInfo.lastStarted ?? now));
-                threadInfo.worker = undefined;
+            const info = [threadInfo, ...(threadInfo.instances ?? [])].find((info) => info.worker === worker);
+            if (info) {
+                info.lastSeen = now;
+                info.lastStopped = now;
+                info.lastDuration = Math.max(0, now - (info.lastStarted ?? now));
+                info.worker = undefined;
             }
-            this.log.debug(`Thread ${threadInfo.name} has exited at ${new Date(now).toISOString()}`);
+            this.log.debug(`Thread ${threadInfo.name} has exited at ${new Date(now).toISOString()} after ${info?.lastDuration ?? 0} ms`);
             this.terminateWorkers.delete(worker);
         });
         worker.on('message', (message) => {
             const now = Date.now();
-            threadInfo.lastSeen = now;
+            const info = [threadInfo, ...(threadInfo.instances ?? [])].find((info) => info.worker === worker);
+            if (info) {
+                info.lastSeen = now;
+            }
             if (this.verbose)
                 this.log.debug(`Thread ${threadInfo.name} sent a message at ${new Date(now).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);
-            }
-            else if (message.type === 'init') {
-                threadInfo.lastStarted = now;
+            if (message.type === 'init') {
                 threadInfo.runCount = (threadInfo.runCount ?? 0) + 1;
                 this.log.debug(`Thread ${threadInfo.name} is online started at ${new Date(now).toISOString()} with thread id ${worker.threadId}`);
+                if (threadInfo.startup) {
+                    const startupMessage = { type: 'startup', threadName: threadInfo.name, threadId: worker.threadId };
+                    worker.postMessage(startupMessage);
+                    this.log.debug(`Thread ${threadInfo.name} sent startup message to thread id ${worker.threadId}`);
+                }
+            }
+            else if (message.type === 'pong') {
+                this.log.debug(`Thread ${threadInfo.name} received a pong at ${new Date(now).toISOString()}`);
+            }
+            else if (message.type === 'log') {
+                AnsiLogger.create({ logName: threadInfo.name, logNameColor: MAGENTA, logTimestampFormat: 4, logLevel: this.log.logLevel }).log(message.logLevel, message.message);
             }
             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;
                 }
                 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`);
+                this.log.debug(`Thread ${threadInfo.name} has exited at ${new Date(now).toISOString()} with thread id ${worker.threadId}`);
             }
         });
         worker.on('messageerror', () => {
             const now = Date.now();
-            threadInfo.lastSeen = now;
-            threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
+            const info = [threadInfo, ...(threadInfo.instances ?? [])].find((info) => info.worker === worker);
+            if (info) {
+                info.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.lastSeen = now;
-            threadInfo.lastStopped = now;
-            threadInfo.lastDuration = Math.max(0, now - (threadInfo.lastStarted ?? now));
-            threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
-            threadInfo.worker = undefined;
+            const info = [threadInfo, ...(threadInfo.instances ?? [])].find((info) => info.worker === worker);
+            if (info) {
+                info.lastSeen = now;
+                info.lastStopped = now;
+                info.lastDuration = Math.max(0, now - (info.lastStarted ?? now));
+                threadInfo.errorCount = (threadInfo.errorCount ?? 0) + 1;
+                info.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.error(`Thread ${threadInfo.name} encountered an error at ${new Date(now).toISOString()} after running for ${info?.lastDuration} ms: ${getErrorMessage(error)}`);
         });
         this.log.debug(`Started thread ${threadInfo.name} from path ${path} type ${threadInfo.type} with thread id ${worker.threadId}`);
-        return threadInfo.worker;
+        return worker;
     }
     async runInMainThread(name, workerData = null) {
         const threadInfo = this.threads.find((t) => t.name === name);
@@ -200,27 +258,30 @@ export class ThreadsManager {
         }
         this.log.debug(`Running thread ${threadInfo.name} in the main thread...`);
         let success = false;
-        const workerWrapper = (await import(this.resolvePath(threadInfo.path))).default;
-        if (workerWrapper && typeof workerWrapper === 'object' && workerWrapper.name === name && workerWrapper.callback && typeof workerWrapper.callback === 'function') {
-            workerWrapper.workerData = workerData ? { ...workerData, type: threadInfo.type } : null;
+        const threadsWrapper = (await import(this.resolvePath(threadInfo.path))).default;
+        if (threadsWrapper && typeof threadsWrapper === 'object' && threadsWrapper.name === name && threadsWrapper.entrypoint && typeof threadsWrapper.entrypoint === 'function') {
+            threadsWrapper.workerData = workerData ? { ...workerData, type: threadInfo.type } : null;
             try {
-                success = await workerWrapper.callback(workerWrapper);
+                success = await threadsWrapper.entrypoint(threadsWrapper);
             }
             finally {
                 if (!success || threadInfo.type !== 'thread')
-                    workerWrapper.destroy(success);
+                    threadsWrapper.destroy(success);
             }
         }
         this.log.debug(`Finished running thread ${threadInfo.name} in the main thread.`);
         return success;
     }
     resolvePath(fileName) {
-        const currentModuleDirectory = path.dirname(fileURLToPath(import.meta.url));
+        const threadDirectory = path.dirname(fileURLToPath(import.meta.url));
         const candidates = [
-            path.join(currentModuleDirectory, fileName),
-            path.join(currentModuleDirectory, '..', 'dist', fileName),
-            path.join(currentModuleDirectory, '..', 'src', fileName.replace(/\.js$/, '.ts')),
-            path.join(currentModuleDirectory, 'workers', fileName),
+            path.join(threadDirectory, fileName),
+            path.join(threadDirectory, '..', 'dist', fileName),
+            path.join(threadDirectory, '..', 'src', fileName.replace(/\.js$/, '.ts')),
+            path.join(threadDirectory, 'workers', fileName),
+            path.join(this.coreDirectory, 'runners', fileName),
+            path.join(this.coreDirectory, '..', 'dist', 'runners', fileName),
+            path.join(this.coreDirectory, '..', 'src', 'runners', fileName.replace(/\.js$/, '.ts')),
         ];
         for (const candidate of candidates) {
             if (fs.existsSync(candidate))

package/dist/{workerWrapper.d.ts → threadsWrapper.d.ts}

@@ -1,10 +1,15 @@
+import { EventEmitter } from 'node:events';
 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 {
+export interface ThreadsWrapperEvents {
+    startup: [];
+    shutdown: [];
+}
+export declare class ThreadsWrapper extends EventEmitter<ThreadsWrapperEvents> {
     name: ThreadNames;
-    callback: (worker: WorkerWrapper) => Promise<boolean>;
+    entrypoint: (worker: ThreadsWrapper) => Promise<boolean>;
     debug: boolean;
     verbose: boolean;
     useTracker: boolean;
@@ -15,7 +20,7 @@ export declare class WorkerWrapper {
     private destroyed;
     private readonly boundUnhandledRejectionHandler;
     private readonly boundUncaughtExceptionHandler;
-    constructor(name: ThreadNames, callback: (worker: WorkerWrapper) => Promise<boolean>);
+    constructor(name: ThreadNames, entrypoint: (worker: ThreadsWrapper) => Promise<boolean>);
     destroy(success: boolean): void;
     private handleUnhandledRejection;
     private handleUncaughtException;

package/dist/{workerWrapper.js → threadsWrapper.js}

@@ -1,3 +1,4 @@
+import { EventEmitter } from 'node:events';
 import { isMainThread, parentPort, threadId, workerData } from 'node:worker_threads';
 import { getErrorMessage, inspectError } from '@matterbridge/utils';
 import { hasAnyParameter } from '@matterbridge/utils/cli';
@@ -6,10 +7,10 @@ import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { AnsiLogger, debugStringify, MAGENTA } from 'node-ansi-logger';
 import { BroadcastServer } from './broadcastServer.js';
 import { ThreadsManager } from './threadsManager.js';
-logModuleLoaded('WorkerWrapper');
-export class WorkerWrapper {
+logModuleLoaded('ThreadsWrapper');
+export class ThreadsWrapper extends EventEmitter {
     name;
-    callback;
+    entrypoint;
     debug = hasAnyParameter('debug', 'verbose', 'debug-threads', 'verbose-threads');
     verbose = hasAnyParameter('verbose', 'verbose-threads');
     useTracker = hasAnyParameter('tracker', 'tracker-threads');
@@ -24,9 +25,10 @@ export class WorkerWrapper {
     boundUncaughtExceptionHandler = (error) => {
         this.handleUncaughtException(error);
     };
-    constructor(name, callback) {
+    constructor(name, entrypoint) {
+        super();
         this.name = name;
-        this.callback = callback;
+        this.entrypoint = entrypoint;
         if (this.workerData) {
             this.debug = this.workerData.debug ?? this.debug;
             this.verbose = this.workerData.verbose ?? this.verbose;
@@ -46,7 +48,7 @@ export class WorkerWrapper {
                 return;
             })
                 .catch((err) => {
-                this.safeParentLog("error", `WorkerWrapper ${this.name}: failed to load Tracker ${getErrorMessage(err)}`);
+                this.safeParentLog("error", `ThreadsWrapper ${this.name}: failed to load Tracker ${getErrorMessage(err)}`);
                 return;
             });
         }
@@ -65,8 +67,11 @@ export class WorkerWrapper {
                         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(this.name, "debug", `Worker ${this.name}:${threadId} received pong message type from parent: ${debugStringify(message)}`);
+                    case 'startup':
+                        setImmediate(() => this.emit('startup'));
+                        break;
+                    case 'shutdown':
+                        setImmediate(() => this.emit('shutdown'));
                         break;
                     default:
                         this.parentLog(this.name, "warn", `Worker ${this.name}:${threadId} received unknown message type from parent: ${debugStringify(message)}`);
@@ -89,10 +94,10 @@ export class WorkerWrapper {
                 void (async () => {
                     let success = false;
                     try {
-                        success = await callback(this);
+                        success = await entrypoint(this);
                     }
                     catch (err) {
-                        inspectError(this.log, `Worker ${this.name} callback failed`, err);
+                        inspectError(this.log, `Worker ${this.name} entrypoint failed`, err);
                     }
                     finally {
                         if (!success || this.workerData?.type !== 'thread')

package/dist/workerArchiveCommand.d.ts

@@ -1,3 +1,3 @@
-import { WorkerWrapper } from './workerWrapper.js';
-declare const _default: WorkerWrapper;
+import { ThreadsWrapper } from './threadsWrapper.js';
+declare const _default: ThreadsWrapper;
 export default _default;

package/dist/workerArchiveCommand.js

@@ -1,9 +1,9 @@
 import { isArchiveWorkerData } from '@matterbridge/types';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
-import { WorkerWrapper } from './workerWrapper.js';
+import { ThreadsWrapper } from './threadsWrapper.js';
 import { createZip, readZip, unZip } from './zipjs.js';
 logModuleLoaded('ArchiveCommand', '\u001B[35m');
-export default new WorkerWrapper('ArchiveCommand', async (worker) => {
+export default new ThreadsWrapper('ArchiveCommand', async (worker) => {
     if (!isArchiveWorkerData(worker.workerData)) {
         worker.logger("error", `ArchiveCommand invalid parameters`);
         return false;

package/dist/workerCheckUpdates.d.ts

@@ -1,3 +1,3 @@
-import { WorkerWrapper } from './workerWrapper.js';
-declare const _default: WorkerWrapper;
+import { ThreadsWrapper } from './threadsWrapper.js';
+declare const _default: ThreadsWrapper;
 export default _default;

package/dist/workerCheckUpdates.js

@@ -1,9 +1,9 @@
 import { inspectError } from '@matterbridge/utils/error';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { checkUpdates } from './checkUpdates.js';
-import { WorkerWrapper } from './workerWrapper.js';
+import { ThreadsWrapper } from './threadsWrapper.js';
 logModuleLoaded('CheckUpdates', '\u001B[35m');
-export default new WorkerWrapper('CheckUpdates', async (worker) => {
+export default new ThreadsWrapper('CheckUpdates', async (worker) => {
     worker.logger("info", `Starting check updates...`);
     let success = false;
     try {

package/dist/workerDockerVersion.d.ts

@@ -1,3 +1,3 @@
-import { WorkerWrapper } from './workerWrapper.js';
-declare const _default: WorkerWrapper;
+import { ThreadsWrapper } from './threadsWrapper.js';
+declare const _default: ThreadsWrapper;
 export default _default;

package/dist/workerDockerVersion.js

@@ -3,9 +3,9 @@ import { inspectError } from '@matterbridge/utils/error';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { debugStringify } from 'node-ansi-logger';
 import { getDockerVersion, takeDockerVersionWarning } from './dockerVersion.js';
-import { WorkerWrapper } from './workerWrapper.js';
+import { ThreadsWrapper } from './threadsWrapper.js';
 logModuleLoaded('DockerVersion', '\u001B[35m');
-export default new WorkerWrapper('DockerVersion', async (worker) => {
+export default new ThreadsWrapper('DockerVersion', async (worker) => {
     worker.logger("info", `Starting docker version check...`);
     let success = false;
     let dockerBuildConfig;

package/dist/workerGlobalPrefix.d.ts

@@ -1,3 +1,3 @@
-import { WorkerWrapper } from './workerWrapper.js';
-declare const _default: WorkerWrapper;
+import { ThreadsWrapper } from './threadsWrapper.js';
+declare const _default: ThreadsWrapper;
 export default _default;

package/dist/workerGlobalPrefix.js

@@ -1,9 +1,9 @@
 import { inspectError } from '@matterbridge/utils/error';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { getGlobalNodeModules } from '@matterbridge/utils/npm-prefix';
-import { WorkerWrapper } from './workerWrapper.js';
+import { ThreadsWrapper } from './threadsWrapper.js';
 logModuleLoaded('GlobalPrefix', '\u001B[35m');
-export default new WorkerWrapper('GlobalPrefix', async (worker) => {
+export default new ThreadsWrapper('GlobalPrefix', async (worker) => {
     let prefix;
     worker.logger("info", `Starting global prefix check...`);
     let success = false;

package/dist/workerSpawnCommand.d.ts

@@ -1,3 +1,3 @@
-import { WorkerWrapper } from './workerWrapper.js';
-declare const _default: WorkerWrapper;
+import { ThreadsWrapper } from './threadsWrapper.js';
+declare const _default: ThreadsWrapper;
 export default _default;

package/dist/workerSpawnCommand.js

@@ -1,9 +1,9 @@
 import { isSpawnWorkerData } from '@matterbridge/types';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { spawnCommand } from './spawnCommand.js';
-import { WorkerWrapper } from './workerWrapper.js';
+import { ThreadsWrapper } from './threadsWrapper.js';
 logModuleLoaded('SpawnCommand', '\u001B[35m');
-export default new WorkerWrapper('SpawnCommand', async (worker) => {
+export default new ThreadsWrapper('SpawnCommand', async (worker) => {
     if (!isSpawnWorkerData(worker.workerData)) {
         worker.logger("error", `SpawnCommand invalid parameters`);
         return false;

package/dist/workerSystemCheck.d.ts

@@ -1,3 +1,3 @@
-import { WorkerWrapper } from './workerWrapper.js';
-declare const _default: WorkerWrapper;
+import { ThreadsWrapper } from './threadsWrapper.js';
+declare const _default: ThreadsWrapper;
 export default _default;

package/dist/workerSystemCheck.js

@@ -3,9 +3,9 @@ import { getBunLatestVersion, getBunVersion, isBun } from '@matterbridge/utils/b
 import { inspectError } from '@matterbridge/utils/error';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { excludedInterfaceNamePattern } from '@matterbridge/utils/network';
-import { WorkerWrapper } from './workerWrapper.js';
+import { ThreadsWrapper } from './threadsWrapper.js';
 logModuleLoaded('SystemCheck', '\u001B[35m');
-export default new WorkerWrapper('SystemCheck', async (worker) => {
+export default new ThreadsWrapper('SystemCheck', async (worker) => {
     worker.logger("info", `Starting system check...`);
     let success = false;
     try {

package/dist/zipjs.js

@@ -1,7 +1,8 @@
 import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { Uint8ArrayReader, Uint8ArrayWriter, ZipReader, ZipWriter } from '@zip.js/zip.js';
+import { configure, Uint8ArrayReader, Uint8ArrayWriter, ZipReader, ZipWriter } from '@zip.js/zip.js';
 import { AnsiLogger } from 'node-ansi-logger';
+configure({ useWebWorkers: false });
 export async function createZip(zipPath, sourcePaths) {
     if (sourcePaths.length === 0)
         throw new Error('No files or directories provided to createZip.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/thread",
-  "version": "3.10.13-dev-20261007-320f739",
+  "version": "3.10.13-dev-20261008-55d98fb",
   "description": "Matterbridge thread library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -57,6 +57,10 @@
     "./manager": {
       "types": "./dist/threadsManager.d.ts",
       "import": "./dist/threadsManager.js"
+    },
+    "./wrapper": {
+      "types": "./dist/threadsWrapper.d.ts",
+      "import": "./dist/threadsWrapper.js"
     }
   },
   "engines": {
@@ -76,15 +80,9 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/types": "3.10.13-dev-20261007-320f739",
-    "@matterbridge/utils": "3.10.13-dev-20261007-320f739",
+    "@matterbridge/types": "3.10.13-dev-20261008-55d98fb",
+    "@matterbridge/utils": "3.10.13-dev-20261008-55d98fb",
     "@zip.js/zip.js": "2.22.0",
-    "escape-html": "1.0.3",
-    "express": "5.2.1",
-    "express-rate-limit": "8.7.0",
-    "multer": "2.4.0",
-    "node-ansi-logger": "3.3.1",
-    "node-persist-manager": "2.1.1",
-    "ws": "8.22.0"
+    "node-ansi-logger": "3.3.1"
   }
 }

package/dist/backend.d.ts

@@ -1,42 +0,0 @@
-import EventEmitter from 'node:events';
-import { type ApiClusters, type ApiDevice, type ApiPlugin, type ApiSettings, type SharedMatterbridge, type ApiMatter } from '@matterbridge/types';
-import type { BackendExpress } from './backendExpress.js';
-import type { BackendWsServer } from './backendWsServer.js';
-interface BackendEvents {
-    server_listening: [protocol: string, port: number, address?: string];
-    server_error: [error: unknown];
-    server_stopped: [];
-    websocket_server_listening: [protocol: string];
-    websocket_server_stopped: [];
-}
-export declare class Backend extends EventEmitter<BackendEvents> {
-    private debug;
-    private verbose;
-    private diagnostic;
-    private log;
-    private matterbridge;
-    private readonly server;
-    private port;
-    private listening;
-    private httpServer;
-    private httpsServer;
-    readonly secure: boolean;
-    readonly requestCert: boolean;
-    backendExpress: BackendExpress | undefined;
-    backendWsServer: BackendWsServer | undefined;
-    storedPassword: string | undefined;
-    authClients: Set<string>;
-    authClientsTimeout: NodeJS.Timeout | undefined;
-    constructor(matterbridge: SharedMatterbridge);
-    destroy(): void;
-    private broadcastMsgHandler;
-    start(port?: number): Promise<void>;
-    stop(): Promise<void>;
-    getApiSettings(): Promise<ApiSettings>;
-    getApiPlugins(): Promise<ApiPlugin[]>;
-    getApiDevices(pluginName?: string): Promise<ApiDevice[]>;
-    getApiCluster(pluginName: string, endpointNumber: number, serialNumber?: string, uniqueId?: string): Promise<ApiClusters | undefined>;
-    generateDiagnostic(): Promise<void>;
-    getApiMatter(id: string): Promise<ApiMatter | undefined>;
-}
-export {};