@code-yeongyu/senpi-codemode 2026.7.25-2

package/src/extension/session-manager.ts

@@ -0,0 +1,215 @@
+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";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import type { CodemodeSettings } from "../config/settings.ts";
+import type { InterpreterAvailability } from "../interpreters/detect.ts";
+import { JuliaKernel } from "../kernels/jl/kernel.ts";
+import { JavaScriptKernel } from "../kernels/js/context-manager.ts";
+import { PythonKernel } from "../kernels/py/kernel.ts";
+import { RubyKernel } from "../kernels/rb/kernel.ts";
+import type { EvalKernel, EvalKernelManager, EvalLanguage, ExecuteTool } from "../tool/types.ts";
+
+export interface CodemodeSessionManager extends EvalKernelManager {
+	dispose(): Promise<void>;
+	complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult>;
+	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>;
+}
+
+export async function createCodemodeSessionManager(
+	options: CreateCodemodeSessionManagerOptions,
+): Promise<CodemodeSessionManager> {
+	const manager = new DefaultCodemodeSessionManager(options);
+	await manager.start();
+	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;
+	}
+
+	async start(): Promise<void> {
+		this.#bridge = await startBridgeServer({
+			onCall: async (request) =>
+				this.#options.executeTool(request.toolName, request.args, { signal: request.signal }),
+			onEmit: async () => undefined,
+			onCompletion: async (request) =>
+				this.#options.complete({ prompt: request.prompt, opts: request.opts }, this.#contextFor(request.signal)),
+		});
+	}
+
+	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
+		// to the current cell, not the one that first created the kernel.
+		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 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> {
+		return await this.#options.complete(request, ctx);
+	}
+
+	setContext(ctx: ExtensionContext): void {
+		this.#context = ctx;
+	}
+
+	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();
+		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,
+				onMessage,
+			});
+		}
+		const detected = this.#options.availability[language].detected;
+		if (!detected.ok) throw new Error(`No ${language} interpreter is available`);
+		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,
+				sessionId: this.#options.sessionId,
+				cwd: this.#options.cwd,
+				connection,
+				onMessage,
+			});
+		}
+		if (language === "rb") {
+			return RubyKernel.start({
+				command: detected.path,
+				sessionId: this.#options.sessionId,
+				cwd: this.#options.cwd,
+				connection,
+				onMessage,
+			});
+		}
+		return JuliaKernel.start({
+			command: detected.path,
+			sessionId: this.#options.sessionId,
+			cwd: this.#options.cwd,
+			connection,
+			onMessage,
+		});
+	}
+
+	#contextFor(signal: AbortSignal): ExtensionContext {
+		const ctx = this.#context;
+		if (!ctx) throw new CodemodeContextUnavailableError();
+		return { ...ctx, signal: ctx.signal ? AbortSignal.any([ctx.signal, signal]) : signal };
+	}
+}

package/src/host-sdk.ts

@@ -0,0 +1 @@
+export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "@code-yeongyu/senpi";

package/src/index.ts

@@ -0,0 +1,181 @@
+import * as os from "node:os";
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
+import { CodeModeSessionRuntime } from "./codemode/runtime.ts";
+import { type CodeModeTool, createCodeModeTools, isGptCodeModeModel } from "./codemode/tools.ts";
+import { type CompletionRequest, type CompletionResult, createCompletionHandler } from "./completion/handler.ts";
+import { defaultCodemodeSettings } from "./config/settings.ts";
+import {
+	createExecuteTool,
+	createRuntime,
+	enabledLanguagesFrom,
+	type SessionRuntime,
+} from "./extension/runtime-factory.ts";
+import type { CodemodeSessionManager, CreateCodemodeSessionManagerOptions } from "./extension/session-manager.ts";
+import { SessionManagerProxy } from "./extension/session-manager-proxy.ts";
+import { createEvalTool } from "./tool/eval-tool.ts";
+import { renderEvalCall, renderEvalResult } from "./tool/render.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 CodemodeEvent = SessionLifecycleEvent | "model_select";
+
+export interface CodemodeExtensionAPI {
+	registerTool(tool: ReturnType<typeof createEvalTool>): void;
+	on(event: CodemodeEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
+	executeTool: AgentExecuteTool;
+	getActiveTools(): string[];
+	setActiveTools?(toolNames: string[]): void | Promise<void>;
+	getAllTools?(): readonly { readonly name: string }[];
+}
+
+export interface SenpiCodemodeOptions {
+	readonly createSessionManager?: (
+		options: CreateCodemodeSessionManagerOptions,
+	) => CodemodeSessionManager | Promise<CodemodeSessionManager>;
+	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
+}
+
+type DynamicCodeModeExtensionAPI = CodemodeExtensionAPI & {
+	registerTool(tool: CodeModeTool): void;
+	setActiveTools(toolNames: string[]): void | Promise<void>;
+	getAllTools(): readonly { readonly name: string }[];
+};
+
+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 };
+	let activeRuntime: (SessionRuntime & { readonly codeMode?: CodeModeSessionRuntime }) | undefined;
+	let activeModelId: string | undefined;
+	const registerEvalForRuntime = (runtime: SessionRuntime, modelId: string | undefined): void => {
+		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,
+				hostLine: hostLine(),
+				...(modelId === undefined ? {} : { modelId }),
+			}),
+		);
+	};
+	const dropRuntime = async (): Promise<void> => {
+		const codeMode = activeRuntime?.codeMode;
+		activeRuntime = undefined;
+		activeModelId = undefined;
+		await Promise.all([manager.dispose(), codeMode?.dispose()]);
+	};
+	const activateCodeModeTools = async (runtime: CodeModeSessionRuntime): Promise<void> => {
+		if (!isDynamicCodeModeExtensionAPI(pi)) return;
+		const tools = createCodeModeTools({ runtime });
+		pi.registerTool(tools.exec);
+		pi.registerTool(tools.wait);
+		await pi.setActiveTools([...new Set([...pi.getActiveTools(), "exec", "wait"])]);
+	};
+	const deactivateCodeModeTools = async (): Promise<void> => {
+		if (!isDynamicCodeModeExtensionAPI(pi)) return;
+		await pi.setActiveTools(pi.getActiveTools().filter((name) => name !== "exec" && name !== "wait"));
+	};
+	pi.registerTool(
+		createEvalTool({
+			enabledLanguages: { py: true, js: true, rb: true, jl: true },
+			kernelManager: manager,
+			cellTimeoutSeconds: defaultCodemodeSettings.cellTimeoutSeconds,
+			executeTool: createExecuteTool(pi),
+			complete,
+			settings: defaultCodemodeSettings,
+			executionTracker: manager,
+			renderers,
+			hostLine: hostLine(),
+		}),
+	);
+
+	pi.on("session_start", async (event, ctx) => {
+		const previousCodeMode = activeRuntime?.codeMode;
+		const generation = manager.beginReplacement();
+		const runtime = await createRuntime(pi, ctx, event, complete, options);
+		const replaced = await manager.replace(generation, runtime.manager);
+		if (!replaced) return;
+		await previousCodeMode?.dispose();
+		const codeMode = isGptCodeModeModel(ctx.model?.id)
+			? new CodeModeSessionRuntime({
+					sessionId: runtime.sessionId,
+					cwd: runtime.cwd,
+					parallelPoolWidth: runtime.parallelPoolWidth,
+					executeTool: runtime.executeTool,
+				})
+			: undefined;
+		activeRuntime = { ...runtime, ...(codeMode === undefined ? {} : { codeMode }) };
+		activeModelId = ctx.model?.id;
+		registerEvalForRuntime(activeRuntime, activeModelId);
+		if (codeMode) await activateCodeModeTools(codeMode);
+		else await deactivateCodeModeTools();
+	});
+	pi.on("session_shutdown", async () => dropRuntime());
+	pi.on("session_before_switch", async () => dropRuntime());
+	pi.on("session_before_fork", async () => dropRuntime());
+	pi.on("model_select", async (event) => {
+		const runtime = activeRuntime;
+		if (runtime === undefined) return;
+		const modelId = modelIdFrom(event);
+		if (modelId === undefined || modelId === activeModelId) return;
+		activeModelId = modelId;
+		registerEvalForRuntime(runtime, modelId);
+		if (!isGptCodeModeModel(modelId)) {
+			const { codeMode, ...nextRuntime } = runtime;
+			await codeMode?.dispose();
+			activeRuntime = nextRuntime;
+			await deactivateCodeModeTools();
+			return;
+		}
+		if (runtime.codeMode) {
+			if (isDynamicCodeModeExtensionAPI(pi)) {
+				await pi.setActiveTools([...new Set([...pi.getActiveTools(), "exec", "wait"])]);
+			}
+			return;
+		}
+		const codeMode = new CodeModeSessionRuntime({
+			sessionId: runtime.sessionId,
+			cwd: runtime.cwd,
+			parallelPoolWidth: runtime.parallelPoolWidth,
+			executeTool: runtime.executeTool,
+		});
+		activeRuntime = { ...runtime, codeMode };
+		await activateCodeModeTools(codeMode);
+	});
+}
+
+function isDynamicCodeModeExtensionAPI(pi: CodemodeExtensionAPI): pi is DynamicCodeModeExtensionAPI {
+	return typeof pi.setActiveTools === "function" && typeof pi.getAllTools === "function";
+}
+
+function hostLine(): string {
+	const cpu = os.cpus()[0]?.model?.trim();
+	return [`${os.platform()} ${os.arch()}`, cpu, `${os.availableParallelism()} cores`]
+		.filter((part): part is string => !!part)
+		.join(" \u00b7 ");
+}
+
+function modelIdFrom(event: unknown): string | undefined {
+	if (typeof event !== "object" || event === null || !("model" in event)) return undefined;
+	const model = event.model;
+	if (typeof model !== "object" || model === null || !("id" in model)) return undefined;
+	return typeof model.id === "string" ? model.id : undefined;
+}
+
+export { enabledLanguagesFrom };

package/src/interpreters/detect.ts

@@ -0,0 +1,161 @@
+import { execFile } from "node:child_process";
+import { platform as currentPlatform } from "node:os";
+import { promisify } from "node:util";
+import type { CodemodeSettings } from "../config/settings.ts";
+
+const execFileAsync = promisify(execFile);
+const probeTimeoutMs = 3_000;
+
+export type CodemodeLanguage = "py" | "js" | "rb" | "jl";
+
+export interface InterpreterDetected {
+	readonly ok: true;
+	readonly path: string;
+	readonly version: string;
+}
+
+export interface InterpreterUnavailable {
+	readonly ok: false;
+}
+
+export type InterpreterDetection = InterpreterDetected | InterpreterUnavailable;
+
+export interface ExecFileProbeOptions {
+	readonly timeoutMs: number;
+}
+
+export type ExecFileProbe = (
+	command: string,
+	args: readonly string[],
+	options: ExecFileProbeOptions,
+) => Promise<{ readonly stdout: string; readonly stderr: string }>;
+
+export interface CreateInterpreterDetectorOptions {
+	readonly platform?: NodeJS.Platform;
+	readonly execFile?: ExecFileProbe;
+	readonly nodeVersion?: string;
+}
+
+export interface InterpreterDetector {
+	detect(language: CodemodeLanguage): Promise<InterpreterDetection>;
+}
+
+export interface LanguageAvailability {
+	readonly enabled: boolean;
+	readonly detected: InterpreterDetection;
+}
+
+export type InterpreterAvailability = {
+	readonly [Language in CodemodeLanguage]: LanguageAvailability;
+};
+
+const unavailable: InterpreterUnavailable = { ok: false };
+
+export function createInterpreterDetector(options: CreateInterpreterDetectorOptions = {}): InterpreterDetector {
+	const probe = options.execFile ?? defaultExecFileProbe;
+	const hostPlatform = options.platform ?? currentPlatform();
+	const nodeVersion = options.nodeVersion ?? process.versions.node;
+	const cache = new Map<CodemodeLanguage, Promise<InterpreterDetection>>();
+
+	return {
+		detect(language) {
+			const cached = cache.get(language);
+			if (cached !== undefined) {
+				return cached;
+			}
+
+			const pending = detectUncached(language, hostPlatform, probe, nodeVersion);
+			cache.set(language, pending);
+			return pending;
+		},
+	};
+}
+
+export async function getInterpreterAvailability(
+	settings: CodemodeSettings,
+	detector: InterpreterDetector,
+): Promise<InterpreterAvailability> {
+	return {
+		py: await availabilityFor("py", settings.languages.py, detector),
+		js: await availabilityFor("js", settings.languages.js, detector),
+		rb: await availabilityFor("rb", settings.languages.rb, detector),
+		jl: await availabilityFor("jl", settings.languages.jl, detector),
+	};
+}
+
+async function availabilityFor(
+	language: CodemodeLanguage,
+	enabled: boolean,
+	detector: InterpreterDetector,
+): Promise<LanguageAvailability> {
+	return {
+		enabled,
+		detected: enabled ? await detector.detect(language) : unavailable,
+	};
+}
+
+async function detectUncached(
+	language: CodemodeLanguage,
+	hostPlatform: NodeJS.Platform,
+	probe: ExecFileProbe,
+	nodeVersion: string,
+): Promise<InterpreterDetection> {
+	if (language === "js") {
+		return { ok: true, path: "node", version: nodeVersion };
+	}
+
+	for (const candidate of candidatesFor(language, hostPlatform)) {
+		const result = await probeCandidate(candidate, probe);
+		if (result.ok) {
+			return result;
+		}
+	}
+
+	return unavailable;
+}
+
+async function probeCandidate(candidate: string, probe: ExecFileProbe): Promise<InterpreterDetection> {
+	const invocation = candidateInvocation(candidate);
+	try {
+		const result = await probe(invocation.command, [...invocation.args, "--version"], { timeoutMs: probeTimeoutMs });
+		const version = parseVersion(`${result.stdout}\n${result.stderr}`);
+		return version === null ? unavailable : { ok: true, path: candidate, version };
+	} catch {
+		return unavailable;
+	}
+}
+
+function candidatesFor(language: CodemodeLanguage, hostPlatform: NodeJS.Platform): readonly string[] {
+	if (language === "py") {
+		return hostPlatform === "win32" ? ["python", "py -3", "python3"] : ["python3", "python"];
+	}
+	if (language === "rb") {
+		return ["ruby"];
+	}
+	if (language === "jl") {
+		return ["julia"];
+	}
+	return [];
+}
+
+function candidateInvocation(candidate: string): { readonly command: string; readonly args: readonly string[] } {
+	const [command, ...args] = candidate.split(" ");
+	return { command: command ?? candidate, args };
+}
+
+function parseVersion(output: string): string | null {
+	const match = /(?:Python|ruby|julia)\s+(?:version\s+)?v?(\d+(?:\.\d+){1,3})/i.exec(output.trim());
+	return match?.[1] ?? null;
+}
+
+async function defaultExecFileProbe(
+	command: string,
+	args: readonly string[],
+	options: ExecFileProbeOptions,
+): Promise<{ readonly stdout: string; readonly stderr: string }> {
+	const result = await execFileAsync(command, [...args], { timeout: options.timeoutMs });
+	return {
+		stdout: String(result.stdout),
+		stderr: String(result.stderr),
+	};
+}

package/src/kernels/jl/kernel.ts

@@ -0,0 +1,37 @@
+import { join } from "node:path";
+import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
+import { SubprocessKernel, type SubprocessSpawn } from "../shared/subprocess-kernel.ts";
+
+export interface JuliaKernelStartOptions {
+	readonly cwd: string;
+	readonly sessionId: string;
+	readonly connection: BridgeConnectionConfig;
+	readonly command?: string;
+	readonly spawn?: SubprocessSpawn;
+	readonly onMessage?: (message: KernelToHostMessage) => void;
+}
+
+export class JuliaKernel extends SubprocessKernel {
+	static start(options: JuliaKernelStartOptions): JuliaKernel {
+		return new JuliaKernel({
+			command: options.command ?? "julia",
+			// --compile=min/--optimize=0 keep the runner in the interpreter with minimal
+			// JIT, which does not change cell results but sharply cuts the process's memory
+			// and CPU spike at startup — this makes the kernel far less likely to be
+			// OOM/CPU-starved (and killed) on an oversubscribed CI runner.
+			args: [
+				"--startup-file=no",
+				"--history-file=no",
+				"--color=no",
+				"--compile=min",
+				"--optimize=0",
+				join(import.meta.dirname, "runner.jl"),
+			],
+			cwd: options.cwd,
+			sessionId: options.sessionId,
+			connection: options.connection,
+			spawn: options.spawn,
+			onMessage: options.onMessage,
+		});
+	}
+}