@code-yeongyu/senpi 2026.7.4 → 2026.7.9-2

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/context-manager.ts

@@ -0,0 +1,247 @@
+import { Worker } from "node:worker_threads";
+import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import { createInlineWorker, type WorkerLike } from "./inline-worker.ts";
+
+export type JavaScriptKernelMode = "worker" | "inline";
+
+export interface JavaScriptKernelOptions {
+	readonly sessionId: string;
+	readonly cwd: string;
+	readonly parallelPoolWidth: number;
+	readonly onMessage?: (message: KernelToHostMessage) => void;
+	readonly workerEntryUrl?: URL;
+}
+
+export interface JavaScriptRunInput {
+	readonly cellId: string;
+	readonly code: string;
+	readonly timeoutMs?: number;
+	readonly onMessage?: (message: KernelToHostMessage) => void;
+}
+
+type ResultMessage = Extract<KernelToHostMessage, { type: "result" }>;
+type ToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;
+
+interface QueuedRun {
+	readonly input: JavaScriptRunInput;
+	resolve(message: ResultMessage): void;
+}
+
+export class JavaScriptKernel {
+	readonly #options: JavaScriptKernelOptions;
+	#worker: WorkerLike | null = null;
+	#mode: JavaScriptKernelMode = "worker";
+	#ready: Promise<void> | null = null;
+	#queue: QueuedRun[] = [];
+	#active: QueuedRun | null = null;
+	#timeout: NodeJS.Timeout | null = null;
+	#toolWaiters: Array<(message: ToolCallMessage) => void> = [];
+	#pendingToolCalls: ToolCallMessage[] = [];
+
+	constructor(options: JavaScriptKernelOptions) {
+		this.#options = options;
+	}
+
+	get mode(): JavaScriptKernelMode {
+		return this.#mode;
+	}
+
+	async run(input: JavaScriptRunInput): Promise<ResultMessage> {
+		await this.#ensureReady();
+		const promise = new Promise<ResultMessage>((resolve) => {
+			this.#queue.push({ input, resolve });
+		});
+		this.#startNext();
+		return await promise;
+	}
+
+	async reset(): Promise<void> {
+		await this.#terminate();
+		this.#ready = null;
+		await this.#ensureReady();
+	}
+
+	deliverToolReply(message: Extract<HostToKernelMessage, { type: "tool-reply" }>): void {
+		this.#worker?.postMessage(message);
+	}
+
+	async nextToolCall(): Promise<ToolCallMessage> {
+		const pending = this.#pendingToolCalls.shift();
+		if (pending) return pending;
+		return await new Promise((resolve) => this.#toolWaiters.push(resolve));
+	}
+
+	async close(): Promise<void> {
+		this.#worker?.postMessage({ type: "close" });
+		await this.#terminate();
+	}
+
+	async #ensureReady(): Promise<void> {
+		if (!this.#ready) this.#ready = this.#startWorker();
+		return await this.#ready;
+	}
+
+	async #startWorker(): Promise<void> {
+		const worker = this.#spawnWorker();
+		this.#worker = worker;
+		this.#mode = worker.mode;
+		const ready = waitForReady(worker);
+		worker.onMessage((message) => this.#handleMessage(message));
+		worker.onError((error) => this.#handleCrash(error));
+		worker.postMessage({ type: "init", sessionId: this.#options.sessionId, connection: { port: 1, token: "local" } });
+		try {
+			await ready;
+		} catch (error) {
+			if (worker.mode === "inline") throw error;
+			await worker.terminate().catch(() => undefined);
+			const inline = createInlineWorker(this.#options.parallelPoolWidth);
+			this.#worker = inline;
+			this.#mode = "inline";
+			const inlineReady = waitForReady(inline);
+			inline.onMessage((message) => this.#handleMessage(message));
+			inline.onError((crash) => this.#handleCrash(crash));
+			inline.postMessage({
+				type: "init",
+				sessionId: this.#options.sessionId,
+				connection: { port: 1, token: "local" },
+			});
+			await inlineReady;
+		}
+	}
+
+	#spawnWorker(): WorkerLike {
+		try {
+			const url = this.#options.workerEntryUrl ?? new URL("./worker-entry.js", import.meta.url);
+			const worker = new Worker(url, {
+				workerData: { cwd: this.#options.cwd, parallelPoolWidth: this.#options.parallelPoolWidth },
+			});
+			return wrapNodeWorker(worker);
+		} catch {
+			return createInlineWorker(this.#options.parallelPoolWidth);
+		}
+	}
+
+	#startNext(): void {
+		if (this.#active || !this.#worker) return;
+		const next = this.#queue.shift();
+		if (!next) return;
+		this.#active = next;
+		if (next.input.timeoutMs) {
+			this.#timeout = setTimeout(() => void this.#timeoutActive(next.input.cellId), next.input.timeoutMs);
+		}
+		this.#worker.postMessage({
+			type: "run",
+			cellId: next.input.cellId,
+			code: next.input.code,
+			timeoutMs: next.input.timeoutMs,
+		});
+	}
+
+	async #timeoutActive(cellId: string): Promise<void> {
+		const active = this.#active;
+		if (!active || active.input.cellId !== cellId) return;
+		const durationMs = active.input.timeoutMs ?? 0;
+		active.resolve({
+			type: "result",
+			cellId,
+			ok: false,
+			error: { message: `JS cell timed out after ${durationMs}ms` },
+			durationMs,
+		});
+		this.#active = null;
+		await this.#terminate();
+		this.#ready = null;
+		await this.#ensureReady();
+		this.#startNext();
+	}
+
+	#handleMessage(message: KernelToHostMessage): void {
+		this.#options.onMessage?.(message);
+		this.#active?.input.onMessage?.(message);
+		if (message.type === "tool-call") {
+			const waiter = this.#toolWaiters.shift();
+			if (waiter) waiter(message);
+			else this.#pendingToolCalls.push(message);
+			return;
+		}
+		if (message.type !== "result") return;
+		if (this.#timeout) clearTimeout(this.#timeout);
+		this.#timeout = null;
+		const active = this.#active;
+		this.#active = null;
+		active?.resolve(message);
+		this.#startNext();
+	}
+
+	#handleCrash(error: Error): void {
+		const active = this.#active;
+		if (!active) return;
+		this.#active = null;
+		active.resolve({
+			type: "result",
+			cellId: active.input.cellId,
+			ok: false,
+			error: bridgeError(error),
+			durationMs: 0,
+		});
+	}
+
+	async #terminate(): Promise<void> {
+		if (this.#timeout) clearTimeout(this.#timeout);
+		this.#timeout = null;
+		const worker = this.#worker;
+		this.#worker = null;
+		await worker?.terminate().catch(() => undefined);
+	}
+}
+
+function waitForReady(worker: WorkerLike): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const offMessage = worker.onMessage((message) => {
+			if (message.type === "ready") {
+				offMessage();
+				offError();
+				resolve();
+			} else if (message.type === "init-failed") {
+				offMessage();
+				offError();
+				reject(errorFromBridge(message.error));
+			}
+		});
+		const offError = worker.onError((error) => {
+			offMessage();
+			offError();
+			reject(error);
+		});
+	});
+}
+
+function wrapNodeWorker(worker: Worker): WorkerLike {
+	return {
+		mode: "worker",
+		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) {
+			worker.on("error", handler);
+			return () => worker.off("error", handler);
+		},
+		async terminate() {
+			await worker.terminate();
+		},
+	};
+}
+
+function errorFromBridge(error: { message: string; name?: string; 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;
+}
+
+function bridgeError(error: Error): { message: string; name?: string; stack?: string } {
+	return { message: error.message, name: error.name, stack: error.stack };
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/inline-worker.ts

@@ -0,0 +1,186 @@
+import { inspect } from "node:util";
+import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { JavaScriptKernelMode } from "./context-manager.ts";
+
+type AsyncFunctionType = new (...args: string[]) => (...values: unknown[]) => Promise<unknown>;
+const AsyncFunction = async function inlineAsyncFunction() {
+	return undefined;
+}.constructor as AsyncFunctionType;
+
+export interface WorkerLike {
+	readonly mode: JavaScriptKernelMode;
+	postMessage(message: HostToKernelMessage): void;
+	onMessage(handler: (message: KernelToHostMessage) => void): () => void;
+	onError(handler: (error: Error) => void): () => void;
+	terminate(): Promise<void>;
+}
+
+export function createInlineWorker(parallelPoolWidth: number): WorkerLike {
+	return new InlineWorker(parallelPoolWidth);
+}
+
+class InlineWorker implements WorkerLike {
+	readonly mode = "inline";
+	readonly #parallelPoolWidth: number;
+	readonly #state: Record<string, unknown> = {};
+	#handlers: Array<(message: KernelToHostMessage) => void> = [];
+	#errorHandlers: Array<(error: Error) => void> = [];
+	#pendingTools = new Map<string, { resolve(value: unknown): void; reject(error: Error): void }>();
+
+	constructor(parallelPoolWidth: number) {
+		this.#parallelPoolWidth = parallelPoolWidth;
+	}
+
+	postMessage(message: HostToKernelMessage): void {
+		if (message.type === "init") this.#emit({ type: "ready" });
+		else if (message.type === "run") void this.#run(message.cellId, message.code);
+		else if (message.type === "tool-reply") this.#deliverToolReply(message);
+		else if (message.type === "close") this.#emit({ type: "closed" });
+	}
+
+	onMessage(handler: (message: KernelToHostMessage) => void): () => void {
+		this.#handlers.push(handler);
+		return () => {
+			this.#handlers = this.#handlers.filter((existing) => existing !== handler);
+		};
+	}
+
+	onError(handler: (error: Error) => void): () => void {
+		this.#errorHandlers.push(handler);
+		return () => {
+			this.#errorHandlers = this.#errorHandlers.filter((existing) => existing !== handler);
+		};
+	}
+
+	async terminate(): Promise<void> {
+		this.#handlers = [];
+		this.#errorHandlers = [];
+		this.#pendingTools.clear();
+	}
+
+	async #run(cellId: string, code: string): Promise<void> {
+		const started = Date.now();
+		try {
+			const value = await this.#execute(code);
+			this.#emit({
+				type: "result",
+				cellId,
+				ok: true,
+				valueRepr: valueRepr(value),
+				durationMs: Date.now() - started,
+			});
+		} catch (error) {
+			this.#emit({ type: "result", cellId, ok: false, error: bridgeError(error), durationMs: Date.now() - started });
+		}
+	}
+
+	async #execute(code: string): Promise<unknown> {
+		const transformed = code.replace(/(^|\n)\s*(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/gu, "$1state.$2 =");
+		const body = /\breturn\b/u.test(transformed) ? transformed : `return await (${transformed})`;
+		const fn = new AsyncFunction(
+			"state",
+			"tool",
+			"parallel",
+			"print",
+			"display",
+			"log",
+			"phase",
+			`with (state) { ${body} }`,
+		);
+		return await fn(
+			this.#state,
+			this.#toolProxy(),
+			this.#parallel.bind(this),
+			this.#print.bind(this),
+			this.#display.bind(this),
+			this.#log.bind(this),
+			this.#phase.bind(this),
+		);
+	}
+
+	#toolProxy(): unknown {
+		return new Proxy(
+			{},
+			{
+				get: (_target, prop) => {
+					if (typeof prop !== "string") return undefined;
+					return async (args: unknown) => await this.#callTool(prop, args);
+				},
+			},
+		);
+	}
+
+	async #callTool(toolName: string, args: unknown): Promise<unknown> {
+		const callId = `js-${crypto.randomUUID()}`;
+		const promise = new Promise<unknown>((resolve, reject) => this.#pendingTools.set(callId, { resolve, reject }));
+		this.#emit({ type: "tool-call", callId, toolName, args });
+		return await promise;
+	}
+
+	#deliverToolReply(message: Extract<HostToKernelMessage, { type: "tool-reply" }>): void {
+		const pending = this.#pendingTools.get(message.callId);
+		if (!pending) return;
+		this.#pendingTools.delete(message.callId);
+		if (message.ok) pending.resolve(message.value);
+		else pending.reject(errorFromBridge(message.error));
+	}
+
+	async #parallel(thunks: Array<() => Promise<unknown>>): Promise<unknown[]> {
+		const results = new Array<unknown>(thunks.length);
+		let next = 0;
+		await Promise.all(
+			Array.from({ length: Math.min(this.#parallelPoolWidth, thunks.length) }, async () => {
+				while (next < thunks.length) {
+					const index = next;
+					next += 1;
+					results[index] = await thunks[index]();
+				}
+			}),
+		);
+		return results;
+	}
+
+	#print(...values: unknown[]): void {
+		this.#emit({ type: "text", stream: "stdout", data: `${values.map(formatValue).join(" ")}\n` });
+	}
+
+	#display(value: unknown): void {
+		this.#emit({
+			type: "display",
+			mimeType: "application/json",
+			dataBase64: Buffer.from(JSON.stringify(value), "utf8").toString("base64"),
+		});
+	}
+
+	#log(message: unknown): void {
+		this.#emit({ type: "log", message: String(message) });
+	}
+
+	#phase(title: unknown): void {
+		this.#emit({ type: "phase", title: String(title) });
+	}
+
+	#emit(message: KernelToHostMessage): void {
+		for (const handler of this.#handlers) handler(message);
+	}
+}
+
+function valueRepr(value: unknown): string | undefined {
+	return value === undefined ? undefined : JSON.stringify(value);
+}
+
+function formatValue(value: unknown): string {
+	return typeof value === "string" ? value : inspect(value, { colors: false, depth: 5 });
+}
+
+function errorFromBridge(error: { message: string; name?: string; 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;
+}
+
+function bridgeError(error: unknown): { message: string; name?: string; stack?: string } {
+	if (error instanceof Error) return { message: error.message, name: error.name, stack: error.stack };
+	return { message: String(error) };
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/prelude.ts

@@ -0,0 +1,13 @@
+export const JAVASCRIPT_KERNEL_PRELUDE = [
+	"print(...values): write stdout text.",
+	"display(value): emit JSON or image display output.",
+	"log(message): emit a progress log line.",
+	"phase(title): emit a progress phase.",
+	"env(key?, value?): read, set, or list environment values.",
+	"read(path, offset?, limit?): read UTF-8 text with optional 1-indexed line slicing.",
+	"write(path, content): write UTF-8 text and return the resolved path.",
+	"tool.<name>(args): request a host tool call through the bridge.",
+	"completion(prompt, opts?): request a host completion bridge call.",
+	"parallel(thunks): run async thunks through the configured bounded pool.",
+	"pipeline(items, ...stages): map items through staged async transforms.",
+].join("\n");

package/node_modules/@code-yeongyu/senpi-codemode/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/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/worker-core.js

@@ -0,0 +1,85 @@
+import { JsWorkerRuntime } from "./worker-runtime.js";
+
+export function createWorkerCore(transport, options) {
+	let runtime = null;
+	const pendingTools = new Map();
+	const started = Date.now();
+
+	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;
+		}
+		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: Date.now() - started });
+		} catch (error) {
+			emit({ type: "result", cellId: message.cellId, ok: false, error: bridgeError(error), durationMs: Date.now() - started });
+		}
+	}
+
+	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 });
+			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 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/node_modules/@code-yeongyu/senpi-codemode/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/node_modules/@code-yeongyu/senpi-codemode/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;
+}