path: root/modules/core/module-sandbox.js

// module-sandbox.js — Sandboxed execution pool using WebWorkers
// Commands: sandbox-status, sandbox-config, sandbox-run
class SandboxModule {
    constructor() {
        this.commands = {};
        this.terminal = null;
        this.workers = [];
        this.MAX_WORKERS = 4;
        this.MIN_WORKERS = 1;
        this.queue = [];
        this.activeTasks = {};
        this._nextTaskId = 0;
        this._totalRuns = 0;
        this._totalErrors = 0;
        this._totalDuration = 0;
        this._fallbackMode = false; // true if WebWorkers unavailable
        this._workerReady = {};
    }

    getHelpInfo() {
        return {
            'sandbox-status': 'sandbox-status — Show sandbox pool health and task metrics',
            'sandbox-config': 'sandbox-config <key> <value> — Tune: max-workers, min-workers, pool-timeout',
            'sandbox-run': 'sandbox-run <task> — Run a task in the sandbox (automatic routing)',
        };
    }

    registerCommands() {
        this.commands['sandbox-status'] = () => this.showStatus();
        this.commands['sandbox-config'] = (args) => this.setConfig(args);
        this.commands['sandbox-run'] = (args) => this.runInSandbox(args.join(' '));
    }

    init(terminal) {
        this.terminal = terminal;
        this.workerUrl = '/spaces/newos4/modules/core/sandbox-worker.js?v=2026-06-05-v4.4.0';

        // Detect Worker availability
        if (typeof Worker === 'undefined') {
            this._fallbackMode = true;
            this.terminal.print('⚠️  WebWorkers not available — sandbox using inline fallback', 'warning');
        } else {
            this._initPool();
            // Deferred check: workers may fail asynchronously (headless browsers)
            // If no worker proves alive within 1.5s, switch to inline fallback
            this._workerCheckTimer = setTimeout(() => {
                if (!this._fallbackMode && this.workers.length > 0) {
                    const alive = this.workers.some(w => !w._failed && this._workerReady[w._sandboxId]);
                    if (!alive) {
                        this._fallbackMode = true;
                        this.workers.forEach(w => w.terminate());
                        this.workers = [];
                        this.terminal.print('⚠️  WebWorkers unavailable — switching to inline fallback', 'warning');
                    }
                }
            }, 1500);
        }

        this.terminal.print('🧪 Sandbox module loaded', 'info');
    }

    _initPool() {
        // Start with MIN_WORKERS, grow on demand up to MAX_WORKERS
        for (let i = 0; i < this.MIN_WORKERS; i++) {
            const w = this._spawnWorker();
            if (!w) break; // first failure kills the pool
        }
    }

    _spawnWorker() {
        if (this.workers.length >= this.MAX_WORKERS) return null;
        if (this._fallbackMode) return null;
        try {
            const worker = new Worker(this.workerUrl);
            const id = `w${this.workers.length + 1}`;
            worker._sandboxId = id;
            worker._busy = false;
            worker._failed = false;

            // Detect immediate worker failure (headless browsers, restricted contexts)
            const failTimer = setTimeout(() => {
                if (!worker._failed) {
                    // Worker survived 2 seconds - likely functional
                }
            }, 2000);

            worker.onmessage = (e) => {
                clearTimeout(failTimer);
                if (e.data && e.data.type === 'ready') {
                    this._workerReady[id] = true;
                } else {
                    this._handleResult(e.data, id);
                }
            };
            worker.onerror = (e) => {
                clearTimeout(failTimer);
                worker._failed = true;
                worker.terminate();
                console.warn(`[Sandbox] Worker ${id} failed (headless env) — switching to inline`);
                this._fallbackMode = true;
                this.workers.forEach(w => w.terminate());
                this.workers = [];
                this.terminal.print('⚠️  WebWorkers unavailable in this environment — using inline fallback', 'warning');
            };

            this.workers.push(worker);
            return worker;
        } catch (e) {
            console.warn('[Sandbox] Failed to spawn worker:', e);
            this._fallbackMode = true;
            return null;
        }
    }

    _replaceWorker(id) {
        // In headless environments, workers don't work — don't retry
        if (this._fallbackMode) return;
        const idx = this.workers.findIndex(w => w._sandboxId === id);
        if (idx !== -1) {
            this.workers[idx].terminate();
            this.workers.splice(idx, 1);
            delete this._workerReady[id];
        }
    }

    _getIdleWorker() {
        for (const w of this.workers) {
            if (!w._busy) return w;
        }
        // Grow pool if under max
        if (this.workers.length < this.MAX_WORKERS) {
            const w = this._spawnWorker();
            if (w) return w;
        }
        return null;
    }

    async runInSandbox(task, capabilities) {
        if (!task) return this.terminal.print('Usage: sandbox-run <task>', 'error');

        // Check if any worker is actually alive and ready
        const hasAliveWorker = this.workers.some(w =>
            !w._failed && this._workerReady[w._sandboxId]
        );
        const useInline = this._fallbackMode || this.workers.length === 0 || !hasAliveWorker;

        if (useInline) {
            return this._runInline(task, capabilities);
        }

        const worker = this._getIdleWorker();
        if (!worker) {
            // Queue it
            return new Promise((resolve) => {
                this.queue.push({ task, capabilities, resolve });
                this.terminal.print(`⏳ Task queued (${this.queue.length} waiting)`, 'info');
                this._drainQueue();
            });
        }

        return this._executeOnWorker(worker, task, capabilities);
    }

    async _executeOnWorker(worker, task, capabilities) {
        const taskId = `task-${++this._nextTaskId}`;
        worker._busy = true;

        const startTime = performance.now();

        return new Promise((resolve) => {
            const handler = (e) => {
                if (e.data && e.data.taskId === taskId) {
                    worker.removeEventListener('message', handler);
                    worker._busy = false;

                    const duration = ((performance.now() - startTime) / 1000).toFixed(2);
                    this._totalRuns++;
                    this._totalDuration += parseFloat(duration);

                    if (e.data.error) {
                        this._totalErrors++;
                        this.terminal.print(`❌ Sandbox task failed: ${e.data.error}`, 'error');
                        resolve({ error: e.data.error, duration });
                    } else {
                        this.terminal.print(`✅ Sandbox task complete (${duration}s, ${e.data.toolCalls || 0} tools)`, 'success');
                        resolve({ result: e.data.result, duration, toolCalls: e.data.toolCalls || 0 });
                    }

                    this._drainQueue();
                }
            };

            worker.addEventListener('message', handler);

            // Get VFS snapshot from terminal
            let vfsSnapshot = null;
            try {
                if (this.terminal && this.terminal.fs && this.terminal.fs.root) {
                    vfsSnapshot = JSON.stringify({
                        root: this.terminal.fs.root,
                        currentPath: this.terminal.fs.currentPath || []
                    });
                }
            } catch (e) {
                console.warn('[Sandbox] Could not serialize VFS:', e.message);
            }

            const caps = capabilities || ['list_files', 'read_file'];
            const allowedCommands = ['ls', 'cat', 'echo', 'find', 'grep', 'help', 'status',
                'touch', 'mkdir', 'rm', 'cp', 'mv'];

            worker.postMessage({
                taskId,
                task,
                capabilities: caps,
                vfsSnapshot,
                allowedCommands,
                apiProxy: window.location.origin + '/api'
            });

            // Timeout after 30 seconds
            setTimeout(() => {
                if (worker._busy) {
                    worker._busy = false;
                    this._totalErrors++;
                    this.terminal.print(`⏰ Sandbox task ${taskId} timed out after 30s`, 'error');
                    resolve({ error: 'Timeout (30s)', duration: 30 });
                    this._drainQueue();
                }
            }, 30000);
        });
    }

    _handleResult(data, workerId) {
        // Handled via promise in _executeOnWorker
        // This is the fallback handler for tasks not tracked by promise
        if (data.error) {
            this.terminal.print(`[Sandbox ${workerId}] Error: ${data.error}`, 'error');
        }
    }

    _drainQueue() {
        if (this.queue.length === 0) return;
        const next = this.queue.shift();
        this.runInSandbox(next.task, next.capabilities).then(result => {
            next.resolve(result);
        });
    }

    _runInline(task, capabilities) {
        // Fallback when WebWorkers unavailable — runs in main thread
        const startTime = performance.now();
        const parts = task.trim().split(/\s+/);
        const cmd = parts[0].toLowerCase();
        let result = '';
        let toolCalls = 0;

        const fs = this.terminal ? this.terminal.fs : null;

        if (cmd === 'ls' && fs) {
            const path = parts[1] || '/';
            const entries = fs.ls(path);
            if (!entries) return this.terminal.print(`ls: ${path}: No such directory`, 'error');
            result = entries.map(e => `${e.type === 'dir' ? '[dir]' : '[file]'} ${e.name}`).join('\\n');
            toolCalls++;
        } else if ((cmd === 'cat' || cmd === 'read') && fs) {
            const path = parts[1] || '';
            const content = fs.readFile(path);
            if (content === null) return this.terminal.print(`cat: ${path}: No such file`, 'error');
            result = typeof content === 'string' ? content.substring(0, 8000) : String(content);
            toolCalls++;
        } else if (cmd === 'find' && fs) {
            const q = parts.slice(1).join(' ') || '';
            // Walk VFS
            const results = [];
            const walk = (p) => {
                const entries = fs.ls(p);
                if (!entries) return;
                for (const e of entries) {
                    const full = p === '/' ? '/' + e.name : p + '/' + e.name;
                    if (e.type === 'file' && (!q || full.toLowerCase().includes(q.toLowerCase()))) {
                        results.push(full);
                    }
                    if (e.type === 'dir') walk(full);
                }
            };
            walk('/');
            result = results.join('\\n') || '(empty)';
            toolCalls++;
        } else if (cmd === 'status') {
            let f = 0, d = 0;
            const walk = (p) => {
                const entries = fs ? fs.ls(p) : [];
                if (!entries) return;
                for (const e of entries) {
                    if (e.type === 'file') f++;
                    else { d++; walk(p === '/' ? '/' + e.name : p + '/' + e.name); }
                }
            };
            walk('/');
            result = `Files: ${f}, Dirs: ${d}`;
            toolCalls++;
        } else {
            result = `Task: "${task}" (inline fallback)`;
        }

        const duration = ((performance.now() - startTime) / 1000).toFixed(2);
        this._totalRuns++;
        this._totalDuration += parseFloat(duration);
        this.terminal.print(result, 'info');
        return { result, duration, toolCalls };
    }

    // ─── Config ───

    setConfig(args) {
        if (args.length < 2) return this.terminal.print('Usage: sandbox-config <key> <value>', 'error');
        const key = args[0];
        const val = args[1];

        const configMap = {
            'max-workers': () => {
                const n = parseInt(val);
                if (isNaN(n) || n < 1 || n > 8) return 'Must be 1-8';
                this.MAX_WORKERS = n;
                // Scale down if needed
                while (this.workers.length > n) {
                    const w = this.workers.pop();
                    w.terminate();
                }
                // Scale up
                for (let i = this.workers.length; i < Math.min(n, this.MIN_WORKERS); i++) {
                    this._spawnWorker();
                }
                return `max-workers set to ${n}`;
            },
            'min-workers': () => {
                const n = parseInt(val);
                if (isNaN(n) || n < 0 || n > this.MAX_WORKERS) return `Must be 0-${this.MAX_WORKERS}`;
                this.MIN_WORKERS = n;
                while (this.workers.length < n) this._spawnWorker();
                return `min-workers set to ${n}`;
            },
        };

        if (!configMap[key]) {
            return this.terminal.print(`Unknown: ${key}. Valid: ${Object.keys(configMap).join(', ')}`, 'error');
        }
        const msg = configMap[key]();
        this.terminal.print(`✅ ${msg}`, 'success');
    }

    // ─── Status ───

    showStatus() {
        const busy = this.workers.filter(w => w._busy).length;
        const idle = this.workers.length - busy;
        const avgDuration = this._totalRuns > 0 ? (this._totalDuration / this._totalRuns).toFixed(2) : 'N/A';

        this.terminal.print('🧪 Sandbox Pool', 'header');
        this.terminal.print(`  Workers: ${this.workers.length}/${this.MAX_WORKERS} (${busy} busy, ${idle} idle)`, 'info');
        this.terminal.print(`  Mode: ${this._fallbackMode ? '⚠️ Inline fallback' : '✅ WebWorker'}`, 'info');
        this.terminal.print(`  Queue: ${this.queue.length} pending`, 'info');
        this.terminal.print(`  Total runs: ${this._totalRuns} (errors: ${this._totalErrors})`, 'info');
        this.terminal.print(`  Avg duration: ${avgDuration}s`, 'info');
    }
}

// Required for module system
if (typeof window !== 'undefined') {
    window.SandboxModule = SandboxModule;
}