@code-yeongyu/senpi-codemode 2026.7.25-2

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

@@ -0,0 +1,101 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { KernelResult, KernelRunInput, ToolCallMessage } from "./subprocess-contract.ts";
+import { createPendingRun, failureResult, type PendingRun, settlePendingRun } from "./subprocess-run.ts";
+
+export class SubprocessRunQueue {
+	readonly #queue: PendingRun[] = [];
+	readonly #pendingCalls: ToolCallMessage[] = [];
+	readonly #callWaiters: Array<(message: ToolCallMessage) => void> = [];
+	#active: PendingRun | null = null;
+
+	get active(): PendingRun | null {
+		return this.#active;
+	}
+
+	enqueue(input: KernelRunInput): Promise<KernelResult> {
+		return new Promise((resolve) => this.#queue.push(createPendingRun(input, resolve)));
+	}
+
+	startNext(startedAt: number): PendingRun | null {
+		if (this.#active) return null;
+		const next = this.#queue.shift() ?? null;
+		if (next) next.startedAt = startedAt;
+		this.#active = next;
+		return next;
+	}
+
+	takeWaiting(): PendingRun | null {
+		return this.#queue.shift() ?? null;
+	}
+
+	releaseActive(run: PendingRun): boolean {
+		if (this.#active !== run) return false;
+		this.#active = null;
+		return true;
+	}
+
+	settle(run: PendingRun, result: KernelResult): void {
+		if (settlePendingRun(run, result) && this.#active === run) this.#active = null;
+	}
+
+	settleAll(error: Error): void {
+		const runs = this.#active ? [this.#active, ...this.#queue] : [...this.#queue];
+		this.#active = null;
+		this.#queue.length = 0;
+		for (const run of runs) this.settle(run, failureResult(run, error));
+	}
+
+	clearToolCalls(): void {
+		this.#pendingCalls.length = 0;
+		this.#callWaiters.length = 0;
+	}
+
+	nextToolCall(): Promise<ToolCallMessage> {
+		const queued = this.#pendingCalls.shift();
+		if (queued !== undefined) return Promise.resolve(queued);
+		return new Promise((resolve) => this.#callWaiters.push(resolve));
+	}
+
+	pushToolCall(message: ToolCallMessage): void {
+		const waiter = this.#callWaiters.shift();
+		if (waiter) waiter(message);
+		else this.#pendingCalls.push(message);
+	}
+
+	handleMessage(
+		message: KernelToHostMessage,
+		onMessage: ((message: KernelToHostMessage) => void) | undefined,
+	): boolean {
+		switch (message.type) {
+			case "result": {
+				const run = this.#active;
+				if (!run || run.input.cellId !== message.cellId) return false;
+				onMessage?.(message);
+				this.releaseActive(run);
+				this.settle(run, message);
+				return true;
+			}
+			case "tool-call":
+				if (!this.#active) return false;
+				onMessage?.(message);
+				this.pushToolCall(message);
+				return false;
+			case "text":
+			case "display":
+			case "log":
+			case "phase":
+			case "status":
+				if (this.#active) onMessage?.(message);
+				return false;
+			case "ready":
+			case "init-failed":
+			case "closed":
+				onMessage?.(message);
+				return false;
+			default: {
+				const exhaustive: never = message;
+				return exhaustive;
+			}
+		}
+	}
+}

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

@@ -0,0 +1,98 @@
+import type { KernelResult, KernelRunInput } from "./subprocess-contract.ts";
+
+export interface PendingRun {
+	readonly input: KernelRunInput;
+	readonly resolve: (message: KernelResult) => void;
+	timer: NodeJS.Timeout | null;
+	startedAt: number | null;
+	settled: boolean;
+}
+
+export class KernelClosedError extends Error {
+	constructor() {
+		super("Kernel is closed");
+		this.name = "KernelClosedError";
+	}
+}
+
+export class KernelStartupError extends Error {
+	constructor(message: string) {
+		super(`Kernel startup failed: ${message}`);
+		this.name = "KernelStartupError";
+	}
+}
+
+export class KernelRetirementError extends Error {
+	constructor() {
+		super("Kernel process did not exit after SIGKILL");
+		this.name = "KernelRetirementError";
+	}
+}
+
+export class KernelExitedError extends Error {
+	constructor(status: string | number) {
+		super(`Kernel exited before completing the cell (${status})`);
+		this.name = "KernelExitedError";
+	}
+}
+
+export class KernelProcessError extends Error {
+	constructor(message: string) {
+		super(`Kernel process error: ${message}`);
+		this.name = "KernelProcessError";
+	}
+}
+
+export class CellInterruptedError extends Error {
+	constructor(reason: string) {
+		super(reason === "Eval interrupted" ? reason : `Eval interrupted: ${reason}`);
+		this.name = "CellInterruptedError";
+	}
+}
+
+export class KernelResetError extends Error {
+	constructor() {
+		super("Kernel reset");
+		this.name = "KernelResetError";
+	}
+}
+
+export class KernelClosingError extends Error {
+	constructor() {
+		super("Kernel closed");
+		this.name = "KernelClosingError";
+	}
+}
+
+export function createPendingRun(input: KernelRunInput, resolve: (message: KernelResult) => void): PendingRun {
+	return { input, resolve, timer: null, startedAt: null, settled: false };
+}
+
+export function failureResult(run: PendingRun, error: Error): KernelResult {
+	return {
+		type: "result",
+		cellId: run.input.cellId,
+		ok: false,
+		error: { message: error.message },
+		durationMs: run.startedAt === null ? 0 : Math.max(0, Math.round(performance.now() - run.startedAt)),
+	};
+}
+
+export function timeoutResult(run: PendingRun, timeoutMs: number): KernelResult {
+	return {
+		type: "result",
+		cellId: run.input.cellId,
+		ok: false,
+		error: { message: `Cell timed out after ${timeoutMs}ms` },
+		durationMs: timeoutMs,
+	};
+}
+
+export function settlePendingRun(run: PendingRun, result: KernelResult): boolean {
+	if (run.settled) return false;
+	run.settled = true;
+	if (run.timer) clearTimeout(run.timer);
+	run.timer = null;
+	run.resolve(result);
+	return true;
+}

package/src/output/output-meta.ts

@@ -0,0 +1,89 @@
+import { randomBytes } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export interface SessionArtifactsDir {
+	readonly dir: string;
+	readonly temp: boolean;
+}
+
+export function formatMiddleElisionMarker(elidedLines: number, elidedBytes: number): string {
+	return elidedLines <= 1 ? `[…${elidedBytes}B elided…]` : `[…${elidedLines}ln elided…]`;
+}
+
+export function artifactNotice(path: string): string {
+	return `[Full output: ${path}]`;
+}
+
+export function resolveSessionArtifactsDir(sessionFile: string | undefined): SessionArtifactsDir {
+	const temp = sessionFile === undefined;
+	const dir =
+		sessionFile === undefined
+			? join(tmpdir(), `senpi-codemode-${randomBytes(8).toString("hex")}`)
+			: `${sessionFile.endsWith(".jsonl") ? sessionFile.slice(0, -6) : sessionFile}-artifacts`;
+	mkdirSync(dir, { recursive: true });
+	return { dir, temp };
+}
+
+export interface TruncationMeta {
+	readonly direction: "head" | "tail" | "middle";
+	readonly truncatedBy: "lines" | "bytes" | "middle";
+	readonly totalLines: number;
+	readonly totalBytes: number;
+	readonly outputLines: number;
+	readonly outputBytes: number;
+	readonly maxBytes?: number;
+	readonly shownRange?: { readonly start: number; readonly end: number };
+	readonly headRange?: { readonly start: number; readonly end: number };
+	readonly tailRange?: { readonly start: number; readonly end: number };
+	readonly elidedBytes?: number;
+	readonly elidedLines?: number;
+	/** Plain absolute artifact path; retained under the upstream field name. */
+	readonly artifactId?: string;
+}
+
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+function assertNever(value: never): never {
+	throw new TypeError(`Unhandled truncation direction: ${String(value)}`);
+}
+
+export function formatTruncationWarning(meta: TruncationMeta | undefined): string | null {
+	if (meta === undefined) return null;
+	let message: string;
+	switch (meta.direction) {
+		case "middle": {
+			const elidedLines = meta.elidedLines ?? Math.max(0, meta.totalLines - meta.outputLines);
+			const elidedBytes = meta.elidedBytes ?? Math.max(0, meta.totalBytes - meta.outputBytes);
+			message =
+				meta.headRange !== undefined && meta.tailRange !== undefined
+					? `Showing lines ${meta.headRange.start}-${meta.headRange.end} and ${meta.tailRange.start}-${meta.tailRange.end} of ${meta.totalLines}; ${elidedLines} middle line${elidedLines === 1 ? "" : "s"} (${formatBytes(elidedBytes)}) elided`
+					: `Showing ${meta.outputLines} of ${meta.totalLines} lines; middle elided`;
+			break;
+		}
+		case "head":
+		case "tail":
+			message =
+				meta.shownRange !== undefined && meta.shownRange.end >= meta.shownRange.start
+					? `Showing lines ${meta.shownRange.start}-${meta.shownRange.end} of ${meta.totalLines}`
+					: `Showing ${meta.outputLines} of ${meta.totalLines} lines`;
+			if (meta.truncatedBy === "bytes") message += ` (${formatBytes(meta.maxBytes ?? meta.outputBytes)} limit)`;
+			break;
+		default:
+			return assertNever(meta.direction);
+	}
+	if (meta.artifactId !== undefined) message += `. Full output: ${meta.artifactId}`;
+	return `[${message}]`;
+}
+
+export function stripOutputNotice(text: string, meta: TruncationMeta | undefined): string {
+	const notice = formatTruncationWarning(meta);
+	if (notice === null) return text;
+	const trimmed = text.trimEnd();
+	return trimmed.endsWith(notice) ? trimmed.slice(0, -notice.length).trimEnd() : text;
+}

package/src/output/streaming-output.ts

@@ -0,0 +1,296 @@
+import { createWriteStream, mkdirSync, type WriteStream } from "node:fs";
+import { dirname } from "node:path";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "../host-sdk.ts";
+import { formatMiddleElisionMarker } from "./output-meta.ts";
+
+export { artifactNotice, formatMiddleElisionMarker, resolveSessionArtifactsDir } from "./output-meta.ts";
+export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail };
+
+export const ARTIFACT_DEFAULT_HEAD_BYTES = 3 * 1024 * 1024;
+
+export interface OutputSummary {
+	readonly output: string;
+	readonly truncated: boolean;
+	readonly totalLines: number;
+	readonly totalBytes: number;
+	readonly outputLines: number;
+	readonly outputBytes: number;
+	readonly elidedBytes?: number;
+	readonly elidedLines?: number;
+	readonly columnDroppedBytes?: number;
+	readonly columnTruncatedLines?: number;
+	readonly artifactId?: string;
+}
+
+export interface OutputSinkOptions {
+	readonly artifactPath?: string;
+	readonly spillThreshold?: number;
+	readonly headBytes?: number;
+	readonly maxColumns?: number;
+	readonly onChunk?: (chunk: string) => void;
+	readonly chunkThrottleMs?: number;
+}
+
+interface ByteSlice {
+	readonly text: string;
+	readonly bytes: number;
+}
+
+function countNewlines(text: string): number {
+	let count = 0;
+	let cursor = text.indexOf("\n");
+	while (cursor !== -1) {
+		count++;
+		cursor = text.indexOf("\n", cursor + 1);
+	}
+	return count;
+}
+
+function lineCount(text: string): number {
+	return text.length === 0 ? 0 : countNewlines(text) + 1;
+}
+
+function truncateHeadBytes(text: string, maxBytes: number): ByteSlice {
+	if (maxBytes <= 0) return { text: "", bytes: 0 };
+	const buffer = Buffer.from(text, "utf8");
+	if (buffer.length <= maxBytes) return { text, bytes: buffer.length };
+	let end = maxBytes;
+	while (end > 0 && (buffer[end] & 0xc0) === 0x80) end--;
+	const slice = buffer.subarray(0, end);
+	return { text: slice.toString("utf8"), bytes: slice.length };
+}
+
+function truncateTailBytes(text: string, maxBytes: number): ByteSlice {
+	if (maxBytes <= 0) return { text: "", bytes: 0 };
+	const buffer = Buffer.from(text, "utf8");
+	if (buffer.length <= maxBytes) return { text, bytes: buffer.length };
+	let start = buffer.length - maxBytes;
+	while (start < buffer.length && (buffer[start] & 0xc0) === 0x80) start++;
+	const slice = buffer.subarray(start);
+	return { text: slice.toString("utf8"), bytes: slice.length };
+}
+
+export class TailBuffer {
+	readonly #maxBytes: number;
+	#text = "";
+	#bytes = 0;
+
+	constructor(maxBytes: number) {
+		this.#maxBytes = Math.max(0, Math.floor(maxBytes));
+	}
+
+	append(text: string): void {
+		if (text.length === 0) return;
+		if (this.#maxBytes === 0) {
+			this.#text = "";
+			this.#bytes = 0;
+			return;
+		}
+		const incomingBytes = Buffer.byteLength(text, "utf8");
+		const next =
+			incomingBytes >= this.#maxBytes
+				? truncateTailBytes(text, this.#maxBytes)
+				: truncateTailBytes(this.#text + text, this.#maxBytes);
+		this.#text = next.text;
+		this.#bytes = next.bytes;
+	}
+
+	text(): string {
+		return this.#text;
+	}
+
+	bytes(): number {
+		return this.#bytes;
+	}
+}
+
+export class OutputSink {
+	readonly #artifactPath: string | undefined;
+	readonly #spillThreshold: number;
+	readonly #headLimit: number;
+	readonly #maxColumns: number;
+	readonly #onChunk: ((chunk: string) => void) | undefined;
+	readonly #chunkThrottleMs: number;
+	readonly #tail: TailBuffer;
+	#head = "";
+	#headBytes = 0;
+	#totalNewlines = 0;
+	#totalBytes = 0;
+	#sawData = false;
+	#truncated = false;
+	#currentLineBytes = 0;
+	#columnCapped = false;
+	#columnDroppedBytes = 0;
+	#columnTruncatedLines = 0;
+	#lastChunkTime = 0;
+	#pendingChunk = "";
+	#beforeSpill = "";
+	#file: WriteStream | undefined;
+	#fileError: Error | undefined;
+	#dumpPromise: Promise<OutputSummary> | undefined;
+
+	constructor(options: OutputSinkOptions = {}) {
+		this.#artifactPath = options.artifactPath;
+		this.#spillThreshold = Math.max(0, Math.floor(options.spillThreshold ?? DEFAULT_MAX_BYTES));
+		this.#headLimit = Math.max(0, Math.floor(options.headBytes ?? 0));
+		this.#maxColumns = Math.max(0, Math.floor(options.maxColumns ?? 0));
+		this.#onChunk = options.onChunk;
+		this.#chunkThrottleMs = Math.max(0, Math.floor(options.chunkThrottleMs ?? 0));
+		this.#tail = new TailBuffer(this.#spillThreshold);
+	}
+
+	push(chunk: string): void {
+		if (chunk.length === 0) return;
+		this.#emitPreview(chunk);
+		const rawBytes = Buffer.byteLength(chunk, "utf8");
+		this.#totalBytes += rawBytes;
+		this.#totalNewlines += countNewlines(chunk);
+		this.#sawData = true;
+		this.#mirrorRaw(chunk);
+		this.#retain(this.#maxColumns > 0 ? this.#clampColumns(chunk) : chunk);
+	}
+
+	dump(notice?: string): Promise<OutputSummary> {
+		this.#dumpPromise ??= this.#finishDump(notice);
+		return this.#dumpPromise;
+	}
+
+	#emitPreview(chunk: string): void {
+		if (this.#onChunk === undefined) return;
+		const now = Date.now();
+		if (now - this.#lastChunkTime >= this.#chunkThrottleMs) {
+			this.#lastChunkTime = now;
+			this.#onChunk(this.#pendingChunk + chunk);
+			this.#pendingChunk = "";
+			return;
+		}
+		this.#pendingChunk += chunk;
+	}
+
+	#mirrorRaw(chunk: string): void {
+		if (this.#artifactPath === undefined) return;
+		if (this.#file !== undefined) {
+			this.#file.write(chunk);
+			return;
+		}
+		if (this.#totalBytes <= this.#spillThreshold) {
+			this.#beforeSpill += chunk;
+			return;
+		}
+		mkdirSync(dirname(this.#artifactPath), { recursive: true });
+		const stream = createWriteStream(this.#artifactPath, { encoding: "utf8" });
+		stream.on("error", (error) => {
+			this.#fileError = error;
+		});
+		this.#file = stream;
+		if (this.#beforeSpill.length > 0) stream.write(this.#beforeSpill);
+		this.#beforeSpill = "";
+		stream.write(chunk);
+	}
+
+	#retain(text: string): void {
+		let tailText = text;
+		if (this.#headBytes < this.#headLimit) {
+			const head = truncateHeadBytes(text, this.#headLimit - this.#headBytes);
+			this.#head += head.text;
+			this.#headBytes += head.bytes;
+			tailText = text.substring(head.text.length);
+		}
+		this.#tail.append(tailText);
+		const effectiveBytes = this.#totalBytes - this.#columnDroppedBytes;
+		if (effectiveBytes > this.#headBytes + this.#tail.bytes()) this.#truncated = true;
+	}
+
+	#clampColumns(chunk: string): string {
+		const output: string[] = [];
+		let cursor = 0;
+		while (cursor < chunk.length) {
+			const newline = chunk.indexOf("\n", cursor);
+			const end = newline === -1 ? chunk.length : newline;
+			const segment = chunk.substring(cursor, end);
+			if (segment.length > 0) {
+				const segmentBytes = Buffer.byteLength(segment, "utf8");
+				if (this.#columnCapped) {
+					this.#columnDroppedBytes += segmentBytes;
+				} else {
+					const remaining = Math.max(0, this.#maxColumns - this.#currentLineBytes);
+					const kept = truncateHeadBytes(segment, remaining);
+					output.push(kept.text);
+					this.#currentLineBytes += kept.bytes;
+					if (kept.bytes < segmentBytes) {
+						output.push("…");
+						this.#columnDroppedBytes += segmentBytes - kept.bytes;
+						this.#columnTruncatedLines++;
+						this.#columnCapped = true;
+						this.#truncated = true;
+					}
+				}
+			}
+			if (newline === -1) break;
+			output.push("\n");
+			this.#currentLineBytes = 0;
+			this.#columnCapped = false;
+			cursor = newline + 1;
+		}
+		return output.join("");
+	}
+
+	async #finishDump(notice: string | undefined): Promise<OutputSummary> {
+		if (this.#onChunk !== undefined && this.#pendingChunk.length > 0) {
+			this.#onChunk(this.#pendingChunk);
+			this.#pendingChunk = "";
+		}
+		await this.#closeFile();
+		let tail = this.#tail.text();
+		if (lineCount(tail) > DEFAULT_MAX_LINES) {
+			tail = truncateTail(tail, { maxLines: DEFAULT_MAX_LINES, maxBytes: Number.MAX_SAFE_INTEGER }).content;
+			this.#truncated = true;
+		}
+		const totalLines = this.#sawData ? this.#totalNewlines + 1 : 0;
+		const tailBytes = Buffer.byteLength(tail, "utf8");
+		const effectiveBytes = Math.max(0, this.#totalBytes - this.#columnDroppedBytes);
+		let body = this.#head + tail;
+		let elidedBytes: number | undefined;
+		let elidedLines: number | undefined;
+		if (this.#headBytes > 0 && effectiveBytes > this.#headBytes + tailBytes) {
+			elidedBytes = effectiveBytes - this.#headBytes - tailBytes;
+			elidedLines = Math.max(0, totalLines - lineCount(this.#head) - lineCount(tail));
+			const headSeparator = this.#head.endsWith("\n") ? "" : "\n";
+			const tailSeparator = tail.length === 0 || tail.startsWith("\n") ? "" : "\n";
+			body = `${this.#head}${headSeparator}${formatMiddleElisionMarker(elidedLines, elidedBytes)}${tailSeparator}${tail}`;
+			this.#truncated = true;
+		}
+		return {
+			output: notice === undefined ? body : `[${notice}]\n${body}`,
+			truncated: this.#truncated,
+			totalLines,
+			totalBytes: this.#totalBytes,
+			outputLines: lineCount(body),
+			outputBytes: Buffer.byteLength(body, "utf8"),
+			elidedBytes,
+			elidedLines,
+			columnDroppedBytes: this.#columnDroppedBytes > 0 ? this.#columnDroppedBytes : undefined,
+			columnTruncatedLines: this.#columnTruncatedLines > 0 ? this.#columnTruncatedLines : undefined,
+			artifactId: this.#file === undefined ? undefined : this.#artifactPath,
+		};
+	}
+
+	async #closeFile(): Promise<void> {
+		const stream = this.#file;
+		if (stream === undefined) return;
+		if (this.#fileError !== undefined) throw this.#fileError;
+		await new Promise<void>((resolve, reject) => {
+			const onError = (error: Error) => {
+				stream.off("finish", onFinish);
+				reject(error);
+			};
+			const onFinish = () => {
+				stream.off("error", onError);
+				resolve();
+			};
+			stream.once("error", onError);
+			stream.once("finish", onFinish);
+			stream.end();
+		});
+	}
+}