@oh-my-pi/pi-coding-agent 14.9.5 → 14.9.7

package/src/tools/eval.ts

@@ -26,7 +26,7 @@ export const EVAL_DEFAULT_PREVIEW_LINES = 10;
 
 export const evalSchema = Type.Object({
 	input: Type.String({
-		description: "eval input as a sequence of `*** Begin <LANG>` cell headers followed by code",
+		description: 'eval input as a sequence of `*** Cell <lang>:"title"` cell headers followed by code',
 	}),
 });
 export type EvalToolParams = Static<typeof evalSchema>;

package/src/web/search/index.ts

@@ -136,6 +136,7 @@ function formatForLLM(response: SearchResponse): string {
 async function executeSearch(
 	_toolCallId: string,
 	params: SearchQueryParams,
+	signal?: AbortSignal,
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
 	const providers =
 		params.provider && params.provider !== "auto"
@@ -165,6 +166,7 @@ async function executeSearch(
 				maxOutputTokens: params.max_tokens,
 				numSearchResults: params.num_search_results,
 				temperature: params.temperature,
+				signal,
 			});
 
 			const text = formatForLLM(response);
@@ -221,11 +223,11 @@ export class WebSearchTool implements AgentTool<typeof webSearchSchema, SearchRe
 	async execute(
 		_toolCallId: string,
 		params: SearchToolParams,
-		_signal?: AbortSignal,
+		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<SearchRenderDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<SearchRenderDetails>> {
-		return executeSearch(_toolCallId, params);
+		return executeSearch(_toolCallId, params, signal);
 	}
 }
 
@@ -241,9 +243,9 @@ export const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRende
 		params: SearchToolParams,
 		_onUpdate,
 		_ctx: CustomToolContext,
-		_signal?: AbortSignal,
+		signal?: AbortSignal,
 	) {
-		return executeSearch(toolCallId, params);
+		return executeSearch(toolCallId, params, signal);
 	},
 
 	renderCall(args: SearchToolParams, options: RenderResultOptions, theme: Theme) {

package/src/cli/jupyter-cli.ts

@@ -1,106 +0,0 @@
-/**
- * Jupyter CLI command handlers.
- *
- * Handles `omp jupyter` subcommand for managing the shared Python gateway.
- */
-
-import { APP_NAME } from "@oh-my-pi/pi-utils";
-import chalk from "chalk";
-import { getGatewayStatus, shutdownSharedGateway } from "../eval/py/gateway-coordinator";
-
-export type JupyterAction = "kill" | "status";
-
-export interface JupyterCommandArgs {
-	action: JupyterAction;
-}
-
-export function parseJupyterArgs(args: string[]): JupyterCommandArgs | undefined {
-	if (args.length === 0 || args[0] !== "jupyter") {
-		return undefined;
-	}
-
-	const action = args[1] as JupyterAction | undefined;
-	if (!action || !["kill", "status"].includes(action)) {
-		return { action: "status" };
-	}
-
-	return { action };
-}
-
-export async function runJupyterCommand(cmd: JupyterCommandArgs): Promise<void> {
-	switch (cmd.action) {
-		case "kill":
-			await runKill();
-			break;
-		case "status":
-			await runStatus();
-			break;
-	}
-}
-
-async function runKill(): Promise<void> {
-	const status = await getGatewayStatus();
-
-	if (!status.active) {
-		console.log(chalk.dim("No Jupyter gateway is running"));
-		return;
-	}
-
-	console.log(`Killing Jupyter gateway (PID ${status.pid})...`);
-	await shutdownSharedGateway();
-	console.log(chalk.green("Jupyter gateway stopped"));
-}
-
-async function runStatus(): Promise<void> {
-	const status = await getGatewayStatus();
-
-	if (!status.active) {
-		console.log(chalk.dim("No Jupyter gateway is running"));
-		return;
-	}
-
-	console.log(chalk.bold("Jupyter Gateway Status\n"));
-	console.log(`  ${chalk.green("●")} Running`);
-	console.log(`  PID:    ${status.pid}`);
-	console.log(`  URL:    ${status.url}`);
-	if (status.uptime !== null) {
-		console.log(`  Uptime: ${formatUptime(status.uptime)}`);
-	}
-	if (status.pythonPath) {
-		console.log(`  Python: ${status.pythonPath}`);
-	}
-	if (status.venvPath) {
-		console.log(`  Venv:   ${status.venvPath}`);
-	}
-}
-
-function formatUptime(ms: number): string {
-	const seconds = Math.floor(ms / 1000);
-	const minutes = Math.floor(seconds / 60);
-	const hours = Math.floor(minutes / 60);
-
-	if (hours > 0) {
-		return `${hours}h ${minutes % 60}m`;
-	}
-	if (minutes > 0) {
-		return `${minutes}m ${seconds % 60}s`;
-	}
-	return `${seconds}s`;
-}
-
-export function printJupyterHelp(): void {
-	console.log(`${chalk.bold(`${APP_NAME} jupyter`)} - Manage the shared Jupyter gateway
-
-${chalk.bold("Usage:")}
-  ${APP_NAME} jupyter <command>
-
-${chalk.bold("Commands:")}
-  status    Show gateway status (default)
-  kill      Stop the running gateway
-
-${chalk.bold("Examples:")}
-  ${APP_NAME} jupyter           # Show status
-  ${APP_NAME} jupyter status    # Show status
-  ${APP_NAME} jupyter kill      # Stop the gateway
-`);
-}

package/src/commands/jupyter.ts

@@ -1,32 +0,0 @@
-/**
- * Manage the shared Jupyter gateway.
- */
-import { Args, Command } from "@oh-my-pi/pi-utils/cli";
-import { type JupyterAction, type JupyterCommandArgs, runJupyterCommand } from "../cli/jupyter-cli";
-import { initTheme } from "../modes/theme/theme";
-
-const ACTIONS: JupyterAction[] = ["kill", "status"];
-
-export default class Jupyter extends Command {
-	static description = "Manage the shared Jupyter gateway";
-
-	static args = {
-		action: Args.string({
-			description: "Jupyter action",
-			required: false,
-			options: ACTIONS,
-		}),
-	};
-
-	async run(): Promise<void> {
-		const { args } = await this.parse(Jupyter);
-		const action = (args.action ?? "status") as JupyterAction;
-
-		const cmd: JupyterCommandArgs = {
-			action,
-		};
-
-		await initTheme();
-		await runJupyterCommand(cmd);
-	}
-}

package/src/eval/py/cancellation.ts

@@ -1,28 +0,0 @@
-export function getAbortReason(signal: AbortSignal | undefined, fallbackReason: string): Error {
-	if (signal?.reason instanceof Error) return signal.reason;
-	if (typeof signal?.reason === "string" && signal.reason.length > 0) {
-		return new Error(signal.reason);
-	}
-
-	return new Error(fallbackReason);
-}
-
-export function createCancellationError(name: "AbortError" | "TimeoutError", message: string): Error {
-	const error = new Error(message);
-	error.name = name;
-	return error;
-}
-
-export function getExecutionCancellationError(
-	result: { timedOut?: boolean },
-	signal: AbortSignal | undefined,
-	fallbackReason: string,
-): Error {
-	if (signal?.aborted) {
-		return getAbortReason(signal, fallbackReason);
-	}
-	if (result.timedOut) {
-		return createCancellationError("TimeoutError", fallbackReason);
-	}
-	return createCancellationError("AbortError", fallbackReason);
-}

package/src/eval/py/gateway-coordinator.ts

@@ -1,424 +0,0 @@
-import * as fs from "node:fs";
-import { createServer } from "node:net";
-import * as path from "node:path";
-import { Process } from "@oh-my-pi/pi-natives";
-import { getPythonGatewayDir, isEnoent, logger, procmgr } from "@oh-my-pi/pi-utils";
-import type { Subprocess } from "bun";
-import { Settings } from "../../config/settings";
-import { getOrCreateSnapshot } from "../../utils/shell-snapshot";
-import { filterEnv, resolvePythonRuntime } from "./runtime";
-
-const GATEWAY_INFO_FILE = "gateway.json";
-const GATEWAY_LOCK_FILE = "gateway.lock";
-const GATEWAY_STARTUP_TIMEOUT_MS = 30000;
-const GATEWAY_LOCK_TIMEOUT_MS = GATEWAY_STARTUP_TIMEOUT_MS + 5000;
-const GATEWAY_LOCK_RETRY_MS = 50;
-const GATEWAY_LOCK_STALE_MS = GATEWAY_STARTUP_TIMEOUT_MS * 2;
-const GATEWAY_LOCK_HEARTBEAT_MS = 5000;
-const HEALTH_CHECK_TIMEOUT_MS = 3000;
-
-export interface GatewayInfo {
-	url: string;
-	pid: number;
-	startedAt: number;
-	pythonPath?: string;
-	venvPath?: string | null;
-}
-
-interface GatewayLockInfo {
-	pid: number;
-	startedAt: number;
-}
-
-interface AcquireResult {
-	url: string;
-	isShared: boolean;
-}
-
-let localGatewayProcess: Subprocess | null = null;
-let localGatewayUrl: string | null = null;
-let isCoordinatorInitialized = false;
-
-async function allocatePort(): Promise<number> {
-	const { promise, resolve, reject } = Promise.withResolvers<number>();
-	const server = createServer();
-	server.unref();
-	server.on("error", reject);
-	server.listen(0, "127.0.0.1", () => {
-		const address = server.address();
-		if (address && typeof address === "object") {
-			const port = address.port;
-			server.close((err: Error | null | undefined) => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve(port);
-				}
-			});
-		} else {
-			server.close();
-			reject(new Error("Failed to allocate port"));
-		}
-	});
-
-	return promise;
-}
-
-function getGatewayDir(): string {
-	return getPythonGatewayDir();
-}
-
-function getGatewayInfoPath(): string {
-	return path.join(getGatewayDir(), GATEWAY_INFO_FILE);
-}
-
-function getGatewayLockPath(): string {
-	return path.join(getGatewayDir(), GATEWAY_LOCK_FILE);
-}
-
-async function writeLockInfo(lockPath: string): Promise<void> {
-	const payload: GatewayLockInfo = { pid: process.pid, startedAt: Date.now() };
-	try {
-		await Bun.write(lockPath, JSON.stringify(payload));
-	} catch {
-		// Ignore lock write failures
-	}
-}
-
-async function readLockInfo(lockPath: string): Promise<GatewayLockInfo | null> {
-	try {
-		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 };
-		}
-	} catch {
-		// Ignore parse errors
-	}
-	return null;
-}
-
-async function ensureGatewayDir(): Promise<void> {
-	const dir = getGatewayDir();
-	await fs.promises.mkdir(dir, { recursive: true });
-}
-
-async function withGatewayLock<T>(handler: () => Promise<T>): Promise<T> {
-	await ensureGatewayDir();
-	const lockPath = getGatewayLockPath();
-	const start = Date.now();
-	while (true) {
-		let fd: fs.promises.FileHandle | undefined;
-		try {
-			fd = await fs.promises.open(lockPath, "wx");
-			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
-					}
-				}
-			})();
-			try {
-				await writeLockInfo(lockPath);
-				return await handler();
-			} finally {
-				heartbeatRunning = false;
-				void heartbeat.catch(() => {}); // Don't await - let it die naturally
-				try {
-					await fd.close();
-					await fs.promises.unlink(lockPath);
-				} catch {
-					// Ignore lock cleanup errors
-				}
-			}
-		} catch (err) {
-			const error = err as NodeJS.ErrnoException;
-			if (error.code === "EEXIST") {
-				let removedStale = false;
-				try {
-					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() - lockStat.mtimeMs;
-					const staleByTime = lockAgeMs > GATEWAY_LOCK_STALE_MS;
-					const staleByPid = lockPid !== undefined && !procmgr.isPidRunning(lockPid);
-					const staleByMissingPid = lockPid === undefined && staleByTime;
-					if (staleByPid || staleByMissingPid) {
-						await fs.promises.unlink(lockPath);
-						removedStale = true;
-						logger.warn("Removed stale shared gateway lock", { path: lockPath, pid: lockPid });
-					}
-				} catch {
-					// Ignore stat errors; keep waiting
-				}
-				if (!removedStale) {
-					if (Date.now() - start > GATEWAY_LOCK_TIMEOUT_MS) {
-						throw new Error("Timed out waiting for shared gateway lock");
-					}
-					await Bun.sleep(GATEWAY_LOCK_RETRY_MS);
-				}
-				continue;
-			}
-			throw err;
-		}
-	}
-}
-
-async function readGatewayInfo(): Promise<GatewayInfo | null> {
-	const infoPath = getGatewayInfoPath();
-	try {
-		const content = await Bun.file(infoPath).text();
-		const parsed = JSON.parse(content) as Partial<GatewayInfo>;
-
-		if (typeof parsed.url !== "string" || typeof parsed.pid !== "number" || typeof parsed.startedAt !== "number") {
-			return null;
-		}
-		return {
-			url: parsed.url,
-			pid: parsed.pid,
-			startedAt: parsed.startedAt,
-			pythonPath: typeof parsed.pythonPath === "string" ? parsed.pythonPath : undefined,
-			venvPath: typeof parsed.venvPath === "string" || parsed.venvPath === null ? parsed.venvPath : undefined,
-		};
-	} catch (err) {
-		if (isEnoent(err)) return null;
-		return null;
-	}
-}
-
-async function writeGatewayInfo(info: GatewayInfo): Promise<void> {
-	const infoPath = getGatewayInfoPath();
-	const tempPath = `${infoPath}.tmp`;
-	await Bun.write(tempPath, JSON.stringify(info, null, 2));
-	await fs.promises.rename(tempPath, infoPath);
-}
-
-async function clearGatewayInfo(): Promise<void> {
-	const infoPath = getGatewayInfoPath();
-	try {
-		await fs.promises.unlink(infoPath);
-	} catch {
-		// Ignore errors on cleanup (file may not exist)
-	}
-}
-
-async function isGatewayHealthy(url: string): Promise<boolean> {
-	try {
-		const response = await fetch(`${url}/api/kernelspecs`, {
-			signal: AbortSignal.timeout(HEALTH_CHECK_TIMEOUT_MS),
-		});
-		return response.ok;
-	} catch {
-		return false;
-	}
-}
-
-async function isGatewayAlive(info: GatewayInfo): Promise<boolean> {
-	if (!procmgr.isPidRunning(info.pid)) return false;
-	return await isGatewayHealthy(info.url);
-}
-
-async function startGatewayProcess(
-	cwd: string,
-): Promise<{ url: string; pid: number; pythonPath: string; venvPath: string | null }> {
-	const settings = await Settings.init();
-	const { shell, env } = settings.getShellConfig();
-	const filteredEnv = filterEnv(env);
-	const runtime = resolvePythonRuntime(cwd, filteredEnv);
-	const snapshotPath = await getOrCreateSnapshot(shell, env).catch((err: unknown) => {
-		logger.warn("Failed to resolve shell snapshot for shared Python gateway", {
-			error: err instanceof Error ? err.message : String(err),
-		});
-		return null;
-	});
-
-	const kernelEnv: Record<string, string | undefined> = {
-		...runtime.env,
-		PYTHONUNBUFFERED: "1",
-		PI_SHELL_SNAPSHOT: snapshotPath ?? undefined,
-	};
-
-	const gatewayPort = await allocatePort();
-	const gatewayUrl = `http://127.0.0.1:${gatewayPort}`;
-
-	const gatewayProcess = Bun.spawn(
-		[
-			runtime.pythonPath,
-			"-m",
-			"kernel_gateway",
-			"--KernelGatewayApp.ip=127.0.0.1",
-			`--KernelGatewayApp.port=${gatewayPort}`,
-			"--KernelGatewayApp.port_retries=0",
-			"--KernelGatewayApp.allow_origin=*",
-			"--JupyterApp.answer_yes=true",
-		],
-		{
-			cwd,
-			stdin: "ignore",
-			stdout: "pipe",
-			stderr: "pipe",
-			windowsHide: true,
-			detached: true,
-			env: kernelEnv,
-		},
-	);
-
-	let exited = false;
-	gatewayProcess.exited
-		.catch(() => {})
-		.then(() => {
-			exited = true;
-		});
-
-	const startTime = Date.now();
-	while (Date.now() - startTime < GATEWAY_STARTUP_TIMEOUT_MS) {
-		if (exited) {
-			throw new Error("Gateway process exited during startup");
-		}
-		if (await isGatewayHealthy(gatewayUrl)) {
-			localGatewayProcess = gatewayProcess;
-			localGatewayUrl = gatewayUrl;
-			return {
-				url: gatewayUrl,
-				pid: gatewayProcess.pid,
-				pythonPath: runtime.pythonPath,
-				venvPath: runtime.venvPath ?? null,
-			};
-		}
-		await Bun.sleep(100);
-	}
-
-	gatewayProcess.kill();
-	throw new Error("Gateway startup timeout");
-}
-
-async function killGateway(pid: number, context: string): Promise<void> {
-	try {
-		await Process.fromPid(pid)?.terminate();
-	} catch (err) {
-		logger.warn("Failed to kill shared gateway process", {
-			error: err instanceof Error ? err.message : String(err),
-			pid,
-			context,
-		});
-	}
-}
-
-export async function acquireSharedGateway(cwd: string): Promise<AcquireResult | null> {
-	try {
-		return await withGatewayLock(async () => {
-			const existingInfo = await logger.time("acquireSharedGateway:readInfo", readGatewayInfo);
-			if (existingInfo) {
-				if (await logger.time("acquireSharedGateway:isAlive", isGatewayAlive, existingInfo)) {
-					localGatewayUrl = existingInfo.url;
-					isCoordinatorInitialized = true;
-					logger.debug("Reusing global Python gateway", { url: existingInfo.url });
-					return { url: existingInfo.url, isShared: true };
-				}
-
-				logger.debug("Cleaning up stale gateway info", { pid: existingInfo.pid });
-				if (procmgr.isPidRunning(existingInfo.pid)) {
-					await killGateway(existingInfo.pid, "stale");
-				}
-				await clearGatewayInfo();
-			}
-
-			const { url, pid, pythonPath, venvPath } = await logger.time(
-				"acquireSharedGateway:startGateway",
-				startGatewayProcess,
-				cwd,
-			);
-			const info: GatewayInfo = {
-				url,
-				pid,
-				startedAt: Date.now(),
-				pythonPath,
-				venvPath,
-			};
-			await writeGatewayInfo(info);
-			isCoordinatorInitialized = true;
-			logger.debug("Started global Python gateway", { url, pid });
-			return { url, isShared: true };
-		});
-	} catch (err) {
-		logger.warn("Failed to acquire shared gateway, falling back to local", {
-			error: err instanceof Error ? err.message : String(err),
-		});
-		return null;
-	}
-}
-
-export async function releaseSharedGateway(): Promise<void> {
-	if (!isCoordinatorInitialized) return;
-}
-
-export async function getSharedGatewayUrl(): Promise<string | null> {
-	if (localGatewayUrl) return localGatewayUrl;
-	return (await readGatewayInfo())?.url ?? null;
-}
-
-export async function isSharedGatewayActive(): Promise<boolean> {
-	return (await getGatewayStatus()).active;
-}
-
-export interface GatewayStatus {
-	active: boolean;
-	url: string | null;
-	pid: number | null;
-	uptime: number | null;
-	pythonPath: string | null;
-	venvPath: string | null;
-}
-
-export async function getGatewayStatus(): Promise<GatewayStatus> {
-	const info = await readGatewayInfo();
-	if (!info) {
-		return {
-			active: false,
-			url: null,
-			pid: null,
-			uptime: null,
-			pythonPath: null,
-			venvPath: null,
-		};
-	}
-	const active = procmgr.isPidRunning(info.pid);
-	return {
-		active,
-		url: info.url,
-		pid: info.pid,
-		uptime: active ? Date.now() - info.startedAt : null,
-		pythonPath: info.pythonPath ?? null,
-		venvPath: info.venvPath ?? null,
-	};
-}
-
-export async function shutdownSharedGateway(): Promise<void> {
-	try {
-		await withGatewayLock(async () => {
-			const info = await readGatewayInfo();
-			if (!info) return;
-			if (procmgr.isPidRunning(info.pid)) {
-				await killGateway(info.pid, "shutdown");
-			}
-			await clearGatewayInfo();
-		});
-	} catch (err) {
-		logger.warn("Failed to shutdown shared gateway", {
-			error: err instanceof Error ? err.message : String(err),
-		});
-	} finally {
-		if (localGatewayProcess) {
-			await killGateway(localGatewayProcess.pid, "shutdown-local");
-		}
-		localGatewayProcess = null;
-		localGatewayUrl = null;
-		isCoordinatorInitialized = false;
-	}
-}