@code-yeongyu/senpi 2026.7.10 → 2026.7.13

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

@@ -1,3 +1,4 @@
+import { join } from "node:path";
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import { type BridgeServerHandle, startBridgeServer } from "../bridge/http-server.ts";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
@@ -16,11 +17,20 @@ export interface CodemodeSessionManager extends EvalKernelManager {
 	setContext?(ctx: ExtensionContext): void;
 }
 
+export interface EvalExecutionTracker {
+	assertEvalExecutionAllowed(): void;
+	trackEvalExecution<Result>(execution: Promise<Result>, controller: AbortController): Promise<Result>;
+}
+
 export interface CreateCodemodeSessionManagerOptions {
 	readonly sessionId: string;
 	readonly cwd: string;
 	readonly settings: CodemodeSettings;
 	readonly availability: InterpreterAvailability;
+	/** Session-scoped roots exposed to kernel helpers such as local://. */
+	readonly localRoots?: Readonly<Record<string, string>>;
+	/** Session-adjacent directory used for persisted eval artifacts. */
+	readonly artifactsDir?: string;
 	readonly executeTool: ExecuteTool;
 	readonly complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 }
@@ -33,12 +43,31 @@ export async function createCodemodeSessionManager(
 	return manager;
 }
 
+export 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 +84,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 +92,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,28 +113,73 @@ 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> {
 		const bridge = this.#bridge;
 		if (!bridge) throw new Error("codemode bridge server is not running");
+		const configuredPoolWidth = this.#options.settings.parallelPoolWidth;
+		const parallelPoolWidth = Number.isFinite(configuredPoolWidth) ? Math.max(1, Math.trunc(configuredPoolWidth)) : 1;
 		if (language === "js") {
 			return new JavaScriptKernel({
 				sessionId: this.#options.sessionId,
 				cwd: this.#options.cwd,
-				parallelPoolWidth: this.#options.settings.parallelPoolWidth,
+				parallelPoolWidth,
 				onMessage,
 			});
 		}
 		const detected = this.#options.availability[language].detected;
 		if (!detected.ok) throw new Error(`No ${language} interpreter is available`);
-		const connection = { port: bridge.port, token: bridge.token };
+		const localRoots =
+			this.#options.localRoots ??
+			(this.#options.artifactsDir ? { local: join(this.#options.artifactsDir, "local") } : undefined);
+		const connection = {
+			port: bridge.port,
+			token: bridge.token,
+			parallelPoolWidth,
+			...(localRoots ? { localRoots: { ...localRoots } } : {}),
+			...(this.#options.artifactsDir ? { artifactsDir: this.#options.artifactsDir } : {}),
+		};
 		if (language === "py") {
 			return await PythonKernel.start({
 				interpreterPath: detected.path,
@@ -127,7 +209,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,20 +1,60 @@
-import type { ExtensionAPI, ExtensionContext } from "@code-yeongyu/senpi";
+import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "./bridge/protocol.ts";
+import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
 import { type CompletionRequest, type CompletionResult, createCompletionHandler } from "./completion/handler.ts";
-import { type CodemodeSettings, loadCodemodeSettings } from "./config/settings.ts";
 import {
+	type CodemodeSettings,
+	defaultCodemodeSettings,
+	loadCodemodeSettings,
+	type ResolvedCodemodeSettings,
+	resolveEnabledLanguages,
+} from "./config/settings.ts";
+import {
+	CodemodeSessionDisposedError,
 	type CodemodeSessionManager,
 	type CreateCodemodeSessionManagerOptions,
 	createCodemodeSessionManager,
+	type EvalExecutionTracker,
 } from "./extension/session-manager.ts";
 import {
 	createInterpreterDetector,
 	getInterpreterAvailability,
 	type InterpreterAvailability,
 } from "./interpreters/detect.ts";
+import { resolveSessionArtifactsDir } from "./output/streaming-output.ts";
 import { createEvalTool } from "./tool/eval-tool.ts";
-import type { EvalKernel, EvalLanguage } from "./tool/types.ts";
-import { evalLanguageOrder } from "./tool/types.ts";
+import { renderEvalCall, renderEvalResult } from "./tool/render.ts";
+import type { EnabledEvalLanguages, EvalKernel, EvalLanguage } from "./tool/types.ts";
+
+const SESSION_LIFECYCLE_EVENTS = [
+	"session_start",
+	"session_shutdown",
+	"session_before_switch",
+	"session_before_fork",
+] as const;
+
+type SessionLifecycleEvent = (typeof SESSION_LIFECYCLE_EVENTS)[number];
+
+type TrackedExecution = {
+	readonly promise: Promise<unknown>;
+	readonly controller: AbortController;
+};
+
+type SessionRuntime = {
+	readonly manager: CodemodeSessionManager;
+	readonly enabledLanguages: EnabledEvalLanguages;
+	readonly settings: ResolvedCodemodeSettings;
+	readonly artifactsDir: string;
+	readonly executeTool: AgentExecuteTool;
+	readonly spawns: boolean;
+};
+
+export interface CodemodeExtensionAPI {
+	registerTool(tool: ReturnType<typeof createEvalTool>): void;
+	on(event: SessionLifecycleEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
+	executeTool: AgentExecuteTool;
+	getActiveTools(): string[];
+}
 
 export interface SenpiCodemodeOptions {
 	readonly createSessionManager?: (
@@ -23,43 +63,122 @@ export interface SenpiCodemodeOptions {
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 }
 
-export default function senpiCodemode(pi: ExtensionAPI, options: SenpiCodemodeOptions = {}): void {
+class CodemodeSessionNotStartedError extends Error {
+	readonly name = "CodemodeSessionNotStartedError";
+
+	constructor() {
+		super("codemode session has not started");
+	}
+}
+
+export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCodemodeOptions = {}): void {
 	const manager = new SessionManagerProxy();
 	const complete = options.complete ?? ((request, ctx) => createCompletionHandler()(ctx)(request));
+	const renderers = { renderCall: renderEvalCall, renderResult: renderEvalResult };
 	pi.registerTool(
 		createEvalTool({
 			enabledLanguages: { py: true, js: true, rb: true, jl: true },
 			kernelManager: manager,
-			cellTimeoutSeconds: 30,
-			executeTool: (toolName, params, executeOptions) => pi.executeTool(toolName, params, executeOptions),
+			cellTimeoutSeconds: defaultCodemodeSettings.cellTimeoutSeconds,
+			executeTool: createExecuteTool(pi),
 			complete,
+			settings: defaultCodemodeSettings,
+			executionTracker: manager,
+			renderers,
 		}),
 	);
 
 	pi.on("session_start", async (event, ctx) => {
-		await manager.replace(await createManager(pi, ctx, event, complete, options));
+		const generation = manager.beginReplacement();
+		const runtime = await createRuntime(pi, ctx, event, complete, options);
+		if (!(await manager.replace(generation, runtime.manager))) return;
+		pi.registerTool(
+			createEvalTool({
+				enabledLanguages: runtime.enabledLanguages,
+				kernelManager: manager,
+				cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
+				executeTool: runtime.executeTool,
+				complete,
+				settings: runtime.settings,
+				artifactsDir: runtime.artifactsDir,
+				executionTracker: manager,
+				renderers,
+				spawns: runtime.spawns,
+				spawnDefaultAgent: runtime.settings.taskTools.task,
+			}),
+		);
 	});
 	pi.on("session_shutdown", async () => manager.dispose());
 	pi.on("session_before_switch", async () => manager.dispose());
 	pi.on("session_before_fork", async () => manager.dispose());
 }
 
-class SessionManagerProxy implements CodemodeSessionManager {
+class SessionManagerProxy implements CodemodeSessionManager, EvalExecutionTracker {
 	#current: CodemodeSessionManager | undefined;
+	#generation = 0;
+	#started = false;
+	#acceptingExecutions = false;
+	readonly #executions = new Set<TrackedExecution>();
 
-	async replace(next: CodemodeSessionManager): Promise<void> {
-		await this.dispose();
+	beginReplacement(): number {
+		this.#generation++;
+		this.#acceptingExecutions = false;
+		this.#abortExecutions();
+		return this.#generation;
+	}
+
+	async replace(generation: number, next: CodemodeSessionManager): Promise<boolean> {
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return false;
+		}
+		await this.#settleExecutions();
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return false;
+		}
+		const current = this.#current;
+		this.#current = undefined;
+		await current?.dispose();
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return false;
+		}
 		this.#current = next;
+		this.#started = true;
+		this.#acceptingExecutions = true;
+		return true;
+	}
+
+	assertEvalExecutionAllowed(): void {
+		if (this.#acceptingExecutions && this.#current !== undefined) return;
+		if (this.#started) throw new CodemodeSessionDisposedError();
+		throw new CodemodeSessionNotStartedError();
+	}
+
+	async trackEvalExecution<Result>(execution: Promise<Result>, controller: AbortController): Promise<Result> {
+		this.assertEvalExecutionAllowed();
+		const tracked: TrackedExecution = { promise: execution, controller };
+		this.#executions.add(tracked);
+		try {
+			return await execution;
+		} finally {
+			this.#executions.delete(tracked);
+		}
 	}
 
 	async getKernel(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): Promise<EvalKernel> {
-		if (!this.#current) throw new Error("codemode session has not started");
-		return await this.#current.getKernel(language, onMessage);
+		this.assertEvalExecutionAllowed();
+		const current = this.#current;
+		if (current === undefined) throw new CodemodeSessionNotStartedError();
+		return await current.getKernel(language, onMessage);
 	}
 
 	async complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult> {
-		if (!this.#current) throw new Error("codemode session has not started");
-		return await this.#current.complete(request, ctx);
+		this.assertEvalExecutionAllowed();
+		const current = this.#current;
+		if (current === undefined) throw new CodemodeSessionNotStartedError();
+		return await current.complete(request, ctx);
 	}
 
 	setContext(ctx: ExtensionContext): void {
@@ -67,30 +186,70 @@ class SessionManagerProxy implements CodemodeSessionManager {
 	}
 
 	async dispose(): Promise<void> {
+		this.#generation++;
+		this.#acceptingExecutions = false;
+		this.#abortExecutions();
+		await this.#settleExecutions();
 		const current = this.#current;
 		this.#current = undefined;
 		await current?.dispose();
 	}
+
+	#abortExecutions(): void {
+		if (this.#executions.size === 0) return;
+		const error = new CodemodeSessionDisposedError();
+		for (const execution of this.#executions) execution.controller.abort(error);
+	}
+
+	async #settleExecutions(): Promise<void> {
+		if (this.#executions.size === 0) return;
+		await Promise.allSettled([...this.#executions].map((execution) => execution.promise));
+	}
 }
 
-async function createManager(
-	pi: ExtensionAPI,
+async function createRuntime(
+	pi: CodemodeExtensionAPI,
 	ctx: ExtensionContext,
 	event: unknown,
 	complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>,
 	options: SenpiCodemodeOptions,
-): Promise<CodemodeSessionManager> {
+): Promise<SessionRuntime> {
 	const loaded = await loadCodemodeSettings({ cwd: ctx.cwd });
-	const availability = await getInterpreterAvailability(loaded.settings, createInterpreterDetector());
+	const settings: ResolvedCodemodeSettings = {
+		...loaded.settings,
+		languages: resolveEnabledLanguages(loaded.settings),
+	};
+	const availability = await getInterpreterAvailability(settings, createInterpreterDetector());
+	const enabledLanguages = enabledLanguagesFrom(settings, availability);
+	const artifacts = resolveSessionArtifactsDir(ctx.sessionManager.getSessionFile());
+	const activeTools = new Set(pi.getActiveTools());
+	const executeTool = createExecuteTool(pi, activeTools);
 	const create = options.createSessionManager ?? createCodemodeSessionManager;
-	return await create({
+	const manager = await create({
 		sessionId: sessionIdFrom(event),
 		cwd: ctx.cwd,
-		settings: loaded.settings,
+		settings,
 		availability,
-		executeTool: (toolName, params, executeOptions) => pi.executeTool(toolName, params, executeOptions),
+		artifactsDir: artifacts.dir,
+		executeTool,
 		complete,
 	});
+	return {
+		manager,
+		enabledLanguages,
+		settings,
+		artifactsDir: artifacts.dir,
+		executeTool,
+		spawns: activeTools.has(settings.taskTools.task),
+	};
+}
+
+function createExecuteTool(pi: CodemodeExtensionAPI, activeTools?: ReadonlySet<string>): AgentExecuteTool {
+	const executeTool: AgentExecuteTool = (toolName, params, executeOptions) =>
+		pi.executeTool(toolName, params, executeOptions);
+	return Object.assign(executeTool, {
+		isToolAvailable: (name: string): boolean => activeTools?.has(name) ?? pi.getActiveTools().includes(name),
+	});
 }
 
 function sessionIdFrom(event: unknown): string {
@@ -104,9 +263,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,
+	};
 }

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

@@ -144,7 +144,7 @@ function candidateInvocation(candidate: string): { readonly command: string; rea
 }
 
 function parseVersion(output: string): string | null {
-	const match = /(?:Python|ruby|julia)\s+v?(\d+(?:\.\d+){1,3})/i.exec(output.trim());
+	const match = /(?:Python|ruby|julia)\s+(?:version\s+)?v?(\d+(?:\.\d+){1,3})/i.exec(output.trim());
 	return match?.[1] ?? null;
 }