@matterbridge/thread 3.6.1-dev-20260311-7da5ff8 → 3.6.1-dev-20260312-a699c0e

package/dist/threadsManager.d.ts

@@ -17,6 +17,7 @@ export declare class ThreadsManager {
     private msgHandler;
     private intervalHandler;
     runThread(name: string, workerData?: WorkerData, argv?: string[], env?: NodeJS.ProcessEnv, execArgv?: string[], pipedOutput?: boolean): Worker;
+    runInMainThread(name: string, workerData?: WorkerData | null): Promise<boolean>;
     resolvePath(fileName: string): string;
     createESMWorker(name: string, relativePath: string, workerData?: Record<string, boolean | number | string | object>, argv?: string[], env?: NodeJS.ProcessEnv, execArgv?: string[], pipedOutput?: boolean): Worker;
 }

package/dist/threadsManager.js

@@ -69,7 +69,7 @@ export class ThreadsManager {
                         this.server.respond({ ...msg, result: { success: true } });
                     }
                     catch (err) {
-                        this.log.error(`Failed to run thread ${CYAN}${msg.params.name}${db}: ${err.message}`);
+                        this.log.warn(`Failed to run thread ${CYAN}${msg.params.name}${db}: ${err.message}`);
                         this.server.respond({ ...msg, result: { success: false } });
                     }
                     break;
@@ -143,6 +143,22 @@ export class ThreadsManager {
         this.log.debug(`Started thread ${threadInfo.name} from path ${path} type ${threadInfo.type} with thread id ${worker.threadId}`);
         return threadInfo.worker;
     }
+    async runInMainThread(name, workerData = null) {
+        const threadInfo = this.threads.find((t) => t.name === name);
+        if (!threadInfo) {
+            throw new Error(`Thread ${name} not found`);
+        }
+        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;
+            success = await workerWrapper.callback(workerWrapper);
+            workerWrapper.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 candidates = [

package/dist/workerCheckUpdates.d.ts

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

package/dist/workerCheckUpdates.js

@@ -1,7 +1,7 @@
 import { inspectError } from '@matterbridge/utils/error';
 import { checkUpdates } from './checkUpdates.js';
 import { WorkerWrapper } from './workerWrapper.js';
-new WorkerWrapper('CheckUpdates', async (worker) => {
+export default new WorkerWrapper('CheckUpdates', async (worker) => {
     worker.logger("info", `Starting check updates...`);
     let success = false;
     try {

package/dist/workerGlobalPrefix.d.ts

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

package/dist/workerGlobalPrefix.js

@@ -1,7 +1,7 @@
 import { inspectError } from '@matterbridge/utils/error';
 import { getGlobalNodeModules } from '@matterbridge/utils/npm-prefix';
 import { WorkerWrapper } from './workerWrapper.js';
-new WorkerWrapper('GlobalPrefix', async (worker) => {
+export default new WorkerWrapper('GlobalPrefix', async (worker) => {
     let prefix;
     worker.logger("info", `Starting global prefix check...`);
     let success = false;

package/dist/workerSpawnCommand.d.ts

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

package/dist/workerSpawnCommand.js

@@ -1,7 +1,7 @@
 import { isSpawnWorkerData } from '@matterbridge/types';
 import { spawnCommand } from './spawnCommand.js';
 import { WorkerWrapper } from './workerWrapper.js';
-new WorkerWrapper('SpawnCommand', async (worker) => {
+export default new WorkerWrapper('SpawnCommand', async (worker) => {
     if (!isSpawnWorkerData(worker.workerData)) {
         worker.logger("error", `SpawnCommand invalid parameters`);
         return false;

package/dist/workerSystemCheck.d.ts

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

package/dist/workerSystemCheck.js

@@ -2,7 +2,7 @@ import os from 'node:os';
 import { inspectError } from '@matterbridge/utils/error';
 import { excludedInterfaceNamePattern } from '@matterbridge/utils/network';
 import { WorkerWrapper } from './workerWrapper.js';
-new WorkerWrapper('SystemCheck', async (worker) => {
+export default new WorkerWrapper('SystemCheck', async (worker) => {
     worker.logger("info", `Starting system check...`);
     let success = false;
     try {

package/dist/workerWrapper.d.ts

@@ -4,6 +4,7 @@ import { AnsiLogger, LogLevel } from 'node-ansi-logger';
 import { BroadcastServer } from './broadcastServer.js';
 export declare class WorkerWrapper {
     name: ThreadNames;
+    callback: (worker: WorkerWrapper) => Promise<boolean>;
     debug: boolean;
     verbose: boolean;
     useTracker: boolean;

package/dist/workerWrapper.js

@@ -8,6 +8,7 @@ import { BroadcastServer } from './broadcastServer.js';
 import { ThreadsManager } from './threadsManager.js';
 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');
@@ -17,6 +18,7 @@ export class WorkerWrapper {
     tracker;
     constructor(name, callback) {
         this.name = name;
+        this.callback = callback;
         if (this.workerData) {
             this.debug = this.workerData.debug || this.debug;
             this.verbose = this.workerData.verbose || this.verbose;
@@ -65,12 +67,18 @@ export class WorkerWrapper {
             if (this.debug)
                 this.parentLog(this.name, "info", `Worker ${this.name}:${threadId} initialized.`);
         }
+        else {
+            if (this.debug)
+                this.log.debug(`Worker ${this.name}:${threadId} initialized in main thread.`);
+        }
         if (this.verbose)
             this.logWorkerInfo(this.log, false);
-        setImmediate(async () => {
-            const success = await callback(this);
-            this.destroy(success);
-        });
+        if (!isMainThread) {
+            setImmediate(async () => {
+                const success = await callback(this);
+                this.destroy(success);
+            });
+        }
     }
     destroy(success) {
         if (this.tracker)
@@ -82,6 +90,10 @@ export class WorkerWrapper {
             this.parentPost({ type: 'exit', threadId, threadName: this.name, memoryUsage: process.memoryUsage(), success });
             parentPort.close();
         }
+        else {
+            if (this.debug)
+                this.log.debug(`Worker ${this.name}:${threadId} exiting with success in main thread: ${success}.`);
+        }
     }
     parentPost(message) {
         if (!parentPort)

package/dist/zipjs.d.ts

@@ -0,0 +1,10 @@
+export interface ZipContentEntry {
+    filename: string;
+    directory: boolean;
+    compressedSize: number;
+    uncompressedSize: number;
+    lastModDate: Date;
+}
+export declare function createZip(zipPath: string, sourcePaths: string[]): Promise<number>;
+export declare function readZip(zipPath: string): Promise<ZipContentEntry[]>;
+export declare function unZip(zipPath: string, destinationPath?: string): Promise<string>;

package/dist/zipjs.js

@@ -0,0 +1,114 @@
+import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { Uint8ArrayReader, Uint8ArrayWriter, ZipReader, ZipWriter } from '@zip.js/zip.js';
+import { AnsiLogger } from 'node-ansi-logger';
+export async function createZip(zipPath, sourcePaths) {
+    if (sourcePaths.length === 0)
+        throw new Error('No files or directories provided to createZip.');
+    const log = createLogger();
+    const writer = new ZipWriter(new Uint8ArrayWriter());
+    let entryCount = 0;
+    for (const sourcePath of sourcePaths) {
+        const resolvedSourcePath = resolve(sourcePath);
+        entryCount += await addZipEntry(writer, resolvedSourcePath, basename(resolvedSourcePath), log);
+    }
+    const zipData = await writer.close();
+    await mkdir(dirname(zipPath), { recursive: true });
+    await writeFile(zipPath, zipData);
+    log.info(`Created zip ${zipPath} with ${entryCount} entries (${zipData.byteLength} bytes).`);
+    return zipData.byteLength;
+}
+export async function readZip(zipPath) {
+    const log = createLogger();
+    const reader = new ZipReader(new Uint8ArrayReader(await readFile(zipPath)));
+    try {
+        const entries = await reader.getEntries();
+        const content = entries.map((entry) => ({
+            filename: entry.filename,
+            directory: entry.directory,
+            compressedSize: entry.compressedSize,
+            uncompressedSize: entry.uncompressedSize,
+            lastModDate: entry.lastModDate,
+        }));
+        if (content.length === 0) {
+            log.info(`Zip ${zipPath} is empty.`);
+        }
+        else {
+            for (const entry of content) {
+                log.info(`${entry.directory ? 'dir ' : 'file'} ${entry.filename} (${entry.uncompressedSize} bytes)`);
+            }
+        }
+        return content;
+    }
+    finally {
+        await reader.close();
+    }
+}
+export async function unZip(zipPath, destinationPath = getDefaultDestinationPath(zipPath)) {
+    const log = createLogger();
+    const reader = new ZipReader(new Uint8ArrayReader(await readFile(zipPath)));
+    let extractedEntries = 0;
+    await mkdir(destinationPath, { recursive: true });
+    try {
+        const entries = await reader.getEntries();
+        for (const entry of entries) {
+            const entryPath = resolveEntryPath(destinationPath, entry.filename);
+            if (entry.directory) {
+                await mkdir(entryPath, { recursive: true });
+                extractedEntries++;
+                continue;
+            }
+            await mkdir(dirname(entryPath), { recursive: true });
+            const fileData = await entry.getData(new Uint8ArrayWriter());
+            await writeFile(entryPath, fileData);
+            extractedEntries++;
+        }
+    }
+    finally {
+        await reader.close();
+    }
+    log.info(`Extracted ${extractedEntries} entries from ${zipPath} to ${destinationPath}.`);
+    return destinationPath;
+}
+function createLogger() {
+    return new AnsiLogger({ logName: 'ZipJs', logTimestampFormat: 4, logLevel: "info" });
+}
+async function addZipEntry(writer, sourcePath, entryName, log) {
+    const sourceStats = await stat(sourcePath);
+    const normalizedEntryName = normalizeEntryName(entryName);
+    if (sourceStats.isDirectory()) {
+        const directoryEntryName = normalizedEntryName.replace(/\/?$/, '/');
+        await writer.add(directoryEntryName, undefined, { directory: true, lastModDate: sourceStats.mtime, level: 9 });
+        const children = await readdir(sourcePath, { withFileTypes: true });
+        children.sort((left, right) => left.name.localeCompare(right.name));
+        let childEntries = 1;
+        for (const child of children) {
+            childEntries += await addZipEntry(writer, join(sourcePath, child.name), `${directoryEntryName}${child.name}`, log);
+        }
+        log.debug(`Added directory ${directoryEntryName}`);
+        return childEntries;
+    }
+    if (sourceStats.isFile()) {
+        await writer.add(normalizedEntryName, new Uint8ArrayReader(await readFile(sourcePath)), { lastModDate: sourceStats.mtime, level: 9 });
+        log.debug(`Added file ${normalizedEntryName}`);
+        return 1;
+    }
+    throw new Error(`Unsupported source path type: ${sourcePath}`);
+}
+function getDefaultDestinationPath(zipPath) {
+    const zipExtension = extname(zipPath);
+    const zipName = basename(zipPath, zipExtension);
+    return join(dirname(zipPath), zipName);
+}
+function normalizeEntryName(entryName) {
+    return entryName.replace(/\\/g, '/');
+}
+function resolveEntryPath(destinationPath, entryName) {
+    const resolvedDestinationPath = resolve(destinationPath);
+    const resolvedEntryPath = resolve(resolvedDestinationPath, normalizeEntryName(entryName));
+    const relativeEntryPath = relative(resolvedDestinationPath, resolvedEntryPath);
+    if (isAbsolute(relativeEntryPath) || relativeEntryPath.startsWith('..')) {
+        throw new Error(`Refusing to extract zip entry outside destination: ${entryName}`);
+    }
+    return resolvedEntryPath;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/thread",
-  "version": "3.6.1-dev-20260311-7da5ff8",
+  "version": "3.6.1-dev-20260312-a699c0e",
   "description": "Matterbridge thread library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -69,8 +69,9 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@matterbridge/types": "3.6.1-dev-20260311-7da5ff8",
-    "@matterbridge/utils": "3.6.1-dev-20260311-7da5ff8",
+    "@matterbridge/types": "3.6.1-dev-20260312-a699c0e",
+    "@matterbridge/utils": "3.6.1-dev-20260312-a699c0e",
+    "@zip.js/zip.js": "2.8.23",
     "node-ansi-logger": "3.2.0"
   }
 }