@code-yeongyu/senpi-codemode 2026.9.28 → 2026.9.29-3

package/src/kernels/js/worker-slot.ts

@@ -1,8 +1,10 @@
+import type { MessagePort } from "node:worker_threads";
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { WorkerLike } from "./inline-worker.ts";
 import { retireWorker, type WorkerRetirement } from "./interrupt-bounds.ts";
 import type { JavaScriptKernelMode } from "./kernel-contract.ts";
 import type { JavaScriptKernelOptions } from "./local-module-loader.ts";
+import { KernelWebViewClients } from "./webview-host.ts";
 import { WorkerStartupCancelledError } from "./worker-host.ts";
 import { startWorkerWithInlineFallback } from "./worker-startup.ts";
 
@@ -17,6 +19,7 @@ export class WorkerSlot {
 	readonly #options: JavaScriptKernelOptions;
 	readonly #listeners: WorkerSlotListeners;
 	#worker: WorkerLike | null = null;
+	#webViews: KernelWebViewClients | null = null;
 	#mode: JavaScriptKernelMode = "worker";
 	#generation = 0;
 	#ready: Promise<void> | null = null;
@@ -43,8 +46,8 @@ export class WorkerSlot {
 		return this.#generation;
 	}
 
-	postMessage(message: HostToKernelMessage): void {
-		this.#worker?.postMessage(message);
+	postMessage(message: HostToKernelMessage, transfer?: readonly MessagePort[]): void {
+		this.#worker?.postMessage(message, transfer);
 	}
 
 	async ensureReady(): Promise<void> {
@@ -89,16 +92,24 @@ export class WorkerSlot {
 		this.#startupAbort = null;
 		this.#ready = null;
 		const worker = this.#worker;
+		const webViews = this.#webViews;
 		this.#worker = null;
-		if (!worker) return "terminated";
-		return await retireWorker(worker);
+		this.#webViews = null;
+		const retirement = worker
+			? await retireWorker(worker, this.#options.interruptBounds?.terminateDeadlineMs)
+			: "terminated";
+		await webViews?.release();
+		return retirement;
 	}
 
 	#publish(worker: WorkerLike, generation: number): void {
 		if (!this.#listeners.isOpen() || generation !== this.#generation) throw new WorkerStartupCancelledError();
 		this.#worker = worker;
+		const webViews = new KernelWebViewClients((message, transfer) => worker.postMessage(message, transfer));
+		this.#webViews = webViews;
 		worker.onMessage((message) => {
-			if (this.#isCurrent(worker, generation)) this.#listeners.onMessage(message);
+			if (!this.#isCurrent(worker, generation) || webViews.consume(message)) return;
+			this.#listeners.onMessage(message);
 		});
 		worker.onError((error) => {
 			if (this.#isCurrent(worker, generation)) this.#listeners.onCrash(error);

package/src/kernels/js/worker-startup.ts

@@ -67,6 +67,7 @@ async function initializeWorker(worker: WorkerLike, hooks: WorkerStartupHooks, s
 		hostToolNames: resolveKernelToolNameSource(options.hostToolNames),
 		foreignLanguageNames: resolveKernelToolNameSource(options.foreignLanguageNames),
 		...(options.sessionEnv === undefined ? {} : { sessionEnv: options.sessionEnv }),
+		...(options.memory === undefined ? {} : { memory: options.memory }),
 	});
 	await ready;
 }

package/src/kernels/js/worker-webview-client.js

@@ -0,0 +1,79 @@
+// The kernel worker's end of its private port to the main-thread Bun.WebView service. Mirrors
+// the message shapes in packages/coding-agent/src/core/webview/webview-wire.ts (this worker file
+// cannot import TypeScript); keep the two in sync.
+
+export const DELIVER_EVENT = Symbol("senpi.webview.deliver");
+
+export function webViewError(wire) {
+	const error = new Error(wire?.message ?? "Bun.WebView request failed");
+	if (typeof wire?.name === "string") error.name = wire.name;
+	if (typeof wire?.code === "string") error.code = wire.code;
+	return error;
+}
+
+export class WebViewPortClient {
+	#port;
+	#pending = new Map();
+	#views = new Map();
+	#nextId = 1;
+	#closed = false;
+	#onClosed;
+
+	constructor(port, onClosed) {
+		this.#port = port;
+		this.#onClosed = onClosed;
+		port.on("message", message => this.#receive(message));
+		port.on("close", () => this.#fail(new Error("Bun.WebView service connection closed")));
+	}
+
+	register(viewId, view) {
+		this.#views.set(viewId, new WeakRef(view));
+	}
+
+	forget(viewId) {
+		this.#views.delete(viewId);
+	}
+
+	request(message) {
+		if (this.#closed) return Promise.reject(new Error("Bun.WebView service connection closed"));
+		const id = this.#nextId++;
+		return new Promise((resolve, reject) => {
+			this.#pending.set(id, { resolve, reject });
+			try {
+				this.#port.postMessage({ ...message, id });
+			} catch (error) {
+				this.#pending.delete(id);
+				reject(error);
+			}
+		});
+	}
+
+	post(message) {
+		if (this.#closed) return;
+		try {
+			this.#port.postMessage(message);
+		} catch {
+			// A closed port has already released every view on the service side.
+		}
+	}
+
+	#receive(message) {
+		if (message?.kind === "reply") {
+			const pending = this.#pending.get(message.id);
+			if (!pending) return;
+			this.#pending.delete(message.id);
+			if (message.ok) pending.resolve({ value: message.value, state: message.state });
+			else pending.reject(webViewError(message.error));
+			return;
+		}
+		if (message?.kind === "event") this.#views.get(message.viewId)?.deref()?.[DELIVER_EVENT](message.event);
+	}
+
+	#fail(error) {
+		if (this.#closed) return;
+		this.#closed = true;
+		for (const pending of this.#pending.values()) pending.reject(error);
+		this.#pending.clear();
+		this.#onClosed();
+	}
+}

package/src/kernels/js/worker-webview.js

@@ -0,0 +1,204 @@
+import { DELIVER_EVENT, WebViewPortClient, webViewError } from "./worker-webview-client.js";
+
+// Bun constructs "chrome"-backend WebViews only on the process main thread, and this kernel runs in
+// a worker where `globalThis.Bun` and `Bun.WebView` are non-writable. Cells therefore run with a
+// `Bun` parameter bound to a stand-in whose `WebView` forwards Chrome-backed views to the
+// main-thread service over a private port; every other `Bun.*` member is the real one.
+const KERNEL_BUN = Symbol.for("senpi.kernel.bun");
+
+export function bindKernelBun(source) {
+	if (!globalThis[KERNEL_BUN]) return source;
+	return `((Bun) => ${source})(globalThis[Symbol.for("senpi.kernel.bun")])`;
+}
+
+export function installKernelWebView(requestPort) {
+	const bun = globalThis.Bun;
+	if (typeof bun !== "object" || bun === null || typeof bun.WebView !== "function") return;
+	globalThis[KERNEL_BUN] = shadowBun(bun, createKernelWebView(bun.WebView, requestPort));
+}
+
+function shadowBun(real, WebView) {
+	return new Proxy(
+		{},
+		{
+			get: (_target, key) => (key === "WebView" ? WebView : Reflect.get(real, key)),
+			set: (_target, key, value) => Reflect.set(real, key, value),
+			has: (_target, key) => key === "WebView" || Reflect.has(real, key),
+			ownKeys: () => Reflect.ownKeys(real),
+			getOwnPropertyDescriptor: (_target, key) => {
+				if (key === "WebView") return { value: WebView, writable: false, enumerable: true, configurable: true };
+				const descriptor = Reflect.getOwnPropertyDescriptor(real, key);
+				return descriptor && { ...descriptor, configurable: true };
+			},
+		},
+	);
+}
+
+// The macOS default (WebKit) stays a native worker view: its host process serves any thread.
+function needsMainThread(options) {
+	const backend = options?.backend;
+	if (backend === undefined) return process.platform !== "darwin";
+	return backend === "chrome" || (typeof backend === "object" && backend !== null && backend.type === "chrome");
+}
+
+function closedError(method) {
+	const error = new Error(`Invalid state: WebView.${method}: view is closed`);
+	error.code = "ERR_INVALID_STATE";
+	return error;
+}
+
+function createKernelWebView(NativeWebView, requestPort) {
+	let connecting = null;
+	const proxied = new WeakSet();
+	const live = new Set();
+	const natives = new Set();
+	const finalizer = new FinalizationRegistry(({ client, viewId }) => client.post({ kind: "close", viewId }));
+
+	function connect() {
+		if (!connecting) {
+			const attempt = requestPort().then(port => new WebViewPortClient(port, () => (connecting = null)));
+			attempt.catch(() => {
+				if (connecting === attempt) connecting = null;
+			});
+			connecting = attempt;
+		}
+		return connecting;
+	}
+
+	class WebView extends EventTarget {
+		static closeAll() {
+			for (const view of [...live]) view.close();
+			for (const ref of [...natives]) ref.deref()?.close();
+			natives.clear();
+		}
+
+		static [Symbol.hasInstance](value) {
+			return value instanceof NativeWebView || proxied.has(value);
+		}
+
+		#viewId = crypto.randomUUID();
+		#state = { url: "", title: "", loading: false };
+		#listening = new Set();
+		#console;
+		#ready;
+		#closed = false;
+		onNavigated = null;
+		onNavigationFailed = null;
+
+		constructor(options = {}) {
+			if (!needsMainThread(options)) {
+				const view = new NativeWebView(options);
+				natives.add(new WeakRef(view));
+				return view;
+			}
+			super();
+			const { console: capture, ...rest } = options;
+			this.#console = capture;
+			proxied.add(this);
+			live.add(this);
+			const viewId = this.#viewId;
+			this.#ready = connect().then(async client => {
+				client.register(viewId, this);
+				finalizer.register(this, { client, viewId }, this);
+				const reply = await client.request({ kind: "create", viewId, options: rest, captureConsole: capture !== undefined });
+				this.#apply(reply.state);
+				return client;
+			});
+			this.#ready.catch(() => {});
+		}
+
+		get url() {
+			return this.#state.url;
+		}
+
+		get title() {
+			return this.#state.title;
+		}
+
+		get loading() {
+			return this.#state.loading;
+		}
+
+		navigate(url) { return this.#call("navigate", [url]); }
+		evaluate(script) { return this.#call("evaluate", [script]); }
+		click(...args) { return this.#call("click", args); }
+		type(text) { return this.#call("type", [text]); }
+		press(...args) { return this.#call("press", args); }
+		scroll(dx, dy) { return this.#call("scroll", [dx, dy]); }
+		scrollTo(...args) { return this.#call("scrollTo", args); }
+		resize(width, height) { return this.#call("resize", [width, height]); }
+		back() { return this.#call("back", []); }
+		forward() { return this.#call("forward", []); }
+		reload() { return this.#call("reload", []); }
+		cdp(...args) { return this.#call("cdp", args); }
+
+		async screenshot(options) {
+			const value = await this.#call("screenshot", [options]);
+			if (options?.encoding === "buffer" && value instanceof Uint8Array) return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+			return value;
+		}
+
+		addEventListener(type, listener, options) {
+			super.addEventListener(type, listener, options);
+			if (this.#closed || this.#listening.has(type)) return;
+			this.#listening.add(type);
+			const viewId = this.#viewId;
+			this.#ready.then(client => client.post({ kind: "listen", viewId, event: type }), () => {});
+		}
+
+		close() {
+			if (this.#closed) return;
+			this.#closed = true;
+			live.delete(this);
+			const viewId = this.#viewId;
+			this.#ready.then(
+				client => {
+					client.post({ kind: "close", viewId });
+					client.forget(viewId);
+					finalizer.unregister(this);
+				},
+				() => {},
+			);
+		}
+
+		[Symbol.dispose]() {
+			this.close();
+		}
+
+		[Symbol.asyncDispose]() {
+			this.close();
+		}
+
+		[DELIVER_EVENT](event) {
+			if (event.type === "console") {
+				const [type, ...args] = event.args;
+				if (typeof this.#console === "function") this.#console(type, ...args);
+				else this.#console?.[type]?.(...args);
+			} else if (event.type === "navigated") {
+				this.#state = { ...this.#state, url: event.url, title: event.title };
+				this.onNavigated?.(event.url, event.title);
+			} else if (event.type === "navigation-failed") {
+				this.onNavigationFailed?.(webViewError(event.error));
+			} else if (event.type === "dom") {
+				this.dispatchEvent(new MessageEvent(event.name, { data: event.data }));
+			}
+		}
+
+		async #call(method, args) {
+			if (this.#closed) throw closedError(method);
+			const client = await this.#ready;
+			if (this.#closed) throw closedError(method);
+			const trimmed = [...args];
+			while (trimmed.length > 0 && trimmed.at(-1) === undefined) trimmed.pop();
+			const reply = await client.request({ kind: "call", viewId: this.#viewId, method, args: trimmed });
+			this.#apply(reply.state);
+			return reply.value;
+		}
+
+		#apply(state) {
+			if (state) this.#state = state;
+		}
+	}
+
+	return WebView;
+}

package/src/kernels/py/kernel-contract.ts

@@ -1,3 +1,4 @@
+import type { KernelMemoryThresholds } from "../../bridge/memory-protocol.ts";
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { EvalKernelRunInput } from "../../tool/types.ts";
 import type { SessionEnvironment } from "../session-env.ts";
@@ -15,6 +16,8 @@ export interface PythonKernelStartOptions {
 	readonly startupTimeoutMs?: number;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
 	readonly spawnProcess?: KernelSpawnProcess;
+	/** Post-cell collection, notice, and ceiling thresholds sent on `init`; absent leaves memory unmanaged. */
+	readonly memory?: KernelMemoryThresholds;
 }
 
 export type PythonKernelRunOptions = EvalKernelRunInput;

package/src/kernels/py/kernel.ts

@@ -1,6 +1,7 @@
 import type { KernelInterruptHandle } from "../../tool/types.ts";
 import type { KernelToolsInvokeOptions } from "../js/kernel-tools-types.ts";
 import { rejectKernelToolsUnavailable } from "../kernel-tools-unavailable.ts";
+import { KernelMemoryHost } from "../shared/kernel-memory-host.ts";
 import { KernelPreludeTracker } from "../shared/kernel-prelude-plan.ts";
 import type { PendingRun, PythonKernelRunOptions, PythonKernelStartOptions, ResultMessage } from "./kernel-contract.ts";
 import { failedPythonResult, PythonKernelTransport } from "./transport.ts";
@@ -22,11 +23,13 @@ export class PythonKernel {
 	#closePromise: Promise<void> | null = null;
 	#failure: Error | null = null;
 	readonly #preludes = new KernelPreludeTracker();
+	readonly #memory: KernelMemoryHost | null;
 	#generation = 0;
 	#closed = false;
 
 	private constructor(options: PythonKernelStartOptions) {
 		this.#options = options;
+		this.#memory = options.memory === undefined ? null : new KernelMemoryHost("py", options.memory);
 	}
 
 	static async start(options: PythonKernelStartOptions): Promise<PythonKernel> {
@@ -215,6 +218,7 @@ export class PythonKernel {
 
 	async #spawn(generation: number): Promise<void> {
 		if (this.#closed || generation !== this.#generation) throw new Error("Python kernel startup was superseded");
+		this.#memory?.processReplaced();
 		this.#transport = await PythonKernelTransport.start({
 			...this.#options,
 			onMessage: (message) => {
@@ -241,11 +245,20 @@ export class PythonKernel {
 		if (this.#transport !== transport) return;
 		const pending = this.#pending.get(result.cellId);
 		if (pending) {
-			(pending.input.onMessage ?? this.#options.onMessage)?.(result);
-			this.#settleRun(pending, result);
+			const annotated = this.#memory?.annotate(result) ?? result;
+			(pending.input.onMessage ?? this.#options.onMessage)?.(annotated);
+			this.#settleRun(pending, annotated);
 		}
 		// A result frame from the live runner proves the process survived the interrupt.
 		if (pending?.resolveStateRetained) pending.resolveStateRetained(true);
+		this.#recycleOverCeilingWhenIdle();
+	}
+
+	/** An over-ceiling kernel restarts only once no cell is running or queued on it. */
+	#recycleOverCeilingWhenIdle(): void {
+		if (!this.#memory?.claimRecycle(this.#active === null && this.#queue.length === 0)) return;
+		// A failed restart is recorded in #failure and rejects the next run; a superseded one lost to close/reset.
+		void this.reset().catch(() => undefined);
 	}
 
 	#onExit(transport: PythonKernelTransport, error: Error): void {