@oh-my-pi/pi-coding-agent 14.9.5 → 14.9.7

package/src/eval/js/context-manager.ts

@@ -1,21 +1,25 @@
-import * as fs from "node:fs";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
-import * as util from "node:util";
-import * as vm from "node:vm";
-
-import { parse as babelParse } from "@babel/parser";
-import * as Diff from "diff";
+import { logger, Snowflake } from "@oh-my-pi/pi-utils";
 import type { ToolSession } from "../../tools";
-import { ToolError } from "../../tools/tool-errors";
-import { JAVASCRIPT_PRELUDE_SOURCE } from "./prelude";
+import { ToolAbortError, ToolError } from "../../tools/tool-errors";
 import { callSessionTool, type JsStatusEvent } from "./tool-bridge";
-
-export type JsDisplayOutput =
-	| { type: "json"; data: unknown }
-	| { type: "image"; data: string; mimeType: string }
-	| { type: "status"; event: JsStatusEvent };
+import { WorkerCore } from "./worker-core";
+// Imported with `type: "file"` so Bun's bundler statically discovers the worker entry and
+// embeds it inside `bun build --compile` single-file binaries. Mirrors the browser tab
+// worker setup; see packages/coding-agent/src/tools/browser/tab-supervisor.ts for the
+// rationale.
+// @ts-expect-error -- Bun file-URL import attribute is not modeled by tsgo.
+import jsWorkerEntryUrl from "./worker-entry.ts" with { type: "file" };
+import type {
+	JsDisplayOutput,
+	RunErrorPayload,
+	SessionSnapshot,
+	Transport,
+	WorkerInbound,
+	WorkerOutbound,
+} from "./worker-protocol";
+
+export { rewriteStaticImports } from "./shared/rewrite-imports";
+export type { JsDisplayOutput } from "./worker-protocol";
 
 export interface VmRunState {
 	signal?: AbortSignal;
@@ -23,617 +27,383 @@ export interface VmRunState {
 	onDisplay?: (output: JsDisplayOutput) => void;
 }
 
-interface VmHelperOptions {
-	path?: string;
-	hidden?: boolean;
-	maxDepth?: number;
-	limit?: number;
-	offset?: number;
-	reverse?: boolean;
-	unique?: boolean;
-	count?: boolean;
+interface WorkerHandle {
+	mode: "worker" | "inline";
+	send(msg: WorkerInbound): void;
+	onMessage(handler: (msg: WorkerOutbound) => void): () => void;
+	terminate(): Promise<void>;
+}
+
+interface PendingRun {
+	runId: string;
+	runState: VmRunState;
+	toolSession: ToolSession;
+	resolve(value: { value: unknown }): void;
+	reject(error: Error): void;
+	toolCalls: Map<string, AbortController>;
+	settled: boolean;
 }
 
-interface VmContextState {
+interface JsSession {
 	sessionKey: string;
-	cwd: string;
-	sessionId: string;
-	session: ToolSession;
-	context: vm.Context;
-	env: Map<string, string>;
-	timers: Set<NodeJS.Timeout>;
-	intervals: Set<NodeJS.Timeout>;
-	currentRun?: VmRunState;
+	worker: WorkerHandle;
+	state: "alive" | "dead";
+	pending: Map<string, PendingRun>;
 	queue: Promise<void>;
 }
 
-const vmContexts = new Map<string, VmContextState>();
-const utf8Encoder = new TextEncoder();
+const sessions = new Map<string, JsSession>();
+const READY_TIMEOUT_MS = 5_000;
 
-function getMergedEnv(state: VmContextState): Record<string, string> {
-	const env: Record<string, string> = {};
-	for (const [key, value] of Object.entries(Bun.env)) {
-		if (typeof value === "string") {
-			env[key] = value;
-		}
-	}
-	for (const [key, value] of state.env) {
-		env[key] = value;
+export async function executeInVmContext(options: {
+	sessionKey: string;
+	sessionId: string;
+	cwd: string;
+	session: ToolSession;
+	reset?: boolean;
+	code: string;
+	filename: string;
+	timeoutMs?: number;
+	runState: VmRunState;
+}): Promise<{ value: unknown }> {
+	if (options.reset) {
+		await resetVmContext(options.sessionKey);
 	}
-	return env;
+	const session = await acquireSession(options.sessionKey, {
+		cwd: options.cwd,
+		sessionId: options.sessionId,
+	});
+	return await runQueued(session, () => runOnce(session, options));
 }
 
-function resolvePath(state: VmContextState, value: string): string {
-	if (value.includes("://")) {
-		throw new ToolError(`Protocol paths are not supported by this helper: ${value}`);
-	}
-	return path.isAbsolute(value) ? path.normalize(value) : path.join(state.cwd, value);
+export async function resetVmContext(sessionKey: string): Promise<void> {
+	const session = sessions.get(sessionKey);
+	if (!session) return;
+	sessions.delete(sessionKey);
+	await killSession(session, new ToolError("JS context reset"));
 }
 
-async function resolveRegularFile(
-	state: VmContextState,
-	rawPath: string,
-): Promise<{ filePath: string; file: Bun.BunFile; size: number }> {
-	const filePath = resolvePath(state, rawPath);
-	const file = Bun.file(filePath);
-	const info = await file.stat().catch(() => undefined);
-	if (!info) {
-		throw new ToolError(`File not found: ${filePath}`);
-	}
-	if (info.isDirectory()) {
-		throw new ToolError(`Directory paths are not supported by this helper: ${filePath}`);
-	}
-	return { filePath, file, size: info.size };
+export async function disposeAllVmContexts(): Promise<void> {
+	const all = [...sessions.values()];
+	sessions.clear();
+	await Promise.all(all.map(session => killSession(session, new ToolError("JS context disposed"))));
 }
 
-function getDataSize(data: string | Blob | ArrayBuffer | ArrayBufferView): number {
-	if (typeof data === "string") {
-		return utf8Encoder.encode(data).byteLength;
-	}
-	if (data instanceof Blob) {
-		return data.size;
-	}
-	if (data instanceof ArrayBuffer) {
-		return data.byteLength;
+async function runQueued<T>(session: JsSession, work: () => Promise<T>): Promise<T> {
+	const previous = session.queue;
+	const { promise, resolve } = Promise.withResolvers<void>();
+	session.queue = promise;
+	try {
+		await previous;
+	} catch {
+		// Previous run's failure must not poison this one.
 	}
-	return data.byteLength;
-}
-
-function isWriteData(value: unknown): value is string | Blob | ArrayBuffer | ArrayBufferView {
-	return (
-		typeof value === "string" || value instanceof Blob || value instanceof ArrayBuffer || ArrayBuffer.isView(value)
-	);
-}
-
-function emitText(state: VmContextState, text: string): void {
-	if (!text) return;
-	state.currentRun?.onText?.(text.endsWith("\n") ? text : `${text}\n`);
-}
-
-function emitStatus(state: VmContextState, event: JsStatusEvent): void {
-	state.currentRun?.onDisplay?.({ type: "status", event });
-}
-
-function displayValue(state: VmContextState, value: unknown): void {
-	if (value === undefined) return;
-	if (value && typeof value === "object") {
-		const record = value as Record<string, unknown>;
-		if (record.type === "image" && typeof record.data === "string" && typeof record.mimeType === "string") {
-			state.currentRun?.onDisplay?.({
-				type: "image",
-				data: record.data,
-				mimeType: record.mimeType,
-			});
-			return;
-		}
-		state.currentRun?.onDisplay?.({
-			type: "json",
-			data: structuredClone(value),
-		});
-		return;
+	try {
+		return await work();
+	} finally {
+		resolve();
 	}
-	emitText(state, String(value));
 }
 
-function formatConsoleArgs(args: unknown[]): string {
-	return args
-		.map(arg => (typeof arg === "string" ? arg : util.inspect(arg, { depth: 6, colors: false, breakLength: 120 })))
-		.join(" ");
-}
-
-function createTrackedTimeout(state: VmContextState, repeat: boolean) {
-	return (callback: (...args: unknown[]) => void, delay?: number, ...args: unknown[]) => {
-		const fn = () => callback(...args);
-		const timer = repeat ? setInterval(fn, delay) : setTimeout(fn, delay);
-		if (repeat) {
-			state.intervals.add(timer);
-		} else {
-			state.timers.add(timer);
-		}
-		return timer;
+async function runOnce(
+	session: JsSession,
+	options: {
+		sessionId: string;
+		cwd: string;
+		session: ToolSession;
+		code: string;
+		filename: string;
+		runState: VmRunState;
+	},
+): Promise<{ value: unknown }> {
+	const runId = `r-${Snowflake.next()}`;
+	const { promise, resolve, reject } = Promise.withResolvers<{ value: unknown }>();
+	const pending: PendingRun = {
+		runId,
+		runState: options.runState,
+		toolSession: options.session,
+		resolve,
+		reject,
+		toolCalls: new Map(),
+		settled: false,
+	};
+	session.pending.set(runId, pending);
+
+	const onAbort = (): void => {
+		const reason = options.runState.signal?.reason;
+		const abortError = reasonToError(reason, "Execution aborted");
+		// Cancel any in-flight tool calls first.
+		for (const ctrl of pending.toolCalls.values()) ctrl.abort(abortError);
+		// Hard-kill the worker — only way to interrupt synchronous user code.
+		void killSessionFor(session, abortError);
 	};
-}
 
-function clearTrackedTimeout(state: VmContextState, repeat: boolean, timer: NodeJS.Timeout | undefined): void {
-	if (!timer) return;
-	if (repeat) {
-		clearInterval(timer);
-		state.intervals.delete(timer);
-		return;
+	if (options.runState.signal?.aborted) {
+		queueMicrotask(onAbort);
+	} else {
+		options.runState.signal?.addEventListener("abort", onAbort, { once: true });
 	}
-	clearTimeout(timer);
-	state.timers.delete(timer);
-}
 
-async function createHelpers(state: VmContextState) {
-	return {
-		read: async (rawPath: string, options: VmHelperOptions = {}): Promise<string> => {
-			const { filePath, file, size } = await resolveRegularFile(state, rawPath);
-			let text = await file.text();
-			const offset = typeof options.offset === "number" ? options.offset : 1;
-			const limit = typeof options.limit === "number" ? options.limit : undefined;
-			if (offset > 1 || limit !== undefined) {
-				const lines = text.split(/\r?\n/);
-				const start = Math.max(0, offset - 1);
-				const end = limit !== undefined ? start + limit : lines.length;
-				text = lines.slice(start, end).join("\n");
-			}
-			emitStatus(state, { op: "read", path: filePath, bytes: size, chars: text.length });
-			return text;
-		},
-		writeFile: async (rawPath: string, data: unknown): Promise<string> => {
-			if (!isWriteData(data)) {
-				throw new ToolError("write() expects string, Blob, ArrayBuffer, or TypedArray data");
-			}
-			const filePath = resolvePath(state, rawPath);
-			if (typeof data === "string" || data instanceof Blob || data instanceof ArrayBuffer) {
-				await Bun.write(filePath, data);
-			} else {
-				await Bun.write(filePath, new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
-			}
-			emitStatus(state, { op: "write", path: filePath, bytes: getDataSize(data) });
-			return filePath;
-		},
-		append: async (rawPath: string, content: string): Promise<string> => {
-			const target = resolvePath(state, rawPath);
-			await Bun.write(
-				target,
-				`${await Bun.file(target)
-					.text()
-					.catch(() => "")}${content}`,
-			);
-			emitStatus(state, {
-				op: "append",
-				path: target,
-				chars: content.length,
-				bytes: utf8Encoder.encode(content).byteLength,
-			});
-			return target;
-		},
-		sortText: (text: string, options: VmHelperOptions = {}): string => {
-			const lines = String(text).split(/\r?\n/);
-			const deduped = options.unique ? Array.from(new Set(lines)) : lines;
-			const sorted = deduped.sort((a, b) => a.localeCompare(b));
-			if (options.reverse) {
-				sorted.reverse();
-			}
-			const result = sorted.join("\n");
-			emitStatus(state, {
-				op: "sort",
-				lines: sorted.length,
-				reverse: options.reverse === true,
-				unique: options.unique === true,
-			});
-			return result;
-		},
-		uniqText: (text: string, options: VmHelperOptions = {}): string | Array<[number, string]> => {
-			const lines = String(text)
-				.split(/\r?\n/)
-				.filter(line => line.length > 0);
-			const groups: Array<[number, string]> = [];
-			for (const line of lines) {
-				const last = groups.at(-1);
-				if (last && last[1] === line) {
-					last[0] += 1;
-					continue;
-				}
-				groups.push([1, line]);
-			}
-			emitStatus(state, { op: "uniq", groups: groups.length, count_mode: options.count === true });
-			if (options.count) {
-				return groups;
-			}
-			return groups.map(([, line]) => line).join("\n");
-		},
-		counter: (items: string | string[], options: VmHelperOptions = {}): Array<[number, string]> => {
-			const values = Array.isArray(items) ? items : String(items).split(/\r?\n/).filter(Boolean);
-			const counts = new Map<string, number>();
-			for (const item of values) {
-				counts.set(item, (counts.get(item) ?? 0) + 1);
-			}
-			const entries = Array.from(counts.entries())
-				.map(([item, count]) => [count, item] as [number, string])
-				.sort((a, b) => (options.reverse === false ? a[0] - b[0] : b[0] - a[0]) || a[1].localeCompare(b[1]));
-			const limited = entries.slice(0, options.limit ?? entries.length);
-			emitStatus(state, { op: "counter", unique: counts.size, total: values.length, top: limited.slice(0, 10) });
-			return limited;
-		},
-		diff: async (rawA: string, rawB: string): Promise<string> => {
-			const fileA = resolvePath(state, rawA);
-			const fileB = resolvePath(state, rawB);
-			const [a, b] = await Promise.all([Bun.file(fileA).text(), Bun.file(fileB).text()]);
-			const result = Diff.createTwoFilesPatch(fileA, fileB, a, b, "", "", { context: 3 });
-			emitStatus(state, {
-				op: "diff",
-				file_a: fileA,
-				file_b: fileB,
-				identical: a === b,
-				preview: result.slice(0, 500),
-			});
-			return result;
-		},
-		tree: async (searchPath = ".", options: VmHelperOptions = {}): Promise<string> => {
-			const root = resolvePath(state, searchPath);
-			const maxDepth = options.maxDepth ?? 3;
-			const showHidden = options.hidden ?? false;
-			const lines: string[] = [`${root}/`];
-			let entryCount = 0;
-			const walk = async (dir: string, prefix: string, depth: number): Promise<void> => {
-				if (depth > maxDepth) return;
-				const entries = (await fs.promises.readdir(dir, { withFileTypes: true }))
-					.filter(entry => showHidden || !entry.name.startsWith("."))
-					.sort((a, b) => a.name.localeCompare(b.name));
-				for (let index = 0; index < entries.length; index++) {
-					const entry = entries[index];
-					const isLast = index === entries.length - 1;
-					const connector = isLast ? "└── " : "├── ";
-					const suffix = entry.isDirectory() ? "/" : "";
-					lines.push(`${prefix}${connector}${entry.name}${suffix}`);
-					entryCount += 1;
-					if (entry.isDirectory()) {
-						await walk(path.join(dir, entry.name), `${prefix}${isLast ? "    " : "│   "}`, depth + 1);
-					}
-				}
-			};
-			await walk(root, "", 1);
-			const result = lines.join("\n");
-			emitStatus(state, { op: "tree", path: root, entries: entryCount, preview: result.slice(0, 1000) });
-			return result;
-		},
-		env: (key?: string, value?: string): string | Record<string, string> | undefined => {
-			if (!key) {
-				const env = Object.fromEntries(Object.entries(getMergedEnv(state)).sort(([a], [b]) => a.localeCompare(b)));
-				emitStatus(state, { op: "env", count: Object.keys(env).length, keys: Object.keys(env).slice(0, 20) });
-				return env;
-			}
-			if (value !== undefined) {
-				state.env.set(key, value);
-				emitStatus(state, { op: "env", key, value, action: "set" });
-				return value;
-			}
-			const result = state.env.get(key) ?? Bun.env[key];
-			emitStatus(state, { op: "env", key, value: result, action: "get" });
-			return result;
-		},
-	};
+	try {
+		session.worker.send({
+			type: "run",
+			runId,
+			code: options.code,
+			filename: options.filename,
+			snapshot: { cwd: options.cwd, sessionId: options.sessionId },
+		});
+		return await promise;
+	} finally {
+		options.runState.signal?.removeEventListener("abort", onAbort);
+		session.pending.delete(runId);
+	}
 }
 
-function createProcessSubset(cwd: string): Record<string, unknown> {
-	return Object.freeze({
-		arch: process.arch,
-		cwd: () => cwd,
-		platform: process.platform,
-		release: Object.freeze({ ...process.release }),
-		version: process.version,
-		versions: Object.freeze({ ...process.versions }),
-	});
-}
+async function acquireSession(sessionKey: string, snapshot: SessionSnapshot): Promise<JsSession> {
+	const existing = sessions.get(sessionKey);
+	if (existing && existing.state === "alive") return existing;
 
-async function createVmState(
-	sessionKey: string,
-	sessionId: string,
-	cwd: string,
-	session: ToolSession,
-): Promise<VmContextState> {
-	const state: VmContextState = {
+	const worker = await spawnJsWorker();
+	const session: JsSession = {
 		sessionKey,
-		cwd,
-		sessionId,
-		session,
-		context: {} as vm.Context,
-		env: new Map(),
-		timers: new Set(),
-		intervals: new Set(),
+		worker,
+		state: "alive",
+		pending: new Map(),
 		queue: Promise.resolve(),
 	};
-
-	const helpers = await createHelpers(state);
-	const contextGlobals: Record<string, unknown> = {
-		__omp_session__: { cwd, sessionId },
-		__omp_helpers__: helpers,
-		__omp_call_tool__: async (name: string, args: unknown) =>
-			callSessionTool(name, args, {
-				session: state.session,
-				signal: state.currentRun?.signal,
-				emitStatus: event => emitStatus(state, event),
-			}),
-		__omp_emit_status__: (op: string, data: Record<string, unknown> = {}) => emitStatus(state, { op, ...data }),
-		__omp_log__: (level: string, ...args: unknown[]) => {
-			const prefix = level === "error" ? "[error] " : level === "warn" ? "[warn] " : "";
-			emitText(state, `${prefix}${formatConsoleArgs(args)}`);
-		},
-		__omp_display__: (value: unknown) => displayValue(state, value),
-		setTimeout: createTrackedTimeout(state, false),
-		setInterval: createTrackedTimeout(state, true),
-		clearTimeout: (timer?: NodeJS.Timeout) => clearTrackedTimeout(state, false, timer),
-		clearInterval: (timer?: NodeJS.Timeout) => clearTrackedTimeout(state, true, timer),
-		queueMicrotask,
-		URL,
-		URLSearchParams,
-		TextEncoder,
-		TextDecoder,
-		AbortController,
-		AbortSignal,
-		structuredClone,
-		crypto,
-		webcrypto: crypto,
-		performance,
-		atob,
-		btoa,
-		Buffer,
-		Bun,
-		process: createProcessSubset(cwd),
-		require: buildRequire(cwd),
-		createRequire,
-		fs,
-		fetch,
-		Blob,
-		File,
-		Headers,
-		Request,
-		Response,
-		globalThis: undefined,
-	};
-	const context = vm.createContext(contextGlobals);
-	context.globalThis = context;
-	state.context = context;
-	vm.runInContext(JAVASCRIPT_PRELUDE_SOURCE, context, {
-		filename: "js-prelude.js",
-		importModuleDynamically: vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
+	const { promise: readyPromise, resolve: resolveReady, reject: rejectReady } = Promise.withResolvers<void>();
+	let resolved = false;
+	const unsubscribe = worker.onMessage(msg => {
+		if (!resolved && msg.type === "ready") {
+			resolved = true;
+			resolveReady();
+			return;
+		}
+		if (!resolved && msg.type === "init-failed") {
+			resolved = true;
+			rejectReady(errorFromPayload(msg.error));
+			return;
+		}
+		handleSessionMessage(session, msg);
 	});
-	return state;
-}
-
-async function getOrCreateVmState(
-	sessionKey: string,
-	sessionId: string,
-	cwd: string,
-	session: ToolSession,
-): Promise<VmContextState> {
-	const existing = vmContexts.get(sessionKey);
-	if (existing) {
-		existing.cwd = cwd;
-		existing.sessionId = sessionId;
-		existing.session = session;
-		return existing;
+	try {
+		await raceWithTimeout(readyPromise, READY_TIMEOUT_MS, "Timed out initializing JS eval worker");
+	} catch (error) {
+		unsubscribe();
+		await worker.terminate().catch(() => undefined);
+		throw error;
 	}
-	const created = await createVmState(sessionKey, sessionId, cwd, session);
-	vmContexts.set(sessionKey, created);
-	return created;
+	worker.send({ type: "init", snapshot });
+	sessions.set(sessionKey, session);
+	return session;
 }
 
-async function disposeState(state: VmContextState): Promise<void> {
-	for (const timer of state.timers) {
-		clearTimeout(timer);
-	}
-	state.timers.clear();
-	for (const timer of state.intervals) {
-		clearInterval(timer);
+function handleSessionMessage(session: JsSession, msg: WorkerOutbound): void {
+	switch (msg.type) {
+		case "text": {
+			const pending = session.pending.get(msg.runId);
+			pending?.runState.onText?.(msg.chunk);
+			return;
+		}
+		case "display": {
+			const pending = session.pending.get(msg.runId);
+			pending?.runState.onDisplay?.(msg.output);
+			return;
+		}
+		case "tool-call":
+			void handleToolCall(session, msg);
+			return;
+		case "result":
+			settlePending(session, msg);
+			return;
+		case "log":
+			logWorkerMessage(msg);
+			return;
+		case "ready":
+		case "init-failed":
+		case "closed":
+			return;
 	}
-	state.intervals.clear();
-	state.currentRun = undefined;
 }
 
-async function runQueued<T>(state: VmContextState, work: () => Promise<T>): Promise<T> {
-	const previous = state.queue;
-	const { promise, resolve } = Promise.withResolvers<void>();
-	state.queue = promise;
-	await previous;
+async function handleToolCall(session: JsSession, msg: Extract<WorkerOutbound, { type: "tool-call" }>): Promise<void> {
+	const pending = session.pending.get(msg.runId);
+	if (!pending) {
+		safeSend(session, {
+			type: "tool-reply",
+			id: msg.id,
+			reply: { ok: false, error: { message: "Run no longer active" } },
+		});
+		return;
+	}
+	const ctrl = new AbortController();
+	pending.toolCalls.set(msg.id, ctrl);
 	try {
-		return await work();
+		const value = await callSessionTool(msg.name, msg.args, {
+			session: pending.toolSession,
+			signal: ctrl.signal,
+			emitStatus: (event: JsStatusEvent) => pending.runState.onDisplay?.({ type: "status", event }),
+		});
+		safeSend(session, { type: "tool-reply", id: msg.id, reply: { ok: true, value } });
+	} catch (error) {
+		safeSend(session, { type: "tool-reply", id: msg.id, reply: { ok: false, error: toErrorPayload(error) } });
 	} finally {
-		resolve();
+		pending.toolCalls.delete(msg.id);
 	}
 }
 
-function buildRequire(cwd: string): NodeJS.Require {
-	// Anchor `require` resolution at the session cwd. The filename does not need to exist;
-	// Node only uses it as a base for module resolution.
-	return createRequire(pathToFileURL(path.join(cwd, "[eval]")).href);
-}
-
-// Static `import ... from "x"` is not valid inside vm.runInContext (script-mode parsing).
-// Rewrite top-level static imports to dynamic `await import(...)` so users can paste ESM
-// source verbatim. We use a real parser instead of regex matching so imports embedded in
-// string literals, template literals, or comments — common in codemods — stay intact.
-
-type BabelImportDeclaration = {
-	type: "ImportDeclaration";
-	start: number;
-	end: number;
-	source: { value: string };
-	specifiers: ReadonlyArray<{
-		type: "ImportDefaultSpecifier" | "ImportNamespaceSpecifier" | "ImportSpecifier";
-		local: { name: string };
-		imported?: { type: "Identifier"; name: string } | { type: "StringLiteral"; value: string };
-	}>;
-	attributes?: ReadonlyArray<{
-		key: { type: "Identifier"; name: string } | { type: "StringLiteral"; value: string };
-		value: { value: string };
-	}>;
-};
-
-function buildDynamicImportCall(sourceLiteral: string, withClause: string | undefined): string {
-	return withClause ? `import(${sourceLiteral}, { with: ${withClause} })` : `import(${sourceLiteral})`;
-}
-
-function buildWithClause(node: BabelImportDeclaration): string | undefined {
-	const attrs = node.attributes;
-	if (!attrs || attrs.length === 0) return undefined;
-	const pairs = attrs.map(attr => {
-		const key = attr.key.type === "Identifier" ? attr.key.name : JSON.stringify(attr.key.value);
-		return `${key}: ${JSON.stringify(attr.value.value)}`;
-	});
-	return `{ ${pairs.join(", ")} }`;
+function settlePending(session: JsSession, msg: Extract<WorkerOutbound, { type: "result" }>): void {
+	const pending = session.pending.get(msg.runId);
+	if (!pending || pending.settled) return;
+	pending.settled = true;
+	if (msg.ok) {
+		pending.resolve({ value: undefined });
+		return;
+	}
+	pending.reject(errorFromPayload(msg.error));
 }
 
-function rewriteImportNode(node: BabelImportDeclaration): string {
-	const sourceLiteral = JSON.stringify(node.source.value);
-	const withClause = buildWithClause(node);
-	const importCall = buildDynamicImportCall(sourceLiteral, withClause);
-
-	let defaultName: string | undefined;
-	let namespaceName: string | undefined;
-	const namedPairs: Array<[string, string]> = [];
-	for (const spec of node.specifiers) {
-		if (spec.type === "ImportDefaultSpecifier") {
-			defaultName = spec.local.name;
-		} else if (spec.type === "ImportNamespaceSpecifier") {
-			namespaceName = spec.local.name;
-		} else if (spec.type === "ImportSpecifier" && spec.imported) {
-			const imported = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
-			namedPairs.push([imported, spec.local.name]);
-		}
+async function killSessionFor(session: JsSession, error: Error): Promise<void> {
+	if (sessions.get(session.sessionKey) === session) {
+		sessions.delete(session.sessionKey);
 	}
+	await killSession(session, error);
+}
 
-	if (namedPairs.length > 0) {
-		const inner = namedPairs.map(([imp, loc]) => (imp === loc ? imp : `${imp}: ${loc}`)).join(", ");
-		const props = defaultName ? `default: ${defaultName}, ${inner}` : inner;
-		return `const { ${props} } = await ${importCall};`;
+async function killSession(session: JsSession, error: Error): Promise<void> {
+	if (session.state === "dead") return;
+	session.state = "dead";
+	for (const pending of session.pending.values()) {
+		if (pending.settled) continue;
+		pending.settled = true;
+		for (const ctrl of pending.toolCalls.values()) ctrl.abort(error);
+		pending.reject(error);
 	}
-	if (namespaceName && defaultName) {
-		return `const ${namespaceName} = await ${importCall}; const ${defaultName} = ${namespaceName}.default;`;
-	}
-	if (namespaceName) return `const ${namespaceName} = await ${importCall};`;
-	if (defaultName) return `const ${defaultName} = (await ${importCall}).default;`;
-	return `await ${importCall};`;
+	session.pending.clear();
+	await session.worker.terminate().catch(() => undefined);
 }
 
-export function rewriteStaticImports(code: string): string {
-	if (!code.includes("import")) return code;
-
-	let ast: { program: { body: ReadonlyArray<{ type: string }> } };
+function safeSend(session: JsSession, msg: WorkerInbound): void {
+	if (session.state !== "alive") return;
 	try {
-		ast = babelParse(code, {
-			sourceType: "module",
-			allowAwaitOutsideFunction: true,
-			allowReturnOutsideFunction: true,
-			allowImportExportEverywhere: true,
-			allowNewTargetOutsideFunction: true,
-			allowSuperOutsideMethod: true,
-			allowUndeclaredExports: true,
-			errorRecovery: true,
-		}) as unknown as typeof ast;
-	} catch {
-		// Parser bailed entirely — let the VM surface the real syntax error.
-		return code;
+		session.worker.send(msg);
+	} catch (err) {
+		logger.debug("js worker send failed", { error: err instanceof Error ? err.message : String(err) });
 	}
+}
 
-	// Only rewrite top-level imports. Anything nested deeper is invalid JS anyway and the
-	// VM will report it.
-	const imports: BabelImportDeclaration[] = [];
-	for (const node of ast.program.body) {
-		if (node.type === "ImportDeclaration") imports.push(node as unknown as BabelImportDeclaration);
-	}
-	if (imports.length === 0) return code;
+function reasonToError(reason: unknown, fallback: string): Error {
+	if (reason instanceof Error) return reason;
+	if (typeof reason === "string") return new ToolAbortError(reason);
+	return new ToolAbortError(fallback);
+}
 
-	// Splice from the back so earlier offsets stay valid.
-	imports.sort((a, b) => b.start - a.start);
-	let result = code;
-	for (const node of imports) {
-		result = result.slice(0, node.start) + rewriteImportNode(node) + result.slice(node.end);
+function errorFromPayload(payload: RunErrorPayload): Error {
+	if (payload.isAbort) {
+		const err = new ToolAbortError(payload.message || "Execution aborted");
+		if (payload.stack) err.stack = payload.stack;
+		return err;
 	}
-	return result;
+	const ctor = payload.isToolError ? ToolError : Error;
+	const error = new ctor(payload.message);
+	if (payload.name) error.name = payload.name;
+	if (payload.stack) error.stack = payload.stack;
+	return error;
 }
 
-function wrapCode(code: string): { source: string; asyncWrapped: boolean } {
-	const rewritten = rewriteStaticImports(code);
-	const needsAsyncWrapper = /\bawait\b|\breturn\b/.test(rewritten);
-	if (!needsAsyncWrapper) {
-		return { source: rewritten, asyncWrapped: false };
+function toErrorPayload(error: unknown): RunErrorPayload {
+	if (error instanceof Error) {
+		return {
+			name: error.name,
+			message: error.message,
+			stack: error.stack,
+			isAbort: error.name === "AbortError" || error.name === "ToolAbortError",
+			isToolError: error instanceof ToolError || error.name === "ToolError",
+		};
 	}
-	return {
-		source: `(async () => {\n${rewritten}\n})()`,
-		asyncWrapped: true,
-	};
+	return { message: String(error) };
 }
 
-async function awaitMaybePromise<T>(value: T | Promise<T>, signal?: AbortSignal): Promise<T> {
-	if (!value || typeof value !== "object" || typeof (value as { then?: unknown }).then !== "function") {
-		return value;
-	}
-	const promised = value as Promise<T>;
-	if (!signal) {
-		return promised;
-	}
-	const { promise, resolve, reject } = Promise.withResolvers<T>();
-	if (signal.aborted) {
-		reject(signal.reason ?? new Error("Execution aborted"));
-		return promise;
+function logWorkerMessage(msg: Extract<WorkerOutbound, { type: "log" }>): void {
+	if (msg.level === "debug") logger.debug(msg.msg, msg.meta);
+	else if (msg.level === "warn") logger.warn(msg.msg, msg.meta);
+	else logger.error(msg.msg, msg.meta);
+}
+
+async function raceWithTimeout<T>(promise: Promise<T>, timeoutMs: number, reason: string): Promise<T> {
+	const timeoutSignal = AbortSignal.timeout(timeoutMs);
+	const { promise: timeoutPromise, reject } = Promise.withResolvers<never>();
+	const onAbort = (): void => reject(new ToolError(reason));
+	timeoutSignal.addEventListener("abort", onAbort, { once: true });
+	try {
+		return await Promise.race([promise, timeoutPromise]);
+	} finally {
+		timeoutSignal.removeEventListener("abort", onAbort);
 	}
-	const onAbort = () => reject(signal.reason ?? new Error("Execution aborted"));
-	signal.addEventListener("abort", onAbort, { once: true });
-	promised.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
-	return promise;
 }
 
-export async function executeInVmContext(options: {
-	sessionKey: string;
-	sessionId: string;
-	cwd: string;
-	session: ToolSession;
-	reset?: boolean;
-	code: string;
-	filename: string;
-	timeoutMs?: number;
-	runState: VmRunState;
-}): Promise<{ value: unknown }> {
-	if (options.reset) {
-		await resetVmContext(options.sessionKey);
+async function spawnJsWorker(): Promise<WorkerHandle> {
+	try {
+		const worker = new Worker(jsWorkerEntryUrl, { type: "module" });
+		return wrapBunWorker(worker);
+	} catch (err) {
+		logger.warn("Bun Worker spawn failed; using inline JS eval worker (no sync-loop guard)", {
+			error: err instanceof Error ? err.message : String(err),
+		});
+		return spawnInlineWorker();
 	}
-	const state = await getOrCreateVmState(options.sessionKey, options.sessionId, options.cwd, options.session);
-	return runQueued(state, async () => {
-		state.currentRun = options.runState;
-		try {
-			if (options.runState.signal?.aborted) {
-				throw options.runState.signal.reason ?? new Error("Execution aborted");
-			}
-			const wrapped = wrapCode(options.code);
-			const value = vm.runInContext(wrapped.source, state.context, {
-				filename: options.filename,
-				timeout: options.timeoutMs,
-				importModuleDynamically: vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
-			});
-			const awaited = await awaitMaybePromise(value, options.runState.signal);
-			displayValue(state, awaited);
-			return { value: awaited };
-		} finally {
-			state.currentRun = undefined;
-		}
-	});
 }
 
-export async function resetVmContext(sessionKey: string): Promise<void> {
-	const existing = vmContexts.get(sessionKey);
-	if (!existing) return;
-	vmContexts.delete(sessionKey);
-	await disposeState(existing);
+function wrapBunWorker(worker: Worker): WorkerHandle {
+	return {
+		mode: "worker",
+		send(msg) {
+			worker.postMessage(msg);
+		},
+		onMessage(handler) {
+			const wrap = (event: MessageEvent): void => handler(event.data as WorkerOutbound);
+			worker.addEventListener("message", wrap);
+			return () => worker.removeEventListener("message", wrap);
+		},
+		async terminate() {
+			worker.terminate();
+		},
+	};
 }
 
-export async function disposeAllVmContexts(): Promise<void> {
-	const states = Array.from(vmContexts.values());
-	vmContexts.clear();
-	for (const state of states) {
-		await disposeState(state);
-	}
+/**
+ * Inline fallback for environments where Bun cannot spawn the worker entry
+ * (e.g. some test runners). Preserves behavior but cannot interrupt synchronous
+ * infinite loops because user code runs on the main thread.
+ */
+function spawnInlineWorker(): WorkerHandle {
+	const hostListeners = new Set<(message: WorkerOutbound) => void>();
+	const workerListeners = new Set<(message: WorkerInbound) => void>();
+	const workerTransport: Transport = {
+		send: msg =>
+			queueMicrotask(() => {
+				for (const listener of hostListeners) listener(msg);
+			}),
+		onMessage: handler => {
+			workerListeners.add(handler);
+			return () => workerListeners.delete(handler);
+		},
+		close: () => {},
+	};
+	new WorkerCore(workerTransport);
+	return {
+		mode: "inline",
+		send: msg =>
+			queueMicrotask(() => {
+				for (const listener of workerListeners) listener(msg);
+			}),
+		onMessage: handler => {
+			hostListeners.add(handler);
+			return () => hostListeners.delete(handler);
+		},
+		async terminate() {
+			hostListeners.clear();
+			workerListeners.clear();
+		},
+	};
 }