@code-yeongyu/senpi-codemode 2026.7.25-2

package/src/kernels/rb/runner.rb

@@ -0,0 +1,204 @@
+require "json"
+require "net/http"
+require "uri"
+
+$__senpi_binding = TOPLEVEL_BINDING
+$__senpi_frame_mutex = Mutex.new
+$__senpi_current_cell = nil
+$__senpi_capture_cell = nil
+$__senpi_connection = nil
+$__senpi_frame_io = STDOUT.dup
+$__senpi_frame_io.sync = true
+
+begin
+  stdout_read, stdout_write = IO.pipe
+  STDOUT.reopen(stdout_write)
+  STDOUT.sync = true
+  stdout_write.close
+  $__senpi_stdout_capture = stdout_read
+rescue StandardError
+  $__senpi_stdout_capture = nil
+end
+
+begin
+  stderr_read, stderr_write = IO.pipe
+  STDERR.reopen(stderr_write)
+  STDERR.sync = true
+  stderr_write.close
+  $__senpi_stderr_capture = stderr_read
+rescue StandardError
+  $__senpi_stderr_capture = nil
+end
+
+begin
+  $__senpi_protocol_stdin = STDIN.dup
+  STDIN.reopen(File.open(File::NULL, "r"))
+rescue StandardError
+  $__senpi_protocol_stdin = STDIN
+end
+
+def __senpi_emit(frame)
+  line = JSON.generate(frame)
+  $__senpi_frame_mutex.synchronize do
+    $__senpi_frame_io.write(line)
+    $__senpi_frame_io.write("\n")
+    $__senpi_frame_io.flush
+  end
+rescue StandardError
+  nil
+end
+
+def __senpi_error(error)
+  { "name" => error.class.name, "message" => error.message.to_s, "stack" => error.backtrace&.join("\n") }
+end
+
+def __senpi_emit_stream(stream, data)
+  return if data.nil? || data.empty? || $__senpi_capture_cell.nil?
+  __senpi_emit({ "type" => "text", "stream" => stream, "data" => data })
+end
+
+class SenpiStreamProxy
+  def initialize(stream)
+    @stream = stream
+  end
+
+  def write(*values)
+    data = values.join
+    __senpi_emit_stream(@stream, data)
+    data.bytesize
+  end
+
+  def print(*values)
+    write(*values)
+    nil
+  end
+
+  def puts(*values)
+    values = [""] if values.empty?
+    values.each { |value| write(value.to_s.end_with?("\n") ? value.to_s : "#{value}\n") }
+    nil
+  end
+
+  def printf(format, *values)
+    write(Kernel.format(format, *values))
+    nil
+  end
+
+  def flush
+    self
+  end
+
+  def sync
+    true
+  end
+
+  def sync=(_value)
+    true
+  end
+
+  def tty?
+    false
+  end
+end
+
+def __senpi_start_capture(io, stream)
+  return if io.nil?
+  Thread.new do
+    loop do
+      data = io.readpartial(65_536)
+      __senpi_emit_stream(stream, data)
+    rescue EOFError, IOError, Errno::EBADF
+      break
+    end
+  end
+end
+
+def __senpi_value_repr(value)
+  JSON.generate(value)
+rescue JSON::GeneratorError
+  value.inspect
+end
+
+SENPI_NON_DISPLAY_NODES = %i[
+  LASGN IASGN GASGN CVASGN DASGN OP_ASGN OP_CDECL CDECL MASGN CASGN
+  DEFN DEFS CLASS MODULE SCLASS ALIAS UNDEF
+].freeze
+
+def __senpi_ast_last(node)
+  return nil unless node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+  case node.type
+  when :SCOPE
+    __senpi_ast_last(node.children[2])
+  when :BLOCK
+    children = node.children.compact
+    children.empty? ? nil : __senpi_ast_last(children.last)
+  else
+    node
+  end
+end
+
+def __senpi_should_display_result?(source)
+  return true unless defined?(RubyVM::AbstractSyntaxTree)
+  node = RubyVM::AbstractSyntaxTree.parse(source)
+  last = __senpi_ast_last(node)
+  return true if last.nil?
+  !SENPI_NON_DISPLAY_NODES.include?(last.type)
+rescue StandardError, SyntaxError
+  true
+end
+
+require_relative "prelude"
+
+$stdout = SenpiStreamProxy.new("stdout")
+$stderr = SenpiStreamProxy.new("stderr")
+__senpi_start_capture($__senpi_stdout_capture, "stdout")
+__senpi_start_capture($__senpi_stderr_capture, "stderr")
+
+def __senpi_run_cell(message)
+  started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  cell_id = message["cellId"].to_s
+  $__senpi_current_cell = cell_id
+  $__senpi_capture_cell = cell_id
+  begin
+    source = message["code"].to_s
+    value = eval(source, $__senpi_binding, "(senpi-rb)")
+    STDOUT.flush
+    STDERR.flush
+    Thread.pass
+    frame = {
+      "type" => "result",
+      "cellId" => cell_id,
+      "ok" => true,
+      "durationMs" => ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round,
+    }
+    frame["valueRepr"] = __senpi_value_repr(value) if !value.nil? && __senpi_should_display_result?(source)
+    __senpi_emit(frame)
+  rescue Exception => error
+    __senpi_emit({
+      "type" => "result",
+      "cellId" => cell_id,
+      "ok" => false,
+      "error" => __senpi_error(error),
+      "durationMs" => ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round,
+    })
+  ensure
+    $__senpi_capture_cell = nil
+    $__senpi_current_cell = nil
+  end
+end
+
+$__senpi_protocol_stdin.each_line do |line|
+  message = JSON.parse(line)
+  case message["type"]
+  when "init"
+    $__senpi_connection = message["connection"]
+    __senpi_emit({ "type" => "ready" })
+  when "run"
+    __senpi_run_cell(message)
+  when "close"
+    __senpi_emit({ "type" => "closed" })
+    exit 0
+  end
+rescue JSON::ParserError => error
+  __senpi_emit({ "type" => "init-failed", "error" => __senpi_error(error) })
+end

package/src/kernels/shared/subprocess-contract.ts

@@ -0,0 +1,22 @@
+import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { SubprocessSpawn } from "./subprocess-process.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" }>;
+
+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;
+}

package/src/kernels/shared/subprocess-kernel.ts

@@ -0,0 +1,266 @@
+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 type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
+export type { SubprocessLike, SubprocessSpawn };
+
+export class SubprocessKernel {
+	private readonly options: SubprocessKernelOptions;
+	private readonly onMessage?: (message: KernelToHostMessage) => 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.spawnProcess();
+	}
+
+	run(input: KernelRunInput): Promise<KernelResult> {
+		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> {
+		return this.runs.nextToolCall();
+	}
+
+	deliverToolReply(message: Extract<HostToKernelMessage, { type: "tool-reply" }>): void {
+		this.process?.send(encodeBridgeFrame(message));
+	}
+
+	async reset(): Promise<void> {
+		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> {
+		const wasClosed = this.closed;
+		this.closed = true;
+		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(process: SubprocessProcess, line: string): void {
+		if (!this.accepts(process)) return;
+		const decoded = decodeBridgeFrame(line);
+		if (!decoded.ok) {
+			this.handleMessage(process, { type: "text", stream: "stderr", data: `${decoded.error.message}\n` });
+			return;
+		}
+		if (isKernelToHostMessage(decoded.message)) this.handleMessage(process, decoded.message);
+	}
+
+	private handleMessage(process: SubprocessProcess, message: KernelToHostMessage): void {
+		if (!this.accepts(process)) return;
+		if (this.runs.handleMessage(message, this.onMessage)) this.pumpRuns();
+	}
+
+	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 accepts(process: SubprocessProcess): boolean {
+		return !this.closed && this.process === process && !process.isRetiring;
+	}
+
+	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 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;
+		}
+		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 {
+			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 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;
+		}
+		if (this.process === process) this.process = null;
+		this.retirementFailure = null;
+	}
+
+	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/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"],
+	});
+}