@code-yeongyu/senpi 2026.7.10 → 2026.7.11

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/shared/subprocess-kernel.ts

@@ -1,241 +1,266 @@
-import type { ChildProcessWithoutNullStreams } from "node:child_process";
-import { spawn as nodeSpawn } from "node:child_process";
-import { createInterface } from "node:readline";
-import type { BridgeConnectionConfig, HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
-import { decodeBridgeFrame, encodeBridgeFrame } from "../../bridge/protocol.ts";
-
-export interface KernelRunInput {
-	readonly cellId: string;
-	readonly code: string;
-	readonly timeoutMs?: number;
-}
-
-export type KernelResult = Extract<KernelToHostMessage, { type: "result" }>;
-export type ToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;
+import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import { decodeBridgeFrame, encodeBridgeFrame, isKernelToHostMessage } from "../../bridge/protocol.ts";
+import type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
+import { type SubprocessLike, SubprocessProcess, type SubprocessSpawn, spawnSubprocess } from "./subprocess-process.ts";
+import { SubprocessRunQueue } from "./subprocess-queue.ts";
+import {
+	CellInterruptedError,
+	failureResult,
+	KernelClosedError,
+	KernelClosingError,
+	KernelExitedError,
+	KernelProcessError,
+	KernelResetError,
+	KernelRetirementError,
+	KernelStartupError,
+	type PendingRun,
+	timeoutResult,
+} from "./subprocess-run.ts";
 
-export interface SubprocessLike {
-	readonly pid?: number;
-	readonly stdin: { write(chunk: string): unknown };
-	readonly stdout: NodeJS.ReadableStream;
-	readonly stderr: NodeJS.ReadableStream;
-	once(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
-	kill(signal?: NodeJS.Signals): boolean;
-}
-
-export type SubprocessSpawn = (
-	command: string,
-	args: readonly string[],
-	options: { readonly cwd?: string; readonly env?: NodeJS.ProcessEnv },
-) => SubprocessLike;
-
-export interface SubprocessKernelOptions {
-	readonly command: string;
-	readonly args: readonly string[];
-	readonly cwd?: string;
-	readonly env?: NodeJS.ProcessEnv;
-	readonly sessionId: string;
-	readonly connection: BridgeConnectionConfig;
-	readonly spawn?: SubprocessSpawn;
-	readonly onMessage?: (message: KernelToHostMessage) => void;
-}
+export type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
+export type { SubprocessLike, SubprocessSpawn };
 
 export class SubprocessKernel {
-	private process!: SubprocessLike;
 	private readonly options: SubprocessKernelOptions;
 	private readonly onMessage?: (message: KernelToHostMessage) => void;
-	private readonly processes = new Set<SubprocessLike>();
-	private readonly exitPromises = new WeakMap<SubprocessLike, Promise<void>>();
-	private readonly terminatingProcesses = new WeakSet<SubprocessLike>();
-	private readonly pendingRuns = new Map<
-		string,
-		{ readonly resolve: (message: KernelResult) => void; readonly timer: NodeJS.Timeout | null }
-	>();
-	private readonly retiringProcesses = new WeakSet<SubprocessLike>();
-	private readonly pendingCalls: ToolCallMessage[] = [];
-	private readonly callWaiters: ((message: ToolCallMessage) => void)[] = [];
+	private readonly runs = new SubprocessRunQueue();
+	private process: SubprocessProcess | null = null;
+	private retirementPromise: Promise<void> | null = null;
+	private retirementProcess: SubprocessProcess | null = null;
+	private retirementFailure: Error | null = null;
+	private failure: Error | null = null;
 	private closed = false;
 
 	constructor(options: SubprocessKernelOptions) {
 		this.options = options;
 		this.onMessage = options.onMessage;
-		this.process = this.spawnProcess();
+		this.spawnProcess();
 	}
 
 	run(input: KernelRunInput): Promise<KernelResult> {
-		if (this.closed) throw new Error("Kernel is closed");
-		const message: HostToKernelMessage = {
-			type: "run",
-			cellId: input.cellId,
-			code: input.code,
-			timeoutMs: input.timeoutMs,
-		};
-		this.send(message);
-		return new Promise((resolve) => {
-			const timeoutMs = input.timeoutMs;
-			const timer =
-				timeoutMs === undefined
-					? null
-					: setTimeout(() => {
-							this.pendingRuns.delete(input.cellId);
-							resolve({
-								type: "result",
-								cellId: input.cellId,
-								ok: false,
-								error: { message: `Cell timed out after ${timeoutMs}ms` },
-								durationMs: timeoutMs,
-							});
-							this.restartProcess();
-						}, timeoutMs);
-			this.pendingRuns.set(input.cellId, { resolve, timer });
-		});
+		if (this.closed) throw new KernelClosedError();
+		const run = this.runs.enqueue(input);
+		this.pumpRuns();
+		return run;
+	}
+
+	async interrupt(reason = "interrupted"): Promise<void> {
+		if (this.closed) return;
+		if (!this.runs.active) {
+			if (!this.retirementPromise) return;
+			const queued = this.runs.takeWaiting();
+			if (queued) this.runs.settle(queued, failureResult(queued, new CellInterruptedError(reason)));
+			return;
+		}
+		const process = this.process;
+		process?.retire();
+		this.runs.clearToolCalls();
+		const run = this.runs.active;
+		if (!run) return;
+		this.runs.releaseActive(run);
+		this.runs.settle(run, failureResult(run, new CellInterruptedError(reason)));
+		const signal = globalThis.process.platform === "win32" ? "SIGTERM" : "SIGINT";
+		await this.restartProcess(process, signal, 5_000);
+		if (this.failure) throw this.failure;
 	}
 
 	nextToolCall(): Promise<ToolCallMessage> {
-		const queued = this.pendingCalls.shift();
-		if (queued !== undefined) return Promise.resolve(queued);
-		return new Promise((resolve) => this.callWaiters.push(resolve));
+		return this.runs.nextToolCall();
 	}
 
 	deliverToolReply(message: Extract<HostToKernelMessage, { type: "tool-reply" }>): void {
-		this.send(message);
+		this.process?.send(encodeBridgeFrame(message));
 	}
 
 	async reset(): Promise<void> {
-		this.restartProcess();
-		this.pendingRuns.clear();
-		this.pendingCalls.length = 0;
-		this.callWaiters.length = 0;
+		if (this.closed) throw new KernelClosedError();
+		this.settleAll(new KernelResetError());
+		this.runs.clearToolCalls();
+		await this.restartProcess(this.process);
+		if (this.failure) throw this.failure;
 	}
 
 	async close(): Promise<void> {
-		if (this.closed) return;
+		const wasClosed = this.closed;
 		this.closed = true;
-		this.send({ type: "close" });
-		await Promise.all([...this.processes].map((process) => this.terminateProcess(process)));
-	}
-
-	private attachReaders(): void {
-		const activeProcess = this.process;
-		this.processes.add(activeProcess);
-		const exitPromise = new Promise<void>((resolve) => {
-			activeProcess.once("exit", () => {
-				this.processes.delete(activeProcess);
-				resolve();
-			});
-		});
-		this.exitPromises.set(activeProcess, exitPromise);
-		const stdout = createInterface({ input: this.process.stdout });
-		stdout.on("line", (line) => {
-			if (this.process !== activeProcess) return;
-			this.handleLine(`${line}\n`);
-		});
-		this.process.stderr.on("data", (chunk) => {
-			if (this.process !== activeProcess) return;
-			this.handleMessage({ type: "text", stream: "stderr", data: String(chunk) });
-		});
-		this.process.once("exit", (code, signal) => {
-			if (this.retiringProcesses.has(activeProcess)) return;
-			if (this.process !== activeProcess) return;
-			this.closed = true;
-			const error = { message: `Kernel exited before completing the cell (${signal ?? code ?? "unknown"})` };
-			for (const [cellId, pending] of this.pendingRuns) {
-				if (pending.timer) clearTimeout(pending.timer);
-				pending.resolve({ type: "result", cellId, ok: false, error, durationMs: 0 });
-			}
-			this.pendingRuns.clear();
+		if (!wasClosed) {
+			this.settleAll(new KernelClosingError());
+			this.runs.clearToolCalls();
+		}
+		if (this.retirementPromise) {
+			await this.retirementPromise;
+			if (this.retirementFailure) throw this.retirementFailure;
+			return;
+		}
+		const process = this.process;
+		if (!process) return;
+		const closeFrame = wasClosed ? undefined : encodeBridgeFrame({ type: "close" });
+		if (!(await process.shutdown(closeFrame))) {
+			const error = new KernelRetirementError();
+			this.retirementFailure = error;
+			throw error;
+		}
+		if (this.process === process) this.process = null;
+		this.retirementFailure = null;
+	}
+
+	private pumpRuns(): void {
+		const process = this.process;
+		if (this.closed || this.runs.active || !process || process.isRetiring) return;
+		const run = this.runs.startNext(performance.now());
+		if (!run) return;
+		const timeoutMs = run.input.timeoutMs;
+		if (timeoutMs !== undefined) run.timer = setTimeout(() => this.handleTimeout(run, timeoutMs), timeoutMs);
+		try {
+			process.send(encodeBridgeFrame({ type: "run", cellId: run.input.cellId, code: run.input.code, timeoutMs }));
+		} catch (error) {
+			this.failClosed(new KernelProcessError(error instanceof Error ? error.message : String(error)));
+		}
+	}
+
+	private handleTimeout(run: PendingRun, timeoutMs: number): void {
+		if (this.runs.active !== run || run.settled) return;
+		const process = this.process;
+		process?.retire();
+		this.runs.clearToolCalls();
+		this.runs.releaseActive(run);
+		this.runs.settle(run, timeoutResult(run, timeoutMs));
+		void this.restartProcess(process);
+	}
+
+	private spawnProcess(): void {
+		const child = spawnSubprocess(this.options.spawn, this.options);
+		const process = new SubprocessProcess(child, {
+			onLine: (source, line) => this.handleLine(source, line),
+			onStderr: (source, data) => this.handleMessage(source, { type: "text", stream: "stderr", data }),
+			onExit: (source, code, signal) => this.handleExit(source, code, signal),
+			onError: (source, error) => {
+				if (this.accepts(source)) this.failClosed(new KernelProcessError(error.message));
+			},
 		});
+		this.process = process;
+		try {
+			process.send(
+				encodeBridgeFrame({ type: "init", sessionId: this.options.sessionId, connection: this.options.connection }),
+			);
+		} catch (error) {
+			const failure = new KernelStartupError(error instanceof Error ? error.message : String(error));
+			this.failClosed(failure);
+			throw failure;
+		}
 	}
 
-	private handleLine(line: string): void {
+	private handleLine(process: SubprocessProcess, line: string): void {
+		if (!this.accepts(process)) return;
 		const decoded = decodeBridgeFrame(line);
 		if (!decoded.ok) {
-			this.handleMessage({ type: "text", stream: "stderr", data: `${decoded.error.message}\n` });
+			this.handleMessage(process, { type: "text", stream: "stderr", data: `${decoded.error.message}\n` });
 			return;
 		}
-		this.handleMessage(decoded.message as KernelToHostMessage);
+		if (isKernelToHostMessage(decoded.message)) this.handleMessage(process, decoded.message);
 	}
 
-	private handleMessage(message: KernelToHostMessage): void {
-		this.onMessage?.(message);
-		if (message.type === "tool-call") {
-			const waiter = this.callWaiters.shift();
-			if (waiter) waiter(message);
-			else this.pendingCalls.push(message);
-			return;
-		}
-		if (message.type === "result") {
-			const pending = this.pendingRuns.get(message.cellId);
-			if (pending?.timer) clearTimeout(pending.timer);
-			pending?.resolve(message);
-			this.pendingRuns.delete(message.cellId);
-		}
+	private handleMessage(process: SubprocessProcess, message: KernelToHostMessage): void {
+		if (!this.accepts(process)) return;
+		if (this.runs.handleMessage(message, this.onMessage)) this.pumpRuns();
 	}
 
-	private send(message: HostToKernelMessage): void {
-		this.process.stdin.write(encodeBridgeFrame(message));
+	private handleExit(process: SubprocessProcess, code: number | null, signal: NodeJS.Signals | null): void {
+		if (this.process !== process) return;
+		if (process.isRetiring) {
+			this.process = null;
+			this.retirementFailure = null;
+			return;
+		}
+		this.process = null;
+		this.failClosed(new KernelExitedError(signal ?? code ?? "unknown"));
 	}
 
-	private restartProcess(): void {
-		const activeProcess = this.process;
-		this.retiringProcesses.add(activeProcess);
-		this.process = this.spawnProcess();
-		void this.terminateProcess(activeProcess);
+	private accepts(process: SubprocessProcess): boolean {
+		return !this.closed && this.process === process && !process.isRetiring;
 	}
 
-	private spawnProcess(): SubprocessLike {
-		const spawn = this.options.spawn ?? defaultSpawn;
-		this.closed = false;
-		const child = spawn(this.options.command, this.options.args, { cwd: this.options.cwd, env: this.options.env });
-		this.process = child;
-		this.attachReaders();
-		this.send({ type: "init", sessionId: this.options.sessionId, connection: this.options.connection });
-		return child;
+	private restartProcess(
+		process: SubprocessProcess | null,
+		initialSignal: NodeJS.Signals = "SIGTERM",
+		escalationMs = 1_500,
+	): Promise<void> {
+		if (!process || this.closed) return Promise.resolve();
+		if (this.retirementPromise) return this.retirementPromise;
+		process.retire();
+		const retirement = this.replaceAfterRetirement(process, initialSignal, escalationMs);
+		return this.trackRetirement(process, retirement);
 	}
 
-	private async terminateProcess(process: SubprocessLike): Promise<void> {
-		if (!this.terminatingProcesses.has(process)) {
-			this.terminatingProcesses.add(process);
-			this.killProcess(process, "SIGTERM");
+	private async replaceAfterRetirement(
+		process: SubprocessProcess,
+		initialSignal: NodeJS.Signals,
+		escalationMs: number,
+	): Promise<void> {
+		const termination = await process.terminateSafely(initialSignal, escalationMs);
+		if (!termination.ok) {
+			const error = new KernelProcessError(termination.error.message);
+			this.retirementFailure = error;
+			this.failClosed(error);
+			return;
 		}
-		const exitPromise = this.exitPromises.get(process);
-		if (!exitPromise) return;
-		let forceTimer: NodeJS.Timeout | undefined;
+		if (!termination.exited) {
+			const error = new KernelRetirementError();
+			this.retirementFailure = error;
+			this.failClosed(error);
+			return;
+		}
+		if (this.process === process) this.process = null;
+		this.retirementFailure = null;
+		if (this.closed) return;
 		try {
-			await Promise.race([
-				exitPromise,
-				new Promise<void>((resolve) => {
-					forceTimer = setTimeout(() => {
-						this.killProcess(process, "SIGKILL");
-						resolve();
-					}, 1_500);
-				}),
-			]);
-			await exitPromise;
-		} finally {
-			if (forceTimer) clearTimeout(forceTimer);
+			this.spawnProcess();
+		} catch (error) {
+			if (!(error instanceof KernelStartupError)) {
+				this.failClosed(new KernelStartupError(error instanceof Error ? error.message : String(error)));
+			}
+			return;
 		}
+		this.pumpRuns();
+	}
+
+	private settleAll(error: Error): void {
+		this.runs.settleAll(error);
+	}
+
+	private failClosed(error: Error): void {
+		const process = this.process;
+		this.failure = error;
+		this.closed = true;
+		process?.retire();
+		this.runs.clearToolCalls();
+		this.settleAll(error);
+		if (!process || this.retirementProcess === process) return;
+		this.trackRetirement(process, this.terminateOwnedProcess(process));
 	}
 
-	private killProcess(process: SubprocessLike, signal: NodeJS.Signals): void {
-		if (process.pid !== undefined) {
-			try {
-				globalThis.process.kill(-process.pid, signal);
-				return;
-			} catch {}
+	private async terminateOwnedProcess(process: SubprocessProcess): Promise<void> {
+		const termination = await process.terminateSafely();
+		if (!termination.ok) {
+			this.retirementFailure = new KernelProcessError(termination.error.message);
+			return;
+		}
+		if (!termination.exited) {
+			this.retirementFailure = new KernelRetirementError();
+			return;
 		}
-		process.kill(signal);
+		if (this.process === process) this.process = null;
+		this.retirementFailure = null;
 	}
-}
 
-function defaultSpawn(
-	command: string,
-	args: readonly string[],
-	options: { readonly cwd?: string; readonly env?: NodeJS.ProcessEnv },
-): SubprocessLike {
-	return nodeSpawn(command, [...args], {
-		cwd: options.cwd,
-		detached: true,
-		env: options.env,
-		stdio: "pipe",
-	}) as ChildProcessWithoutNullStreams;
+	private trackRetirement(process: SubprocessProcess, retirement: Promise<void>): Promise<void> {
+		this.retirementProcess = process;
+		this.retirementPromise = retirement;
+		void retirement.then(() => {
+			if (this.retirementPromise !== retirement) return;
+			this.retirementPromise = null;
+			this.retirementProcess = null;
+		});
+		return retirement;
+	}
 }

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/shared/subprocess-process.ts

@@ -0,0 +1,174 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { createInterface, type Interface as ReadlineInterface } from "node:readline";
+
+export interface SubprocessLike {
+	readonly pid?: number;
+	readonly stdin: { write(chunk: string): unknown };
+	readonly stdout: NodeJS.ReadableStream;
+	readonly stderr: NodeJS.ReadableStream;
+	on(event: "error", listener: (error: Error) => void): this;
+	once(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+	removeListener(event: "error", listener: (error: Error) => void): this;
+	kill(signal?: NodeJS.Signals): boolean;
+}
+
+export type SubprocessSpawn = (
+	command: string,
+	args: readonly string[],
+	options: { readonly cwd?: string; readonly env?: NodeJS.ProcessEnv },
+) => SubprocessLike;
+
+export interface SubprocessSpawnRequest {
+	readonly command: string;
+	readonly args: readonly string[];
+	readonly cwd?: string;
+	readonly env?: NodeJS.ProcessEnv;
+}
+
+interface SubprocessProcessHandlers {
+	readonly onLine: (process: SubprocessProcess, line: string) => void;
+	readonly onStderr: (process: SubprocessProcess, data: string) => void;
+	readonly onExit: (process: SubprocessProcess, code: number | null, signal: NodeJS.Signals | null) => void;
+	readonly onError: (process: SubprocessProcess, error: Error) => void;
+}
+
+export type SubprocessTermination =
+	| { readonly ok: true; readonly exited: boolean }
+	| { readonly ok: false; readonly error: Error };
+
+const gracefulExitWaitMs = 1_500;
+const forcedExitWaitMs = 500;
+
+export class SubprocessProcess {
+	readonly child: SubprocessLike;
+	private readonly handlers: SubprocessProcessHandlers;
+	private readonly exit = Promise.withResolvers<void>();
+	private readonly stdoutReader: ReadlineInterface;
+	private readonly stderrListener: (chunk: string | Buffer) => void;
+	private readonly errorListener: (error: Error) => void;
+	private exited = false;
+	private retiring = false;
+	private outputDetached = false;
+	private errorReported = false;
+	private terminationPromise: Promise<boolean> | null = null;
+
+	constructor(child: SubprocessLike, handlers: SubprocessProcessHandlers) {
+		this.child = child;
+		this.handlers = handlers;
+		this.stdoutReader = createInterface({ input: child.stdout });
+		this.stderrListener = (chunk) => {
+			if (!this.retiring) this.handlers.onStderr(this, String(chunk));
+		};
+		this.errorListener = (error) => {
+			if (this.errorReported) return;
+			this.errorReported = true;
+			this.handlers.onError(this, error);
+		};
+		this.stdoutReader.on("line", (line) => {
+			if (!this.retiring) this.handlers.onLine(this, `${line}\n`);
+		});
+		child.stderr.on("data", this.stderrListener);
+		child.on("error", this.errorListener);
+		child.once("exit", (code, signal) => {
+			this.exited = true;
+			this.detachOutput();
+			child.removeListener("error", this.errorListener);
+			this.exit.resolve();
+			this.handlers.onExit(this, code, signal);
+		});
+	}
+
+	get isRetiring(): boolean {
+		return this.retiring;
+	}
+
+	send(frame: string): boolean {
+		if (this.retiring) return false;
+		this.child.stdin.write(frame);
+		return true;
+	}
+
+	retire(): void {
+		if (this.retiring) return;
+		this.retiring = true;
+		this.detachOutput();
+	}
+
+	terminate(initialSignal: NodeJS.Signals = "SIGTERM", escalationMs = gracefulExitWaitMs): Promise<boolean> {
+		if (this.exited) return Promise.resolve(true);
+		if (this.terminationPromise) return this.terminationPromise;
+		this.terminationPromise = this.performTermination(initialSignal, escalationMs);
+		return this.terminationPromise;
+	}
+
+	async terminateSafely(initialSignal?: NodeJS.Signals, escalationMs?: number): Promise<SubprocessTermination> {
+		try {
+			return { ok: true, exited: await this.terminate(initialSignal, escalationMs) };
+		} catch (error) {
+			return { ok: false, error: error instanceof Error ? error : new Error(String(error)) };
+		}
+	}
+
+	async shutdown(frame?: string): Promise<boolean> {
+		if (frame !== undefined) {
+			try {
+				this.send(frame);
+			} catch (error) {
+				if (!(error instanceof Error)) throw error;
+			}
+		}
+		this.retire();
+		return await this.terminate();
+	}
+
+	private async performTermination(initialSignal: NodeJS.Signals, escalationMs: number): Promise<boolean> {
+		this.retire();
+		if (this.exited) return true;
+		this.kill(initialSignal);
+		if (await this.waitForExit(escalationMs)) return true;
+		this.kill("SIGKILL");
+		return await this.waitForExit(forcedExitWaitMs);
+	}
+
+	private async waitForExit(timeoutMs: number): Promise<boolean> {
+		if (this.exited) return true;
+		let timer: NodeJS.Timeout | undefined;
+		const timeout = new Promise<false>((resolve) => {
+			timer = setTimeout(() => resolve(false), timeoutMs);
+		});
+		try {
+			return await Promise.race([this.exit.promise.then(() => true as const), timeout]);
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
+	}
+
+	private detachOutput(): void {
+		if (this.outputDetached) return;
+		this.outputDetached = true;
+		this.stdoutReader.close();
+		this.child.stderr.removeListener("data", this.stderrListener);
+	}
+
+	private kill(signal: NodeJS.Signals): void {
+		if (this.child.pid !== undefined) {
+			try {
+				globalThis.process.kill(-this.child.pid, signal);
+				return;
+			} catch (error) {
+				if (!(error instanceof Error)) throw error;
+			}
+		}
+		this.child.kill(signal);
+	}
+}
+
+export function spawnSubprocess(spawn: SubprocessSpawn | undefined, request: SubprocessSpawnRequest): SubprocessLike {
+	if (spawn) return spawn(request.command, request.args, { cwd: request.cwd, env: request.env });
+	return nodeSpawn(request.command, [...request.args], {
+		cwd: request.cwd,
+		detached: true,
+		env: request.env,
+		stdio: ["pipe", "pipe", "pipe"],
+	});
+}