@matterbridge/thread 3.5.3 → 3.5.4-dev-20260211-520e349

package/README.md

@@ -19,4 +19,4 @@
 
 ---
 
-Matterbridge internal package (not intended for direct use).
+[Matterbridge](https://matterbridge.io) internal package (not intended for direct use).

package/dist/broadcastServer.d.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from 'node:events';
+import { AnsiLogger } from 'node-ansi-logger';
+import type { WorkerMessage, WorkerMessageRequest, WorkerMessageRequestAny, WorkerMessageResponse, WorkerMessageResponseSuccess, WorkerMessageTypes, WorkerSrcType } from '@matterbridge/types';
+interface BroadcastServerEvents {
+    broadcast_message: [msg: WorkerMessage];
+}
+export declare class BroadcastServer extends EventEmitter<BroadcastServerEvents> {
+    readonly name: WorkerSrcType;
+    private readonly log;
+    private readonly channel;
+    private readonly broadcastChannel;
+    private closed;
+    private readonly debug;
+    private readonly verbose;
+    constructor(name: WorkerSrcType, log: AnsiLogger, channel?: string);
+    close(): void;
+    private broadcastMessageHandler;
+    private broadcastMessageErrorHandler;
+    getUniqueId(): number;
+    isWorkerRequest(value: unknown): value is WorkerMessageRequest;
+    isWorkerRequestOfType<K extends keyof WorkerMessageTypes>(value: unknown, type: K): value is WorkerMessageRequest<K>;
+    isWorkerResponse(value: unknown): value is WorkerMessageResponse;
+    isWorkerResponseOfType<K extends keyof WorkerMessageTypes>(value: unknown, type: K): value is WorkerMessageResponse<K>;
+    broadcast(message: WorkerMessage): void;
+    request<K extends keyof WorkerMessageTypes>(message: WorkerMessageRequest<K>): void;
+    respond<K extends keyof WorkerMessageTypes>(message: WorkerMessageResponse<K>): void;
+    fetch<T extends WorkerMessageRequestAny, K extends Extract<keyof WorkerMessageTypes, T['type']>>(message: T, timeout?: number): Promise<WorkerMessageResponseSuccess<K>>;
+}
+export {};

package/dist/broadcastServer.js

@@ -0,0 +1,198 @@
+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 { CYAN, db, debugStringify, er } from 'node-ansi-logger';
+import { hasParameter, logError } from '@matterbridge/utils';
+export class BroadcastServer extends EventEmitter {
+    name;
+    log;
+    channel;
+    broadcastChannel;
+    closed = false;
+    debug = hasParameter('debug') || hasParameter('verbose');
+    verbose = hasParameter('verbose');
+    constructor(name, log, channel = 'broadcast-channel') {
+        super();
+        this.name = name;
+        this.log = log;
+        this.channel = channel;
+        this.broadcastChannel = new BroadcastChannel(this.channel);
+        this.broadcastChannel.onmessage = this.broadcastMessageHandler.bind(this);
+        this.broadcastChannel.onmessageerror = this.broadcastMessageErrorHandler.bind(this);
+    }
+    close() {
+        this.broadcastChannel.onmessage = null;
+        this.broadcastChannel.onmessageerror = null;
+        this.broadcastChannel.close();
+        this.closed = true;
+    }
+    broadcastMessageHandler(event) {
+        const msg = event.data;
+        if (msg.dst === this.name || msg.dst === 'all') {
+            if (this.verbose)
+                this.log.debug(`Server ${CYAN}${this.name}${db} received broadcast message: ${debugStringify(msg)}`);
+            this.emit('broadcast_message', msg);
+        }
+        else {
+            if (this.verbose)
+                this.log.debug(`Server ${CYAN}${this.name}${db} received unrelated broadcast message: ${debugStringify(msg)}`);
+        }
+    }
+    broadcastMessageErrorHandler(event) {
+        const msg = event.data;
+        this.log.error(`Server ${CYAN}${this.name}${db} received message error: ${debugStringify(msg)}`);
+    }
+    getUniqueId() {
+        return Math.floor(Math.random() * 900000000) + 100000000;
+    }
+    isWorkerRequest(value) {
+        if (typeof value !== 'object' || value === null) {
+            return false;
+        }
+        const message = value;
+        if (typeof message.type !== 'string' ||
+            typeof message.src !== 'string' ||
+            typeof message.dst !== 'string' ||
+            typeof message.id !== 'number' ||
+            typeof message.timestamp !== 'number') {
+            return false;
+        }
+        return message.result === undefined && message.error === undefined;
+    }
+    isWorkerRequestOfType(value, type) {
+        return this.isWorkerRequest(value) && value.type === type;
+    }
+    isWorkerResponse(value) {
+        if (typeof value !== 'object' || value === null) {
+            return false;
+        }
+        const message = value;
+        if (typeof message.type !== 'string' ||
+            typeof message.src !== 'string' ||
+            typeof message.dst !== 'string' ||
+            typeof message.id !== 'number' ||
+            typeof message.timestamp !== 'number') {
+            return false;
+        }
+        const hasError = typeof message.error === 'string';
+        const hasResult = message.result !== undefined;
+        return hasError !== hasResult;
+    }
+    isWorkerResponseOfType(value, type) {
+        return this.isWorkerResponse(value) && value.type === type;
+    }
+    broadcast(message) {
+        if (this.closed) {
+            this.log.error('Broadcast channel is closed');
+            return;
+        }
+        if (message.id === undefined) {
+            message.id = this.getUniqueId();
+        }
+        if (message.timestamp === undefined) {
+            message.timestamp = Date.now();
+        }
+        message.src = this.name;
+        if (this.verbose)
+            this.log.debug(`Broadcasting message: ${debugStringify(message)}`);
+        try {
+            this.broadcastChannel.postMessage(message);
+        }
+        catch (error) {
+            logError(this.log, `Failed to broadcast message ${debugStringify(message)}${er}`, error);
+        }
+    }
+    request(message) {
+        if (this.closed) {
+            this.log.error('Broadcast channel is closed');
+            return;
+        }
+        if (message.id === undefined) {
+            message.id = this.getUniqueId();
+        }
+        if (message.timestamp === undefined) {
+            message.timestamp = Date.now();
+        }
+        message.src = this.name;
+        if (!this.isWorkerRequest(message)) {
+            this.log.error(`Invalid request message format: ${debugStringify(message)}`);
+            return;
+        }
+        if (this.verbose)
+            this.log.debug(`Broadcasting request message: ${debugStringify(message)}`);
+        try {
+            this.broadcastChannel.postMessage(message);
+        }
+        catch (error) {
+            logError(this.log, `Failed to broadcast request message ${debugStringify(message)}${er}`, error);
+        }
+    }
+    respond(message) {
+        if (this.closed) {
+            this.log.error('Broadcast channel is closed');
+            return;
+        }
+        if (typeof message.timestamp === 'number') {
+            message.elapsed = Date.now() - message.timestamp;
+        }
+        if (message.timestamp === undefined) {
+            message.timestamp = Date.now();
+        }
+        if (message.dst === this.name || message.dst === 'all') {
+            message.dst = message.src;
+        }
+        message.src = this.name;
+        if (!this.isWorkerResponse(message)) {
+            this.log.error(`Invalid response message format: ${debugStringify(message)}`);
+            return;
+        }
+        if (this.verbose)
+            this.log.debug(`Broadcasting response message: ${debugStringify(message)}`);
+        try {
+            this.broadcastChannel.postMessage(message);
+        }
+        catch (error) {
+            logError(this.log, `Failed to broadcast response message ${debugStringify(message)}${er}`, error);
+        }
+    }
+    async fetch(message, timeout = 250) {
+        if (this.closed) {
+            return Promise.reject(new Error('Broadcast channel is closed'));
+        }
+        if (message.id === undefined) {
+            message.id = this.getUniqueId();
+        }
+        if (message.timestamp === undefined) {
+            message.timestamp = Date.now();
+        }
+        if (this.verbose)
+            this.log.debug(`Fetching message: ${debugStringify(message)}`);
+        return new Promise((resolve, reject) => {
+            const responseHandler = (msg) => {
+                if (this.isWorkerResponseOfType(msg, message.type) && msg.id === message.id) {
+                    clearTimeout(timeoutId);
+                    this.off('broadcast_message', responseHandler);
+                    if (this.verbose)
+                        this.log.debug(`Fetch response: ${debugStringify(msg)}`);
+                    if ('error' in msg && typeof msg.error === 'string') {
+                        reject(new Error(`Fetch received error response ${msg.error} to message type ${message.type} id ${message.id} from ${message.src} to ${message.dst}`));
+                    }
+                    else if ('result' in msg) {
+                        resolve(msg);
+                    }
+                    else {
+                        reject(new Error(`Fetch received malformed response for message type ${message.type} id ${message.id} from ${message.src} to ${message.dst}`));
+                    }
+                    return;
+                }
+            };
+            this.on('broadcast_message', responseHandler);
+            this.request(message);
+            const timeoutId = setTimeout(() => {
+                this.off('broadcast_message', responseHandler);
+                reject(new Error(`Fetch timeout after ${timeout}ms for message type ${message.type} id ${message.id} from ${message.src} to ${message.dst}`));
+            }, timeout);
+        });
+    }
+}

package/dist/checkUpdates.d.ts

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

package/dist/checkUpdates.js

@@ -0,0 +1,139 @@
+import { AnsiLogger, db, debugStringify, nt, wr } from 'node-ansi-logger';
+import { isValidString } from '@matterbridge/utils';
+import { plg } from '@matterbridge/types';
+import { BroadcastServer } from './broadcastServer.js';
+export async function checkUpdates(matterbridge) {
+    const log = new AnsiLogger({ logName: 'MatterbridgeUpdates', logTimestampFormat: 4, logLevel: matterbridge.logLevel });
+    const server = new BroadcastServer('updates', log);
+    const checkUpdatePromise = checkUpdatesAndLog(matterbridge, log, server);
+    const latestVersionPromise = getMatterbridgeLatestVersion(matterbridge, log, server);
+    const devVersionPromise = getMatterbridgeDevVersion(matterbridge, log, server);
+    const pluginsVersionPromises = [];
+    const pluginsDevVersionPromises = [];
+    try {
+        const plugins = (await server.fetch({ type: 'plugins_apipluginarray', src: server.name, dst: 'plugins' }, 1000)).result.plugins;
+        for (const plugin of plugins) {
+            pluginsVersionPromises.push(getPluginLatestVersion(log, server, plugin));
+            pluginsDevVersionPromises.push(getPluginDevVersion(log, server, plugin));
+        }
+    }
+    catch (error) {
+        log.debug(`Error fetching plugins for update check: ${error instanceof Error ? error.message : error}`);
+    }
+    await Promise.all([checkUpdatePromise, latestVersionPromise, devVersionPromise, ...pluginsVersionPromises, ...pluginsDevVersionPromises]);
+    server.close();
+}
+export async function checkUpdatesAndLog(matterbridge, log, server) {
+    const { getGitHubUpdate } = await import('@matterbridge/utils');
+    const branch = matterbridge.matterbridgeVersion.includes('-dev-') ? 'dev' : 'main';
+    try {
+        const updateJson = await getGitHubUpdate(branch, 'update.json', 5_000);
+        log.debug(`GitHub ${branch} update status: ${debugStringify(updateJson)}.`);
+        if (isValidString(branch === 'main' ? updateJson.latestMessage : updateJson.devMessage, 1) &&
+            isValidString(branch === 'main' ? updateJson.latestMessageSeverity : updateJson.devMessageSeverity, 4) &&
+            ['info', 'warning', 'error', 'success'].includes(branch === 'main' ? updateJson.latestMessageSeverity : updateJson.devMessageSeverity)) {
+            log.notice(`GitHub ${branch} update message: ${branch === 'main' ? updateJson.latestMessage : updateJson.devMessage}`);
+            server.request({
+                type: 'frontend_snackbarmessage',
+                src: server.name,
+                dst: 'frontend',
+                params: {
+                    message: branch === 'main' ? updateJson.latestMessage : updateJson.devMessage,
+                    timeout: 0,
+                    severity: branch === 'main' ? updateJson.latestMessageSeverity : updateJson.devMessageSeverity,
+                },
+            });
+        }
+    }
+    catch (error) {
+        log.debug(`Error checking GitHub ${branch} updates: ${error instanceof Error ? error.message : error}`);
+    }
+}
+export async function getMatterbridgeLatestVersion(matterbridge, log, server) {
+    const { getNpmPackageVersion } = await import('@matterbridge/utils');
+    try {
+        const version = await getNpmPackageVersion('matterbridge');
+        server.request({ type: 'matterbridge_latest_version', src: server.name, dst: 'matterbridge', params: { version } });
+        if (matterbridge.matterbridgeVersion !== version) {
+            log.notice(`Matterbridge is out of date. Current version: ${matterbridge.matterbridgeVersion}. Latest version: ${version}.`);
+            server.request({
+                type: 'frontend_snackbarmessage',
+                src: server.name,
+                dst: 'frontend',
+                params: { message: 'Matterbridge latest update available', timeout: 0, severity: 'info' },
+            });
+            server.request({ type: 'frontend_updaterequired', src: server.name, dst: 'frontend', params: { devVersion: false } });
+            server.request({ type: 'frontend_refreshrequired', src: server.name, dst: 'frontend', params: { changed: 'settings' } });
+        }
+        else {
+            log.debug(`Matterbridge is up to date. Current version: ${matterbridge.matterbridgeVersion}. Latest version: ${version}.`);
+        }
+        return version;
+    }
+    catch (error) {
+        log.warn(`Error getting Matterbridge latest version: ${error instanceof Error ? error.message : error}`);
+    }
+}
+export async function getMatterbridgeDevVersion(matterbridge, log, server) {
+    const { getNpmPackageVersion } = await import('@matterbridge/utils');
+    try {
+        const version = await getNpmPackageVersion('matterbridge', 'dev');
+        server.request({ type: 'matterbridge_dev_version', src: server.name, dst: 'matterbridge', params: { version } });
+        if ((matterbridge.matterbridgeVersion.includes('-dev-') || matterbridge.matterbridgeVersion.includes('-git-')) && matterbridge.matterbridgeVersion !== version) {
+            log.notice(`Matterbridge@dev is out of date. Current version: ${matterbridge.matterbridgeVersion}. Latest dev version: ${version}.`);
+            server.request({
+                type: 'frontend_snackbarmessage',
+                src: server.name,
+                dst: 'frontend',
+                params: { message: 'Matterbridge dev update available', timeout: 0, severity: 'info' },
+            });
+            server.request({ type: 'frontend_updaterequired', src: server.name, dst: 'frontend', params: { devVersion: true } });
+            server.request({ type: 'frontend_refreshrequired', src: server.name, dst: 'frontend', params: { changed: 'settings' } });
+        }
+        else if ((matterbridge.matterbridgeVersion.includes('-dev-') || matterbridge.matterbridgeVersion.includes('-git-')) && matterbridge.matterbridgeVersion === version) {
+            log.debug(`Matterbridge@dev is up to date. Current version: ${matterbridge.matterbridgeVersion}. Latest dev version: ${version}.`);
+        }
+        return version;
+    }
+    catch (error) {
+        log.warn(`Error getting Matterbridge latest dev version: ${error instanceof Error ? error.message : error}`);
+    }
+}
+export async function getPluginLatestVersion(log, server, plugin) {
+    const { getNpmPackageVersion } = await import('@matterbridge/utils');
+    try {
+        const version = await getNpmPackageVersion(plugin.name);
+        plugin.latestVersion = version;
+        server.request({ type: 'plugins_set_latest_version', src: server.name, dst: 'plugins', params: { plugin, version } });
+        if (plugin.version !== plugin.latestVersion) {
+            log.notice(`The plugin ${plg}${plugin.name}${nt} is out of date. Current version: ${plugin.version}. Latest version: ${plugin.latestVersion}.`);
+            server.request({ type: 'frontend_refreshrequired', src: server.name, dst: 'frontend', params: { changed: 'plugins' } });
+        }
+        else {
+            log.debug(`The plugin ${plg}${plugin.name}${db} is up to date. Current version: ${plugin.version}. Latest version: ${plugin.latestVersion}.`);
+        }
+        return version;
+    }
+    catch (error) {
+        log.warn(`Error getting plugin ${plg}${plugin.name}${wr} latest version: ${error instanceof Error ? error.message : error}`);
+    }
+}
+export async function getPluginDevVersion(log, server, plugin) {
+    const { getNpmPackageVersion } = await import('@matterbridge/utils');
+    try {
+        const version = await getNpmPackageVersion(plugin.name, 'dev');
+        plugin.devVersion = version;
+        server.request({ type: 'plugins_set_dev_version', src: server.name, dst: 'plugins', params: { plugin, version } });
+        if ((plugin.version.includes('-dev-') || plugin.version.includes('-git-')) && plugin.version !== plugin.devVersion) {
+            log.notice(`The plugin ${plg}${plugin.name}${nt} is out of date. Current version: ${plugin.version}. Latest dev version: ${plugin.devVersion}.`);
+            server.request({ type: 'frontend_refreshrequired', src: server.name, dst: 'frontend', params: { changed: 'plugins' } });
+        }
+        else if (plugin.version.includes('-dev-') && plugin.version === plugin.devVersion) {
+            log.debug(`The plugin ${plg}${plugin.name}${db} is up to date. Current version: ${plugin.version}. Latest dev version: ${plugin.devVersion}.`);
+        }
+        return version;
+    }
+    catch (error) {
+        log.debug(`Error getting plugin ${plg}${plugin.name}${db} latest dev version: ${error instanceof Error ? error.message : error}`);
+    }
+}

package/dist/export.d.ts

@@ -1,2 +1,2 @@
 export * from './worker.js';
-export * from './workerTypes.js';
+export * from './broadcastServer.js';

package/dist/export.js

@@ -1,2 +1,2 @@
 export * from './worker.js';
-export * from './workerTypes.js';
+export * from './broadcastServer.js';

package/dist/worker.d.ts

@@ -1,6 +1,6 @@
 import { Worker } from 'node:worker_threads';
 import { AnsiLogger, LogLevel } from 'node-ansi-logger';
-import type { ParentPortMessage } from './workerTypes.js';
+import type { ParentPortMessage } from '@matterbridge/types';
 export declare function parentPost(message: ParentPortMessage): void;
 export declare function parentLog(logName: string | undefined, logLevel: 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[]): Worker;

package/dist/worker.js

@@ -2,11 +2,11 @@ import { isMainThread, parentPort, threadId, Worker, workerData } from 'node:wor
 import { pathToFileURL } from 'node:url';
 import { resolve } from 'node:path';
 import { inspect } from 'node:util';
-import { AnsiLogger, debugStringify } from 'node-ansi-logger';
+import { AnsiLogger, debugStringify, MAGENTA } from 'node-ansi-logger';
 import { hasParameter } from '@matterbridge/utils';
-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', logTimestampFormat: 4, logLevel: debug ? "debug" : "info" });
+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.`);

package/dist/workerCheckUpdates.js

@@ -0,0 +1,42 @@
+import { threadId, isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { AnsiLogger, MAGENTA } from 'node-ansi-logger';
+import { hasParameter, inspectError } from '@matterbridge/utils';
+import { checkUpdates } from './checkUpdates.js';
+import { logWorkerInfo, parentLog, parentPost } from './worker.js';
+import { BroadcastServer } from './broadcastServer.js';
+const debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-worker') || hasParameter('verbose-worker');
+const verbose = hasParameter('verbose') || hasParameter('verbose-worker');
+if (!isMainThread && parentPort) {
+    parentPost({ type: 'init', threadId, threadName: workerData.threadName, success: true });
+    if (debug)
+        parentLog('MatterbridgeCheckUpdates', "info", `Worker ${workerData.threadName}:${threadId} initialized.`);
+}
+const log = new AnsiLogger({
+    logName: 'MatterbridgeCheckUpdates',
+    logNameColor: MAGENTA,
+    logTimestampFormat: 4,
+    logLevel: debug ? "debug" : "info",
+});
+const server = new BroadcastServer('matterbridge', log);
+if (verbose)
+    logWorkerInfo(log, verbose);
+let success = false;
+try {
+    const shared = (await server.fetch({ type: 'matterbridge_shared', src: `matterbridge`, dst: 'matterbridge' })).result.data;
+    await checkUpdates(shared);
+    success = true;
+    log.debug(`Check updates succeeded`);
+    if (!isMainThread && parentPort)
+        parentLog('MatterbridgeCheckUpdates', "debug", `Check updates succeeded`);
+}
+catch (error) {
+    const errorMessage = inspectError(log, `Failed to check updates`, error);
+    if (!isMainThread && parentPort)
+        parentLog('MatterbridgeCheckUpdates', "error", errorMessage);
+}
+server.close();
+if (!isMainThread && parentPort) {
+    parentPost({ type: 'exit', threadId, threadName: workerData.threadName, success });
+    if (debug)
+        parentLog('MatterbridgeCheckUpdates', "info", `Worker ${workerData.threadName}:${threadId} exiting with success: ${success}.`);
+}

package/dist/workerGlobalPrefix.d.ts

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

package/dist/workerGlobalPrefix.js

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

package/package.json

@@ -1,17 +1,42 @@
 {
   "name": "@matterbridge/thread",
-  "version": "3.5.3",
+  "version": "3.5.4-dev-20260211-520e349",
   "description": "Matterbridge thread library",
   "author": "https://github.com/Luligu",
+  "homepage": "https://matterbridge.io/",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Luligu/matterbridge.git",
     "directory": "packages/thread"
   },
+  "bugs": {
+    "url": "https://github.com/Luligu/matterbridge/issues"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "keywords": [],
+  "keywords": [
+    "matterbridge",
+    "homebridge",
+    "bridge",
+    "plugin",
+    "frontend",
+    "matter.js",
+    "matter-node.js",
+    "matter",
+    "matterprotocol",
+    "iot",
+    "smarthome",
+    "connectedthings",
+    "hap",
+    "homekit",
+    "siri",
+    "google-home",
+    "alexa",
+    "homeassistant",
+    "smartthings",
+    "ewelink"
+  ],
   "license": "Apache-2.0",
   "funding": {
     "type": "buymeacoffee",
@@ -35,7 +60,13 @@
     "npm-shrinkwrap.json",
     "CHANGELOG.md"
   ],
+  "overrides": {
+    "eslint": "9.39.2",
+    "@eslint/js": "9.39.2"
+  },
   "dependencies": {
-    "node-ansi-logger": "3.2.0"
+    "node-ansi-logger": "3.2.0",
+    "@matterbridge/utils": "3.5.4-dev-20260211-520e349",
+    "@matterbridge/types": "3.5.4-dev-20260211-520e349"
   }
 }

package/dist/workerTypes.d.ts

@@ -1,27 +0,0 @@
-import type { LogLevel } from 'node-ansi-logger';
-export type ParentPortMessage = {
-    type: 'init';
-    threadName: string | null;
-    threadId: number;
-    success: boolean;
-} | {
-    type: 'ping';
-    threadName: string | null;
-    threadId: number;
-} | {
-    type: 'pong';
-    threadName: string | null;
-    threadId: number;
-} | {
-    type: 'log';
-    threadName: string | null;
-    threadId: number;
-    logName: string | undefined;
-    logLevel: LogLevel;
-    message: string;
-} | {
-    type: 'exit';
-    threadName: string | null;
-    threadId: number;
-    success: boolean;
-};