@matterbridge/thread 3.5.4-edge-20260211-1ea4e31 → 3.5.4

package/dist/checkUpdates.d.ts

@@ -1,6 +1,6 @@
 import { AnsiLogger } from 'node-ansi-logger';
 import type { ApiPlugin, SharedMatterbridge } from '@matterbridge/types';
-import { BroadcastServer } from '@matterbridge/thread';
+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>;

package/dist/checkUpdates.js

@@ -1,7 +1,7 @@
 import { AnsiLogger, db, debugStringify, nt, wr } from 'node-ansi-logger';
 import { isValidString } from '@matterbridge/utils';
 import { plg } from '@matterbridge/types';
-import { BroadcastServer } from '@matterbridge/thread';
+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);

package/dist/export.d.ts

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

package/dist/export.js

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

package/dist/worker.d.ts

@@ -3,5 +3,6 @@ import { AnsiLogger, LogLevel } from 'node-ansi-logger';
 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;
+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

@@ -22,7 +22,12 @@ export function parentLog(logName, logLevel, message) {
     if (debug)
         log.debug(`Worker ${workerData.threadName}:${threadId} sent log to parent: ${logName} ${logLevel} ${message}`);
 }
-export function createESMWorker(name, relativePath, workerData, argv, env, execArgv) {
+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 },
@@ -31,6 +36,8 @@ export function createESMWorker(name, relativePath, workerData, argv, env, execA
         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)}`);

package/dist/workerCheckUpdates.js

@@ -2,17 +2,18 @@ import { threadId, isMainThread, parentPort, workerData } from 'node:worker_thre
 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 { logWorkerInfo, parentLog, parentPost, threadLogger } 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');
+const name = 'MatterbridgeCheckUpdates';
 if (!isMainThread && parentPort) {
     parentPost({ type: 'init', threadId, threadName: workerData.threadName, success: true });
     if (debug)
-        parentLog('MatterbridgeCheckUpdates', "info", `Worker ${workerData.threadName}:${threadId} initialized.`);
+        parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} initialized.`);
 }
 const log = new AnsiLogger({
-    logName: 'MatterbridgeCheckUpdates',
+    logName: name,
     logNameColor: MAGENTA,
     logTimestampFormat: 4,
     logLevel: debug ? "debug" : "info",
@@ -20,23 +21,21 @@ const log = new AnsiLogger({
 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' })).result.data;
+    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;
-    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);
+    threadLogger(name, "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}.`);
+        parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} exiting with success: ${success}.`);
 }

package/dist/workerGlobalPrefix.js

@@ -1,17 +1,18 @@
 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 { logWorkerInfo, parentLog, parentPost, threadLogger } 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');
+const name = 'MatterbridgeGlobalPrefix';
 if (!isMainThread && parentPort) {
     parentPost({ type: 'init', threadId, threadName: workerData.threadName, success: true });
     if (debug)
-        parentLog('MatterbridgePrefix', "info", `Worker ${workerData.threadName}:${threadId} initialized.`);
+        parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} initialized.`);
 }
 const log = new AnsiLogger({
-    logName: 'MatterbridgePrefix',
+    logName: name,
     logNameColor: MAGENTA,
     logTimestampFormat: 4,
     logLevel: debug ? "debug" : "info",
@@ -20,23 +21,21 @@ 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();
-    log.debug(`Global node_modules Directory: ${prefix}`);
     server.request({ type: 'matterbridge_global_prefix', src: `matterbridge`, dst: 'matterbridge', params: { prefix } });
+    threadLogger(name, "info", `Global node_modules directory: ${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);
+    threadLogger(name, "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}.`);
+        parentLog(name, "info", `Worker ${workerData.threadName}:${threadId} exiting with success: ${success}.`);
 }

package/dist/workerSystemCheck.d.ts

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

package/dist/workerSystemCheck.js

@@ -0,0 +1,84 @@
+import { threadId, isMainThread, parentPort, workerData } from 'node:worker_threads';
+import os from 'node:os';
+import { AnsiLogger, MAGENTA } from 'node-ansi-logger';
+import { hasParameter, inspectError, excludedInterfaceNamePattern } from '@matterbridge/utils';
+import { logWorkerInfo, parentLog, parentPost, threadLogger } 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');
+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;
+        }
+    }
+    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}.`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/thread",
-  "version": "3.5.4-edge-20260211-1ea4e31",
+  "version": "3.5.4",
   "description": "Matterbridge thread library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -65,6 +65,8 @@
     "@eslint/js": "9.39.2"
   },
   "dependencies": {
-    "node-ansi-logger": "3.2.0"
+    "node-ansi-logger": "3.2.0",
+    "@matterbridge/utils": "3.5.4",
+    "@matterbridge/types": "3.5.4"
   }
 }