@code-yeongyu/senpi 2026.7.10 → 2026.7.11

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

@@ -3,7 +3,6 @@ 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);
@@ -14,14 +13,15 @@ export function createWorkerCore(transport, options) {
 			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: Date.now() - started });
+			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: Date.now() - started });
+			emit({ type: "result", cellId: message.cellId, ok: false, error: bridgeError(error), durationMs: durationMs(startedAtMs) });
 		}
 	}
 
@@ -65,6 +65,10 @@ export function createWorkerCore(transport, options) {
 	};
 }
 
+function durationMs(startedAtMs) {
+	return Math.max(0, Math.round(performance.now() - startedAtMs));
+}
+
 function valueRepr(value) {
 	if (value === undefined) return undefined;
 	return JSON.stringify(value);

package/node_modules/@code-yeongyu/senpi-codemode/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/node_modules/@code-yeongyu/senpi-codemode/src/kernels/py/kernel-contract.ts

@@ -0,0 +1,32 @@
+import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { KernelSpawnProcess } from "./process.ts";
+import type { PythonTransportResult } from "./transport.ts";
+
+export interface PythonKernelStartOptions {
+	readonly interpreterPath: string;
+	readonly sessionId: string;
+	readonly cwd: string;
+	readonly connection: BridgeConnectionConfig;
+	readonly env?: NodeJS.ProcessEnv;
+	readonly startupTimeoutMs?: number;
+	readonly onMessage?: (message: KernelToHostMessage) => void;
+	readonly spawnProcess?: KernelSpawnProcess;
+}
+
+export interface PythonKernelRunOptions {
+	readonly cellId: string;
+	readonly code: string;
+	readonly timeoutMs?: number;
+}
+
+export type ResultMessage = PythonTransportResult;
+
+export interface PendingRun {
+	readonly input: PythonKernelRunOptions;
+	readonly resolve: (result: ResultMessage) => void;
+	readonly reject: (error: unknown) => void;
+	startedAt: number | null;
+	timeoutTimer: NodeJS.Timeout | null;
+	escalationTimer?: NodeJS.Timeout;
+	interruptReason?: string;
+}