@mhingston5/conduit 1.0.0

package/src/executors/deno.executor.ts

@@ -0,0 +1,342 @@
+import { spawn, exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+import fs from 'node:fs';
+import path from 'node:path';
+import { platform } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { ExecutionContext } from '../core/execution.context.js';
+import { ResourceLimits } from '../core/config.service.js';
+import { ConduitError } from '../core/types.js';
+import { resolveAssetPath } from '../core/asset.utils.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+import { Executor, ExecutorConfig, ExecutionResult } from '../core/interfaces/executor.interface.js';
+
+export { ExecutionResult };
+
+// Deprecated: use ExecutorConfig
+export interface IPCInfo {
+    ipcAddress: string;
+    ipcToken: string;
+    sdkCode?: string;
+}
+
+export class DenoExecutor implements Executor {
+    private shimContent: string = '';
+    // Track active processes for cleanup
+    // Using 'any' for the Set because ChildProcess type import can be finicky across node versions/types
+    // but at runtime it is a ChildProcess
+    private activeProcesses = new Set<any>();
+    private maxConcurrentProcesses: number;
+
+    constructor(maxConcurrentProcesses = 10) {
+        this.maxConcurrentProcesses = maxConcurrentProcesses;
+    }
+
+    private getShim(): string {
+        if (this.shimContent) return this.shimContent;
+        try {
+            const assetPath = resolveAssetPath('deno-shim.ts');
+            this.shimContent = fs.readFileSync(assetPath, 'utf-8');
+            return this.shimContent;
+        } catch (err: any) {
+            throw new Error(`Failed to load Deno shim: ${err.message}`);
+        }
+    }
+
+    async execute(code: string, limits: ResourceLimits, context: ExecutionContext, config?: ExecutorConfig): Promise<ExecutionResult> {
+        const { logger } = context;
+
+        // Check concurrent process limit
+        if (this.activeProcesses.size >= this.maxConcurrentProcesses) {
+            return {
+                stdout: '',
+                stderr: '',
+                exitCode: null,
+                error: {
+                    code: ConduitError.ServerBusy,
+                    message: 'Too many concurrent Deno processes'
+                }
+            };
+        }
+
+        let stdout = '';
+        let stderr = '';
+        let totalOutputBytes = 0;
+        let totalLogEntries = 0;
+        let isTerminated = false;
+
+        let shim = this.getShim()
+            .replace('__CONDUIT_IPC_ADDRESS__', config?.ipcAddress || '')
+            .replace('__CONDUIT_IPC_TOKEN__', config?.ipcToken || '');
+
+        if (shim.includes('__CONDUIT_IPC_ADDRESS__')) {
+            throw new Error('Failed to inject IPC address into Deno shim');
+        }
+        if (shim.includes('__CONDUIT_IPC_TOKEN__')) {
+            throw new Error('Failed to inject IPC token into Deno shim');
+        }
+
+        // Inject SDK if provided
+        if (config?.sdkCode) {
+            shim = shim.replace('// __CONDUIT_SDK_INJECTION__', config.sdkCode);
+            if (shim.includes('// __CONDUIT_SDK_INJECTION__')) {
+                // Should have been replaced
+                throw new Error('Failed to inject SDK code into Deno shim');
+            }
+        }
+
+        const fullCode = shim + '\n' + code;
+
+        // Use --v8-flags for memory limit if possible, or monitor RSS
+        // Deno 2.x supports --v8-flags
+        const args = [
+            'run',
+            `--v8-flags=--max-heap-size=${limits.memoryLimitMb}`,
+        ];
+
+        // Security: Restrict permissions. 
+        // We only allow network access to the IPC host if it's a TCP address.
+        // Unix sockets don't need --allow-net.
+        if (config?.ipcAddress && !config.ipcAddress.includes('/') && !config.ipcAddress.includes('\\')) {
+            try {
+                // Use URL parser to safely extract hostname (handles IPv6 brackets and ports correctly)
+                // Prepend http:// to ensure it parses as a valid URL structure
+                const url = new URL(`http://${config.ipcAddress}`);
+                let normalizedHost = url.hostname;
+
+                // Remove brackets from IPv6 addresses if present (e.g., [::1] -> ::1)
+                normalizedHost = normalizedHost.replace(/[\[\]]/g, '');
+
+                if (normalizedHost === '0.0.0.0' || normalizedHost === '::' || normalizedHost === '::1' || normalizedHost === '') {
+                    normalizedHost = '127.0.0.1';
+                }
+                args.push(`--allow-net=${normalizedHost}`);
+            } catch (err) {
+                // If address is malformed, we simply don't add the permission
+                logger.warn({ address: config.ipcAddress, err }, 'Failed to parse IPC address for Deno permissions');
+            }
+        } else {
+            // No network by default
+        }
+
+        args.push('-'); // Read from stdin
+
+        // logger.info({ args }, 'Spawning Deno');
+        const child = spawn('deno', args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                PATH: process.env.PATH,
+                HOME: process.env.HOME,
+                TMPDIR: process.env.TMPDIR,
+            }
+        });
+
+        this.activeProcesses.add(child);
+
+        child.on('spawn', () => {
+            // logger.info('Deno process spawned');
+        });
+
+        const cleanupProcess = () => {
+            this.activeProcesses.delete(child);
+        };
+
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                if (!isTerminated) {
+                    isTerminated = true;
+                    if (typeof (monitorInterval as any) !== 'undefined') clearInterval(monitorInterval);
+                    child.kill('SIGKILL');
+                    logger.warn('Execution timed out, SIGKILL sent');
+                    cleanupProcess();
+                    resolve({
+                        stdout,
+                        stderr,
+                        exitCode: null,
+                        error: {
+                            code: ConduitError.RequestTimeout,
+                            message: 'Execution timed out',
+                        },
+                    });
+                }
+            }, limits.timeoutMs);
+
+            // RSS Monitoring loop
+            // Optimization: increased interval to 2s and added platform check
+            const isWindows = platform() === 'win32';
+            const monitorInterval = setInterval(async () => {
+                if (isTerminated || !child.pid) {
+                    clearInterval(monitorInterval);
+                    return;
+                }
+                try {
+                    let rssMb = 0;
+                    if (isWindows) {
+                        try {
+                            // Windows: tasklist /FI "PID eq <pid>" /FO CSV /NH
+                            // Output: "deno.exe","1234","Console","1","12,345 K"
+                            const { stdout: tasklistOut } = await execAsync(`tasklist /FI "PID eq ${child.pid}" /FO CSV /NH`);
+                            const match = tasklistOut.match(/"([^"]+ K)"$/m); // Matches the last column with K
+                            if (match) {
+                                // Remove ' K' and ',' then parse
+                                const memStr = match[1].replace(/[ K,]/g, '');
+                                const memKb = parseInt(memStr, 10);
+                                if (!isNaN(memKb)) {
+                                    rssMb = memKb / 1024;
+                                }
+                            }
+                        } catch (e) {
+                            // tasklist might fail if process gone
+                        }
+                    } else {
+                        // On Mac/Linux, ps -o rss= -p [pid] returns RSS in KB
+                        const { stdout: rssStdout } = await execAsync(`ps -o rss= -p ${child.pid}`);
+                        const rssKb = parseInt(rssStdout.trim());
+                        if (!isNaN(rssKb)) {
+                            rssMb = rssKb / 1024;
+                        }
+                    }
+
+                    if (rssMb > limits.memoryLimitMb) {
+                        isTerminated = true;
+                        if (typeof (monitorInterval as any) !== 'undefined') clearInterval(monitorInterval);
+                        child.kill('SIGKILL');
+                        logger.warn({ rssMb, limitMb: limits.memoryLimitMb }, 'Deno RSS limit exceeded, SIGKILL sent');
+                        cleanupProcess();
+                        resolve({
+                            stdout,
+                            stderr,
+                            exitCode: null,
+                            error: {
+                                code: ConduitError.MemoryLimitExceeded,
+                                message: `Memory limit exceeded: ${rssMb.toFixed(2)}MB > ${limits.memoryLimitMb}MB`,
+                            },
+                        });
+                    }
+                } catch (err) {
+                    // Process might have exited already or ps failed
+                    clearInterval(monitorInterval);
+                }
+            }, 2000); // Check every 2000ms
+
+            child.stdout.on('data', (chunk: Buffer) => {
+                if (isTerminated) return;
+
+                totalOutputBytes += chunk.length;
+                const newLines = (chunk.toString().match(/\n/g) || []).length;
+                totalLogEntries += newLines;
+
+                if (totalOutputBytes > limits.maxOutputBytes || totalLogEntries > limits.maxLogEntries) {
+                    isTerminated = true;
+                    if (typeof (monitorInterval as any) !== 'undefined') clearInterval(monitorInterval);
+                    child.kill('SIGKILL');
+                    logger.warn({ bytes: totalOutputBytes, lines: totalLogEntries }, 'Limits exceeded, SIGKILL sent');
+                    cleanupProcess();
+                    resolve({
+                        stdout: stdout + chunk.toString().slice(0, limits.maxOutputBytes - (totalOutputBytes - chunk.length)),
+                        stderr,
+                        exitCode: null,
+                        error: {
+                            code: totalOutputBytes > limits.maxOutputBytes ? ConduitError.OutputLimitExceeded : ConduitError.LogLimitExceeded,
+                            message: totalOutputBytes > limits.maxOutputBytes ? 'Output limit exceeded' : 'Log entry limit exceeded',
+                        },
+                    });
+                    return;
+                }
+                stdout += chunk.toString();
+            });
+
+            child.stderr.on('data', (chunk: Buffer) => {
+                if (isTerminated) return;
+
+                totalOutputBytes += chunk.length;
+                const newLines = (chunk.toString().match(/\n/g) || []).length;
+                totalLogEntries += newLines;
+
+                if (totalOutputBytes > limits.maxOutputBytes || totalLogEntries > limits.maxLogEntries) {
+                    isTerminated = true;
+                    if (typeof (monitorInterval as any) !== 'undefined') clearInterval(monitorInterval);
+                    child.kill('SIGKILL');
+                    logger.warn({ bytes: totalOutputBytes, lines: totalLogEntries }, 'Limits exceeded, SIGKILL sent');
+                    cleanupProcess();
+                    resolve({
+                        stdout,
+                        stderr: stderr + chunk.toString().slice(0, limits.maxOutputBytes - (totalOutputBytes - chunk.length)),
+                        exitCode: null,
+                        error: {
+                            code: totalOutputBytes > limits.maxOutputBytes ? ConduitError.OutputLimitExceeded : ConduitError.LogLimitExceeded,
+                            message: totalOutputBytes > limits.maxOutputBytes ? 'Output limit exceeded' : 'Log entry limit exceeded',
+                        },
+                    });
+                    return;
+                }
+                stderr += chunk.toString();
+            });
+
+            child.on('close', (code) => {
+                clearTimeout(timeout);
+                if (typeof (monitorInterval as any) !== 'undefined') clearInterval(monitorInterval);
+                cleanupProcess();
+                if (isTerminated) return; // Already resolved via timeout or limit
+
+                resolve({
+                    stdout,
+                    stderr,
+                    exitCode: code,
+                });
+            });
+
+            child.on('error', (err: any) => {
+                clearTimeout(timeout);
+                logger.error({ err }, 'Child process error');
+                cleanupProcess();
+
+                let message = err.message;
+                if (err.code === 'ENOENT') {
+                    message = 'Deno executable not found in PATH. Please ensure Deno is installed.';
+                }
+
+                resolve({
+                    stdout,
+                    stderr,
+                    exitCode: null,
+                    error: {
+                        code: ConduitError.InternalError,
+                        message: message,
+                    },
+                });
+            });
+
+            // Write code to stdin
+            child.stdin.write(fullCode);
+            child.stdin.end();
+        });
+    }
+
+    async shutdown() {
+        for (const child of this.activeProcesses) {
+            try {
+                child.kill('SIGKILL');
+            } catch (err) {
+                // Ignore, process might be dead already
+            }
+        }
+        this.activeProcesses.clear();
+    }
+
+    async healthCheck(): Promise<{ status: string; detail?: string }> {
+        try {
+            const { stdout } = await execAsync('deno --version');
+            return { status: 'ok', detail: stdout.split('\n')[0] };
+        } catch (err: any) {
+            return { status: 'error', detail: err.message };
+        }
+    }
+
+    async warmup(): Promise<void> {
+        // No-op for Deno
+    }
+}

package/src/executors/isolate.executor.ts

@@ -0,0 +1,281 @@
+import ivm from 'isolated-vm';
+import { Logger } from 'pino';
+import { ExecutionContext } from '../core/execution.context.js';
+import { ResourceLimits } from '../core/config.service.js';
+import { GatewayService } from '../gateway/gateway.service.js';
+import { ConduitError } from '../core/types.js';
+
+import { Executor, ExecutorConfig, ExecutionResult } from '../core/interfaces/executor.interface.js';
+
+export { ExecutionResult as IsolateExecutionResult };
+
+/**
+ * IsolateExecutor - In-process V8 isolate execution using isolated-vm.
+ * 
+ * Security model: Capability-based (not OS sandbox)
+ * - Only approved functions exposed to isolate
+ * - Hard time/memory limits
+ * - No process/fs/net access
+ */
+export class IsolateExecutor implements Executor {
+    private logger: Logger;
+    private gatewayService: GatewayService;
+
+    constructor(logger: Logger, gatewayService: GatewayService) {
+        this.logger = logger;
+        this.gatewayService = gatewayService;
+    }
+
+    async execute(
+        code: string,
+        limits: ResourceLimits,
+        context: ExecutionContext,
+        config?: ExecutorConfig
+    ): Promise<ExecutionResult> {
+        const logs: string[] = [];
+        const errors: string[] = [];
+        let isolate: ivm.Isolate | null = null;
+
+        try {
+            // Create isolate with memory limit
+            isolate = new ivm.Isolate({ memoryLimit: limits.memoryLimitMb });
+            const ctx = await isolate.createContext();
+            const jail = ctx.global;
+
+            let currentLogBytes = 0;
+            let currentErrorBytes = 0;
+
+            // Inject console.log/error for output capture
+            // Inject console.log/error for output capture
+            await jail.set('__log', new ivm.Callback((msg: string) => {
+                if (currentLogBytes + msg.length + 1 > limits.maxOutputBytes) {
+                    // Check log entry count limit? We don't track count here yet effectively, but bytes is safer.
+                    // The interface says maxOutputBytes applies to total output.
+                    throw new Error('[LIMIT_LOG]');
+                }
+                if (currentLogBytes < limits.maxOutputBytes) {
+                    logs.push(msg);
+                    currentLogBytes += msg.length + 1; // +1 for newline approximation
+                }
+            }));
+            await jail.set('__error', new ivm.Callback((msg: string) => {
+                if (currentErrorBytes + msg.length + 1 > limits.maxOutputBytes) {
+                    throw new Error('[LIMIT_OUTPUT]');
+                }
+                if (currentErrorBytes < limits.maxOutputBytes) {
+                    errors.push(msg);
+                    currentErrorBytes += msg.length + 1;
+                }
+            }));
+
+            // Async tool bridge (ID-based to avoid Promise transfer issues)
+            let requestIdCounter = 0;
+            const pendingToolCalls = new Map<number, Promise<any>>(); // Not used by Host, but Host initiates work
+
+            await jail.set('__dispatchToolCall', new ivm.Callback((nameStr: string, argsStr: string) => {
+                const requestId = ++requestIdCounter;
+                const name = nameStr;
+                let args = {};
+                try {
+                    args = JSON.parse(argsStr);
+                } catch (e) {
+                    // ignore
+                }
+
+                // Process async
+                this.gatewayService.callTool(name, args, context)
+                    .then(res => {
+                        // callback to isolate
+                        return ctx.evalClosure(`resolveRequest($0, $1, null)`, [requestId, JSON.stringify(res)], { arguments: { copy: true } });
+                    })
+                    .catch(err => {
+                        return ctx.evalClosure(`resolveRequest($0, null, $1)`, [requestId, err.message || 'Unknown error'], { arguments: { copy: true } });
+                    })
+                    .catch(e => {
+                        // Ignore errors calling back into isolate (e.g. if disposed)
+                    });
+
+                return requestId;
+            }));
+
+            // Bootstrap code: create console and async handling
+            const bootstrap = `
+                const requests = new Map();
+                
+                // Host calls this to resolve requests
+                globalThis.resolveRequest = (id, resultJson, error) => {
+                    const req = requests.get(id);
+                    if (req) {
+                        requests.delete(id);
+                        if (error) req.reject(new Error(error));
+                        else req.resolve(resultJson);
+                    }
+                };
+
+                // Internal tool call wrapper
+                globalThis.__callTool = (name, argsJson) => {
+                    return new Promise((resolve, reject) => {
+                        const id = __dispatchToolCall(name, argsJson);
+                        requests.set(id, { resolve, reject });
+                    });
+                };
+
+                const format = (arg) => {
+                    if (typeof arg === 'string') return arg;
+                    if (arg instanceof Error) return arg.stack || arg.message;
+                    if (typeof arg === 'object' && arg !== null && arg.message && arg.stack) return arg.stack; // Duck typing
+                    return JSON.stringify(arg);
+                };
+                const console = {
+                    log: (...args) => __log(args.map(format).join(' ')),
+                    error: (...args) => __error(args.map(format).join(' ')),
+                };
+            `;
+            const bootstrapScript = await isolate.compileScript(bootstrap);
+            await bootstrapScript.run(ctx, { timeout: 1000 });
+
+            // Inject SDK (typed tools or fallback)
+            const sdkScript = config?.sdkCode || `
+                const tools = {
+                    $raw: async (name, args) => {
+                        const resStr = await __callTool(name, JSON.stringify(args || {}));
+                        return JSON.parse(resStr);
+                    }
+                };
+            `;
+            const compiledSdk = await isolate.compileScript(sdkScript);
+            await compiledSdk.run(ctx, { timeout: 1000 });
+
+            // Compile and run user code
+            // Async completion tracking
+            let executionPromiseResolve: () => void;
+            const executionPromise = new Promise<void>((resolve) => {
+                executionPromiseResolve = resolve;
+            });
+            await jail.set('__done', new ivm.Callback(() => {
+                if (executionPromiseResolve) executionPromiseResolve();
+            }));
+
+            let scriptFailed = false;
+            await jail.set('__setFailed', new ivm.Callback(() => {
+                scriptFailed = true;
+            }));
+
+            // Compile and run user code
+            // Wrap in async IIFE to support top-level await and track completion
+            // Use 'void' to ensure the script returns undefined (transferrable) instead of a Promise
+            const wrappedCode = `void (async () => {
+                try {
+                    ${code}
+                } catch (err) {
+                    console.error(err);
+                    __setFailed();
+                } finally {
+                    __done();
+                }
+            })()`;
+
+            const script = await isolate.compileScript(wrappedCode);
+
+            // NOTE: Two timeouts exist intentionally:
+            // 1. script.run timeout (below) - catches infinite synchronous loops
+            // 2. Promise.race timeout (after) - catches stuck async operations (tool calls)
+            // Tool calls may continue briefly after timeout; isolate.dispose() cleans up.
+
+            // Start execution with synchronous timeout protection
+            await script.run(ctx, { timeout: limits.timeoutMs });
+
+            // Wait for completion or timeout
+            let timedOut = false;
+            const timeoutPromise = new Promise<void>((_, reject) => {
+                setTimeout(() => {
+                    timedOut = true;
+                    reject(new Error('Script execution timed out'));
+                }, limits.timeoutMs);
+            });
+
+            try {
+                await Promise.race([executionPromise, timeoutPromise]);
+            } catch (err: any) {
+                if (err.message === 'Script execution timed out') {
+                    return {
+                        stdout: logs.join('\n'),
+                        stderr: errors.join('\n'),
+                        exitCode: null,
+                        error: {
+                            code: ConduitError.RequestTimeout,
+                            message: 'Execution timed out',
+                        },
+                    };
+                }
+                throw err;
+            }
+
+            return {
+                stdout: logs.join('\n'),
+                stderr: errors.join('\n'),
+                exitCode: scriptFailed ? 1 : 0,
+            };
+        } catch (err: any) {
+            const message = err.message || 'Unknown error';
+
+            // Handle specific error types
+            if (message.includes('Script execution timed out')) {
+                return {
+                    stdout: logs.join('\n'),
+                    stderr: errors.join('\n'),
+                    exitCode: null,
+                    error: {
+                        code: ConduitError.RequestTimeout,
+                        message: 'Execution timed out',
+                    },
+                };
+            }
+
+            if (message.includes('memory limit') || message.includes('disposed')) {
+                return {
+                    stdout: logs.join('\n'),
+                    stderr: errors.join('\n'),
+                    exitCode: null,
+                    error: {
+                        code: ConduitError.MemoryLimitExceeded,
+                        message: 'Memory limit exceeded',
+                    },
+                };
+            }
+
+            this.logger.error({ err }, 'Isolate execution failed');
+            return {
+                stdout: logs.join('\n'),
+                stderr: message,
+                exitCode: 1,
+                error: {
+                    code: ConduitError.InternalError,
+                    message,
+                },
+            };
+        } finally {
+            if (isolate) {
+                isolate.dispose();
+            }
+        }
+    }
+
+    async shutdown(): Promise<void> {
+        // No-op
+    }
+
+    async healthCheck(): Promise<{ status: string; detail?: string }> {
+        try {
+            const isolate = new ivm.Isolate({ memoryLimit: 8 });
+            isolate.dispose();
+            return { status: 'ok' };
+        } catch (err: any) {
+            return { status: 'error', detail: err.message };
+        }
+    }
+
+    async warmup(): Promise<void> {
+        // No-op
+    }
+}