@code-yeongyu/senpi 2026.7.10 → 2026.7.11

package/node_modules/@code-yeongyu/senpi-codemode/src/bridge/protocol.ts

@@ -158,9 +158,10 @@ export function parseBridgeJsonLine(line: string, options: BridgeFrameOptions =
 		};
 	}
 	try {
-		return { ok: true, value: JSON.parse(trimmedLine) as unknown };
+		return { ok: true, value: JSON.parse(trimmedLine) };
 	} catch (error) {
-		return { ok: false, error: { code: "malformed_json", message: errorMessage(error) } };
+		const message = error instanceof Error ? error.message : "Invalid JSON bridge frame";
+		return { ok: false, error: { code: "malformed_json", message } };
 	}
 }
 
@@ -175,11 +176,10 @@ export function decodeBridgeFrame(line: string, options: BridgeFrameOptions = {}
 	return { ok: false, error: { code: "invalid_message", message } };
 }
 
-function tokenHash(token: string): Buffer {
-	return createHash("sha256").update(token, "utf8").digest();
+export function isKernelToHostMessage(message: BridgeMessage): message is KernelToHostMessage {
+	return Value.Check(kernelToHostMessageSchema, message);
 }
 
-function errorMessage(error: unknown): string {
-	if (error instanceof Error) return error.message;
-	return "Invalid JSON bridge frame";
+function tokenHash(token: string): Buffer {
+	return createHash("sha256").update(token, "utf8").digest();
 }

package/node_modules/@code-yeongyu/senpi-codemode/src/completion/tool-bridge.ts

@@ -8,6 +8,7 @@ export interface CompletionToolCallOptions {
 	readonly kernel: EvalKernel;
 	readonly complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 	readonly ctx: ExtensionContext;
+	readonly isActive: () => boolean;
 }
 
 export type CompletionToolCallSummary = { readonly ok: true } | { readonly ok: false; readonly error: string };
@@ -15,10 +16,12 @@ export type CompletionToolCallSummary = { readonly ok: true } | { readonly ok: f
 export async function handleCompletionToolCall(options: CompletionToolCallOptions): Promise<CompletionToolCallSummary> {
 	try {
 		const value = await options.complete(toCompletionRequest(options.message.args), options.ctx);
+		if (!options.isActive()) return { ok: false, error: "completion() result ignored after eval finalization" };
 		options.kernel.deliverToolReply({ type: "tool-reply", callId: options.message.callId, ok: true, value });
 		return { ok: true };
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
+		if (!options.isActive()) return { ok: false, error: message };
 		options.kernel.deliverToolReply({
 			type: "tool-reply",
 			callId: options.message.callId,

package/node_modules/@code-yeongyu/senpi-codemode/src/extension/session-manager.ts

@@ -33,12 +33,31 @@ export async function createCodemodeSessionManager(
 	return manager;
 }
 
+class CodemodeSessionDisposedError extends Error {
+	readonly name = "CodemodeSessionDisposedError";
+
+	constructor() {
+		super("codemode session manager is disposed");
+	}
+}
+
+class CodemodeContextUnavailableError extends Error {
+	readonly name = "CodemodeContextUnavailableError";
+
+	constructor() {
+		super("codemode completion context is unavailable");
+	}
+}
+
 class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 	readonly #options: CreateCodemodeSessionManagerOptions;
 	#bridge: BridgeServerHandle | undefined;
 	#kernels = new Map<EvalLanguage, EvalKernel>();
+	#kernelCreations = new Map<EvalLanguage, Promise<EvalKernel>>();
 	#onMessageRefs = new Map<EvalLanguage, (message: KernelToHostMessage) => void>();
 	#context: ExtensionContext | undefined;
+	#generation = 0;
+	#disposePromise: Promise<void> | undefined;
 
 	constructor(options: CreateCodemodeSessionManagerOptions) {
 		this.#options = options;
@@ -55,6 +74,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 	}
 
 	async getKernel(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): Promise<EvalKernel> {
+		if (this.#disposePromise) throw new CodemodeSessionDisposedError();
 		// Persistent kernels are reused across cells, but each cell needs its OWN
 		// onMessage (bound to that cell's streaming state). Rebind on every call via
 		// a stable dispatcher so the 2nd+ cell's text/display/log output is attributed
@@ -62,10 +82,17 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		this.#onMessageRefs.set(language, onMessage);
 		const existing = this.#kernels.get(language);
 		if (existing) return existing;
+		const pending = this.#kernelCreations.get(language);
+		if (pending) return await pending;
 		const dispatch = (message: KernelToHostMessage): void => this.#onMessageRefs.get(language)?.(message);
-		const kernel = await this.#createKernel(language, dispatch);
-		this.#kernels.set(language, kernel);
-		return kernel;
+		const generation = this.#generation;
+		const creation = this.#createAndStoreKernel(language, dispatch, generation);
+		this.#kernelCreations.set(language, creation);
+		try {
+			return await creation;
+		} finally {
+			if (this.#kernelCreations.get(language) === creation) this.#kernelCreations.delete(language);
+		}
 	}
 
 	async complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult> {
@@ -76,12 +103,46 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		this.#context = ctx;
 	}
 
-	async dispose(): Promise<void> {
+	dispose(): Promise<void> {
+		if (this.#disposePromise) return this.#disposePromise;
+		this.#generation++;
+		this.#disposePromise = this.#disposeGeneration();
+		return this.#disposePromise;
+	}
+
+	async #disposeGeneration(): Promise<void> {
+		await Promise.allSettled(this.#kernelCreations.values());
 		const kernels = [...this.#kernels.values()];
+		const bridge = this.#bridge;
 		this.#kernels.clear();
-		await Promise.all(kernels.map((kernel) => kernel.close()));
-		await this.#bridge?.close();
+		this.#onMessageRefs.clear();
 		this.#bridge = undefined;
+		this.#context = undefined;
+		const failures: unknown[] = [];
+		for (const outcome of await Promise.allSettled(kernels.map((kernel) => kernel.close()))) {
+			if (outcome.status === "rejected") failures.push(outcome.reason);
+		}
+		if (bridge) {
+			const [outcome] = await Promise.allSettled([bridge.close()]);
+			if (outcome?.status === "rejected") failures.push(outcome.reason);
+		}
+		if (failures.length > 0) {
+			throw new AggregateError(failures, "Failed to dispose codemode session manager");
+		}
+	}
+
+	async #createAndStoreKernel(
+		language: EvalLanguage,
+		onMessage: (message: KernelToHostMessage) => void,
+		generation: number,
+	): Promise<EvalKernel> {
+		const kernel = await this.#createKernel(language, onMessage);
+		if (generation !== this.#generation) {
+			await kernel.close();
+			throw new CodemodeSessionDisposedError();
+		}
+		this.#kernels.set(language, kernel);
+		return kernel;
 	}
 
 	async #createKernel(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): Promise<EvalKernel> {
@@ -127,7 +188,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 
 	#contextFor(signal: AbortSignal): ExtensionContext {
 		const ctx = this.#context;
-		if (!ctx) return { signal } as ExtensionContext;
-		return ctx;
+		if (!ctx) throw new CodemodeContextUnavailableError();
+		return { ...ctx, signal: ctx.signal ? AbortSignal.any([ctx.signal, signal]) : signal };
 	}
 }

package/node_modules/@code-yeongyu/senpi-codemode/src/index.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionContext } from "@code-yeongyu/senpi";
+import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "./bridge/protocol.ts";
 import { type CompletionRequest, type CompletionResult, createCompletionHandler } from "./completion/handler.ts";
 import { type CodemodeSettings, loadCodemodeSettings } from "./config/settings.ts";
@@ -13,8 +13,15 @@ import {
 	type InterpreterAvailability,
 } from "./interpreters/detect.ts";
 import { createEvalTool } from "./tool/eval-tool.ts";
-import type { EvalKernel, EvalLanguage } from "./tool/types.ts";
-import { evalLanguageOrder } from "./tool/types.ts";
+import type { EvalKernel, EvalLanguage, ExecuteTool } from "./tool/types.ts";
+
+type SessionLifecycleEvent = "session_start" | "session_shutdown" | "session_before_switch" | "session_before_fork";
+
+export interface CodemodeExtensionAPI {
+	registerTool(tool: ReturnType<typeof createEvalTool>): void;
+	on(event: SessionLifecycleEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
+	executeTool: ExecuteTool;
+}
 
 export interface SenpiCodemodeOptions {
 	readonly createSessionManager?: (
@@ -23,7 +30,7 @@ export interface SenpiCodemodeOptions {
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 }
 
-export default function senpiCodemode(pi: ExtensionAPI, options: SenpiCodemodeOptions = {}): void {
+export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCodemodeOptions = {}): void {
 	const manager = new SessionManagerProxy();
 	const complete = options.complete ?? ((request, ctx) => createCompletionHandler()(ctx)(request));
 	pi.registerTool(
@@ -37,7 +44,8 @@ export default function senpiCodemode(pi: ExtensionAPI, options: SenpiCodemodeOp
 	);
 
 	pi.on("session_start", async (event, ctx) => {
-		await manager.replace(await createManager(pi, ctx, event, complete, options));
+		const generation = manager.beginReplacement();
+		await manager.replace(generation, await createManager(pi, ctx, event, complete, options));
 	});
 	pi.on("session_shutdown", async () => manager.dispose());
 	pi.on("session_before_switch", async () => manager.dispose());
@@ -46,9 +54,25 @@ export default function senpiCodemode(pi: ExtensionAPI, options: SenpiCodemodeOp
 
 class SessionManagerProxy implements CodemodeSessionManager {
 	#current: CodemodeSessionManager | undefined;
+	#generation = 0;
+
+	beginReplacement(): number {
+		this.#generation++;
+		return this.#generation;
+	}
 
-	async replace(next: CodemodeSessionManager): Promise<void> {
-		await this.dispose();
+	async replace(generation: number, next: CodemodeSessionManager): Promise<void> {
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return;
+		}
+		const current = this.#current;
+		this.#current = undefined;
+		await current?.dispose();
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return;
+		}
 		this.#current = next;
 	}
 
@@ -67,6 +91,7 @@ class SessionManagerProxy implements CodemodeSessionManager {
 	}
 
 	async dispose(): Promise<void> {
+		this.#generation++;
 		const current = this.#current;
 		this.#current = undefined;
 		await current?.dispose();
@@ -74,7 +99,7 @@ class SessionManagerProxy implements CodemodeSessionManager {
 }
 
 async function createManager(
-	pi: ExtensionAPI,
+	pi: CodemodeExtensionAPI,
 	ctx: ExtensionContext,
 	event: unknown,
 	complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>,
@@ -104,9 +129,10 @@ export function enabledLanguagesFrom(
 	settings: CodemodeSettings,
 	availability: InterpreterAvailability,
 ): Record<EvalLanguage, boolean> {
-	const enabled = {} as Record<EvalLanguage, boolean>;
-	for (const language of evalLanguageOrder) {
-		enabled[language] = settings.languages[language] && availability[language].detected.ok;
-	}
-	return enabled;
+	return {
+		py: settings.languages.py && availability.py.detected.ok,
+		js: settings.languages.js && availability.js.detected.ok,
+		rb: settings.languages.rb && availability.rb.detected.ok,
+		jl: settings.languages.jl && availability.jl.detected.ok,
+	};
 }