@oh-my-pi/pi-coding-agent 8.0.20 → 8.2.0

package/src/ipy/executor.ts

@@ -1,3 +1,7 @@
+import { logger } from "@oh-my-pi/pi-utils";
+import { OutputSink } from "../session/streaming-output";
+import { time } from "../utils/timings";
+import { shutdownSharedGateway } from "./gateway-coordinator";
 import {
 	checkPythonKernelAvailability,
 	type KernelDisplayOutput,
@@ -5,9 +9,12 @@ import {
 	type KernelExecuteResult,
 	type PreludeHelper,
 	PythonKernel,
-} from "@oh-my-pi/pi-coding-agent/ipy/kernel";
-import { OutputSink } from "@oh-my-pi/pi-coding-agent/session/streaming-output";
-import { logger } from "@oh-my-pi/pi-utils";
+} from "./kernel";
+
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_KERNEL_SESSIONS = 4;
+const CLEANUP_INTERVAL_MS = 30 * 1000; // 30 seconds
+
 export type PythonKernelMode = "session" | "per-call";
 
 export interface PythonExecutorOptions {
@@ -77,10 +84,60 @@ interface KernelSession {
 
 const kernelSessions = new Map<string, KernelSession>();
 let cachedPreludeDocs: PreludeHelper[] | null = null;
+let cleanupTimer: NodeJS.Timeout | null = null;
+
+function startCleanupTimer(): void {
+	if (cleanupTimer) return;
+	cleanupTimer = setInterval(() => {
+		void cleanupIdleSessions();
+	}, CLEANUP_INTERVAL_MS);
+	cleanupTimer.unref();
+}
+
+function stopCleanupTimer(): void {
+	if (cleanupTimer) {
+		clearInterval(cleanupTimer);
+		cleanupTimer = null;
+	}
+}
+
+async function cleanupIdleSessions(): Promise<void> {
+	const now = Date.now();
+	const toDispose: KernelSession[] = [];
+
+	for (const session of kernelSessions.values()) {
+		if (session.dead || now - session.lastUsedAt > IDLE_TIMEOUT_MS) {
+			toDispose.push(session);
+		}
+	}
+
+	if (toDispose.length > 0) {
+		logger.debug("Cleaning up idle kernel sessions", { count: toDispose.length });
+		await Promise.allSettled(toDispose.map(session => disposeKernelSession(session)));
+	}
+
+	if (kernelSessions.size === 0) {
+		stopCleanupTimer();
+	}
+}
+
+async function evictOldestSession(): Promise<void> {
+	let oldest: KernelSession | null = null;
+	for (const session of kernelSessions.values()) {
+		if (!oldest || session.lastUsedAt < oldest.lastUsedAt) {
+			oldest = session;
+		}
+	}
+	if (oldest) {
+		logger.debug("Evicting oldest kernel session", { id: oldest.id });
+		await disposeKernelSession(oldest);
+	}
+}
 
 export async function disposeAllKernelSessions(): Promise<void> {
+	stopCleanupTimer();
 	const sessions = Array.from(kernelSessions.values());
-	await Promise.allSettled(sessions.map((session) => disposeKernelSession(session)));
+	await Promise.allSettled(sessions.map(session => disposeKernelSession(session)));
 }
 
 async function ensureKernelAvailable(cwd: string): Promise<void> {
@@ -98,6 +155,7 @@ export async function warmPythonEnvironment(
 ): Promise<{ ok: boolean; reason?: string; docs: PreludeHelper[] }> {
 	try {
 		await ensureKernelAvailable(cwd);
+		time("warmPython:ensureKernelAvailable");
 	} catch (err: unknown) {
 		const reason = err instanceof Error ? err.message : String(err);
 		cachedPreludeDocs = [];
@@ -111,10 +169,11 @@ export async function warmPythonEnvironment(
 		const docs = await withKernelSession(
 			resolvedSessionId,
 			cwd,
-			async (kernel) => kernel.introspectPrelude(),
+			async kernel => kernel.introspectPrelude(),
 			useSharedGateway,
 			sessionFile,
 		);
+		time("warmPython:withKernelSession");
 		cachedPreludeDocs = docs;
 		return { ok: true, docs };
 	} catch (err: unknown) {
@@ -132,12 +191,36 @@ export function resetPreludeDocsCache(): void {
 	cachedPreludeDocs = null;
 }
 
+function isResourceExhaustionError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return (
+		message.includes("Too many open files") ||
+		message.includes("EMFILE") ||
+		message.includes("ENFILE") ||
+		message.includes("resource temporarily unavailable")
+	);
+}
+
+async function recoverFromResourceExhaustion(): Promise<void> {
+	logger.warn("Resource exhaustion detected, recovering by restarting shared gateway");
+	stopCleanupTimer();
+	const sessions = Array.from(kernelSessions.values());
+	for (const session of sessions) {
+		if (session.heartbeatTimer) {
+			clearInterval(session.heartbeatTimer);
+		}
+		kernelSessions.delete(session.id);
+	}
+	await shutdownSharedGateway();
+}
+
 async function createKernelSession(
 	sessionId: string,
 	cwd: string,
 	useSharedGateway?: boolean,
 	sessionFile?: string,
 	artifactsDir?: string,
+	isRetry?: boolean,
 ): Promise<KernelSession> {
 	const env: Record<string, string> | undefined =
 		sessionFile || artifactsDir
@@ -146,7 +229,19 @@ async function createKernelSession(
 					...(artifactsDir ? { ARTIFACTS: artifactsDir } : {}),
 				}
 			: undefined;
-	const kernel = await PythonKernel.start({ cwd, useSharedGateway, env });
+
+	let kernel: PythonKernel;
+	try {
+		kernel = await PythonKernel.start({ cwd, useSharedGateway, env });
+		time("createKernelSession:PythonKernel.start");
+	} catch (err) {
+		if (!isRetry && isResourceExhaustionError(err)) {
+			await recoverFromResourceExhaustion();
+			return createKernelSession(sessionId, cwd, useSharedGateway, sessionFile, artifactsDir, true);
+		}
+		throw err;
+	}
+
 	const session: KernelSession = {
 		id: sessionId,
 		kernel,
@@ -218,8 +313,13 @@ async function withKernelSession<T>(
 ): Promise<T> {
 	let session = kernelSessions.get(sessionId);
 	if (!session) {
+		// Evict oldest session if at capacity
+		if (kernelSessions.size >= MAX_KERNEL_SESSIONS) {
+			await evictOldestSession();
+		}
 		session = await createKernelSession(sessionId, cwd, useSharedGateway, sessionFile, artifactsDir);
 		kernelSessions.set(sessionId, session);
+		startCleanupTimer();
 	}
 
 	const run = async (): Promise<T> => {
@@ -266,8 +366,8 @@ async function executeWithKernel(
 		const result = await kernel.execute(code, {
 			signal: options?.signal,
 			timeoutMs: options?.timeoutMs,
-			onChunk: (text) => sink.push(text),
-			onDisplay: (output) => void displayOutputs.push(output),
+			onChunk: text => sink.push(text),
+			onDisplay: output => void displayOutputs.push(output),
 		});
 
 		if (result.cancelled) {
@@ -351,7 +451,7 @@ export async function executePython(code: string, options?: PythonExecutorOption
 	return await withKernelSession(
 		sessionId,
 		cwd,
-		async (kernel) => executeWithKernel(kernel, code, options),
+		async kernel => executeWithKernel(kernel, code, options),
 		useSharedGateway,
 		sessionFile,
 		artifactsDir,

package/src/ipy/gateway-coordinator.ts

@@ -1,22 +1,12 @@
-import {
-	closeSync,
-	existsSync,
-	mkdirSync,
-	openSync,
-	readFileSync,
-	renameSync,
-	statSync,
-	unlinkSync,
-	utimesSync,
-	writeFileSync,
-} from "node:fs";
+import * as fs from "node:fs";
 import { createServer } from "node:net";
-import { delimiter, join } from "node:path";
-import { getAgentDir } from "@oh-my-pi/pi-coding-agent/config";
-import { getShellConfig, killProcessTree } from "@oh-my-pi/pi-coding-agent/utils/shell";
-import { getOrCreateSnapshot } from "@oh-my-pi/pi-coding-agent/utils/shell-snapshot";
-import { logger } from "@oh-my-pi/pi-utils";
+import * as path from "node:path";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 import type { Subprocess } from "bun";
+import { getAgentDir } from "../config";
+import { getShellConfig, killProcessTree } from "../utils/shell";
+import { getOrCreateSnapshot } from "../utils/shell-snapshot";
+import { time } from "../utils/timings";
 
 const GATEWAY_DIR_NAME = "python-gateway";
 const GATEWAY_INFO_FILE = "gateway.json";
@@ -114,13 +104,13 @@ const CASE_INSENSITIVE_ENV = process.platform === "win32";
 const ACTIVE_ENV_ALLOWLIST = CASE_INSENSITIVE_ENV ? WINDOWS_ENV_ALLOWLIST : DEFAULT_ENV_ALLOWLIST;
 
 const NORMALIZED_ALLOWLIST = new Map(
-	Array.from(ACTIVE_ENV_ALLOWLIST, (key) => [CASE_INSENSITIVE_ENV ? key.toUpperCase() : key, key] as const),
+	Array.from(ACTIVE_ENV_ALLOWLIST, key => [CASE_INSENSITIVE_ENV ? key.toUpperCase() : key, key] as const),
 );
 const NORMALIZED_DENYLIST = new Set(
-	Array.from(DEFAULT_ENV_DENYLIST, (key) => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
+	Array.from(DEFAULT_ENV_DENYLIST, key => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
 );
 const NORMALIZED_ALLOW_PREFIXES = CASE_INSENSITIVE_ENV
-	? DEFAULT_ENV_ALLOW_PREFIXES.map((prefix) => prefix.toUpperCase())
+	? DEFAULT_ENV_ALLOW_PREFIXES.map(prefix => prefix.toUpperCase())
 	: DEFAULT_ENV_ALLOW_PREFIXES;
 
 function normalizeEnvKey(key: string): string {
@@ -129,7 +119,7 @@ function normalizeEnvKey(key: string): string {
 
 function resolvePathKey(env: Record<string, string | undefined>): string {
 	if (!CASE_INSENSITIVE_ENV) return "PATH";
-	const match = Object.keys(env).find((candidate) => candidate.toLowerCase() === "path");
+	const match = Object.keys(env).find(candidate => candidate.toLowerCase() === "path");
 	return match ?? "PATH";
 }
 
@@ -166,7 +156,7 @@ function filterEnv(env: Record<string, string | undefined>): Record<string, stri
 			filtered[canonicalKey] = value;
 			continue;
 		}
-		if (NORMALIZED_ALLOW_PREFIXES.some((prefix) => normalizedKey.startsWith(prefix))) {
+		if (NORMALIZED_ALLOW_PREFIXES.some(prefix => normalizedKey.startsWith(prefix))) {
 			filtered[key] = value;
 		}
 	}
@@ -175,7 +165,7 @@ function filterEnv(env: Record<string, string | undefined>): Record<string, stri
 
 async function resolveVenvPath(cwd: string): Promise<string | null> {
 	if (process.env.VIRTUAL_ENV) return process.env.VIRTUAL_ENV;
-	const candidates = [join(cwd, ".venv"), join(cwd, "venv")];
+	const candidates = [path.join(cwd, ".venv"), path.join(cwd, "venv")];
 	for (const candidate of candidates) {
 		if (await Bun.file(candidate).exists()) {
 			return candidate;
@@ -189,12 +179,12 @@ async function resolvePythonRuntime(cwd: string, baseEnv: Record<string, string
 	const venvPath = env.VIRTUAL_ENV ?? (await resolveVenvPath(cwd));
 	if (venvPath) {
 		env.VIRTUAL_ENV = venvPath;
-		const binDir = process.platform === "win32" ? join(venvPath, "Scripts") : join(venvPath, "bin");
-		const pythonCandidate = join(binDir, process.platform === "win32" ? "python.exe" : "python");
+		const binDir = process.platform === "win32" ? path.join(venvPath, "Scripts") : path.join(venvPath, "bin");
+		const pythonCandidate = path.join(binDir, process.platform === "win32" ? "python.exe" : "python");
 		if (await Bun.file(pythonCandidate).exists()) {
 			const pathKey = resolvePathKey(env);
 			const currentPath = env[pathKey];
-			env[pathKey] = currentPath ? `${binDir}${delimiter}${currentPath}` : binDir;
+			env[pathKey] = currentPath ? `${binDir}${path.delimiter}${currentPath}` : binDir;
 			return { pythonPath: pythonCandidate, env, venvPath };
 		}
 	}
@@ -232,33 +222,29 @@ async function allocatePort(): Promise<number> {
 }
 
 function getGatewayDir(): string {
-	return join(getAgentDir(), GATEWAY_DIR_NAME);
+	return path.join(getAgentDir(), GATEWAY_DIR_NAME);
 }
 
 function getGatewayInfoPath(): string {
-	return join(getGatewayDir(), GATEWAY_INFO_FILE);
+	return path.join(getGatewayDir(), GATEWAY_INFO_FILE);
 }
 
 function getGatewayLockPath(): string {
-	return join(getGatewayDir(), GATEWAY_LOCK_FILE);
+	return path.join(getGatewayDir(), GATEWAY_LOCK_FILE);
 }
 
-function writeLockInfo(lockPath: string, fd: number): void {
+async function writeLockInfo(lockPath: string): Promise<void> {
 	const payload: GatewayLockInfo = { pid: process.pid, startedAt: Date.now() };
 	try {
-		writeFileSync(fd, JSON.stringify(payload));
+		await Bun.write(lockPath, JSON.stringify(payload));
 	} catch {
-		try {
-			writeFileSync(lockPath, JSON.stringify(payload));
-		} catch {
-			// Ignore lock write failures
-		}
+		// Ignore lock write failures
 	}
 }
 
-function readLockInfo(lockPath: string): GatewayLockInfo | null {
+async function readLockInfo(lockPath: string): Promise<GatewayLockInfo | null> {
 	try {
-		const raw = readFileSync(lockPath, "utf-8");
+		const raw = await Bun.file(lockPath).text();
 		const parsed = JSON.parse(raw) as Partial<GatewayLockInfo>;
 		if (typeof parsed.pid === "number" && Number.isFinite(parsed.pid)) {
 			return { pid: parsed.pid, startedAt: typeof parsed.startedAt === "number" ? parsed.startedAt : 0 };
@@ -269,36 +255,41 @@ function readLockInfo(lockPath: string): GatewayLockInfo | null {
 	return null;
 }
 
-function ensureGatewayDir(): void {
+async function ensureGatewayDir(): Promise<void> {
 	const dir = getGatewayDir();
-	if (!existsSync(dir)) {
-		mkdirSync(dir, { recursive: true });
-	}
+	await fs.promises.mkdir(dir, { recursive: true });
 }
 
 async function withGatewayLock<T>(handler: () => Promise<T>): Promise<T> {
-	ensureGatewayDir();
+	await ensureGatewayDir();
 	const lockPath = getGatewayLockPath();
 	const start = Date.now();
 	while (true) {
+		let fd: fs.promises.FileHandle | undefined;
 		try {
-			const fd = openSync(lockPath, "wx");
-			const heartbeat = setInterval(() => {
-				try {
-					const now = new Date();
-					utimesSync(lockPath, now, now);
-				} catch {
-					// Ignore heartbeat errors
+			fd = await fs.promises.open(lockPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL);
+			let heartbeatRunning = true;
+			const heartbeat = (async () => {
+				while (heartbeatRunning) {
+					await Bun.sleep(GATEWAY_LOCK_HEARTBEAT_MS);
+					if (!heartbeatRunning) break;
+					try {
+						const now = new Date();
+						await fs.promises.utimes(lockPath, now, now);
+					} catch {
+						// Ignore heartbeat errors
+					}
 				}
-			}, GATEWAY_LOCK_HEARTBEAT_MS);
+			})();
 			try {
-				writeLockInfo(lockPath, fd);
+				await writeLockInfo(lockPath);
 				return await handler();
 			} finally {
-				clearInterval(heartbeat);
+				heartbeatRunning = false;
+				void heartbeat.catch(() => {}); // Don't await - let it die naturally
 				try {
-					closeSync(fd);
-					unlinkSync(lockPath);
+					await fd.close();
+					await fs.promises.unlink(lockPath);
 				} catch {
 					// Ignore lock cleanup errors
 				}
@@ -308,15 +299,15 @@ async function withGatewayLock<T>(handler: () => Promise<T>): Promise<T> {
 			if (error.code === "EEXIST") {
 				let removedStale = false;
 				try {
-					const stat = statSync(lockPath);
-					const lockInfo = readLockInfo(lockPath);
+					const lockStat = await fs.promises.stat(lockPath);
+					const lockInfo = await readLockInfo(lockPath);
 					const lockPid = lockInfo?.pid;
-					const lockAgeMs = lockInfo?.startedAt ? Date.now() - lockInfo.startedAt : Date.now() - stat.mtimeMs;
+					const lockAgeMs = lockInfo?.startedAt ? Date.now() - lockInfo.startedAt : Date.now() - lockStat.mtimeMs;
 					const staleByTime = lockAgeMs > GATEWAY_LOCK_STALE_MS;
 					const staleByPid = lockPid !== undefined && !isPidRunning(lockPid);
 					const staleByMissingPid = lockPid === undefined && staleByTime;
 					if (staleByPid || staleByMissingPid) {
-						unlinkSync(lockPath);
+						await fs.promises.unlink(lockPath);
 						removedStale = true;
 						logger.warn("Removed stale shared gateway lock", { path: lockPath, pid: lockPid });
 					}
@@ -336,14 +327,12 @@ async function withGatewayLock<T>(handler: () => Promise<T>): Promise<T> {
 	}
 }
 
-function readGatewayInfo(): GatewayInfo | null {
+async function readGatewayInfo(): Promise<GatewayInfo | null> {
 	const infoPath = getGatewayInfoPath();
-	if (!existsSync(infoPath)) return null;
-
 	try {
-		const content = readFileSync(infoPath, "utf-8");
+		const content = await Bun.file(infoPath).text();
 		const parsed = JSON.parse(content) as Partial<GatewayInfo>;
-		if (!parsed || typeof parsed !== "object") return null;
+
 		if (typeof parsed.url !== "string" || typeof parsed.pid !== "number" || typeof parsed.startedAt !== "number") {
 			return null;
 		}
@@ -354,26 +343,25 @@ function readGatewayInfo(): GatewayInfo | null {
 			pythonPath: typeof parsed.pythonPath === "string" ? parsed.pythonPath : undefined,
 			venvPath: typeof parsed.venvPath === "string" || parsed.venvPath === null ? parsed.venvPath : undefined,
 		};
-	} catch {
+	} catch (err) {
+		if (isEnoent(err)) return null;
 		return null;
 	}
 }
 
-function writeGatewayInfo(info: GatewayInfo): void {
+async function writeGatewayInfo(info: GatewayInfo): Promise<void> {
 	const infoPath = getGatewayInfoPath();
 	const tempPath = `${infoPath}.tmp`;
-	writeFileSync(tempPath, JSON.stringify(info, null, 2));
-	renameSync(tempPath, infoPath);
+	await Bun.write(tempPath, JSON.stringify(info, null, 2));
+	await fs.promises.rename(tempPath, infoPath);
 }
 
-function clearGatewayInfo(): void {
+async function clearGatewayInfo(): Promise<void> {
 	const infoPath = getGatewayInfoPath();
-	if (existsSync(infoPath)) {
-		try {
-			unlinkSync(infoPath);
-		} catch {
-			// Ignore errors on cleanup
-		}
+	try {
+		await fs.promises.unlink(infoPath);
+	} catch {
+		// Ignore errors on cleanup (file may not exist)
 	}
 }
 
@@ -388,12 +376,9 @@ function isPidRunning(pid: number): boolean {
 
 async function isGatewayHealthy(url: string): Promise<boolean> {
 	try {
-		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), HEALTH_CHECK_TIMEOUT_MS);
 		const response = await fetch(`${url}/api/kernelspecs`, {
-			signal: controller.signal,
+			signal: AbortSignal.timeout(HEALTH_CHECK_TIMEOUT_MS),
 		});
-		clearTimeout(timeout);
 		return response.ok;
 	} catch {
 		return false;
@@ -497,9 +482,12 @@ export async function acquireSharedGateway(cwd: string): Promise<AcquireResult |
 
 	try {
 		return await withGatewayLock(async () => {
-			const existingInfo = readGatewayInfo();
+			time("acquireSharedGateway:lockAcquired");
+			const existingInfo = await readGatewayInfo();
+			time("acquireSharedGateway:readInfo");
 			if (existingInfo) {
 				if (await isGatewayAlive(existingInfo)) {
+					time("acquireSharedGateway:isAlive");
 					localGatewayUrl = existingInfo.url;
 					isCoordinatorInitialized = true;
 					logger.debug("Reusing global Python gateway", { url: existingInfo.url });
@@ -510,10 +498,11 @@ export async function acquireSharedGateway(cwd: string): Promise<AcquireResult |
 				if (isPidRunning(existingInfo.pid)) {
 					await killGateway(existingInfo.pid, "stale");
 				}
-				clearGatewayInfo();
+				await clearGatewayInfo();
 			}
 
 			const { url, pid, pythonPath, venvPath } = await startGatewayProcess(cwd);
+			time("acquireSharedGateway:startGateway");
 			const info: GatewayInfo = {
 				url,
 				pid,
@@ -521,7 +510,7 @@ export async function acquireSharedGateway(cwd: string): Promise<AcquireResult |
 				pythonPath,
 				venvPath,
 			};
-			writeGatewayInfo(info);
+			await writeGatewayInfo(info);
 			isCoordinatorInitialized = true;
 			logger.debug("Started global Python gateway", { url, pid });
 			return { url, isShared: true };
@@ -538,13 +527,13 @@ export async function releaseSharedGateway(): Promise<void> {
 	if (!isCoordinatorInitialized) return;
 }
 
-export function getSharedGatewayUrl(): string | null {
+export async function getSharedGatewayUrl(): Promise<string | null> {
 	if (localGatewayUrl) return localGatewayUrl;
-	return readGatewayInfo()?.url ?? null;
+	return (await readGatewayInfo())?.url ?? null;
 }
 
-export function isSharedGatewayActive(): boolean {
-	return getGatewayStatus().active;
+export async function isSharedGatewayActive(): Promise<boolean> {
+	return (await getGatewayStatus()).active;
 }
 
 export interface GatewayStatus {
@@ -556,8 +545,8 @@ export interface GatewayStatus {
 	venvPath: string | null;
 }
 
-export function getGatewayStatus(): GatewayStatus {
-	const info = readGatewayInfo();
+export async function getGatewayStatus(): Promise<GatewayStatus> {
+	const info = await readGatewayInfo();
 	if (!info) {
 		return {
 			active: false,
@@ -582,12 +571,12 @@ export function getGatewayStatus(): GatewayStatus {
 export async function shutdownSharedGateway(): Promise<void> {
 	try {
 		await withGatewayLock(async () => {
-			const info = readGatewayInfo();
+			const info = await readGatewayInfo();
 			if (!info) return;
 			if (isPidRunning(info.pid)) {
 				await killGateway(info.pid, "shutdown");
 			}
-			clearGatewayInfo();
+			await clearGatewayInfo();
 		});
 	} catch (err) {
 		logger.warn("Failed to shutdown shared gateway", {