@oh-my-pi/pi-coding-agent 15.10.10 → 15.10.11

package/src/eval/js/shared/prelude.txt

@@ -90,15 +90,25 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 		const limit = await __concurrencyLimit();
 		const concurrency = limit > 0 ? Math.min(limit, list.length) : list.length;
 		const results = new Array(list.length);
+		// Barrier semantics (mirrors the Python _pool_map): every item settles
+		// before we return or throw, then the lowest-index error propagates.
+		// Early-rejecting would orphan in-flight thunks (e.g. live agent()
+		// subagents) whose worker-side promises would never be observed.
+		const errors = new Map();
 		let next = 0;
 		const worker = async () => {
 			while (true) {
 				const index = next++;
 				if (index >= list.length) return;
-				results[index] = await fn(list[index], index);
+				try {
+					results[index] = await fn(list[index], index);
+				} catch (error) {
+					errors.set(index, error);
+				}
 			}
 		};
 		await Promise.all(Array.from({ length: concurrency }, () => worker()));
+		if (errors.size > 0) throw errors.get(Math.min(...errors.keys()));
 		return results;
 	};
 
@@ -148,6 +158,8 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 
 	const formatArgs = args => args.map(arg => (typeof arg === "string" ? arg : arg));
 
+	const consoleTimers = new Map();
+	const consoleCounts = new Map();
 	const consoleBridge = {
 		log: (...args) => globalThis.__omp_log__("log", ...formatArgs(args)),
 		info: (...args) => globalThis.__omp_log__("info", ...formatArgs(args)),
@@ -158,6 +170,55 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 			columns === undefined
 				? globalThis.__omp_table__(data)
 				: globalThis.__omp_table__(data, columns),
+		dir: (value, _options) => globalThis.__omp_log__("log", value),
+		dirxml: (...args) => globalThis.__omp_log__("log", ...formatArgs(args)),
+		trace: (...args) => {
+			const stack = (new Error().stack ?? "").split("\n").slice(2).join("\n");
+			globalThis.__omp_log__("log", args.length > 0 ? `Trace: ${formatArgs(args).join(" ")}` : "Trace", `\n${stack}`);
+		},
+		assert: (condition, ...args) => {
+			if (condition) return;
+			if (args.length > 0) globalThis.__omp_log__("error", "Assertion failed:", ...formatArgs(args));
+			else globalThis.__omp_log__("error", "Assertion failed");
+		},
+		group: (...args) => {
+			if (args.length > 0) globalThis.__omp_log__("log", ...formatArgs(args));
+		},
+		groupCollapsed: (...args) => {
+			if (args.length > 0) globalThis.__omp_log__("log", ...formatArgs(args));
+		},
+		groupEnd: () => {},
+		time: label => {
+			consoleTimers.set(String(label ?? "default"), Date.now());
+		},
+		timeLog: (label, ...args) => {
+			const key = String(label ?? "default");
+			const start = consoleTimers.get(key);
+			if (start === undefined) {
+				globalThis.__omp_log__("warn", `Timer '${key}' does not exist`);
+				return;
+			}
+			globalThis.__omp_log__("log", `${key}: ${Date.now() - start}ms`, ...formatArgs(args));
+		},
+		timeEnd: label => {
+			const key = String(label ?? "default");
+			const start = consoleTimers.get(key);
+			if (start === undefined) {
+				globalThis.__omp_log__("warn", `Timer '${key}' does not exist`);
+				return;
+			}
+			consoleTimers.delete(key);
+			globalThis.__omp_log__("log", `${key}: ${Date.now() - start}ms`);
+		},
+		count: label => {
+			const key = String(label ?? "default");
+			const next = (consoleCounts.get(key) ?? 0) + 1;
+			consoleCounts.set(key, next);
+			globalThis.__omp_log__("log", `${key}: ${next}`);
+		},
+		countReset: label => {
+			consoleCounts.delete(String(label ?? "default"));
+		},
 	};
 
 	globalThis.console = consoleBridge;

package/src/eval/js/shared/rewrite-imports.ts

@@ -1,4 +1,4 @@
-import { parse as babelParse } from "@babel/parser";
+import type * as BabelParser from "@babel/parser";
 
 // Static ESM `import` declarations are not valid inside vm.runInContext (script-mode parsing),
 // and dynamic `import(...)` would otherwise resolve specifiers against the worker module's URL
@@ -64,9 +64,22 @@ type BabelModuleSourceDeclaration = {
 
 type BabelNode = { type: string; start: number; end: number; [key: string]: unknown };
 
-function parseProgram(code: string): { program: { body: ReadonlyArray<BabelProgramNode> } } | null {
+// @babel/parser sits on the CLI launch graph (tools → eval backend → worker-core →
+// runtime → this module) but only runs when an eval cell executes, so it is loaded
+// lazily and memoized.
+let babelParser: typeof BabelParser | undefined;
+
+async function loadBabelParser(): Promise<typeof BabelParser> {
+	if (!babelParser) {
+		babelParser = await import("@babel/parser");
+	}
+	return babelParser;
+}
+
+async function parseProgram(code: string): Promise<{ program: { body: ReadonlyArray<BabelProgramNode> } } | null> {
+	const { parse } = await loadBabelParser();
 	try {
-		return babelParse(code, {
+		return parse(code, {
 			sourceType: "module",
 			allowAwaitOutsideFunction: true,
 			allowReturnOutsideFunction: true,
@@ -162,10 +175,10 @@ function rewriteImportNode(node: BabelImportDeclaration): string {
 	return `await ${importCall};`;
 }
 
-export function rewriteImports(code: string): string {
+export async function rewriteImports(code: string): Promise<string> {
 	if (!code.includes("import")) return code;
 
-	const ast = parseProgram(code);
+	const ast = await parseProgram(code);
 	if (!ast) {
 		// Parser bailed entirely — let the VM surface the real syntax error.
 		return code;
@@ -201,8 +214,8 @@ export function rewriteImports(code: string): string {
 	}
 	return result;
 }
-export function collectModuleSourceSpecifiers(code: string): string[] {
-	const ast = parseProgram(code);
+export async function collectModuleSourceSpecifiers(code: string): Promise<string[]> {
+	const ast = await parseProgram(code);
 	if (!ast) return [];
 	const sources: string[] = [];
 	for (const node of ast.program.body) {
@@ -218,8 +231,11 @@ export function collectModuleSourceSpecifiers(code: string): string[] {
 	return sources;
 }
 
-export function rewriteModuleSourceSpecifiers(code: string, replacer: (source: string) => string): string {
-	const ast = parseProgram(code);
+export async function rewriteModuleSourceSpecifiers(
+	code: string,
+	replacer: (source: string) => string,
+): Promise<string> {
+	const ast = await parseProgram(code);
 	if (!ast) return code;
 
 	type Edit = { start: number; end: number; text: string };
@@ -249,9 +265,9 @@ export function rewriteModuleSourceSpecifiers(code: string, replacer: (source: s
 	return result;
 }
 
-export function rewriteDynamicImports(code: string, callee = "__omp_import__"): string {
+export async function rewriteDynamicImports(code: string, callee = "__omp_import__"): Promise<string> {
 	if (!code.includes("import")) return code;
-	const ast = parseProgram(code);
+	const ast = await parseProgram(code);
 	if (!ast) return code;
 
 	type Edit = { start: number; end: number; text: string };
@@ -339,10 +355,10 @@ function appendGlobalBindingPublish(source: string, names: readonly string[]): s
  * Nested declarations (inside functions, blocks, classes) are left alone \u2014 they're
  * scoped to their enclosing function/block regardless of `var` vs `let`/`const`.
  */
-function demoteTopLevelLexicals(code: string, options: { publishGlobals?: boolean } = {}): string {
+async function demoteTopLevelLexicals(code: string, options: { publishGlobals?: boolean } = {}): Promise<string> {
 	if (!/\b(?:const|let|class)\b/.test(code)) return code;
 
-	const ast = parseProgram(code);
+	const ast = await parseProgram(code);
 	if (!ast) {
 		return code;
 	}
@@ -381,8 +397,8 @@ function demoteTopLevelLexicals(code: string, options: { publishGlobals?: boolea
 	return result;
 }
 
-function returnFinalExpression(code: string): { source: string; returned: boolean } {
-	const ast = parseProgram(code);
+async function returnFinalExpression(code: string): Promise<{ source: string; returned: boolean }> {
+	const ast = await parseProgram(code);
 	const body = ast?.program.body;
 	if (!body) return { source: code, returned: false };
 	let lastIndex = body.length - 1;
@@ -446,8 +462,8 @@ function containsAsyncWrapperSyntax(value: unknown): boolean {
 	return false;
 }
 
-function requiresAsyncWrapper(code: string): boolean {
-	const ast = parseProgram(code);
+async function requiresAsyncWrapper(code: string): Promise<boolean> {
+	const ast = await parseProgram(code);
 	if (!ast) return false;
 	for (const node of ast.program.body) {
 		if (containsAsyncWrapperSyntax(node)) return true;
@@ -494,13 +510,15 @@ export function stripTypeScriptSyntax(
 const LOOKS_LIKE_TS =
 	/(?:\bimport\s+type\b|\bexport\s+type\b|\b(?:import|export)\s*\{[^}\n]*\btype\s+\w|\binterface\s+\w|\btype\s+\w+\s*=|\b(?:as|satisfies)\s+(?:[A-Z]|\bconst\b)|:\s*(?:string|number|boolean|any|unknown|void|never|object|[A-Z]\w*)\b|<\s*[A-Z]\w*\s*[,>])/;
 
-export function wrapCode(code: string): { source: string; asyncWrapped: boolean; finalExpressionReturned: boolean } {
-	const finalExpression = returnFinalExpression(code);
+export async function wrapCode(
+	code: string,
+): Promise<{ source: string; asyncWrapped: boolean; finalExpressionReturned: boolean }> {
+	const finalExpression = await returnFinalExpression(code);
 	const stripped = stripTypeScript(finalExpression.source);
-	const importsRewritten = rewriteImports(stripped);
-	const needsAsyncWrapper = requiresAsyncWrapper(importsRewritten);
+	const importsRewritten = await rewriteImports(stripped);
+	const needsAsyncWrapper = await requiresAsyncWrapper(importsRewritten);
 	const rewritten = {
-		source: demoteTopLevelLexicals(importsRewritten, { publishGlobals: needsAsyncWrapper }),
+		source: await demoteTopLevelLexicals(importsRewritten, { publishGlobals: needsAsyncWrapper }),
 		returned: finalExpression.returned,
 	};
 	if (!needsAsyncWrapper) {

package/src/eval/js/shared/runtime.ts

@@ -181,7 +181,7 @@ export class JsRuntime {
 			finalExpressionValue: undefined,
 		};
 		return await this.#als.run(context, async () => {
-			const wrapped = wrapCode(code);
+			const wrapped = await wrapCode(code);
 			const value = indirectEval(wrapped.source, filename);
 			if (wrapped.finalExpressionReturned) {
 				const awaited = await awaitMaybePromise(value);

package/src/eval/py/index.ts

@@ -42,8 +42,6 @@ export default {
 			localRoots: resolveEvalUrlRoots(opts.session),
 			kernelOwnerId: opts.kernelOwnerId,
 			reset: opts.reset,
-			artifactPath: opts.artifactPath,
-			artifactId: opts.artifactId,
 			onChunk: opts.onChunk,
 			onStatus: opts.onStatus,
 			toolSession: opts.session,

package/src/eval/py/kernel.ts

@@ -129,10 +129,29 @@ function throwIfAborted(signal: AbortSignal | undefined, fallbackReason: string)
 	throw createAbortError("AbortError", typeof reason === "string" ? reason : fallbackReason);
 }
 
+// Cache successful probes per resolved cwd: every cell otherwise pays one (or
+// two — backend.isAvailable + ensureKernelAvailable) interpreter spawns even
+// when the kernel is already hot. Failures are not cached so installing a
+// Python mid-session is picked up on the next attempt.
+const availabilityCache = new Map<string, Promise<PythonKernelAvailability>>();
+
 export async function checkPythonKernelAvailability(cwd: string): Promise<PythonKernelAvailability> {
 	if (isBunTestRuntime() || $flag("PI_PYTHON_SKIP_CHECK")) {
 		return { ok: true };
 	}
+	const key = path.resolve(cwd);
+	const cached = availabilityCache.get(key);
+	if (cached) return await cached;
+	const probe = probePythonKernelAvailability(key);
+	availabilityCache.set(key, probe);
+	const result = await probe;
+	if (!result.ok && availabilityCache.get(key) === probe) {
+		availabilityCache.delete(key);
+	}
+	return result;
+}
+
+async function probePythonKernelAvailability(cwd: string): Promise<PythonKernelAvailability> {
 	try {
 		const settings = await Settings.init();
 		const { env } = settings.getShellConfig();

package/src/eval/py/runner.py

@@ -51,8 +51,23 @@ from typing import Any
 # Frame writer
 # ---------------------------------------------------------------------------
 
-_RAW_STDOUT = sys.__stdout__
+# Frames travel on a private dup of the original stdout. fd 1 itself is then
+# repointed at a capture pipe: child processes spawned by user code without
+# stdout=PIPE inherit fd 1, and their output is forwarded to the host as
+# regular stdout frames by a drain thread instead of being written raw into
+# the NDJSON channel (where it would be dropped as invalid JSON — or worse,
+# spoof a frame). The wire protocol is unchanged: the host still reads NDJSON
+# frames from the subprocess stdout.
 _RAW_STDERR = sys.__stderr__
+try:
+    _FRAME_FD = os.dup(sys.__stdout__.fileno())
+    _RAW_STDOUT = os.fdopen(_FRAME_FD, "w", encoding="utf-8", errors="backslashreplace")
+    _CAPTURE_READ_FD, _capture_write_fd = os.pipe()
+    os.dup2(_capture_write_fd, sys.__stdout__.fileno())
+    os.close(_capture_write_fd)
+except (AttributeError, OSError, ValueError, io.UnsupportedOperation):
+    _RAW_STDOUT = sys.__stdout__
+    _CAPTURE_READ_FD = None
 _OUT_LOCK = threading.Lock()
 
 
@@ -78,11 +93,22 @@ def _emit(frame: dict) -> None:
 
 
 class _StreamProxy(io.TextIOBase):
-    """Emit each ``write()`` as a typed frame tied to the current request."""
+    """Emit ``write()`` data as typed frames tied to the current request.
+
+    Writes are coalesced per request: a frame is emitted once the buffer holds
+    a complete line (everything up to the last newline goes out together) or
+    grows past ``_MAX_BUFFER`` bytes, so the common ``print()`` pair of
+    ``write(text)`` + ``write("\\n")`` costs one frame instead of two. Partial
+    lines are bounded by ``flush()`` and the end-of-request flush.
+    """
+
+    _MAX_BUFFER = 8192
 
     def __init__(self, kind: str) -> None:
         super().__init__()
         self._kind = kind
+        self._lock = threading.Lock()
+        self._buffers: dict[str, str] = {}
 
     def writable(self) -> bool:  # noqa: D401 - protocol method
         return True
@@ -100,12 +126,44 @@ class _StreamProxy(io.TextIOBase):
             _RAW_STDERR.write(data)
             _RAW_STDERR.flush()
             return len(data)
-        _emit({"type": self._kind, "id": rid, "data": data})
+        emit_text = None
+        with self._lock:
+            buf = self._buffers.pop(rid, "") + data
+            if len(buf) >= self._MAX_BUFFER:
+                emit_text = buf
+            else:
+                nl = buf.rfind("\n")
+                if nl >= 0:
+                    emit_text = buf[: nl + 1]
+                    rest = buf[nl + 1 :]
+                    if rest:
+                        self._buffers[rid] = rest
+                else:
+                    self._buffers[rid] = buf
+        if emit_text:
+            _emit({"type": self._kind, "id": rid, "data": emit_text})
         return len(data)
 
     def flush(self) -> None:  # noqa: D401 - protocol method
+        rid = _CURRENT_RID.get()
+        if rid is not None:
+            self.flush_rid(rid)
         return None
 
+    def flush_rid(self, rid: str) -> None:
+        """Flush any buffered partial line for ``rid`` as its own frame."""
+        with self._lock:
+            buf = self._buffers.pop(rid, None)
+        if buf:
+            _emit({"type": self._kind, "id": rid, "data": buf})
+
+
+def _flush_stream_proxies(rid: str) -> None:
+    """Drain buffered proxy output for ``rid`` (called before its done frame)."""
+    for stream in (sys.stdout, sys.stderr):
+        if isinstance(stream, _StreamProxy):
+            stream.flush_rid(rid)
+
 
 # ---------------------------------------------------------------------------
 # Runner state
@@ -125,6 +183,10 @@ class _RunnerState:
         self.last_install_marker: int = 0
         self.loop: asyncio.AbstractEventLoop | None = None
         self.active_executions: int = 0
+        # Best-effort attribution target for captured fd-1 bytes (child
+        # processes inheriting stdout). With overlapping requests the most
+        # recently started one wins — strictly better than dropping the bytes.
+        self.capture_rid: str | None = None
 
 
 _CURRENT_RID: contextvars.ContextVar[str | None] = contextvars.ContextVar("omp_current_rid", default=None)
@@ -132,6 +194,42 @@ _CURRENT_RID: contextvars.ContextVar[str | None] = contextvars.ContextVar("omp_c
 _STATE = _RunnerState()
 
 
+def _drain_captured_stdout() -> None:
+    """Forward bytes written to the captured fd 1 as stdout frames.
+
+    Runs on a daemon thread for the life of the process. Child processes that
+    inherit fd 1 (any ``subprocess`` call without ``stdout=PIPE``) land here.
+    """
+    if _CAPTURE_READ_FD is None:
+        return
+    import codecs
+
+    decoder = codecs.getincrementaldecoder("utf-8")("replace")
+    while True:
+        try:
+            chunk = os.read(_CAPTURE_READ_FD, 65536)
+        except OSError:
+            return
+        if not chunk:
+            return
+        text = decoder.decode(chunk)
+        if not text:
+            continue
+        rid = _STATE.capture_rid
+        if rid is None:
+            _RAW_STDERR.write(text)
+            _RAW_STDERR.flush()
+        else:
+            _emit({"type": "stdout", "id": rid, "data": text})
+
+
+def _start_capture_drain() -> None:
+    if _CAPTURE_READ_FD is None:
+        return
+    thread = threading.Thread(target=_drain_captured_stdout, name="omp-fd1-capture", daemon=True)
+    thread.start()
+
+
 # ---------------------------------------------------------------------------
 # Magic source transformer
 # ---------------------------------------------------------------------------
@@ -880,6 +978,7 @@ def _start_parent_watchdog() -> None:
 async def _handle_request_async(req: dict) -> None:
     rid = str(req.get("id"))
     token = _CURRENT_RID.set(rid)
+    _STATE.capture_rid = rid
     _STATE.user_ns["__omp_run_id__"] = rid
     _STATE.cancel_requested = False
     _STATE.execution_count += 1
@@ -934,6 +1033,7 @@ async def _handle_request_async(req: dict) -> None:
             except Exception:
                 pass
 
+        _flush_stream_proxies(rid)
         _emit({
             "type": "done",
             "id": rid,
@@ -942,6 +1042,9 @@ async def _handle_request_async(req: dict) -> None:
             "cancelled": cancelled,
         })
     finally:
+        if _STATE.capture_rid == rid:
+            _STATE.capture_rid = None
+        _flush_stream_proxies(rid)
         _CURRENT_RID.reset(token)
 
 
@@ -986,6 +1089,7 @@ async def _main_async() -> None:
     sys.stderr = _StreamProxy("stderr")
     _install_idle_sigint()
     _start_parent_watchdog()
+    _start_capture_drain()
 
     stdin = sys.__stdin__
     if stdin is None:

package/src/exec/bash-executor.ts

@@ -314,7 +314,9 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		if (userSignal) {
 			userSignal.removeEventListener("abort", abortHandler);
 		}
-		if (resetSession) {
+		if (resetSession || options?.sessionKey?.includes(":async:")) {
+			// `:async:` keys are per-job (jobId is unique), so the Shell would
+			// otherwise stay in the process-global map forever after completion.
 			shellSessions.delete(sessionKey);
 		}
 	}