u

src/tools/javascript.js

@@ -1,109 +1,33 @@
-import { Worker } from 'worker_threads';
-import { fileURLToPath } from 'url';
 import fs from 'fs';
 import path from 'path';
 import jwt from 'jsonwebtoken';
 import { defineTool, ToolError } from 'libllmorbiter';
 import env from '../config/env.js';
 import { createVfs, prepareVfs, syncVfsToDb } from './vfs.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const ROOT_DIR = path.resolve(__dirname, '../..');
-const WORKER_PATH = fileURLToPath(new URL('./javascript-worker.js', import.meta.url));
+import { runSandboxJob } from '../services/javascriptSandbox.js';
 
 const DEFAULT_TIMEOUT_MS = 20_000;
 const MAX_TIMEOUT_MS = 60_000;
 const DEFAULT_MAX_OUTPUT = 20_000;
-const DEFAULT_BUFFER_LIMIT = 32 * 1024 * 1024;
-
-// Keys already logged as benign non-sandbox worker chatter. Under `node --watch` the loader
-// emits `watch:import` / `watch:require` notices on the worker's parentPort for EVERY import,
-// so warning per message floods the log. We warn once per distinct key instead.
-const WATCH_NOISE_WARNED = new Set();
 
+/**
+ * Runs one snippet/applet on the shared sandbox pool.
+ *
+ * Threads are keyed by VFS root so a reused thread keeps the right company's `vfsDir`, and the
+ * per-run JWT is minted here because it is scoped to THIS `googleAuthId`.
+ *
+ * @param {{ code: string, timeoutMs: number, vfsRoot: string, googleAuthId: number, appletInput?: object, appletFile?: string }} ctx
+ */
 function runInWorker({ code, timeoutMs, vfsRoot, googleAuthId, appletInput, appletFile }) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const token = jwt.sign({ id: googleAuthId }, env.jwtSecret, { expiresIn: '5m' });
-
-        const worker = new Worker(WORKER_PATH, {
-            workerData: {
-                code,
-                root: ROOT_DIR,
-                vmTimeout: timeoutMs,
-                bufferLimit: DEFAULT_BUFFER_LIMIT,
-                dashbackUrl: `http://127.0.0.1:${env.port}/api`,
-                dashbackToken: token,
-                vfsDir: vfsRoot,
-                googleAuthId,
-                appletInput,
-                appletFile,
-            },
-        });
-
-        const finish = (payload) => {
-            if (settled) return;
-            settled = true;
-            clearTimeout(timer);
-            try { worker.terminate(); } catch { /* already closed */ }
-            resolve(payload);
-        };
-
-        const timer = setTimeout(() => {
-            console.error(`[javascript_execute] sandbox worker timed out after ${timeoutMs} ms`);
-            finish({ result: null, stdout: '', consoleLineCount: 0, timedOut: true, timeoutMs });
-        }, timeoutMs);
-
-        worker.on('message', (msg) => {
-            // Ignore anything that is not a genuine sandbox report. Running the server under
-            // `node --watch` (the `dev` script) installs a module-loader hook that posts
-            // `watch:import` notices on this same channel; treating the first message as the
-            // result made the sandbox appear to run for 0ms and return nothing.
-            if (!msg || msg.__sandboxReport !== true) {
-                // Those loader notices fire many times per run, so warn ONCE per key rather
-                // than on every message — expected, benign noise while running under --watch.
-                for (const key of Object.keys(msg || {})) {
-                    if (!WATCH_NOISE_WARNED.has(key)) {
-                        WATCH_NOISE_WARNED.add(key);
-                        console.warn(
-                            `[javascript_execute] ignoring non-sandbox worker message "${key}" ` +
-                            '(expected under `node --watch`; logged once per key).'
-                        );
-                    }
-                }
-                return;
-            }
-            finish(msg);
-        });
-        // A worker 'error' fires BEFORE any message when the thread fails to boot (e.g. an
-        // import throws at startup). ALWAYS send a truthy `error` plus the full stack so the
-        // parent can throw with something actionable; an empty `err.message` must never
-        // degrade into a silent, result-less success payload.
-        worker.on('error', (err) => finish({
-            result: null,
-            stdout: '',
-            consoleLineCount: 0,
-            error: (err && err.message)
-                ? err.message
-                : `Sandbox worker failed to start: ${err?.stack || err?.name || 'unknown error'}`,
-            errorName: (err && err.name) || 'Error',
-            stack: err && typeof err.stack === 'string' ? err.stack : undefined,
-        }));
-        worker.on('exit', (code) => {
-            // `finish` is idempotent via `settled`, so a message that already resolved the
-            // promise is never overwritten. Reaching here means the worker died WITHOUT
-            // reporting — that is a hard failure, so log it and always carry a truthy error.
-            if (!settled) {
-                console.error(`[javascript_execute] sandbox worker exited without reporting (code ${code})`);
-            }
-            finish({
-                result: null,
-                stdout: '',
-                consoleLineCount: 0,
-                error: `Sandbox worker exited unexpectedly without reporting a result (code ${code}).`,
-                errorName: 'WorkerExit',
-            });
-        });
+    const dashbackToken = jwt.sign({ id: googleAuthId }, env.jwtSecret, { expiresIn: '5m' });
+    return runSandboxJob({
+        poolKey: vfsRoot,
+        googleAuthId,
+        code,
+        timeoutMs,
+        dashbackToken,
+        appletInput,
+        appletFile,
     });
 }