@matterbridge/thread 3.10.13-dev-20261005-49e0dbd → 3.10.13-dev-20261007-320f739

package/dist/backendWsServer.js

@@ -0,0 +1,393 @@
+import { Logger, LogLevel as MatterLogLevel } from '@matter/general';
+import { hasAnyParameter } from '@matterbridge/utils/cli';
+import { writeDiagnostic } from '@matterbridge/utils/diagnostic';
+import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
+import { isValidNumber, isValidString } from '@matterbridge/utils/validate';
+import { fireAndForget, withTimeout } from '@matterbridge/utils/wait';
+import { AnsiLogger, CYAN, debugStringify, nf } from 'node-ansi-logger';
+import { WebSocket, WebSocketServer } from 'ws';
+import { BroadcastServer } from './broadcastServer.js';
+logModuleLoaded('BackendWsServer');
+export class BackendWsServer {
+    debug;
+    verbose;
+    diagnostic;
+    log;
+    backend;
+    matterbridge;
+    server;
+    webSocketServer;
+    constructor(matterbridge, backend) {
+        this.debug = hasAnyParameter('debug', 'verbose', 'debug-backend', 'verbose-backend');
+        this.verbose = hasAnyParameter('verbose', 'verbose-backend');
+        this.diagnostic = hasAnyParameter('diagnostic', 'diagnostic-backend');
+        this.backend = backend;
+        this.matterbridge = matterbridge;
+        this.log = new AnsiLogger({
+            logName: 'BackendWsServer',
+            logNameColor: '\x1b[38;5;97m',
+            logTimestampFormat: 4,
+            logLevel: this.debug ? "debug" : "info",
+        });
+        this.server = new BroadcastServer('frontend', this.log);
+        this.server.on('broadcast_message', (msg) => fireAndForget(this.broadcastMsgHandler(msg), this.log, 'Broadcast message handler'));
+    }
+    destroy() {
+        this.server.close();
+    }
+    async broadcastMsgHandler(msg) {
+        if (this.server.isWorkerRequest(msg)) {
+            switch (msg.type) {
+                case 'get_log_level':
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
+                    break;
+                case 'set_log_level':
+                    this.log.logLevel = msg.params.logLevel;
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
+                    break;
+            }
+        }
+    }
+    async start() {
+        this.log.debug(`Creating WebSocketServer...`);
+        this.webSocketServer = new WebSocketServer({ noServer: true });
+        this.backend.emit('websocket_server_listening', this.backend.secure ? 'wss' : 'ws');
+        this.webSocketServer.on('connection', (websocket, request) => {
+            const clientIp = request.socket.remoteAddress;
+            this.log.info(`WebSocketServer client ${CYAN}${clientIp}${nf} connected to Matterbridge`);
+            let callbackLogLevel = "notice";
+            if (this.log.logLevel === "info" || Logger.level === MatterLogLevel.INFO)
+                callbackLogLevel = "info";
+            if (this.log.logLevel === "debug" || Logger.level === MatterLogLevel.DEBUG)
+                callbackLogLevel = "debug";
+            AnsiLogger.setGlobalCallback(this.wssSendLogMessage.bind(this), callbackLogLevel);
+            this.log.debug(`WebSocketServer logger global callback set to ${callbackLogLevel}`);
+            websocket.on('message', (data) => {
+                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} sent a message`);
+                fireAndForget(this.wsMessageHandler(websocket, data), this.log, `Error handling message from WebSocket client ${clientIp}`);
+            });
+            websocket.on('ping', () => {
+                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} ping received`);
+                websocket.pong();
+            });
+            websocket.on('pong', () => {
+                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} pong received`);
+            });
+            websocket.on('close', (code, reason) => {
+                this.log.info(`WebSocket client ${CYAN}${clientIp}${nf} disconnected code ${code} reason ${reason.toString()}`);
+                if (this.webSocketServer?.clients.size === 0) {
+                    AnsiLogger.setGlobalCallback(undefined);
+                    this.log.debug('All WebSocket clients disconnected. WebSocketServer logger global callback removed');
+                    setTimeout(() => {
+                        if (this.webSocketServer?.clients.size === 0) {
+                            this.log.debug('All WebSocket clients disconnected. Auth clients list cleared');
+                            this.backend.authClients.clear();
+                        }
+                    }, 1000).unref();
+                }
+                else {
+                    this.log.debug(`WebSocketServer still has ${this.webSocketServer?.clients.size} connected clients`);
+                }
+            });
+            websocket.on('error', (error) => {
+                inspectError(this.log, `WebSocket client error`, error);
+            });
+        });
+        this.webSocketServer.on('close', () => {
+            this.log.debug(`WebSocketServer closed`);
+        });
+        this.webSocketServer.on('error', (ws, error) => {
+            inspectError(this.log, `WebSocketServer error`, error);
+        });
+        return this.webSocketServer;
+    }
+    async stop() {
+        if (this.webSocketServer) {
+            this.log.debug('Closing WebSocket server...');
+            this.webSocketServer.clients.forEach((client) => {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.close();
+                }
+            });
+            await withTimeout(new Promise((resolve) => {
+                this.webSocketServer?.close((error) => {
+                    if (error) {
+                        inspectError(this.log, `Error closing WebSocket server`, error);
+                    }
+                    else {
+                        this.log.debug('WebSocket server closed successfully');
+                        this.backend.emit('websocket_server_stopped');
+                    }
+                    resolve();
+                });
+            }), 10000, false);
+            this.webSocketServer.removeAllListeners();
+            this.webSocketServer = undefined;
+        }
+        else {
+            this.log.debug('WebSocket server is not running');
+        }
+        return this.webSocketServer;
+    }
+    hasActiveClients() {
+        return this.webSocketServer !== undefined && this.webSocketServer.clients.size > 0;
+    }
+    async wsMessageHandler(client, rawData) {
+        let data;
+        const sendResponse = (data) => {
+            if (client.readyState === client.OPEN) {
+                if ('response' in data) {
+                    const { response, ...rest } = data;
+                    this.log.debug(`Sending api response message: ${debugStringify(rest)}`);
+                }
+                else {
+                    this.log.debug(`Sending api error message: ${debugStringify(data)}`);
+                }
+                const bigintReplacer = (_, v) => (typeof v === 'bigint' ? `${v}n` : v);
+                client.send(JSON.stringify(data, bigintReplacer));
+            }
+            else {
+                this.log.error('Cannot send api response, client not connected');
+            }
+        };
+        try {
+            const raw = Array.isArray(rawData) ? Buffer.concat(rawData) : rawData instanceof ArrayBuffer ? Buffer.from(rawData) : rawData;
+            data = JSON.parse(raw.toString());
+            if (!isValidNumber(data.id) || !isValidString(data.dst) || !isValidString(data.src) || !isValidString(data.method) || data.dst !== 'Matterbridge') {
+                this.log.error(`Invalid message from websocket client: ${debugStringify(data)}`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid message' });
+                return;
+            }
+            this.log.debug(`Received message from websocket client: ${debugStringify(data)}`);
+            if (data.method === 'ping') {
+                sendResponse({ id: data.id, method: 'pong', src: 'Matterbridge', dst: data.src, success: true, response: 'pong' });
+            }
+            else if (data.method === '/api/restart') {
+                this.wssSendSnackbarMessage('Restarting matterbridge...', 0);
+                await this.server.fetch({ type: 'matterbridge_restart', src: 'frontend', dst: 'matterbridge', params: undefined });
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+            }
+            else if (data.method === '/api/shutdown') {
+                this.wssSendSnackbarMessage('Shutting down matterbridge...', 0);
+                await this.server.fetch({ type: 'matterbridge_shutdown', src: 'frontend', dst: 'matterbridge', params: undefined });
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+            }
+            else if (data.method === '/api/settings') {
+                const start = performance.now();
+                const settings = await this.backend.getApiSettings();
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiSettings() took ${(performance.now() - start).toFixed(2)} ms`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: settings });
+            }
+            else if (data.method === '/api/plugins') {
+                const start = performance.now();
+                const plugins = await this.backend.getApiPlugins();
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiPlugins() took ${(performance.now() - start).toFixed(2)} ms`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: plugins });
+            }
+            else if (data.method === '/api/devices') {
+                const start = performance.now();
+                const devices = await this.backend.getApiDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined);
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiDevices() took ${(performance.now() - start).toFixed(2)} ms`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: devices });
+            }
+            else if (data.method === '/api/clusters') {
+                if (!isValidString(data.params.plugin, 10)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/clusters' });
+                    return;
+                }
+                if (!isValidNumber(data.params.endpoint, 1)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter endpoint in /api/clusters' });
+                    return;
+                }
+                const start = performance.now();
+                const clusters = await this.backend.getApiCluster(data.params.plugin, data.params.endpoint, data.params.serialNumber, data.params.uniqueId);
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiCluster() took ${(performance.now() - start).toFixed(2)} ms`);
+                if (clusters) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: clusters });
+                }
+                else {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Endpoint not found in /api/clusters' });
+                }
+            }
+            else if (data.method === '/api/matter') {
+                if (!isValidString(data.params.id)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter id in /api/matter' });
+                    return;
+                }
+                const matter = await this.backend.getApiMatter(data.params.id);
+                if (!matter) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Unknown server node id ${data.params.id} in /api/matter` });
+                    return;
+                }
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: matter });
+                this.wssSendRefreshRequired('matter', { matter });
+            }
+        }
+        catch (error) {
+            inspectError(this.log, `Error parsing message from websocket client`, error);
+            return;
+        }
+    }
+    wssBroadcastMessage(msg) {
+        if (!this.hasActiveClients())
+            return;
+        try {
+            const stringifiedMsg = JSON.stringify(msg);
+            this.webSocketServer?.clients.forEach((client) => {
+                if (client.readyState === client.OPEN) {
+                    client.send(stringifiedMsg);
+                }
+            });
+        }
+        catch (error) {
+            inspectError(this.log, `Error broadcasting message to websocket clients`, error);
+        }
+    }
+    wssSendLogMessage(level, time, name, message) {
+        if (!this.hasActiveClients())
+            return;
+        if (!level || !time || !name || !message)
+            return;
+        message = message.replace(/\x1B\[[0-9;]*[m|s|u|K]/g, '');
+        message = message.replace(/^\*+/, '');
+        message = message.replace(/[\t\n]/g, '');
+        message = message.replace(/[\x00-\x1F\x7F]/g, '');
+        message = message.replace(/\\"/g, '"');
+        const maxContinuousLength = 100;
+        const keepStartLength = 20;
+        const keepEndLength = 20;
+        if (level !== 'spawn') {
+            message = message
+                .split(' ')
+                .map((word) => {
+                if (word.length > maxContinuousLength) {
+                    return word.slice(0, keepStartLength) + ' ... ' + word.slice(-keepEndLength);
+                }
+                return word;
+            })
+                .join(' ');
+        }
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'log', success: true, response: { level, time, name, message } });
+    }
+    wssSendRefreshRequired(changed, params) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a refresh required message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', success: true, response: { changed, lock: params?.lock, ...params } });
+    }
+    wssSendRestartRequired(snackbar = true, fixed = false) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a restart required message to all connected clients');
+        if (snackbar)
+            this.wssSendSnackbarMessage(`Restart required`, 0);
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', success: true, response: { fixed } });
+    }
+    wssSendRestartNotRequired(snackbar = true) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a restart not required message to all connected clients');
+        if (snackbar)
+            this.wssSendCloseSnackbarMessage(`Restart required`);
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
+    }
+    wssSendUpdateRequired(version, devVersion = false) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a matterbridge version update required message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'update_required', success: true, response: { version, devVersion } });
+    }
+    wssSendPluginUpdateRequired(plugin, version, devVersion = false) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a plugin version update required message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'plugin_update_required', success: true, response: { plugin, version, devVersion } });
+    }
+    wssSendPluginStatusUpdate(plugin, status) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a plugin status update message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'plugin_status_update', success: true, response: { plugin, status } });
+    }
+    wssSendMatterbridgeStatusUpdate(status) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a matterbridge status update message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'matterbridge_status_update', success: true, response: { status } });
+    }
+    wssSendCpuUpdate(cpuUsage, processCpuUsage) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a cpu update message to all connected clients');
+        this.wssBroadcastMessage({
+            id: 0,
+            src: 'Matterbridge',
+            dst: 'Frontend',
+            method: 'cpu_update',
+            success: true,
+            response: { cpuUsage: Math.round(cpuUsage * 100) / 100, processCpuUsage: Math.round(processCpuUsage * 100) / 100 },
+        });
+    }
+    wssSendMemoryUpdate(totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a memory update message to all connected clients');
+        this.wssBroadcastMessage({
+            id: 0,
+            src: 'Matterbridge',
+            dst: 'Frontend',
+            method: 'memory_update',
+            success: true,
+            response: { totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers },
+        });
+    }
+    wssSendUptimeUpdate(systemUptime, processUptime) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a uptime update message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'uptime_update', success: true, response: { systemUptime, processUptime } });
+    }
+    wssSendSnackbarMessage(message, timeout = 5, severity = 'info') {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a snackbar message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'snackbar', success: true, response: { message, timeout, severity } });
+    }
+    wssSendCloseSnackbarMessage(message) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a close snackbar message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'close_snackbar', success: true, response: { message } });
+    }
+    wssSendAttributeChangedMessage(plugin, serialNumber, uniqueId, number, id, cluster, attribute, value) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending an attribute update message to all connected clients');
+        this.wssBroadcastMessage({
+            id: 0,
+            src: 'Matterbridge',
+            dst: 'Frontend',
+            method: 'state_update',
+            success: true,
+            response: { plugin, serialNumber, uniqueId, number, id, cluster, attribute, value },
+        });
+    }
+}

package/dist/threadBackend.d.ts

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

package/dist/threadBackend.js

@@ -0,0 +1,24 @@
+import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
+import { WorkerWrapper } from './workerWrapper.js';
+logModuleLoaded('Backend', '\u001B[35m');
+export default new WorkerWrapper('Backend', async (worker) => {
+    worker.logger("info", 'Creating backend...');
+    try {
+        worker.logger("debug", 'Fetching shared Matterbridge state...');
+        const shared = (await worker.server.fetch({ type: 'matterbridge_shared', src: 'matterbridge', dst: 'matterbridge' }, 1000)).result.data;
+        worker.logger("debug", 'Shared Matterbridge state fetched; importing Backend...');
+        const { Backend } = await import('./backend.js');
+        worker.logger("debug", 'Backend imported; creating instance...');
+        const backend = new Backend(shared);
+        worker.logger("debug", 'Starting Backend...');
+        await backend.start();
+        worker.logger("debug", 'Backend started');
+        return true;
+    }
+    catch (error) {
+        const errorMessage = inspectError(worker.log, 'Failed to create backend', error);
+        worker.logger("error", errorMessage);
+        return false;
+    }
+});

package/dist/threadsManager.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { Worker } from 'node:worker_threads';
-import { hasParameter } from '@matterbridge/utils/cli';
+import { hasAnyParameter, hasParameter } from '@matterbridge/utils/cli';
 import { getErrorMessage } from '@matterbridge/utils/error';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { fireAndForget } from '@matterbridge/utils/wait';
@@ -26,12 +26,13 @@ export class ThreadsManager {
         { name: 'SpawnCommand', path: 'workerSpawnCommand.js', type: 'worker' },
         { name: 'ArchiveCommand', path: 'workerArchiveCommand.js', type: 'worker' },
         { name: 'DockerVersion', path: 'workerDockerVersion.js', type: 'worker' },
+        { name: 'Backend', path: 'threadBackend.js', type: 'thread' },
     ];
     terminateWorkers = new Set();
     constructor(intervalMs = 60_000) {
-        this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-threads') || hasParameter('verbose-threads');
-        this.verbose = hasParameter('verbose') || hasParameter('verbose-threads');
-        this.tracker = hasParameter('tracker') || hasParameter('tracker-threads');
+        this.debug = hasAnyParameter('debug', 'verbose', 'debug-threads', 'verbose-threads');
+        this.verbose = hasAnyParameter('verbose', 'verbose-threads');
+        this.tracker = hasAnyParameter('tracker', 'tracker-threads');
         this.log = new AnsiLogger({
             logName: 'ThreadsManager',
             logNameColor: MAGENTA,
@@ -103,7 +104,7 @@ export class ThreadsManager {
     }
     intervalHandler() {
         for (const thread of this.threads) {
-            this.log.debug(`Thread ${thread.name} running: ${thread.worker ? 'yes' : 'no'}, lastSeen: ${thread.lastSeen ? new Date(thread.lastSeen).toISOString() : 'never'}, runs: ${thread.runCount ?? 0}, errors: ${thread.errorCount ?? 0}`);
+            this.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}`);
         }
         this.terminateExitedWorkers();
         for (const thread of this.threads) {
@@ -132,7 +133,7 @@ export class ThreadsManager {
         threadInfo.lastStarted = undefined;
         threadInfo.lastStopped = undefined;
         threadInfo.lastDuration = undefined;
-        threadInfo.worker = this.createESMWorker(threadInfo.name, path, { ...workerData, debug: this.debug, verbose: this.verbose, logLevel: this.log.logLevel }, argv, env, execArgv, pipedOutput);
+        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;
         worker.once('online', () => {
             const now = Date.now();
@@ -201,9 +202,14 @@ export class ThreadsManager {
         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;
-            success = await workerWrapper.callback(workerWrapper);
-            workerWrapper.destroy(success);
+            workerWrapper.workerData = workerData ? { ...workerData, type: threadInfo.type } : null;
+            try {
+                success = await workerWrapper.callback(workerWrapper);
+            }
+            finally {
+                if (!success || threadInfo.type !== 'thread')
+                    workerWrapper.destroy(success);
+            }
         }
         this.log.debug(`Finished running thread ${threadInfo.name} in the main thread.`);
         return success;
@@ -226,7 +232,7 @@ export class ThreadsManager {
     createESMWorker(name, relativePath, workerData, argv, env, execArgv, pipedOutput = false) {
         const fileURL = pathToFileURL(path.resolve(relativePath));
         const options = {
-            workerData: { ...workerData, threadName: name, debug: this.debug, verbose: this.verbose, logLevel: this.log.logLevel, tracker: this.tracker },
+            workerData: { ...workerData, threadName: name, debug: this.debug, verbose: this.verbose, tracker: this.tracker, logLevel: this.log.logLevel },
             name,
             argv: argv ?? process.argv.slice(2),
             env: env ?? process.env,

package/dist/workerWrapper.js

@@ -1,6 +1,6 @@
 import { isMainThread, parentPort, threadId, workerData } from 'node:worker_threads';
 import { getErrorMessage, inspectError } from '@matterbridge/utils';
-import { hasParameter } from '@matterbridge/utils/cli';
+import { hasAnyParameter } from '@matterbridge/utils/cli';
 import { formatBytes } from '@matterbridge/utils/format';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { AnsiLogger, debugStringify, MAGENTA } from 'node-ansi-logger';
@@ -10,9 +10,9 @@ logModuleLoaded('WorkerWrapper');
 export class WorkerWrapper {
     name;
     callback;
-    debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-threads') || hasParameter('verbose-threads');
-    verbose = hasParameter('verbose') || hasParameter('verbose-threads');
-    useTracker = hasParameter('tracker') || hasParameter('tracker-threads');
+    debug = hasAnyParameter('debug', 'verbose', 'debug-threads', 'verbose-threads');
+    verbose = hasAnyParameter('verbose', 'verbose-threads');
+    useTracker = hasAnyParameter('tracker', 'tracker-threads');
     log;
     server;
     workerData = workerData;
@@ -32,25 +32,24 @@ export class WorkerWrapper {
             this.verbose = this.workerData.verbose ?? this.verbose;
             this.useTracker = this.workerData.tracker ?? this.useTracker;
         }
+        this.log = new AnsiLogger({
+            logName: this.name,
+            logNameColor: MAGENTA,
+            logTimestampFormat: 4,
+            logLevel: this.debug ? "debug" : "info",
+        });
         if (this.useTracker) {
             void import('@matterbridge/utils/tracker')
                 .then(({ Tracker }) => {
-                this.tracker = new Tracker(`Thread${this.name}`, this.debug, this.verbose);
+                this.tracker = new Tracker(`Thread${this.name}`, this.debug || this.useTracker, this.verbose, this.useTracker);
                 this.tracker.start();
                 return;
             })
                 .catch((err) => {
-                if (this.debug)
-                    console.error(`WorkerWrapper ${this.name}: failed to load Tracker ${getErrorMessage(err)}`);
+                this.safeParentLog("error", `WorkerWrapper ${this.name}: failed to load Tracker ${getErrorMessage(err)}`);
                 return;
             });
         }
-        this.log = new AnsiLogger({
-            logName: this.name,
-            logNameColor: MAGENTA,
-            logTimestampFormat: 4,
-            logLevel: this.debug ? "debug" : "info",
-        });
         this.server = new BroadcastServer('matterbridge', this.log);
         if (!isMainThread) {
             process.on('unhandledRejection', this.boundUnhandledRejectionHandler);
@@ -96,7 +95,8 @@ export class WorkerWrapper {
                         inspectError(this.log, `Worker ${this.name} callback failed`, err);
                     }
                     finally {
-                        this.destroy(success);
+                        if (!success || this.workerData?.type !== 'thread')
+                            this.destroy(success);
                     }
                 })();
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/thread",
-  "version": "3.10.13-dev-20261005-49e0dbd",
+  "version": "3.10.13-dev-20261007-320f739",
   "description": "Matterbridge thread library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -75,9 +75,16 @@
     "skipTsconfig": true
   },
   "dependencies": {
-    "@matterbridge/types": "3.10.13-dev-20261005-49e0dbd",
-    "@matterbridge/utils": "3.10.13-dev-20261005-49e0dbd",
+    "@matter/main": "0.17.9",
+    "@matterbridge/types": "3.10.13-dev-20261007-320f739",
+    "@matterbridge/utils": "3.10.13-dev-20261007-320f739",
     "@zip.js/zip.js": "2.22.0",
-    "node-ansi-logger": "3.3.1"
+    "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"
   }
 }