@code-yeongyu/senpi-codemode 2026.7.25-2

package/src/kernels/js/run-queue.ts

@@ -0,0 +1,82 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { JavaScriptRunInput } from "./kernel-contract.ts";
+
+type ResultMessage = Extract<KernelToHostMessage, { type: "result" }>;
+
+export interface PendingJavaScriptRun {
+	readonly input: JavaScriptRunInput;
+	readonly resolve: (message: ResultMessage) => void;
+	readonly reject: (error: Error) => void;
+	startedAtMs: number | null;
+	settled: boolean;
+}
+
+export class JavaScriptRunQueue {
+	#queue: PendingJavaScriptRun[] = [];
+	#active: PendingJavaScriptRun | null = null;
+
+	get active(): PendingJavaScriptRun | null {
+		return this.#active;
+	}
+
+	get hasWaiting(): boolean {
+		return this.#queue.length > 0;
+	}
+
+	enqueue(input: JavaScriptRunInput): Promise<ResultMessage> {
+		return new Promise((resolve, reject) => {
+			this.#queue.push({ input, resolve, reject, startedAtMs: null, settled: false });
+		});
+	}
+
+	startNext(startedAtMs: number): PendingJavaScriptRun | null {
+		if (this.#active) return null;
+		const next = this.#queue.shift() ?? null;
+		if (next) next.startedAtMs = startedAtMs;
+		this.#active = next;
+		return next;
+	}
+
+	durationMs(run: PendingJavaScriptRun, finishedAtMs: number): number {
+		if (run.startedAtMs === null) return 0;
+		return Math.max(0, Math.round(finishedAtMs - run.startedAtMs));
+	}
+
+	takeInterruptTarget(): PendingJavaScriptRun | null {
+		if (!this.#active) return this.#queue.shift() ?? null;
+		const active = this.#active;
+		this.#active = null;
+		return active;
+	}
+
+	releaseActive(run: PendingJavaScriptRun): boolean {
+		if (this.#active !== run) return false;
+		this.#active = null;
+		return true;
+	}
+
+	settle(run: PendingJavaScriptRun, result: ResultMessage): void {
+		if (run.settled) return;
+		run.settled = true;
+		run.resolve(result);
+	}
+
+	settleAll(message: string): void {
+		const active = this.#active;
+		this.#active = null;
+		if (active) this.settle(active, stoppedResult(active.input.cellId, message));
+		for (const queued of this.#queue.splice(0)) this.settle(queued, stoppedResult(queued.input.cellId, message));
+	}
+
+	rejectWaiting(error: Error): void {
+		for (const queued of this.#queue.splice(0)) {
+			if (queued.settled) continue;
+			queued.settled = true;
+			queued.reject(error);
+		}
+	}
+}
+
+export function stoppedResult(cellId: string, message: string): ResultMessage {
+	return { type: "result", cellId, ok: false, error: { message }, durationMs: 0 };
+}

package/src/kernels/js/worker-core.d.ts

@@ -0,0 +1,18 @@
+import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+
+export interface WorkerCoreTransport {
+	send(message: KernelToHostMessage): void;
+	onMessage(handler: (message: HostToKernelMessage) => void): () => void;
+	close(): void;
+}
+
+export interface WorkerCoreOptions {
+	cwd: string;
+	parallelPoolWidth: number;
+}
+
+export interface WorkerCoreHandle {
+	dispose(): void;
+}
+
+export function createWorkerCore(transport: WorkerCoreTransport, options: WorkerCoreOptions): WorkerCoreHandle;

package/src/kernels/js/worker-core.js

@@ -0,0 +1,94 @@
+import { JsWorkerRuntime } from "./worker-runtime.js";
+
+export function createWorkerCore(transport, options) {
+	let runtime = null;
+	const pendingTools = new Map();
+
+	function emit(message) {
+		transport.send(message);
+	}
+
+	async function runCell(message) {
+		if (!runtime) {
+			emit({ type: "result", cellId: message.cellId, ok: false, error: { message: "JS runtime not initialized" }, durationMs: 0 });
+			return;
+		}
+		const startedAtMs = performance.now();
+		try {
+			const value = await runtime.run(message.code, message.cellId, {
+				emit,
+				callTool: async (toolName, args) => await callTool(toolName, args),
+			});
+			emit({ type: "result", cellId: message.cellId, ok: true, valueRepr: valueRepr(value), durationMs: durationMs(startedAtMs) });
+		} catch (error) {
+			emit({ type: "result", cellId: message.cellId, ok: false, error: bridgeError(error), durationMs: durationMs(startedAtMs) });
+		}
+	}
+
+	async function callTool(toolName, args) {
+		const callId = `js-${crypto.randomUUID()}`;
+		const promise = new Promise((resolve, reject) => pendingTools.set(callId, { resolve, reject }));
+		emit({ type: "tool-call", callId, toolName, args });
+		return await promise;
+	}
+
+	function onMessage(message) {
+		if (message.type === "init") {
+			runtime = new JsWorkerRuntime({
+				cwd: options.cwd,
+				parallelPoolWidth: options.parallelPoolWidth,
+				localRoots: message.connection.localRoots,
+				artifactsDir: message.connection.artifactsDir,
+			});
+			emit({ type: "ready" });
+			return;
+		}
+		if (message.type === "run") {
+			void runCell(message);
+			return;
+		}
+		if (message.type === "tool-reply") {
+			const pending = pendingTools.get(message.callId);
+			if (!pending) return;
+			pendingTools.delete(message.callId);
+			if (message.ok) pending.resolve(message.value);
+			else pending.reject(errorFromBridge(message.error));
+			return;
+		}
+		if (message.type === "close") {
+			emit({ type: "closed" });
+			transport.close();
+		}
+	}
+
+	const unsubscribe = transport.onMessage(onMessage);
+	return {
+		dispose() {
+			unsubscribe();
+			globalThis.__senpi_restore_console__?.();
+		},
+	};
+}
+
+function durationMs(startedAtMs) {
+	return Math.max(0, Math.round(performance.now() - startedAtMs));
+}
+
+function valueRepr(value) {
+	if (value === undefined) return undefined;
+	return JSON.stringify(value);
+}
+
+function bridgeError(error) {
+	if (error instanceof Error) {
+		return { name: error.name, message: error.message, stack: error.stack };
+	}
+	return { message: String(error) };
+}
+
+function errorFromBridge(error) {
+	const result = new Error(error.message);
+	if (error.name) result.name = error.name;
+	if (error.stack) result.stack = error.stack;
+	return result;
+}

package/src/kernels/js/worker-entry.js

@@ -0,0 +1,23 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { createWorkerCore } from "./worker-core.js";
+
+if (!parentPort) throw new Error("JS kernel worker missing parentPort");
+
+const transport = {
+	send(message) {
+		parentPort.postMessage(message);
+	},
+	onMessage(handler) {
+		parentPort.on("message", handler);
+		return () => parentPort.off("message", handler);
+	},
+	close() {
+		parentPort.close();
+		setTimeout(() => process.exit(0), 0);
+	},
+};
+
+createWorkerCore(transport, {
+	cwd: workerData.cwd,
+	parallelPoolWidth: workerData.parallelPoolWidth,
+});

package/src/kernels/js/worker-host.ts

@@ -0,0 +1,117 @@
+import { Worker } from "node:worker_threads";
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { WorkerLike } from "./inline-worker.ts";
+import type { JavaScriptKernelMode } from "./kernel-contract.ts";
+
+export class WorkerStartupCancelledError extends Error {
+	readonly name = "WorkerStartupCancelledError";
+
+	constructor() {
+		super("JavaScript worker startup was cancelled");
+	}
+}
+
+export class JavaScriptWorkerExitedError extends Error {
+	readonly name = "JavaScriptWorkerExitedError";
+	readonly exitCode: number;
+
+	constructor(exitCode: number) {
+		super(`JavaScript worker exited with code ${exitCode}`);
+		this.exitCode = exitCode;
+	}
+}
+
+export function spawnNodeWorker(
+	url: URL,
+	cwd: string,
+	parallelPoolWidth: number,
+	mode: JavaScriptKernelMode = "worker",
+): WorkerLike {
+	return wrapNodeWorker(
+		new Worker(url, {
+			workerData: { cwd, parallelPoolWidth },
+		}),
+		mode,
+	);
+}
+
+export function waitForReady(worker: WorkerLike, signal: AbortSignal): Promise<void> {
+	return new Promise((resolve, reject) => {
+		let offMessage = (): void => {};
+		let offError = (): void => {};
+		const cleanup = (): void => {
+			offMessage();
+			offError();
+			signal.removeEventListener("abort", onAbort);
+		};
+		const onAbort = (): void => {
+			cleanup();
+			reject(new WorkerStartupCancelledError());
+		};
+		offMessage = worker.onMessage((message) => {
+			if (message.type === "ready") {
+				cleanup();
+				resolve();
+			} else if (message.type === "init-failed") {
+				cleanup();
+				reject(errorFromBridge(message.error));
+			}
+		});
+		offError = worker.onError((error) => {
+			cleanup();
+			reject(error);
+		});
+		if (signal.aborted) onAbort();
+		else signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+
+export function errorFromBridge(error: {
+	readonly message: string;
+	readonly name?: string;
+	readonly stack?: string;
+}): Error {
+	const result = new Error(error.message);
+	if (error.name) result.name = error.name;
+	if (error.stack) result.stack = error.stack;
+	return result;
+}
+
+export function bridgeError(error: Error): {
+	readonly message: string;
+	readonly name?: string;
+	readonly stack?: string;
+} {
+	return { message: error.message, name: error.name, stack: error.stack };
+}
+
+function wrapNodeWorker(worker: Worker, mode: JavaScriptKernelMode): WorkerLike {
+	return {
+		mode,
+		postMessage: (message) => worker.postMessage(message),
+		onMessage(handler) {
+			const listener = (message: KernelToHostMessage): void => handler(message);
+			worker.on("message", listener);
+			return () => worker.off("message", listener);
+		},
+		onError(handler) {
+			let reported = false;
+			const report = (error: Error): void => {
+				if (reported) return;
+				reported = true;
+				handler(error);
+			};
+			const onError = (error: Error): void => report(error);
+			const onExit = (code: number): void => report(new JavaScriptWorkerExitedError(code));
+			worker.on("error", onError);
+			worker.on("exit", onExit);
+			return () => {
+				worker.off("error", onError);
+				worker.off("exit", onExit);
+			};
+		},
+		async terminate() {
+			await worker.terminate();
+		},
+	};
+}

package/src/kernels/js/worker-indirect-eval.js

@@ -0,0 +1,88 @@
+export function indirectEval(source, filename) {
+	const withPragma = filename ? `${source}\n//# sourceURL=${filename}` : source;
+	const geval = globalThis.eval;
+	return geval(withPragma);
+}
+
+export async function awaitMaybePromise(value) {
+	if (!value || typeof value !== "object" || typeof value.then !== "function") return value;
+	return await value;
+}
+
+export function wrapUserCode(code) {
+	const persistentCode = code.replace(/(^|\n)\s*(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/gu, "$1globalThis.$2 =");
+	if (/\breturn\b/u.test(persistentCode)) return `(async () => {\n${persistentCode}\n})()`;
+	return `(async () => {\n${captureLastExpression(persistentCode)}\n})()`;
+}
+
+function captureLastExpression(code) {
+	const start = findLastTopLevelStatementStart(code);
+	const head = code.slice(0, start);
+	const tail = code.slice(start).trim();
+	if (!tail || isStatementOnly(tail)) return code;
+	return `${head}return ${tail.replace(/;+$/u, "")};`;
+}
+
+function isStatementOnly(source) {
+	return /^(?:const|let|var|if|for|while|switch|try|catch|finally|class|function|import|export|throw|return|do|break|continue|debugger)\b/u.test(
+		source,
+	);
+}
+
+function findLastTopLevelStatementStart(code) {
+	let start = 0;
+	let round = 0;
+	let square = 0;
+	let curly = 0;
+	let quote = "";
+	let escaped = false;
+	let lineComment = false;
+	let blockComment = false;
+	for (let index = 0; index < code.length; index += 1) {
+		const char = code[index];
+		const next = code[index + 1];
+		if (lineComment) {
+			if (char === "\n") lineComment = false;
+			continue;
+		}
+		if (blockComment) {
+			if (char === "*" && next === "/") {
+				blockComment = false;
+				index += 1;
+			}
+			continue;
+		}
+		if (quote) {
+			if (escaped) {
+				escaped = false;
+			} else if (char === "\\") {
+				escaped = true;
+			} else if (char === quote) {
+				quote = "";
+			}
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			lineComment = true;
+			index += 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			blockComment = true;
+			index += 1;
+			continue;
+		}
+		if (char === "'" || char === '"' || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "(") round += 1;
+		else if (char === ")") round -= 1;
+		else if (char === "[") square += 1;
+		else if (char === "]") square -= 1;
+		else if (char === "{") curly += 1;
+		else if (char === "}") curly -= 1;
+		else if ((char === ";" || char === "\n") && round === 0 && square === 0 && curly === 0) start = index + 1;
+	}
+	return start;
+}