tywrap 0.1.1 → 0.2.0

package/dist/runtime/optimized-node.js

@@ -1,630 +1,22 @@
 /**
- * Optimized Node.js Runtime Bridge with Connection Pooling and Memory Management
- * High-performance Python subprocess management for production workloads
+ * @deprecated Import from './node.js' instead.
+ *
+ * OptimizedNodeBridge has been unified with NodeBridge. The NodeBridge class
+ * now supports both single-process mode (default) and multi-process pooling
+ * via the minProcesses/maxProcesses options.
+ *
+ * Migration:
+ * ```typescript
+ * // Before
+ * import { OptimizedNodeBridge, ProcessPoolOptions } from './optimized-node.js';
+ * const bridge = new OptimizedNodeBridge({ minProcesses: 2, maxProcesses: 4 });
+ *
+ * // After
+ * import { NodeBridge, NodeBridgeOptions } from './node.js';
+ * const bridge = new NodeBridge({ minProcesses: 2, maxProcesses: 4 });
+ * ```
+ *
+ * This file is maintained for backward compatibility only.
  */
-import { delimiter, isAbsolute, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { EventEmitter } from 'events';
-import { globalCache } from '../utils/cache.js';
-import { decodeValueAsync } from '../utils/codec.js';
-import { getDefaultPythonPath } from '../utils/python.js';
-import { getVenvBinDir, getVenvPythonExe } from '../utils/runtime.js';
-import { RuntimeBridge } from './base.js';
-import { BridgeExecutionError, BridgeProtocolError } from './errors.js';
-import { TYWRAP_PROTOCOL } from './protocol.js';
-import { getComponentLogger } from '../utils/logger.js';
-const log = getComponentLogger('OptimizedBridge');
-function resolveDefaultScriptPath() {
-    try {
-        return fileURLToPath(new URL('../../runtime/python_bridge.py', import.meta.url));
-    }
-    catch {
-        return 'runtime/python_bridge.py';
-    }
-}
-function resolveVirtualEnv(virtualEnv, cwd) {
-    const venvPath = resolve(cwd, virtualEnv);
-    const binDir = join(venvPath, getVenvBinDir());
-    const pythonPath = join(binDir, getVenvPythonExe());
-    return { venvPath, binDir, pythonPath };
-}
-export class OptimizedNodeBridge extends RuntimeBridge {
-    processPool = [];
-    roundRobinIndex = 0;
-    nextId = 1;
-    cleanupTimer;
-    options;
-    emitter = new EventEmitter();
-    disposed = false;
-    // Performance monitoring
-    stats = {
-        totalRequests: 0,
-        totalTime: 0,
-        cacheHits: 0,
-        poolHits: 0,
-        poolMisses: 0,
-        processSpawns: 0,
-        processDeaths: 0,
-        memoryPeak: 0,
-        averageTime: 0,
-        cacheHitRate: 0,
-    };
-    constructor(options = {}) {
-        super();
-        const cwd = options.cwd ?? process.cwd();
-        const virtualEnv = options.virtualEnv ? resolve(cwd, options.virtualEnv) : '';
-        const venv = virtualEnv ? resolveVirtualEnv(virtualEnv, cwd) : undefined;
-        const scriptPath = options.scriptPath ?? resolveDefaultScriptPath();
-        const resolvedScriptPath = isAbsolute(scriptPath) ? scriptPath : resolve(cwd, scriptPath);
-        this.options = {
-            minProcesses: options.minProcesses ?? 2,
-            maxProcesses: options.maxProcesses ?? 8,
-            maxIdleTime: options.maxIdleTime ?? 300000, // 5 minutes
-            maxRequestsPerProcess: options.maxRequestsPerProcess ?? 1000,
-            pythonPath: options.pythonPath ?? venv?.pythonPath ?? getDefaultPythonPath(),
-            scriptPath: resolvedScriptPath,
-            virtualEnv,
-            cwd,
-            timeoutMs: options.timeoutMs ?? 30000,
-            enableJsonFallback: options.enableJsonFallback ?? false,
-            env: options.env ?? {},
-            warmupCommands: options.warmupCommands ?? [],
-        };
-        // Start with minimum processes
-        this.startCleanupScheduler();
-    }
-    async init() {
-        if (this.disposed) {
-            throw new Error('Bridge has been disposed');
-        }
-        // Ensure minimum processes are available
-        while (this.processPool.length < this.options.minProcesses) {
-            await this.spawnProcess();
-        }
-        // Warm up processes if configured
-        if (this.options.warmupCommands.length > 0) {
-            await this.warmupProcesses();
-        }
-    }
-    async call(module, functionName, args, kwargs) {
-        const startTime = performance.now();
-        // Try cache first for pure functions
-        const cacheKey = globalCache.generateKey('runtime_call', module, functionName, args, kwargs);
-        const cached = await globalCache.get(cacheKey);
-        if (cached !== null) {
-            this.stats.cacheHits++;
-            // Runtime cache HIT for ${module}.${functionName}
-            return cached;
-        }
-        try {
-            const result = await this.executeRequest({
-                method: 'call',
-                params: { module, functionName, args, kwargs },
-            });
-            const duration = performance.now() - startTime;
-            // Cache result for pure functions (simple heuristic)
-            if (this.isPureFunctionCandidate(functionName, args)) {
-                await globalCache.set(cacheKey, result, {
-                    computeTime: duration,
-                    dependencies: [module],
-                });
-            }
-            this.updateStats(duration);
-            return result;
-        }
-        catch (error) {
-            this.updateStats(performance.now() - startTime, true);
-            throw error;
-        }
-    }
-    async instantiate(module, className, args, kwargs) {
-        const startTime = performance.now();
-        try {
-            const result = await this.executeRequest({
-                method: 'instantiate',
-                params: { module, className, args, kwargs },
-            });
-            this.updateStats(performance.now() - startTime);
-            return result;
-        }
-        catch (error) {
-            this.updateStats(performance.now() - startTime, true);
-            throw error;
-        }
-    }
-    async callMethod(handle, methodName, args, kwargs) {
-        const startTime = performance.now();
-        try {
-            const result = await this.executeRequest({
-                method: 'call_method',
-                params: { handle, methodName, args, kwargs },
-            });
-            this.updateStats(performance.now() - startTime);
-            return result;
-        }
-        catch (error) {
-            this.updateStats(performance.now() - startTime, true);
-            throw error;
-        }
-    }
-    async disposeInstance(handle) {
-        await this.executeRequest({
-            method: 'dispose_instance',
-            params: { handle },
-        });
-    }
-    /**
-     * Execute request with intelligent process selection
-     */
-    async executeRequest(payload) {
-        let worker = this.selectOptimalWorker();
-        // Spawn new process if none available and under limit
-        if (!worker && this.processPool.length < this.options.maxProcesses) {
-            try {
-                worker = await this.spawnProcess();
-                this.stats.poolMisses++;
-            }
-            catch (error) {
-                throw new Error(`Failed to spawn worker process: ${error}`);
-            }
-        }
-        // Wait for worker if all are busy
-        worker ??= await this.waitForAvailableWorker();
-        this.stats.poolHits++;
-        return this.sendToWorker(worker, payload);
-    }
-    /**
-     * Select optimal worker based on load and performance
-     */
-    selectOptimalWorker() {
-        const availableWorkers = this.processPool.filter(w => !w.busy && w.process.connected);
-        if (availableWorkers.length === 0) {
-            return null;
-        }
-        // Simple round-robin for now, could be enhanced with load-based selection
-        const worker = availableWorkers[this.roundRobinIndex % availableWorkers.length];
-        this.roundRobinIndex = (this.roundRobinIndex + 1) % availableWorkers.length;
-        return worker ?? null;
-    }
-    /**
-     * Wait for any worker to become available
-     */
-    async waitForAvailableWorker(timeoutMs = 5000) {
-        return new Promise((resolvePromise, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error('Timeout waiting for available worker'));
-            }, timeoutMs);
-            const checkWorker = () => {
-                const worker = this.selectOptimalWorker();
-                if (worker) {
-                    clearTimeout(timeout);
-                    resolvePromise(worker);
-                }
-                else {
-                    // Check again in 10ms
-                    setTimeout(checkWorker, 10);
-                }
-            };
-            checkWorker();
-        });
-    }
-    /**
-     * Send request to specific worker
-     */
-    async sendToWorker(worker, payload) {
-        const id = this.nextId++;
-        const message = { id, protocol: TYWRAP_PROTOCOL, ...payload };
-        const text = `${JSON.stringify(message)}\n`;
-        worker.busy = true;
-        worker.requestCount++;
-        worker.lastUsed = Date.now();
-        return new Promise((resolvePromise, reject) => {
-            const startTime = performance.now();
-            const timer = setTimeout(() => {
-                worker.pendingRequests.delete(id);
-                worker.busy = false;
-                reject(new Error(`Request ${id} timed out after ${this.options.timeoutMs}ms`));
-            }, this.options.timeoutMs);
-            worker.pendingRequests.set(id, {
-                resolve: (value) => {
-                    const duration = performance.now() - startTime;
-                    worker.stats.totalTime += duration;
-                    worker.stats.totalRequests++;
-                    worker.stats.averageTime = worker.stats.totalTime / worker.stats.totalRequests;
-                    worker.busy = false;
-                    resolvePromise(value);
-                },
-                reject: (error) => {
-                    worker.stats.errorCount++;
-                    worker.busy = false;
-                    reject(error);
-                },
-                timer,
-                startTime,
-            });
-            if (!worker.process.stdin?.writable) {
-                worker.pendingRequests.delete(id);
-                worker.busy = false;
-                clearTimeout(timer);
-                reject(new Error('Worker process stdin not writable'));
-                return;
-            }
-            try {
-                worker.process.stdin.write(text);
-            }
-            catch (error) {
-                worker.pendingRequests.delete(id);
-                worker.busy = false;
-                clearTimeout(timer);
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Spawn new worker process with optimizations
-     */
-    async spawnProcess() {
-        const { spawn } = await import('child_process');
-        const workerId = `worker_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        const env = {
-            ...process.env,
-            ...this.options.env,
-            PYTHONUNBUFFERED: '1', // Ensure immediate output
-            PYTHONDONTWRITEBYTECODE: '1', // Skip .pyc files for faster startup
-        };
-        if (!env.PYTHONUTF8) {
-            env.PYTHONUTF8 = '1';
-        }
-        if (!env.PYTHONIOENCODING) {
-            env.PYTHONIOENCODING = 'UTF-8';
-        }
-        if (this.options.virtualEnv) {
-            const venv = resolveVirtualEnv(this.options.virtualEnv, this.options.cwd);
-            env.VIRTUAL_ENV = venv.venvPath;
-            env.PATH = `${venv.binDir}${delimiter}${env.PATH ?? ''}`;
-        }
-        if (this.options.enableJsonFallback && !env.TYWRAP_CODEC_FALLBACK) {
-            env.TYWRAP_CODEC_FALLBACK = 'json';
-        }
-        const childProcess = spawn(this.options.pythonPath, [this.options.scriptPath], {
-            cwd: this.options.cwd,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            env,
-        });
-        const worker = {
-            process: childProcess,
-            id: workerId,
-            requestCount: 0,
-            lastUsed: Date.now(),
-            busy: false,
-            buffer: '',
-            pendingRequests: new Map(),
-            stats: {
-                totalRequests: 0,
-                totalTime: 0,
-                averageTime: 0,
-                errorCount: 0,
-            },
-        };
-        // Setup process event handlers
-        this.setupProcessHandlers(worker);
-        this.processPool.push(worker);
-        this.stats.processSpawns++;
-        // Spawned Python worker process ${workerId} (pool size: ${this.processPool.length})
-        return worker;
-    }
-    /**
-     * Setup event handlers for worker process
-     */
-    setupProcessHandlers(worker) {
-        const childProcess = worker.process;
-        // Handle stdout data with efficient buffering
-        childProcess.stdout?.on('data', (chunk) => {
-            worker.buffer += chunk.toString();
-            let idx;
-            while ((idx = worker.buffer.indexOf('\n')) !== -1) {
-                const line = worker.buffer.slice(0, idx).trim();
-                worker.buffer = worker.buffer.slice(idx + 1);
-                if (!line) {
-                    continue;
-                }
-                this.handleWorkerResponse(worker, line).catch(error => {
-                    log.error('Error handling worker response', {
-                        workerId: worker.id,
-                        error: String(error),
-                    });
-                });
-            }
-        });
-        // Handle stderr for debugging
-        childProcess.stderr?.on('data', (chunk) => {
-            const errorText = chunk.toString().trim();
-            if (errorText) {
-                log.warn('Worker stderr', { workerId: worker.id, output: errorText });
-            }
-        });
-        // Handle process exit
-        childProcess.on('exit', code => {
-            log.warn('Worker exited', { workerId: worker.id, code });
-            this.handleWorkerExit(worker, code);
-        });
-        // Handle process errors
-        childProcess.on('error', error => {
-            log.error('Worker error', { workerId: worker.id, error: String(error) });
-            this.handleWorkerExit(worker, -1);
-        });
-    }
-    /**
-     * Handle response from worker process
-     */
-    async handleWorkerResponse(worker, line) {
-        try {
-            const msg = JSON.parse(line);
-            if (msg.protocol !== TYWRAP_PROTOCOL) {
-                this.handleProtocolError(worker, line, new BridgeProtocolError(`Invalid protocol. Expected ${TYWRAP_PROTOCOL} but received ${String(msg.protocol)}`));
-                return;
-            }
-            if (typeof msg.id !== 'number') {
-                this.handleProtocolError(worker, line, new BridgeProtocolError('Invalid response id'));
-                return;
-            }
-            const pending = worker.pendingRequests.get(msg.id);
-            if (!pending) {
-                this.handleProtocolError(worker, line, new BridgeProtocolError(`Unexpected response id ${msg.id}`));
-                return;
-            }
-            worker.pendingRequests.delete(msg.id);
-            if (pending.timer) {
-                clearTimeout(pending.timer);
-            }
-            if (msg.error) {
-                pending.reject(this.errorFrom(msg.error));
-            }
-            else {
-                try {
-                    const decoded = await decodeValueAsync(msg.result);
-                    pending.resolve(decoded);
-                }
-                catch (decodeError) {
-                    pending.reject(new BridgeProtocolError(`Failed to decode response: ${decodeError}`));
-                }
-            }
-        }
-        catch (parseError) {
-            this.handleProtocolError(worker, line, parseError);
-        }
-    }
-    /**
-     * Handle worker process exit
-     */
-    handleWorkerExit(worker, code) {
-        // Reject all pending requests
-        for (const [, pending] of worker.pendingRequests) {
-            if (pending.timer) {
-                clearTimeout(pending.timer);
-            }
-            pending.reject(new Error(`Worker process exited with code ${code}`));
-        }
-        worker.pendingRequests.clear();
-        // Remove from pool
-        const index = this.processPool.indexOf(worker);
-        if (index >= 0) {
-            this.processPool.splice(index, 1);
-            this.stats.processDeaths++;
-        }
-        // Spawn replacement if needed and not disposing
-        if (!this.disposed && this.processPool.length < this.options.minProcesses) {
-            this.spawnProcess().catch(error => {
-                log.error('Failed to spawn replacement worker', { error: String(error) });
-            });
-        }
-    }
-    /**
-     * Warm up processes with configured commands
-     */
-    async warmupProcesses() {
-        const warmupPromises = this.processPool.map(async (worker) => {
-            for (const cmd of this.options.warmupCommands) {
-                try {
-                    await this.sendToWorker(worker, {
-                        method: cmd.method,
-                        params: cmd.params,
-                    });
-                }
-                catch (error) {
-                    log.warn('Warmup command failed', { workerId: worker.id, error: String(error) });
-                }
-            }
-        });
-        await Promise.all(warmupPromises);
-        // Warmed up ${this.processPool.length} worker processes
-    }
-    /**
-     * Heuristic to determine if function result should be cached
-     */
-    isPureFunctionCandidate(functionName, args) {
-        // Simple heuristics - could be made more sophisticated
-        const pureFunctionPatterns = [
-            /^(get|fetch|read|load|find|search|query|select)_/i,
-            /^(compute|calculate|process|transform|convert)_/i,
-            /^(encode|decode|serialize|deserialize)_/i,
-        ];
-        const impureFunctionPatterns = [
-            /^(set|save|write|update|insert|delete|create|modify)_/i,
-            /^(send|post|put|patch)_/i,
-            /random|uuid|timestamp|now|current/i,
-        ];
-        // Don't cache if function name suggests mutation
-        if (impureFunctionPatterns.some(pattern => pattern.test(functionName))) {
-            return false;
-        }
-        // Cache if function name suggests pure computation
-        if (pureFunctionPatterns.some(pattern => pattern.test(functionName))) {
-            return true;
-        }
-        // Don't cache if args contain mutable objects (very basic check)
-        const hasComplexArgs = args.some(arg => arg !== null && typeof arg === 'object' && !(arg instanceof Date));
-        return !hasComplexArgs && args.length <= 3; // Cache simple calls with few args
-    }
-    /**
-     * Update performance statistics
-     */
-    updateStats(duration, _error = false) {
-        this.stats.totalRequests++;
-        this.stats.totalTime += duration;
-        const currentMemory = process.memoryUsage().heapUsed;
-        if (currentMemory > this.stats.memoryPeak) {
-            this.stats.memoryPeak = currentMemory;
-        }
-    }
-    /**
-     * Get performance statistics
-     */
-    getStats() {
-        const avgTime = this.stats.totalRequests > 0 ? this.stats.totalTime / this.stats.totalRequests : 0;
-        const hitRate = this.stats.totalRequests > 0 ? this.stats.cacheHits / this.stats.totalRequests : 0;
-        return {
-            ...this.stats,
-            averageTime: avgTime,
-            cacheHitRate: hitRate,
-            poolSize: this.processPool.length,
-            busyWorkers: this.processPool.filter(w => w.busy).length,
-            memoryUsage: process.memoryUsage(),
-            workerStats: this.processPool.map(w => ({
-                id: w.id,
-                requestCount: w.requestCount,
-                averageTime: w.stats.averageTime,
-                errorCount: w.stats.errorCount,
-                busy: w.busy,
-                pendingRequests: w.pendingRequests.size,
-            })),
-        };
-    }
-    /**
-     * Cleanup idle processes
-     */
-    async cleanup() {
-        const now = Date.now();
-        const idleWorkers = this.processPool.filter(w => !w.busy &&
-            now - w.lastUsed > this.options.maxIdleTime &&
-            this.processPool.length > this.options.minProcesses);
-        for (const worker of idleWorkers) {
-            await this.terminateWorker(worker);
-        }
-        // Restart workers that have handled too many requests
-        const overusedWorkers = this.processPool.filter(w => !w.busy && w.requestCount >= this.options.maxRequestsPerProcess);
-        for (const worker of overusedWorkers) {
-            await this.terminateWorker(worker);
-            if (this.processPool.length < this.options.minProcesses) {
-                await this.spawnProcess();
-            }
-        }
-    }
-    /**
-     * Gracefully terminate a worker
-     */
-    async terminateWorker(worker) {
-        const index = this.processPool.indexOf(worker);
-        if (index >= 0) {
-            this.processPool.splice(index, 1);
-        }
-        // Reject pending requests
-        for (const [, pending] of worker.pendingRequests) {
-            if (pending.timer) {
-                clearTimeout(pending.timer);
-            }
-            pending.reject(new Error('Worker process terminated'));
-        }
-        // Graceful termination
-        try {
-            if (worker.process.connected) {
-                worker.process.kill('SIGTERM');
-                // Force kill if not terminated in 5 seconds
-                setTimeout(() => {
-                    if (!worker.process.killed) {
-                        worker.process.kill('SIGKILL');
-                    }
-                }, 5000);
-            }
-        }
-        catch (error) {
-            log.warn('Error terminating worker', { workerId: worker.id, error: String(error) });
-        }
-        // Terminated worker ${worker.id}
-    }
-    /**
-     * Start cleanup scheduler
-     */
-    startCleanupScheduler() {
-        this.cleanupTimer = setInterval(async () => {
-            try {
-                await this.cleanup();
-            }
-            catch (error) {
-                log.error('Cleanup error', { error: String(error) });
-            }
-        }, 60000); // Cleanup every minute
-    }
-    /**
-     * Dispose all resources
-     */
-    async dispose() {
-        if (this.disposed) {
-            return;
-        }
-        this.disposed = true;
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = undefined;
-        }
-        // Terminate all workers
-        const terminationPromises = this.processPool.map(worker => this.terminateWorker(worker));
-        await Promise.all(terminationPromises);
-        this.processPool.length = 0;
-        this.emitter.removeAllListeners();
-        // Disposed optimized Node.js bridge
-    }
-    errorFrom(err) {
-        const e = new BridgeExecutionError(`${err.type}: ${err.message}`);
-        e.traceback = err.traceback;
-        return e;
-    }
-    handleProtocolError(worker, line, error) {
-        const snippet = line.length > 500 ? `${line.slice(0, 500)}…` : line;
-        const detail = error instanceof Error ? error.message : String(error);
-        const hint = 'Ensure your Python code does not print to stdout and that the bridge outputs only JSON lines.';
-        const msg = `Protocol error from Python bridge. ${detail}\n${hint}\nOffending line: ${snippet}`;
-        const bridgeError = new BridgeProtocolError(msg);
-        for (const [, pending] of worker.pendingRequests) {
-            if (pending.timer) {
-                clearTimeout(pending.timer);
-            }
-            pending.reject(bridgeError);
-        }
-        worker.pendingRequests.clear();
-        try {
-            if (worker.process.connected) {
-                worker.process.kill('SIGTERM');
-            }
-        }
-        catch (killError) {
-            log.warn('Error terminating worker after protocol error', {
-                workerId: worker.id,
-                error: String(killError),
-            });
-        }
-        const index = this.processPool.indexOf(worker);
-        if (index >= 0) {
-            this.processPool.splice(index, 1);
-            this.stats.processDeaths++;
-        }
-        if (!this.disposed && this.processPool.length < this.options.minProcesses) {
-            this.spawnProcess().catch(spawnError => {
-                log.error('Failed to spawn replacement worker after protocol error', {
-                    error: String(spawnError),
-                });
-            });
-        }
-    }
-}
+export { NodeBridge as OptimizedNodeBridge } from './node.js';
 //# sourceMappingURL=optimized-node.js.map