@oh-my-pi/pi-coding-agent 14.5.12 → 14.5.14

package/src/eval/js/executor.ts

@@ -0,0 +1,131 @@
+import { DEFAULT_MAX_BYTES, OutputSink } from "../../session/streaming-output";
+import type { ToolSession } from "../../tools";
+import { executeInVmContext, type JsDisplayOutput } from "./context-manager";
+
+export interface JsExecutorOptions {
+	cwd?: string;
+	timeoutMs?: number;
+	deadlineMs?: number;
+	onChunk?: (chunk: string) => Promise<void> | void;
+	signal?: AbortSignal;
+	sessionId: string;
+	reset?: boolean;
+	sessionFile?: string;
+	artifactPath?: string;
+	artifactId?: string;
+	session: ToolSession;
+}
+
+export interface JsResult {
+	output: string;
+	exitCode: number | undefined;
+	cancelled: boolean;
+	truncated: boolean;
+	artifactId?: string;
+	totalLines: number;
+	totalBytes: number;
+	outputLines: number;
+	outputBytes: number;
+	displayOutputs: JsDisplayOutput[];
+}
+
+function getExecutionTimeoutMs(options: Pick<JsExecutorOptions, "deadlineMs" | "timeoutMs">): number | undefined {
+	if (options.deadlineMs !== undefined) {
+		return Math.max(1, options.deadlineMs - Date.now());
+	}
+	return options.timeoutMs;
+}
+
+function isAbortError(error: unknown): boolean {
+	return (
+		(error instanceof DOMException && (error.name === "AbortError" || error.name === "TimeoutError")) ||
+		(error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError"))
+	);
+}
+
+export async function executeJs(code: string, options: JsExecutorOptions): Promise<JsResult> {
+	const displayOutputs: JsDisplayOutput[] = [];
+	const outputSink = new OutputSink({
+		artifactPath: options.artifactPath,
+		artifactId: options.artifactId,
+		spillThreshold: DEFAULT_MAX_BYTES,
+		onChunk: chunk => options.onChunk?.(chunk),
+	});
+	const timeoutMs = getExecutionTimeoutMs(options);
+	const timeoutSignal =
+		typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0
+			? AbortSignal.timeout(timeoutMs)
+			: undefined;
+	const signal =
+		options.signal && timeoutSignal
+			? AbortSignal.any([options.signal, timeoutSignal])
+			: (options.signal ?? timeoutSignal);
+
+	try {
+		await executeInVmContext({
+			sessionKey: options.sessionId,
+			sessionId: options.sessionId,
+			cwd: options.cwd ?? options.session.cwd,
+			session: options.session,
+			reset: options.reset,
+			code,
+			filename: `js-cell-${crypto.randomUUID()}.js`,
+			timeoutMs,
+			runState: {
+				signal,
+				onText: chunk => outputSink.push(chunk),
+				onDisplay: output => {
+					displayOutputs.push(output);
+				},
+			},
+		});
+		const summary = await outputSink.dump();
+		return {
+			output: summary.output,
+			exitCode: 0,
+			cancelled: false,
+			truncated: summary.truncated,
+			artifactId: summary.artifactId,
+			totalLines: summary.totalLines,
+			totalBytes: summary.totalBytes,
+			outputLines: summary.outputLines,
+			outputBytes: summary.outputBytes,
+			displayOutputs,
+		};
+	} catch (error) {
+		if (signal?.aborted || isAbortError(error)) {
+			const timeoutReason = timeoutSignal?.aborted ? "Command timed out" : "";
+			if (timeoutReason) {
+				outputSink.push(timeoutReason);
+			}
+			const summary = await outputSink.dump();
+			return {
+				output: summary.output,
+				exitCode: undefined,
+				cancelled: true,
+				truncated: summary.truncated,
+				artifactId: summary.artifactId,
+				totalLines: summary.totalLines,
+				totalBytes: summary.totalBytes,
+				outputLines: summary.outputLines,
+				outputBytes: summary.outputBytes,
+				displayOutputs,
+			};
+		}
+		const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+		outputSink.push(message);
+		const summary = await outputSink.dump();
+		return {
+			output: summary.output,
+			exitCode: 1,
+			cancelled: false,
+			truncated: summary.truncated,
+			artifactId: summary.artifactId,
+			totalLines: summary.totalLines,
+			totalBytes: summary.totalBytes,
+			outputLines: summary.outputLines,
+			outputBytes: summary.outputBytes,
+			displayOutputs,
+		};
+	}
+}

package/src/eval/js/index.ts

@@ -0,0 +1,46 @@
+import type { ToolSession } from "../../tools";
+import type { ExecutorBackend, ExecutorBackendExecOptions, ExecutorBackendResult } from "../backend";
+import { executeJs } from "./executor";
+
+const JS_SESSION_PREFIX = "js:";
+
+function namespaceSessionId(sessionId: string): string {
+	return sessionId.startsWith(JS_SESSION_PREFIX) ? sessionId : `${JS_SESSION_PREFIX}${sessionId}`;
+}
+
+export default {
+	id: "js",
+	label: "JavaScript",
+	highlightLang: "javascript",
+
+	async isAvailable(_session: ToolSession): Promise<boolean> {
+		return true;
+	},
+
+	async execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult> {
+		const result = await executeJs(code, {
+			cwd: opts.cwd,
+			deadlineMs: opts.deadlineMs,
+			signal: opts.signal,
+			sessionId: namespaceSessionId(opts.sessionId),
+			sessionFile: opts.sessionFile,
+			reset: opts.reset,
+			artifactPath: opts.artifactPath,
+			artifactId: opts.artifactId,
+			onChunk: opts.onChunk,
+			session: opts.session,
+		});
+		return {
+			output: result.output,
+			exitCode: result.exitCode,
+			cancelled: result.cancelled,
+			truncated: result.truncated,
+			artifactId: result.artifactId,
+			totalLines: result.totalLines,
+			totalBytes: result.totalBytes,
+			outputLines: result.outputLines,
+			outputBytes: result.outputBytes,
+			displayOutputs: result.displayOutputs,
+		};
+	},
+} satisfies ExecutorBackend;

package/src/eval/js/prelude.ts

@@ -0,0 +1,2 @@
+import javascriptPrelude from "./prelude.txt" with { type: "text" };
+export const JAVASCRIPT_PRELUDE_SOURCE = javascriptPrelude;

package/src/eval/js/prelude.txt

@@ -0,0 +1,84 @@
+if (!globalThis.__omp_js_prelude_loaded__) {
+	globalThis.__omp_js_prelude_loaded__ = true;
+
+	const toOptions = value => (value && typeof value === "object" && !Array.isArray(value) ? value : {});
+	const callHelper = (name, ...args) => globalThis.__omp_helpers__[name](...args);
+
+	const read = (path, opts = {}) => callHelper("read", path, toOptions(opts));
+	const write = async (path, data) => callHelper("writeFile", path, data);
+	const append = (path, content) => callHelper("append", path, content);
+	const stat = path => callHelper("stat", path);
+	const grep = (pattern, path, opts = {}) => callHelper("grep", pattern, path, toOptions(opts));
+	const rgrep = (pattern, path = ".", opts = {}) => callHelper("rgrep", pattern, path, toOptions(opts));
+	const find = (pattern, path = ".", opts = {}) => callHelper("find", pattern, path, toOptions(opts));
+	const glob = (pattern, path = ".", opts = {}) => callHelper("glob", pattern, path, toOptions(opts));
+	const sort = (text, opts = {}) => callHelper("sortText", text, toOptions(opts));
+	const uniq = (text, opts = {}) => callHelper("uniqText", text, toOptions(opts));
+	const counter = (items, opts = {}) => callHelper("counter", items, toOptions(opts));
+	const sed = (path, pattern, repl, opts = {}) => callHelper("sed", path, pattern, repl, toOptions(opts));
+	const diff = (a, b) => callHelper("diff", a, b);
+	const tree = (path = ".", opts = {}) => callHelper("tree", path, toOptions(opts));
+	const run = (cmd, opts = {}) => callHelper("run", cmd, toOptions(opts));
+	const env = (key, value) => callHelper("env", key, value);
+
+	const tool = new Proxy(
+		{},
+		{
+			get(_target, prop) {
+				if (typeof prop !== "string") return undefined;
+				return async args => globalThis.__omp_call_tool__(prop, args ?? {});
+			},
+		},
+	);
+
+	const output = async (...args) => {
+		let opts = {};
+		let ids = args;
+		if (args.length > 0) {
+			const last = args.at(-1);
+			if (last && typeof last === "object" && !Array.isArray(last)) {
+				opts = last;
+				ids = args.slice(0, -1);
+			}
+		}
+		const reads = ids.map(id => tool.read({ path: `agent://${id}`, ...opts }));
+		const values = await Promise.all(reads);
+		return values.length === 1 ? values[0] : values;
+	};
+
+	const display = value => {
+		globalThis.__omp_display__(value);
+	};
+
+	const formatArgs = args => args.map(arg => (typeof arg === "string" ? arg : arg));
+
+	const consoleBridge = {
+		log: (...args) => globalThis.__omp_log__("log", ...formatArgs(args)),
+		info: (...args) => globalThis.__omp_log__("info", ...formatArgs(args)),
+		warn: (...args) => globalThis.__omp_log__("warn", ...formatArgs(args)),
+		error: (...args) => globalThis.__omp_log__("error", ...formatArgs(args)),
+		debug: (...args) => globalThis.__omp_log__("debug", ...formatArgs(args)),
+	};
+
+	globalThis.console = consoleBridge;
+	globalThis.print = consoleBridge.log;
+	globalThis.display = display;
+	globalThis.tool = tool;
+	globalThis.output = output;
+	globalThis.read = read;
+	globalThis.write = write;
+	globalThis.append = append;
+	globalThis.stat = stat;
+	globalThis.grep = grep;
+	globalThis.rgrep = rgrep;
+	globalThis.find = find;
+	globalThis.glob = glob;
+	globalThis.sort = sort;
+	globalThis.uniq = uniq;
+	globalThis.counter = counter;
+	globalThis.sed = sed;
+	globalThis.diff = diff;
+	globalThis.tree = tree;
+	globalThis.run = run;
+	globalThis.env = env;
+}

package/src/eval/js/tool-bridge.ts

@@ -0,0 +1,124 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "../../tools";
+import { ToolError } from "../../tools/tool-errors";
+
+export interface JsStatusEvent {
+	op: string;
+	[key: string]: unknown;
+}
+
+interface ToolBridgeOptions {
+	session: ToolSession;
+	signal?: AbortSignal;
+	emitStatus?: (event: JsStatusEvent) => void;
+}
+
+type ToolValue =
+	| string
+	| {
+			text: string;
+			details?: unknown;
+			images?: Array<{ mimeType: string; data: string }>;
+	  };
+
+function getTool(session: ToolSession, name: string): AgentTool {
+	const tool = session.getToolByName?.(name);
+	if (!tool) {
+		throw new ToolError(`Unknown tool from js runtime: ${name}`);
+	}
+	return tool;
+}
+
+function normalizeArgs(args: unknown): unknown {
+	if (!args || typeof args !== "object" || Array.isArray(args)) {
+		return args;
+	}
+	const record = { ...(args as Record<string, unknown>) };
+	if (record._i === undefined) {
+		record._i = "js prelude";
+	}
+	return record;
+}
+
+function summarizeToolResult(name: string, args: unknown, result: AgentToolResult, text: string): JsStatusEvent {
+	const record = (args && typeof args === "object" ? (args as Record<string, unknown>) : {}) as Record<
+		string,
+		unknown
+	>;
+	const details = (
+		result.details && typeof result.details === "object" ? (result.details as Record<string, unknown>) : {}
+	) as Record<string, unknown>;
+
+	switch (name) {
+		case "read":
+			return { op: "read", path: record.path, chars: text.length, preview: text.slice(0, 500) };
+		case "write":
+			return {
+				op: "write",
+				path: record.path,
+				chars: typeof record.content === "string" ? record.content.length : 0,
+			};
+		case "grep":
+			return {
+				op: "grep",
+				pattern: record.pattern,
+				path: record.path,
+				count: details.matchCount ?? undefined,
+			};
+		case "find":
+			return {
+				op: "find",
+				pattern: record.pattern,
+				count: details.fileCount ?? undefined,
+				matches: Array.isArray(details.files) ? details.files.slice(0, 20) : undefined,
+			};
+		case "bash":
+			return {
+				op: "run",
+				cmd: record.command,
+				code: typeof details.exitCode === "number" ? details.exitCode : undefined,
+				output: text.slice(0, 500),
+			};
+		default:
+			return { op: name, chars: text.length };
+	}
+}
+
+export async function callSessionTool(name: string, args: unknown, options: ToolBridgeOptions): Promise<ToolValue> {
+	const tool = getTool(options.session, name);
+	const normalizedArgs = normalizeArgs(args);
+	const toolCallId = `js-${name}-${crypto.randomUUID()}`;
+	try {
+		const result = await tool.execute(toolCallId, normalizedArgs, options.signal);
+		const textBlocks = result.content.filter(
+			(content): content is { type: "text"; text: string } =>
+				content.type === "text" && typeof content.text === "string",
+		);
+		const imageBlocks = result.content.filter(
+			(content): content is { type: "image"; mimeType: string; data: string } =>
+				content.type === "image" && typeof content.mimeType === "string" && typeof content.data === "string",
+		);
+		const text = textBlocks.map(block => block.text).join("");
+		options.emitStatus?.(summarizeToolResult(name, normalizedArgs, result, text));
+		if (result.details === undefined && imageBlocks.length === 0) {
+			return text;
+		}
+		return {
+			text,
+			details: result.details,
+			images:
+				imageBlocks.length > 0
+					? imageBlocks.map(block => ({
+							mimeType: block.mimeType,
+							data: block.data,
+						}))
+					: undefined,
+		};
+	} catch (error) {
+		options.emitStatus?.({
+			op: name,
+			error: error instanceof Error ? error.message : String(error),
+		});
+		throw error;
+	}
+}