@oh-my-pi/pi-coding-agent 15.13.2 → 15.13.3

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

@@ -1,8 +1,8 @@
-import { afterEach, describe, expect, it } from "bun:test";
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 import { TempDir } from "@oh-my-pi/pi-utils";
 import { Settings } from "../../config/settings";
 import type { ToolSession } from "../../tools";
-import { disposeAllVmContexts } from "../js/context-manager";
+import { disposeAllVmContexts, setWorkerCloseTimeoutMsForTests } from "../js/context-manager";
 import { executeJs } from "../js/executor";
 
 const originalWorker = globalThis.Worker;
@@ -180,8 +180,18 @@ function installFakeWorker(stats: FakeWorkerStats, behavior: FakeWorkerBehavior)
 }
 
 describe("JavaScript eval worker lifecycle", () => {
+	let restoreCloseTimeoutMs = 0;
+	beforeEach(() => {
+		// Shrink the graceful-close grace period so the "close acked but the worker
+		// never exits -> force terminate" contract is proven without a real 1s wait.
+		restoreCloseTimeoutMs = setWorkerCloseTimeoutMsForTests(1);
+	});
+
 	afterEach(async () => {
+		// Dispose while the shrunk timeout is still active so a hung worker's afterEach
+		// close also force-terminates instantly, then restore the production default.
 		await disposeAllVmContexts();
+		setWorkerCloseTimeoutMsForTests(restoreCloseTimeoutMs);
 		Object.defineProperty(globalThis, "Worker", {
 			configurable: true,
 			writable: true,

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

@@ -60,6 +60,22 @@ const resettingSessions = new Map<string, Promise<void>>();
 // SIGILL/SIGSEGV. Callers that pass a larger per-cell budget still dominate.
 const WORKER_INIT_TIMEOUT_MS = 15_000;
 const WORKER_CLOSE_TIMEOUT_MS = 1_000;
+// Active graceful-close grace period before a worker that ack'd `close` but never
+// emitted its `close` event is force-terminated. Defaults to the production floor;
+// tests override it (and restore it) to exercise the close-timeout -> terminate
+// path without a real wall-clock wait.
+let workerCloseTimeoutMs: number = WORKER_CLOSE_TIMEOUT_MS;
+
+/**
+ * Test-only seam: override the graceful-close grace period (ms). Returns the
+ * previous value so callers can restore it. Production always uses
+ * {@link WORKER_CLOSE_TIMEOUT_MS}; never call this outside tests.
+ */
+export function setWorkerCloseTimeoutMsForTests(ms: number): number {
+	const previous = workerCloseTimeoutMs;
+	workerCloseTimeoutMs = ms;
+	return previous;
+}
 
 export async function executeInVmContext(options: {
 	sessionKey: string;
@@ -125,6 +141,27 @@ export async function disposeAllVmContexts(): Promise<void> {
 	await Promise.all(all.map(session => killSession(session, new ToolError("JS context disposed"), { force: false })));
 }
 
+/**
+ * Smoke probe: spawn the JS eval worker through the worker-host entry and prove
+ * it answers the `init` handshake on a real worker thread (not the inline
+ * fallback). Catches the silent worker-load and init-message-drop regressions
+ * that otherwise strand every cell on the init timeout in a distribution build —
+ * the failure mode that motivated `installWorkerInbox`. Wired into
+ * `omp --smoke-test` so binary / source / tarball installs all exercise it.
+ */
+export async function smokeTestJsEvalWorker(): Promise<void> {
+	const worker = spawnJsWorker();
+	const session: JsSession = { sessionKey: "smoke", worker, state: "alive", pending: new Map() };
+	try {
+		await initWorker(session, { cwd: process.cwd(), sessionId: "smoke" }, WORKER_INIT_TIMEOUT_MS);
+		if (worker.mode !== "worker") {
+			throw new Error("JS eval worker smoke fell back to the inline worker (real worker failed to start)");
+		}
+	} finally {
+		await worker.terminate().catch(() => undefined);
+	}
+}
+
 async function runOnce(
 	session: JsSession,
 	options: {
@@ -431,7 +468,7 @@ function spawnJsWorker(): WorkerHandle {
 	try {
 		const hostEntry = workerHostEntry();
 		const worker = hostEntry
-			? new Worker(hostEntry, { type: "module", argv: ["__omp_js_eval_worker"] })
+			? new Worker(hostEntry, { type: "module", argv: ["__omp_worker_js_eval"] })
 			: new Worker(new URL("./worker-entry.ts", import.meta.url).href, { type: "module" });
 		return wrapBunWorker(worker);
 	} catch (err) {
@@ -492,7 +529,7 @@ function wrapBunWorker(worker: Worker): WorkerHandle {
 				finishIfClosed();
 			});
 			worker.addEventListener("close", onClose);
-			timeout = setTimeout(() => finish(false), WORKER_CLOSE_TIMEOUT_MS);
+			timeout = setTimeout(() => finish(false), workerCloseTimeoutMs);
 			worker.postMessage({ type: "close" } satisfies WorkerInbound);
 			return await closed;
 		},
@@ -557,7 +594,7 @@ function spawnInlineWorker(): WorkerHandle {
 				if (msg.type === "closed") finish(true);
 			});
 			this.send({ type: "close" });
-			timeout = setTimeout(() => finish(false), WORKER_CLOSE_TIMEOUT_MS);
+			timeout = setTimeout(() => finish(false), workerCloseTimeoutMs);
 			return await closed;
 		},
 		async terminate() {

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

@@ -1,13 +1,20 @@
 import { parentPort } from "node:worker_threads";
+import { consumeWorkerInbox } from "@oh-my-pi/pi-utils/worker-host";
 import { WorkerCore } from "./worker-core";
 import type { Transport, WorkerInbound, WorkerOutbound } from "./worker-protocol";
 
 if (!parentPort) throw new Error("js worker-entry: missing parentPort");
 
 const port = parentPort;
+// When the CLI host pre-buffered messages (it imports this module dynamically),
+// bind that inbox so the parent's already-delivered `init` is replayed. Loaded
+// directly (test/SDK fallback), this module's top-level runs synchronously at
+// worker start, so the direct `parentPort.on` below wins the flush on its own.
+const inbox = consumeWorkerInbox();
 const transport: Transport = {
 	send: (msg: WorkerOutbound) => port.postMessage(msg),
 	onMessage: handler => {
+		if (inbox) return inbox.bind(data => handler(data as WorkerInbound));
 		const wrap = (data: unknown): void => handler(data as WorkerInbound);
 		port.on("message", wrap);
 		return () => port.off("message", wrap);

package/src/export/html/template.js

@@ -278,10 +278,12 @@
       let searchQuery = '';
 
       function hasTextContent(content) {
-        if (typeof content === 'string') return content.trim().length > 0;
+        if (typeof content === 'string') return Boolean(canonicalizeMessage(content));
         if (Array.isArray(content)) {
           for (const c of content) {
-            if (c.type === 'text' && c.text && c.text.trim().length > 0) return true;
+            if (c.type === 'text' && c.text) {
+              if (canonicalizeMessage(c.text)) return true;
+            }
           }
         }
         return false;
@@ -450,24 +452,16 @@
         return div.innerHTML;
       }
 
-      function isDotOnlyThinking(text) {
-        let sawDot = false;
-        for (let i = 0; i < text.length; i++) {
-          const code = text.charCodeAt(i);
-          if (code === 0x2e || code === 0x2026) {
-            sawDot = true;
-            continue;
+      function canonicalizeMessage(text) {
+        if (!text) return '';
+        const trimmed = text.trim();
+        for (let i = 0; i < trimmed.length; i++) {
+          const code = trimmed.charCodeAt(i);
+          if (code !== 0x2e && code !== 0x2026 && code !== 0x20 && code !== 0x09 && code !== 0x0a && code !== 0x0d) {
+            return trimmed;
           }
-          if (code === 0x20 || code === 0x09 || code === 0x0a || code === 0x0d) continue;
-          return false;
         }
-        return sawDot;
-      }
-
-      function visibleThinkingText(block) {
-        const text = block.thinking.trim();
-        if (!text) return '';
-        return isDotOnlyThinking(text) ? '' : text;
+        return '';
       }
 
       /**
@@ -1074,10 +1068,13 @@
             let html = `<div class="assistant-message" id="${entryId}">${copyBtnHtml}${tsHtml}`;
 
             for (const block of msg.content) {
-              if (block.type === 'text' && block.text.trim()) {
-                html += `<div class="assistant-text markdown-content">${safeMarkedParse(block.text)}</div>`;
+              if (block.type === 'text') {
+                const canon = canonicalizeMessage(block.text);
+                if (canon) {
+                  html += `<div class="assistant-text markdown-content">${safeMarkedParse(block.text)}</div>`;
+                }
               } else if (block.type === 'thinking') {
-                const thinking = visibleThinkingText(block);
+                const thinking = canonicalizeMessage(block.thinking);
                 if (!thinking) continue;
                 html += `<div class="thinking-block">
                   <div class="thinking-text">${escapeHtml(thinking)}</div>
@@ -1085,7 +1082,6 @@
                 </div>`;
               }
             }
-
             for (const block of msg.content) {
               if (block.type === 'toolCall') {
                 html += renderToolCall(block, sctx);