@oh-my-pi/pi-coding-agent 16.0.2 → 16.0.4

package/src/eval/js/context-manager.ts

@@ -564,7 +564,7 @@ function spawnInlineWorker(): WorkerHandle {
 		},
 		close: () => {},
 	};
-	new WorkerCore(workerTransport);
+	const core = new WorkerCore(workerTransport);
 	return {
 		mode: "inline",
 		send: msg =>
@@ -600,6 +600,7 @@ function spawnInlineWorker(): WorkerHandle {
 		async terminate() {
 			hostListeners.clear();
 			workerListeners.clear();
+			core.dispose();
 		},
 	};
 }

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

@@ -55,6 +55,32 @@ export interface RuntimeOptions {
 const BASE64_STRICT_RE = /^[A-Za-z0-9+/]+={0,2}$/;
 const DECIMAL_CSV_RE = /^\d{1,3}(?:,\d{1,3})*$/;
 
+const PRELUDE_GLOBAL_KEYS = [
+	"__omp_js_prelude_loaded__",
+	"console",
+	"print",
+	"display",
+	"tool",
+	"completion",
+	"output",
+	"agent",
+	"parallel",
+	"pipeline",
+	"log",
+	"phase",
+	"budget",
+	"__pool",
+	"read",
+	"write",
+	"append",
+	"sort",
+	"uniq",
+	"counter",
+	"diff",
+	"tree",
+	"env",
+];
+
 function isStrictBase64(s: string): boolean {
 	if (s.length === 0 || s.length % 4 !== 0) return false;
 	return BASE64_STRICT_RE.test(s);
@@ -125,6 +151,22 @@ function describeDataType(data: unknown): string {
  * concern.
  */
 export class JsRuntime {
+	#globalOwner = Symbol("JsRuntime globals");
+	#ownedGlobalKeys = new Set<string>();
+	#disposed = false;
+	#runHookResolver = () => this.#als.getStore()?.hooks;
+
+	#ownGlobal(key: string): void {
+		if (this.#ownedGlobalKeys.has(key)) return;
+		claimGlobalKey(key, this.#globalOwner);
+		this.#ownedGlobalKeys.add(key);
+	}
+
+	#activateGlobals(action: string): void {
+		if (this.#disposed) throw new Error(`Cannot ${action} on a disposed JS runtime`);
+		activateGlobalOwner(this.#globalOwner, this.#ownedGlobalKeys, action);
+	}
+
 	readonly helpers: HelperBundle;
 	#cwd: string;
 	readonly sessionId: string;
@@ -153,6 +195,7 @@ export class JsRuntime {
 	}
 
 	setCwd(cwd: string): void {
+		this.#activateGlobals("set cwd");
 		this.#cwd = cwd;
 		const session = (globalThis as { __omp_session__?: { cwd?: string } }).__omp_session__;
 		if (session) session.cwd = cwd;
@@ -164,6 +207,7 @@ export class JsRuntime {
 	 * cleanup it wants.
 	 */
 	setRunScope(scope: Record<string, unknown>): void {
+		this.#activateGlobals("set run scope");
 		Object.assign(globalThis, scope);
 	}
 
@@ -173,6 +217,8 @@ export class JsRuntime {
 		hooks: RuntimeHooks,
 		options: { runId?: string; cwd?: string } = {},
 	): Promise<unknown> {
+		this.#activateGlobals("run code");
+		const leaveRun = enterGlobalRun(this.#globalOwner, "run code");
 		const context: RunContext = {
 			runId: options.runId ?? crypto.randomUUID(),
 			hooks,
@@ -180,21 +226,25 @@ export class JsRuntime {
 			finalExpressionSet: false,
 			finalExpressionValue: undefined,
 		};
-		return await this.#als.run(context, async () => {
-			const wrapped = await wrapCode(code);
-			const value = indirectEval(wrapped.source, filename);
-			if (wrapped.finalExpressionReturned) {
-				const awaited = await awaitMaybePromise(value);
-				if (context.finalExpressionSet) {
-					const finalValue = context.finalExpressionValue;
-					context.finalExpressionSet = false;
-					context.finalExpressionValue = undefined;
-					return await awaitMaybePromise(finalValue);
+		try {
+			return await this.#als.run(context, async () => {
+				const wrapped = await wrapCode(code);
+				const value = indirectEval(wrapped.source, filename);
+				if (wrapped.finalExpressionReturned) {
+					const awaited = await awaitMaybePromise(value);
+					if (context.finalExpressionSet) {
+						const finalValue = context.finalExpressionValue;
+						context.finalExpressionSet = false;
+						context.finalExpressionValue = undefined;
+						return await awaitMaybePromise(finalValue);
+					}
+					return awaited;
 				}
-				return awaited;
-			}
-			return await awaitMaybePromise(value);
-		});
+				return await awaitMaybePromise(value);
+			});
+		} finally {
+			leaveRun();
+		}
 	}
 
 	displayValue(value: unknown, hooks: RuntimeHooks | undefined = this.#als.getStore()?.hooks): void {
@@ -338,13 +388,137 @@ export class JsRuntime {
 			createRequire,
 			fs,
 		};
+
+		const allGlobalKeys = new Set<string>([
+			...Object.keys(injected),
+			...Object.keys(extraGlobals ?? {}),
+			...PRELUDE_GLOBAL_KEYS,
+		]);
+
+		for (const key of allGlobalKeys) {
+			this.#ownGlobal(key);
+		}
+
 		Object.assign(globalThis, injected, extraGlobals ?? {});
 		// Prelude assigns console bridge + short aliases (`read`, `write`, `tool`, `display`, ...)
 		// onto globalThis. Must run after helpers are in place.
 		indirectEval(JAVASCRIPT_PRELUDE_SOURCE);
-		RUN_HOOK_RESOLVERS.add(() => this.#als.getStore()?.hooks);
+		for (const key of allGlobalKeys) recordGlobalValue(key, this.#globalOwner);
+		RUN_HOOK_RESOLVERS.add(this.#runHookResolver);
 		patchStdioOnce();
 	}
+
+	dispose(): void {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		RUN_HOOK_RESOLVERS.delete(this.#runHookResolver);
+		for (const key of this.#ownedGlobalKeys) releaseGlobalKey(key, this.#globalOwner);
+		this.#ownedGlobalKeys.clear();
+	}
+}
+
+interface GlobalSnapshot {
+	exists: boolean;
+	value: unknown;
+}
+
+interface GlobalOwnerEntry {
+	owner: symbol;
+	value: unknown;
+}
+
+interface GlobalStack {
+	base: GlobalSnapshot;
+	entries: GlobalOwnerEntry[];
+}
+
+// Inline fallback and cmux tabs can create multiple JsRuntime instances in one Bun realm.
+// Track reserved helper globals by owner so disposing one runtime restores the next active
+// owner (or the original process global after the last owner), not a stale snapshot.
+const GLOBAL_STACKS = new Map<string, GlobalStack>();
+
+function snapshotGlobal(key: string): GlobalSnapshot {
+	return {
+		exists: key in globalThis,
+		value: (globalThis as Record<string, unknown>)[key],
+	};
+}
+
+function restoreGlobal(key: string, state: GlobalSnapshot): void {
+	if (state.exists) {
+		(globalThis as Record<string, unknown>)[key] = state.value;
+	} else {
+		delete (globalThis as Record<string, unknown>)[key];
+	}
+}
+
+function claimGlobalKey(key: string, owner: symbol): void {
+	let stack = GLOBAL_STACKS.get(key);
+	if (!stack) {
+		stack = { base: snapshotGlobal(key), entries: [] };
+		GLOBAL_STACKS.set(key, stack);
+	}
+	stack.entries.push({ owner, value: (globalThis as Record<string, unknown>)[key] });
+}
+
+function recordGlobalValue(key: string, owner: symbol): void {
+	const stack = GLOBAL_STACKS.get(key);
+	const entry = stack?.entries.findLast(item => item.owner === owner);
+	if (entry) entry.value = (globalThis as Record<string, unknown>)[key];
+}
+
+function releaseGlobalKey(key: string, owner: symbol): void {
+	const stack = GLOBAL_STACKS.get(key);
+	if (!stack) return;
+	const index = stack.entries.findIndex(entry => entry.owner === owner);
+	if (index === -1) return;
+	const wasTop = index === stack.entries.length - 1;
+	stack.entries.splice(index, 1);
+	if (!wasTop) return;
+	const next = stack.entries.at(-1);
+	if (next) {
+		(globalThis as Record<string, unknown>)[key] = next.value;
+		return;
+	}
+	restoreGlobal(key, stack.base);
+	GLOBAL_STACKS.delete(key);
+}
+
+// Plain globalThis cannot safely serve two different runtimes at the same instant:
+// helpers dereference reserved globals on every call. Sequential cmux tab revisits
+// re-activate their owner stack; overlapping cross-runtime runs fail explicitly.
+let activeGlobalRunOwner: symbol | null = null;
+let activeGlobalRunDepth = 0;
+
+function assertCanUseGlobalOwner(owner: symbol, action: string): void {
+	if (activeGlobalRunOwner === null || activeGlobalRunOwner === owner) return;
+	throw new Error(`Cannot ${action} while another same-realm JS runtime is running`);
+}
+
+function activateGlobalOwner(owner: symbol, keys: Iterable<string>, action: string): void {
+	assertCanUseGlobalOwner(owner, action);
+	for (const key of keys) {
+		const stack = GLOBAL_STACKS.get(key);
+		const index = stack?.entries.findIndex(entry => entry.owner === owner) ?? -1;
+		if (!stack || index === -1) throw new Error(`Cannot ${action} on a disposed JS runtime`);
+		const entry = stack.entries[index];
+		stack.entries.splice(index, 1);
+		stack.entries.push(entry);
+		(globalThis as Record<string, unknown>)[key] = entry.value;
+	}
+}
+
+function enterGlobalRun(owner: symbol, action: string): () => void {
+	assertCanUseGlobalOwner(owner, action);
+	activeGlobalRunOwner = owner;
+	activeGlobalRunDepth++;
+	let left = false;
+	return () => {
+		if (left) return;
+		left = true;
+		activeGlobalRunDepth--;
+		if (activeGlobalRunDepth === 0) activeGlobalRunOwner = null;
+	};
 }
 
 /** Resolvers for each live runtime's active-run hooks (one per JsRuntime instance). */

package/src/eval/js/worker-core.ts

@@ -124,9 +124,28 @@ export class WorkerCore {
 			active.pendingTools.clear();
 		}
 		this.#runs.clear();
+		this.#runtime?.dispose?.();
 		this.#runtime = null;
 		this.#transport.send({ type: "closed" });
 		this.#unsubscribe();
 		this.#transport.close();
 	}
+
+	dispose(): void {
+		for (const active of this.#runs.values()) {
+			for (const pending of active.pendingTools.values()) {
+				pending.reject(new ToolError("JS worker closed"));
+			}
+			active.pendingTools.clear();
+		}
+		this.#runs.clear();
+		this.#runtime?.dispose?.();
+		this.#runtime = null;
+		this.#unsubscribe();
+		try {
+			this.#transport.close();
+		} catch {
+			// Ignore
+		}
+	}
 }

package/src/export/html/index.ts

@@ -242,7 +242,7 @@ export async function exportFromFile(inputPath: string, options?: ExportOptions
 
 	let sm: SessionManager;
 	try {
-		sm = await SessionManager.open(inputPath);
+		sm = await SessionManager.open(inputPath, undefined, undefined, { suppressBreadcrumb: true });
 	} catch (err) {
 		if (isEnoent(err)) throw new Error(`File not found: ${inputPath}`);
 		throw err;