@od-oneapp/config 2026.2.2001-canary.1

package/typescript/dist/src/server/worker-pool.d.ts

@@ -0,0 +1,87 @@
+import { EventEmitter } from 'node:events';
+import { Worker } from 'node:worker_threads';
+export interface WorkerPoolOptions {
+    maxWorkers?: number;
+    minWorkers?: number;
+    taskTimeout?: number;
+    idleTimeout?: number;
+    enableProfiling?: boolean;
+}
+export interface WorkerTask<T = unknown, R = unknown> {
+    id: string;
+    type: string;
+    data: T;
+    signal?: AbortSignal;
+    resolve: (result: R) => void;
+    reject: (error: Error) => void;
+    startTime: number;
+    timeout?: number;
+    timeoutId?: ReturnType<typeof setTimeout>;
+    cleanup?: () => void;
+}
+export interface WorkerInfo {
+    id: string;
+    worker: Worker;
+    busy: boolean;
+    currentTask?: string;
+    tasksCompleted: number;
+    totalTime: number;
+    lastUsed: number;
+    errors: number;
+}
+export interface WorkerPoolStats {
+    totalWorkers: number;
+    busyWorkers: number;
+    idleWorkers: number;
+    queuedTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    averageTaskTime: number;
+    totalTaskTime: number;
+    workerUtilization: number;
+}
+export declare class WorkerPool extends EventEmitter {
+    private workers;
+    private taskQueue;
+    private activeTasks;
+    private completedTasks;
+    private failedTasks;
+    private totalTaskTime;
+    private workerScript;
+    private options;
+    private cleanupInterval;
+    private isDestroyed;
+    private workerBitmap;
+    private workerIdToIndex;
+    private indexToWorkerId;
+    constructor(workerScript: string, options?: WorkerPoolOptions);
+    execute<T, R>(taskType: string, taskData: T, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<R>;
+    getStats(): WorkerPoolStats;
+    destroy(): Promise<void>;
+    private initializeMinWorkers;
+    private createWorker;
+    private processQueue;
+    private assignTaskToWorker;
+    private handleWorkerMessage;
+    private handleWorkerError;
+    private handleWorkerExit;
+    private handleTaskTimeout;
+    private cancelTask;
+    private cleanupTask;
+    private startCleanupInterval;
+    private cleanupIdleWorkers;
+    private generateTaskId;
+    private generateWorkerId;
+    private setWorkerIdle;
+    private setWorkerBusy;
+    private findIdleWorker;
+    private addWorkerToBitmap;
+    private removeWorkerFromBitmap;
+}
+export declare function createWorkerScript(handlers: Record<string, (data: any) => Promise<any> | any>): string;
+export declare function getGlobalWorkerPool(workerScript?: string, options?: WorkerPoolOptions): WorkerPool;
+export declare function destroyGlobalWorkerPool(): Promise<void> | void;
+//# sourceMappingURL=worker-pool.d.ts.map

package/typescript/dist/src/server/worker-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-pool.d.ts","sourceRoot":"","sources":["../../../../../core-utils/src/server/worker-pool.ts"],"names":[],"mappings":"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"}

package/typescript/dist/src/server/worker-pool.js

@@ -0,0 +1,586 @@
+import { EventEmitter } from 'node:events';
+import { Worker, isMainThread } from 'node:worker_threads';
+import { logError } from '@repo/shared/logs';
+import { safeThrowIfAborted } from './abort-support';
+export class WorkerPool extends EventEmitter {
+    workers = new Map();
+    taskQueue = [];
+    activeTasks = new Map();
+    completedTasks = 0;
+    failedTasks = 0;
+    totalTaskTime = 0;
+    workerScript;
+    options;
+    cleanupInterval = null;
+    isDestroyed = false;
+    workerBitmap = 0;
+    workerIdToIndex = new Map();
+    indexToWorkerId = new Map();
+    constructor(workerScript, options = {}) {
+        super();
+        this.workerScript = workerScript;
+        const os = require('node:os');
+        this.options = {
+            maxWorkers: options.maxWorkers || Math.max(2, Math.min(8, os.cpus().length)),
+            minWorkers: options.minWorkers ?? 1,
+            taskTimeout: options.taskTimeout ?? 30000,
+            idleTimeout: options.idleTimeout ?? 60000,
+            enableProfiling: options.enableProfiling ?? false,
+        };
+        this.initializeMinWorkers();
+        this.startCleanupInterval();
+    }
+    async execute(taskType, taskData, options = {}) {
+        if (this.isDestroyed) {
+            throw new Error('WorkerPool has been destroyed');
+        }
+        const { timeout = this.options.taskTimeout, signal } = options;
+        safeThrowIfAborted(signal);
+        const taskId = this.generateTaskId();
+        return new Promise((resolve, reject) => {
+            const task = {
+                id: taskId,
+                type: taskType,
+                data: taskData,
+                signal,
+                resolve: result => resolve(result),
+                reject,
+                startTime: Date.now(),
+                timeout,
+            };
+            if (signal) {
+                const onAbort = () => {
+                    this.cancelTask(taskId);
+                    reject(new Error('Task aborted'));
+                };
+                if (signal.aborted) {
+                    onAbort();
+                    return;
+                }
+                signal.addEventListener('abort', onAbort, { once: true });
+                task.cleanup = () => {
+                    signal.removeEventListener('abort', onAbort);
+                };
+            }
+            this.taskQueue.push(task);
+            this.processQueue();
+        });
+    }
+    getStats() {
+        const busyWorkers = Array.from(this.workers.values()).filter(w => w.busy).length;
+        const totalWorkers = this.workers.size;
+        return {
+            totalWorkers,
+            busyWorkers,
+            idleWorkers: totalWorkers - busyWorkers,
+            queuedTasks: this.taskQueue.length,
+            completedTasks: this.completedTasks,
+            failedTasks: this.failedTasks,
+            averageTaskTime: this.completedTasks > 0 ? this.totalTaskTime / this.completedTasks : 0,
+            totalTaskTime: this.totalTaskTime,
+            workerUtilization: totalWorkers > 0 ? (busyWorkers / totalWorkers) * 100 : 0,
+        };
+    }
+    async destroy() {
+        if (this.isDestroyed)
+            return;
+        this.isDestroyed = true;
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        for (const task of this.taskQueue) {
+            task.reject(new Error('WorkerPool destroyed'));
+            this.cleanupTask(task);
+        }
+        this.taskQueue.length = 0;
+        for (const task of this.activeTasks.values()) {
+            task.reject(new Error('WorkerPool destroyed'));
+            this.cleanupTask(task);
+        }
+        this.activeTasks.clear();
+        const terminationPromises = Array.from(this.workers.values()).map(async (workerInfo) => {
+            try {
+                await workerInfo.worker.terminate();
+            }
+            catch (error) {
+                logError(`Error terminating worker ${workerInfo.id}`, { error, workerId: workerInfo.id });
+            }
+        });
+        await Promise.all(terminationPromises);
+        this.workers.clear();
+        this.emit('destroyed');
+    }
+    initializeMinWorkers() {
+        for (let i = 0; i < this.options.minWorkers; i++) {
+            this.createWorker();
+        }
+    }
+    createWorker() {
+        const workerId = this.generateWorkerId();
+        const worker = new Worker(this.workerScript, {
+            workerData: {
+                workerId,
+                enableProfiling: this.options.enableProfiling,
+            },
+        });
+        const workerInfo = {
+            id: workerId,
+            worker,
+            busy: false,
+            tasksCompleted: 0,
+            totalTime: 0,
+            lastUsed: Date.now(),
+            errors: 0,
+        };
+        worker.on('message', message => {
+            this.handleWorkerMessage(workerInfo, message);
+        });
+        worker.on('error', err => {
+            this.handleWorkerError(workerInfo, err instanceof Error ? err : new Error(String(err)));
+        });
+        worker.on('exit', code => {
+            this.handleWorkerExit(workerInfo, code);
+        });
+        this.workers.set(workerId, workerInfo);
+        this.addWorkerToBitmap(workerId);
+        this.emit('workerCreated', workerInfo);
+        return workerInfo;
+    }
+    processQueue() {
+        if (this.taskQueue.length === 0 || this.isDestroyed)
+            return;
+        let availableWorker = this.findIdleWorker();
+        if (!availableWorker && this.workers.size < this.options.maxWorkers) {
+            availableWorker = this.createWorker();
+        }
+        if (availableWorker) {
+            const task = this.taskQueue.shift();
+            if (task) {
+                this.assignTaskToWorker(availableWorker, task);
+                if (this.taskQueue.length > 0) {
+                    setImmediate(() => this.processQueue());
+                }
+            }
+        }
+    }
+    assignTaskToWorker(workerInfo, task) {
+        if (task.signal?.aborted) {
+            task.reject(new Error('Task aborted'));
+            this.cleanupTask(task);
+            return;
+        }
+        workerInfo.busy = true;
+        workerInfo.currentTask = task.id;
+        workerInfo.lastUsed = Date.now();
+        this.setWorkerBusy(workerInfo.id);
+        this.activeTasks.set(task.id, task);
+        const timeout = setTimeout(() => {
+            this.handleTaskTimeout(task);
+        }, task.timeout || this.options.taskTimeout);
+        task.timeoutId = timeout;
+        workerInfo.worker.postMessage({
+            taskId: task.id,
+            type: task.type,
+            data: task.data,
+        });
+        this.emit('taskStarted', { taskId: task.id, workerId: workerInfo.id });
+    }
+    handleWorkerMessage(workerInfo, message) {
+        if (typeof message !== 'object' || message === null)
+            return;
+        const msg = message;
+        const { taskId, success, result, error, duration } = msg;
+        if (!taskId)
+            return;
+        const task = this.activeTasks.get(taskId);
+        if (!task)
+            return;
+        if (task.timeoutId) {
+            clearTimeout(task.timeoutId);
+        }
+        workerInfo.busy = false;
+        workerInfo.currentTask = undefined;
+        workerInfo.tasksCompleted++;
+        workerInfo.totalTime += duration ?? 0;
+        this.setWorkerIdle(workerInfo.id);
+        this.totalTaskTime += duration ?? 0;
+        this.activeTasks.delete(taskId);
+        if (success) {
+            this.completedTasks++;
+            task.resolve(result);
+            this.emit('taskCompleted', { taskId, workerId: workerInfo.id, duration });
+        }
+        else {
+            this.failedTasks++;
+            workerInfo.errors++;
+            const errorMessage = typeof error === 'string'
+                ? error
+                : error instanceof Error
+                    ? error.message
+                    : 'Worker task failed';
+            task.reject(new Error(errorMessage));
+            this.emit('taskFailed', { taskId, workerId: workerInfo.id, error });
+        }
+        this.cleanupTask(task);
+        setImmediate(() => this.processQueue());
+    }
+    handleWorkerError(workerInfo, error) {
+        workerInfo.errors++;
+        this.emit('workerError', { workerId: workerInfo.id, error });
+        if (workerInfo.currentTask) {
+            const task = this.activeTasks.get(workerInfo.currentTask);
+            if (task) {
+                this.failedTasks++;
+                task.reject(error);
+                this.activeTasks.delete(workerInfo.currentTask);
+                this.cleanupTask(task);
+            }
+        }
+        this.workers.delete(workerInfo.id);
+        this.removeWorkerFromBitmap(workerInfo.id);
+        if (!this.isDestroyed && this.workers.size < this.options.minWorkers) {
+            setImmediate(() => this.createWorker());
+        }
+    }
+    handleWorkerExit(workerInfo, code) {
+        this.emit('workerExit', { workerId: workerInfo.id, exitCode: code });
+        if (workerInfo.currentTask) {
+            const task = this.activeTasks.get(workerInfo.currentTask);
+            if (task) {
+                this.failedTasks++;
+                task.reject(new Error(`Worker exited with code ${code}`));
+                this.activeTasks.delete(workerInfo.currentTask);
+                this.cleanupTask(task);
+            }
+        }
+        this.workers.delete(workerInfo.id);
+        this.removeWorkerFromBitmap(workerInfo.id);
+        if (!this.isDestroyed && this.workers.size < this.options.minWorkers) {
+            setImmediate(() => this.createWorker());
+        }
+    }
+    handleTaskTimeout(task) {
+        if (!this.activeTasks.has(task.id))
+            return;
+        this.activeTasks.delete(task.id);
+        this.failedTasks++;
+        task.reject(new Error(`Task timeout after ${task.timeout}ms`));
+        this.cleanupTask(task);
+        const workerInfo = Array.from(this.workers.values()).find(w => w.currentTask === task.id);
+        if (workerInfo) {
+            workerInfo.busy = false;
+            workerInfo.currentTask = undefined;
+            workerInfo.errors++;
+            this.setWorkerIdle(workerInfo.id);
+        }
+        this.emit('taskTimeout', { taskId: task.id });
+    }
+    cancelTask(taskId) {
+        const queueIndex = this.taskQueue.findIndex(t => t.id === taskId);
+        if (queueIndex >= 0) {
+            const [task] = this.taskQueue.splice(queueIndex, 1);
+            if (task) {
+                this.cleanupTask(task);
+            }
+            return;
+        }
+        const task = this.activeTasks.get(taskId);
+        if (task) {
+            if (task.timeoutId) {
+                clearTimeout(task.timeoutId);
+            }
+            this.activeTasks.delete(taskId);
+            this.cleanupTask(task);
+            const workerInfo = Array.from(this.workers.values()).find(w => w.currentTask === taskId);
+            if (workerInfo) {
+                workerInfo.busy = false;
+                workerInfo.currentTask = undefined;
+                this.setWorkerIdle(workerInfo.id);
+            }
+        }
+    }
+    cleanupTask(task) {
+        if (task.cleanup) {
+            task.cleanup();
+        }
+    }
+    startCleanupInterval() {
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupIdleWorkers();
+        }, this.options.idleTimeout / 2);
+        this.cleanupInterval.unref();
+    }
+    cleanupIdleWorkers() {
+        if (this.isDestroyed || this.workers.size <= this.options.minWorkers)
+            return;
+        const now = Date.now();
+        const workersToRemove = [];
+        for (const workerInfo of this.workers.values()) {
+            if (!workerInfo.busy &&
+                now - workerInfo.lastUsed > this.options.idleTimeout &&
+                this.workers.size > this.options.minWorkers) {
+                workersToRemove.push(workerInfo);
+            }
+        }
+        for (const workerInfo of workersToRemove) {
+            if (this.workers.size <= this.options.minWorkers)
+                break;
+            this.workers.delete(workerInfo.id);
+            this.removeWorkerFromBitmap(workerInfo.id);
+            void workerInfo.worker.terminate();
+            this.emit('workerTerminated', { workerId: workerInfo.id, reason: 'idle' });
+        }
+    }
+    generateTaskId() {
+        return `task_${Date.now()}_${crypto.randomUUID().substring(0, 8)}`;
+    }
+    generateWorkerId() {
+        return `worker_${Date.now()}_${crypto.randomUUID().substring(0, 8)}`;
+    }
+    setWorkerIdle(workerId) {
+        const index = this.workerIdToIndex.get(workerId);
+        if (index !== undefined) {
+            this.workerBitmap |= 1 << index;
+        }
+    }
+    setWorkerBusy(workerId) {
+        const index = this.workerIdToIndex.get(workerId);
+        if (index !== undefined) {
+            this.workerBitmap &= ~(1 << index);
+        }
+    }
+    findIdleWorker() {
+        if (this.workerBitmap === 0)
+            return undefined;
+        const idleIndex = Math.log2(this.workerBitmap & -this.workerBitmap);
+        const workerId = this.indexToWorkerId.get(idleIndex);
+        return workerId ? this.workers.get(workerId) : undefined;
+    }
+    addWorkerToBitmap(workerId) {
+        let index = 0;
+        while (index < 32 && this.indexToWorkerId.has(index)) {
+            index++;
+        }
+        if (index >= 32) {
+            throw new Error('Maximum workers exceeded for bitmap optimization');
+        }
+        this.workerIdToIndex.set(workerId, index);
+        this.indexToWorkerId.set(index, workerId);
+        this.setWorkerIdle(workerId);
+        return index;
+    }
+    removeWorkerFromBitmap(workerId) {
+        const index = this.workerIdToIndex.get(workerId);
+        if (index !== undefined) {
+            this.workerBitmap &= ~(1 << index);
+            this.workerIdToIndex.delete(workerId);
+            this.indexToWorkerId.delete(index);
+        }
+    }
+}
+export function createWorkerScript(handlers) {
+    class WorkerSecurityValidator {
+        static DANGEROUS_PATTERNS = [
+            /\beval\s*\(/,
+            /\bFunction\s*\(/,
+            /\bnew\s+Function\s*\(/,
+            /\bprocess\s*[\.\[]/,
+            /\bglobal\s*[\.\[]/,
+            /\bglobalThis\s*[\.\[]/,
+            /\b__dirname\b/,
+            /\b__filename\b/,
+            /\brequire\s*\(/,
+            /\bimport\s*\(/,
+            /child_process/,
+            /\bfs\b/,
+            /\bnet\b/,
+            /\bhttp\b/,
+            /\bconstructor\s*[\.\[]/,
+            /\b__proto__\s*[\.\[]/,
+            /\bprototype\s*[\.\[]/,
+        ];
+        static validateHandlers(handlers) {
+            if (Object.keys(handlers).length > 50) {
+                throw new Error('Too many handlers - security limit exceeded');
+            }
+            return Object.entries(handlers).reduce((acc, [key, handler]) => {
+                this.validateHandler(key, handler);
+                acc[key] = handler.toString();
+                return acc;
+            }, {});
+        }
+        static validateHandler(key, handler) {
+            if (typeof handler !== 'function') {
+                throw new Error(`Handler for '${key}' must be a function`);
+            }
+            const source = handler.toString();
+            if (source.length > 10000) {
+                throw new Error(`Handler '${key}' is too large (${source.length} chars)`);
+            }
+            for (const pattern of this.DANGEROUS_PATTERNS) {
+                if (pattern.test(source)) {
+                    throw new Error(`Handler '${key}' contains dangerous pattern: ${pattern.toString()}`);
+                }
+            }
+        }
+    }
+    const validatedHandlers = WorkerSecurityValidator.validateHandlers(handlers);
+    return `
+    const { parentPort, workerData } = require('worker_threads');
+    const { workerId, enableProfiling } = workerData;
+    const vm = require('vm');
+
+    // Security: Enhanced VM context with comprehensive restrictions
+    class SecureVMContext {
+      static createRestrictedContext() {
+        const safeBuiltins = Object.create(null);
+
+        // Only expose truly safe operations
+        safeBuiltins.Array = Array;
+        safeBuiltins.Object = {
+          keys: Object.keys,
+          values: Object.values,
+          entries: Object.entries,
+          assign: Object.assign,
+        };
+        safeBuiltins.String = String;
+        safeBuiltins.Number = Number;
+        safeBuiltins.Boolean = Boolean;
+        safeBuiltins.JSON = { parse: JSON.parse, stringify: JSON.stringify };
+        safeBuiltins.Date = Date;
+        safeBuiltins.Math = Math;
+        safeBuiltins.Promise = Promise;
+
+        // Restricted console for debugging
+        safeBuiltins.console = {
+          log: (...args) => console.log('[WORKER]', ...args),
+          warn: (...args) => console.warn('[WORKER]', ...args),
+          error: (...args) => console.error('[WORKER]', ...args)
+        };
+
+        // Security: Explicitly poison dangerous globals
+        const poisonedGlobals = {
+          eval: () => { throw new Error('eval not allowed'); },
+          Function: () => { throw new Error('Function constructor not allowed'); },
+          require: () => { throw new Error('require not allowed'); },
+          process: () => { throw new Error('process access not allowed'); },
+          global: () => { throw new Error('global access not allowed'); },
+          Buffer: undefined,
+          setTimeout: () => { throw new Error('setTimeout not allowed'); },
+          constructor: undefined,
+          __proto__: undefined,
+          prototype: undefined,
+        };
+
+        return Object.assign(Object.create(null), safeBuiltins, poisonedGlobals);
+      }
+    }
+
+    const safeContext = SecureVMContext.createRestrictedContext();
+
+    const handlerEntries = ${JSON.stringify(Object.entries(validatedHandlers))};
+
+    const handlers = handlerEntries.reduce((acc, [key, functionSource]) => {
+      try {
+        // Security: Enhanced VM compilation with strict mode
+        const wrappedSource = \`
+          'use strict';
+          (function() {
+            if (typeof this !== 'undefined' && this !== null) {
+              throw new Error('Unexpected this context');
+            }
+            return (\${functionSource});
+          })()
+        \`;
+
+        acc[key] = vm.runInNewContext(wrappedSource, safeContext, {
+          timeout: 3000, // Reduced timeout for security
+          displayErrors: false, // Don't leak error details
+          contextName: \`worker-handler-\${key}\`,
+          contextCodeGeneration: {
+            strings: false, // Disable string-to-code generation
+            wasm: false, // Disable WASM generation
+          },
+        });
+
+        // Security: Comprehensive validation
+        if (typeof acc[key] !== 'function') {
+          throw new Error(\`Handler '\${key}' compilation failed\`);
+        }
+
+        // Security: Wrap function with runtime protections
+        const originalFn = acc[key];
+        acc[key] = function secureWrapper(data) {
+          if (data && typeof data === 'object') {
+            if ('constructor' in data ?? '__proto__' in data) {
+              throw new Error('Dangerous properties in input data');
+            }
+          }
+          return originalFn.call(null, data);
+        };
+      } catch (error) {
+        throw new Error(\`Failed to compile handler '\${key}': \${error.message}\`);
+      }
+      return acc;
+    }, {});
+
+    parentPort.on('message', msg => {
+      void (async () => {
+        const { taskId, type, data } = msg;
+        const startTime = enableProfiling ? performance.now() : 0;
+
+        try {
+          const handler = handlers[type];
+          if (!handler) {
+            throw new Error(\`Unknown task type: \${type}\`);
+          }
+
+          const result = await handler(data);
+          const duration = enableProfiling ? performance.now() - startTime : 0;
+
+          parentPort.postMessage({
+            taskId,
+            success: true,
+            result,
+            duration,
+          });
+        } catch (error) {
+          const duration = enableProfiling ? performance.now() - startTime : 0;
+
+          parentPort.postMessage({
+            taskId,
+            success: false,
+            error: error.message,
+            duration,
+          });
+        }
+      })();
+    });
+  `;
+}
+let globalWorkerPool = null;
+export function getGlobalWorkerPool(workerScript, options) {
+    if (!globalWorkerPool) {
+        if (!workerScript) {
+            throw new Error('Worker script required for first initialization');
+        }
+        globalWorkerPool = new WorkerPool(workerScript, options);
+    }
+    return globalWorkerPool;
+}
+export function destroyGlobalWorkerPool() {
+    if (globalWorkerPool) {
+        const pool = globalWorkerPool;
+        globalWorkerPool = null;
+        return pool.destroy();
+    }
+}
+if (isMainThread) {
+    process.on('beforeExit', () => {
+        if (globalWorkerPool) {
+            void destroyGlobalWorkerPool();
+        }
+    });
+}
+//# sourceMappingURL=worker-pool.js.map