@oh-my-pi/pi-coding-agent 17.2.1 → 17.2.2

package/src/tools/browser/tab-protocol.ts

@@ -59,12 +59,20 @@ export type WorkerInitPayload =
 			safeDir: string;
 			targetId: string;
 			dialogs?: "accept" | "dismiss";
+			url?: string;
+			waitUntil?: "load" | "domcontentloaded" | "networkidle0" | "networkidle2";
+			timeoutMs: number;
 			/**
 			 * Post-timeout recycle: before adopting the page, dismiss any open JS dialog and
 			 * stop a pending navigation so a blocked target cannot stall worker init (which
 			 * previously force-killed the tab). Never set for first-time Electron attach.
 			 */
 			recover?: boolean;
+			/**
+			 * Whether the worker may raise this tab before capturing a screenshot. Unset
+			 * behaves as `true`; the supervisor clears it for browsers we did not launch.
+			 */
+			activateForScreenshot?: boolean;
 	  };
 
 export type ToolReply = { ok: true; value: unknown } | { ok: false; error: RunErrorPayload };

package/src/tools/browser/tab-supervisor.ts

@@ -5,7 +5,7 @@ import { webpExclusionForModel } from "../../utils/image-loading";
 import type { ToolSession } from "../index";
 import { expandPath } from "../path-utils";
 import { ToolAbortError, ToolError } from "../tool-errors";
-import { pickElectronTarget } from "./attach";
+import { pickElectronTarget, shouldPreserveConnectedBrowserFocus } from "./attach";
 import { CmuxTab, runCmuxCode } from "./cmux/cmux-tab";
 import { mapWaitUntil } from "./cmux/rpc";
 import { DEFAULT_VIEWPORT } from "./launch";
@@ -81,6 +81,7 @@ interface TabSessionBase<TBrowser extends BrowserHandle = BrowserHandle> {
 export interface WorkerTabSession extends TabSessionBase<PuppeteerBrowserHandle> {
 	backend: "worker";
 	worker: WorkerHandle;
+	activateForScreenshot: boolean;
 }
 
 export interface CmuxTabSession extends TabSessionBase<CmuxBrowserHandle> {
@@ -139,6 +140,18 @@ const GRACE_MS = 750;
 const killedTabs = new Map<string, string>();
 const DEFAULT_TAB_CLOSE_TIMEOUT_MS = 5_000;
 class RecoverableWorkerError extends ToolError {}
+const REPORTED_INIT_FAILURE = Symbol("reported-init-failure");
+
+type ReportedInitFailure = Error & { [REPORTED_INIT_FAILURE]?: true };
+
+function markReportedInitFailure(error: Error): Error {
+	(error as ReportedInitFailure)[REPORTED_INIT_FAILURE] = true;
+	return error;
+}
+
+function isReportedInitFailure(error: unknown): boolean {
+	return error instanceof Error && (error as ReportedInitFailure)[REPORTED_INIT_FAILURE] === true;
+}
 
 async function waitForTabCleanup<T>(
 	tab: TabSession,
@@ -265,7 +278,7 @@ async function acquireTabImpl(
 		// after `spawnTabWorker`'s synchronous try/catch has already returned. Fall back to
 		// the inline worker here so module-resolution failures don't poison every tab open.
 		await worker.terminate().catch(() => undefined);
-		if (worker.mode === "inline") {
+		if (worker.mode === "inline" || isReportedInitFailure(error)) {
 			if (tempHold || browser.refCount === 0) await releaseBrowser(browser, { kill: false });
 			throw error;
 		}
@@ -312,6 +325,7 @@ async function acquireTabImpl(
 		pending: new Map(),
 		dialogPolicy: opts.dialogs,
 		kindTag: browser.kind.kind,
+		activateForScreenshot: initPayload.mode === "headless" || initPayload.activateForScreenshot !== false,
 		ownerSessionId: opts.ownerSessionId,
 	};
 	worker.onMessage(msg => handleTabMessage(tab, msg));
@@ -684,7 +698,14 @@ async function buildInitPayload(browser: PuppeteerBrowserHandle, opts: AcquireTa
 			timeoutMs: opts.timeoutMs,
 		};
 	}
-	const page = await pickElectronTarget(browser.browser, opts.target);
+	// A connected browser is user-driven. When no target is requested, adopt its
+	// visible tab and avoid raising it before screenshots. An explicit target may
+	// be backgrounded, so retain activation to guarantee target-correct pixels.
+	const activateForScreenshot = browser.kind.kind !== "connected" || !shouldPreserveConnectedBrowserFocus(opts.target);
+	const page = await pickElectronTarget(browser.browser, {
+		matcher: opts.target,
+		preferVisible: !activateForScreenshot,
+	});
 	const targetId = await targetIdForPage(page);
 	return {
 		mode: "attach",
@@ -692,6 +713,10 @@ async function buildInitPayload(browser: PuppeteerBrowserHandle, opts: AcquireTa
 		safeDir,
 		targetId,
 		dialogs: opts.dialogs,
+		url: opts.url,
+		waitUntil: opts.waitUntil,
+		timeoutMs: opts.timeoutMs,
+		activateForScreenshot,
 	};
 }
 
@@ -793,6 +818,8 @@ async function recycleTimedOutWorkerTab(tab: WorkerTabSession, timeoutMs: number
 		// Unblock a wedged page (open JS dialog, hung navigation) before adopting it —
 		// otherwise init stalls, times out, and the tab gets force-killed.
 		recover: true,
+		timeoutMs,
+		activateForScreenshot: tab.activateForScreenshot,
 	};
 	let worker = await spawnTabWorker();
 	try {
@@ -1010,7 +1037,7 @@ async function initializeTabWorker(
 	const { promise, resolve, reject } = Promise.withResolvers<ReadyInfo>();
 	const unlisten = worker.onMessage(msg => {
 		if (msg.type === "ready") resolve(msg.info);
-		else if (msg.type === "init-failed") reject(errorFromPayload(msg.error));
+		else if (msg.type === "init-failed") reject(markReportedInitFailure(errorFromPayload(msg.error)));
 		else if (msg.type === "log") logWorkerMessage(msg);
 	});
 	const unlistenError = worker.onError(error => {

package/src/tools/browser/tab-worker.ts

@@ -72,6 +72,7 @@ declare global {
 	var innerHeight: number;
 	var document: {
 		elementFromPoint(x: number, y: number): Element | null;
+		readonly visibilityState: "visible" | "hidden";
 	};
 }
 
@@ -711,6 +712,22 @@ export function describeScreenshot(opts?: ScreenshotOptions): string {
 	if (opts?.fullPage) return "tab.screenshot({ fullPage: true })";
 	return "tab.screenshot()";
 }
+export async function preparePageForScreenshot(
+	page: Pick<Page, "bringToFront" | "evaluate">,
+	signal: AbortSignal | undefined,
+	activate: boolean,
+): Promise<void> {
+	if (activate) {
+		await untilAborted(signal, () => page.bringToFront()).catch(() => undefined);
+		return;
+	}
+	const visible = await untilAborted(signal, () => page.evaluate(() => document.visibilityState === "visible")).catch(
+		() => false,
+	);
+	if (!visible) {
+		throw new ToolError("The attached browser tab is not visible; switch to it before taking a screenshot");
+	}
+}
 
 /** Summarize still-running helpers (oldest first) so a cell timeout names what stalled. */
 export function describeInflight(inflight: Map<number, InflightOp>): string {
@@ -732,6 +749,7 @@ export class WorkerCore {
 	#runtime: JsRuntime | null = null;
 	#unsub: () => void;
 	#mode?: WorkerInitPayload["mode"];
+	#activateForScreenshot = true;
 	#dialogPolicy?: DialogPolicy;
 	#dialogHandler?: (dialog: Dialog) => void;
 	#openDialog?: OpenDialogInfo;
@@ -780,6 +798,7 @@ export class WorkerCore {
 	async #init(payload: WorkerInitPayload): Promise<void> {
 		try {
 			this.#mode = payload.mode;
+			this.#activateForScreenshot = payload.mode === "headless" || payload.activateForScreenshot !== false;
 			const puppeteer = await loadPuppeteerInWorker(payload.safeDir);
 			this.#browser = await puppeteer.connect({
 				browserWSEndpoint: payload.browserWSEndpoint,
@@ -810,6 +829,13 @@ export class WorkerCore {
 				this.#page = page;
 				this.#observeDialogs();
 				if (payload.dialogs) this.#applyDialogPolicy(payload.dialogs);
+				if (payload.url) {
+					await this.#page.goto(payload.url, {
+						// Same default as the headless arm: dev servers with HMR/WS never reach networkidle.
+						waitUntil: payload.waitUntil ?? "load",
+						timeout: payload.timeoutMs,
+					});
+				}
 			}
 			this.#targetId = await targetIdForPage(this.#page);
 			this.#transport.send({ type: "ready", info: await this.#currentReadyInfo() });
@@ -1521,11 +1547,15 @@ export class WorkerCore {
 		const page = this.#requirePage();
 		// Multiple tabs can share one Chromium (sibling headless tabs on a shared
 		// endpoint, cdp/app attach). CDP `Page.captureScreenshot` reads the
-		// compositor surface, which follows the *active* target — a backgrounded
+		// compositor surface, which follows the *active* target: a backgrounded
 		// page can stall waiting for a fresh frame (the 20s screenshot timeouts)
 		// or hand back a sibling tab's pixels. Activate first; best-effort so an
 		// already-active or freshly-closed target never fails the capture.
-		await untilAborted(signal, () => page.bringToFront()).catch(() => undefined);
+		//
+		// For a user-driven browser, redundant activation would steal window focus.
+		// The supervisor disables it only after adopting the visible tab; if the user
+		// later switches away, reject capture rather than risk sibling-tab pixels.
+		await preparePageForScreenshot(page, signal, this.#activateForScreenshot);
 		const fullPage = opts.selector ? false : (opts.fullPage ?? false);
 		const captureType = "png";
 		const captureMime = "image/png" as const;

package/src/tools/output-meta.ts

@@ -458,6 +458,9 @@ export function formatTruncationMetaNotice(truncation: TruncationMeta): string {
 		} else {
 			notice = `Showing ${truncation.outputLines} of ${totalLines} lines; middle elided`;
 		}
+		if (truncation.nextOffset != null) {
+			notice += `. Use :${truncation.nextOffset} to continue`;
+		}
 		if (truncation.artifactId != null) {
 			notice += `. ${formatFullOutputReference(truncation.artifactId)}`;
 		}
@@ -674,13 +677,23 @@ async function spillLargeResultToArtifact(
 ): Promise<AgentToolResult> {
 	const sessionManager = context?.sessionManager;
 	if (!sessionManager) return result;
-	if (toolName === "read") return result;
 	const { threshold, tailBytes, tailLines, headBytes } = getSpillConfig(context?.settings);
 
 	// Skip if tool already saved an artifact
 	const existingMeta: OutputMeta | undefined = result.details?.meta;
 	if (existingMeta?.truncation?.artifactId) return result;
 
+	// Reading an artifact already addresses recoverable full output. Spilling that
+	// read would only create a redundant artifact containing another artifact's
+	// page (and can repeat indefinitely on subsequent reads).
+	if (
+		toolName === "read" &&
+		existingMeta?.source?.type === "internal" &&
+		existingMeta.source.value.startsWith("artifact://")
+	) {
+		return result;
+	}
+
 	// Measure total text content
 	const textParts: string[] = [];
 	for (const block of result.content) {
@@ -760,6 +773,7 @@ async function spillLargeResultToArtifact(
 			elidedLines,
 			elidedBytes,
 			artifactId,
+			nextOffset: existingMeta?.truncation?.nextOffset,
 		};
 	} else {
 		const shownStart = truncated.totalLines - outputLines + 1;
@@ -773,6 +787,7 @@ async function spillLargeResultToArtifact(
 			maxBytes: tailBytes,
 			shownRange: { start: shownStart, end: truncated.totalLines },
 			artifactId,
+			nextOffset: existingMeta?.truncation?.nextOffset,
 		};
 	}
 

package/src/tools/shell-tokenize.ts

@@ -81,3 +81,104 @@ export function tokenizeShellSegments(command: string): string[][] {
 	pushSegment();
 	return segments;
 }
+
+/**
+ * Returns the original text of flat shell command segments. Unlike
+ * `tokenizeShellSegments`, this preserves quoting and escaping so the results
+ * are safe to match against user-configured regular expressions.
+ *
+ * The extractor deliberately declines to split syntax whose execution context
+ * cannot be determined with this small scanner (heredocs, command substitution,
+ * backticks, grouping, and malformed quoting). Callers must still check the
+ * complete input in that case.
+ */
+export function extractFlatShellCommandSegments(command: string): string[] {
+	const segments: string[] = [];
+	let segmentStart = 0;
+	let inSingle = false;
+	let inDouble = false;
+	let atWordStart = true;
+
+	const pushSegment = (end: number) => {
+		const segment = command.slice(segmentStart, end).trim();
+		if (segment.length > 0) segments.push(segment);
+	};
+
+	for (let i = 0; i < command.length; i++) {
+		const ch = command[i];
+		if (inSingle) {
+			if (ch === "'") inSingle = false;
+			continue;
+		}
+		if (inDouble) {
+			if (ch === "\\") {
+				if (i + 1 >= command.length) return [];
+				i++;
+				continue;
+			}
+			if (ch === '"') {
+				inDouble = false;
+				continue;
+			}
+			if (ch === "`" || (ch === "$" && command[i + 1] === "(")) return [];
+			continue;
+		}
+
+		if (ch === "'") {
+			inSingle = true;
+			atWordStart = false;
+			continue;
+		}
+		if (ch === '"') {
+			inDouble = true;
+			atWordStart = false;
+			continue;
+		}
+		if (ch === "\\") {
+			if (i + 1 >= command.length) return [];
+			i++;
+			atWordStart = false;
+			continue;
+		}
+		if (
+			ch === "`" ||
+			ch === "(" ||
+			ch === ")" ||
+			(ch === "$" && command[i + 1] === "(") ||
+			(ch === "$" && command[i + 1] === "{") ||
+			(ch === "<" && command[i + 1] === "<") ||
+			((ch === "{" || ch === "}") &&
+				atWordStart &&
+				(command[i + 1] === undefined || /[ \t\n;]/.test(command[i + 1])))
+		) {
+			return [];
+		}
+		if (ch === "#" && atWordStart) {
+			pushSegment(i);
+			const newline = command.indexOf("\n", i + 1);
+			if (newline === -1) return segments;
+			i = newline;
+			segmentStart = newline + 1;
+			atWordStart = true;
+			continue;
+		}
+		const isRedirectionOperatorCharacter =
+			ch === "|"
+				? command[i - 1] === ">"
+				: ch === "&"
+					? command[i - 1] === ">" || command[i - 1] === "<" || command[i + 1] === ">"
+					: false;
+		if ((ch === "\n" || ch === ";" || ch === "|" || ch === "&") && !isRedirectionOperatorCharacter) {
+			pushSegment(i);
+			if ((ch === "|" || ch === "&") && command[i + 1] === ch) i++;
+			segmentStart = i + 1;
+			atWordStart = true;
+			continue;
+		}
+		atWordStart = ch === " " || ch === "\t";
+	}
+
+	if (inSingle || inDouble) return [];
+	pushSegment(command.length);
+	return segments;
+}

package/src/utils/image-loading.ts

@@ -80,14 +80,19 @@ export class ImageInputTooLargeError extends Error {
 	}
 }
 
+/** Converts an image to PNG, rejecting when the runtime cannot decode or encode it. */
+export async function convertImageToPng(image: ImageContent): Promise<ImageContent> {
+	const bytes = Buffer.from(image.data, "base64");
+	const data = await new Bun.Image(bytes).png().toBase64();
+	return { ...image, data, mimeType: "image/png" };
+}
+
 export async function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null> {
 	if (SUPPORTED_INPUT_IMAGE_MIME_TYPES.has(image.mimeType)) {
 		return image;
 	}
 	try {
-		const bytes = Buffer.from(image.data, "base64");
-		const data = await new Bun.Image(bytes).png().toBase64();
-		return { type: "image", data, mimeType: "image/png" };
+		return await convertImageToPng(image);
 	} catch {
 		return null;
 	}

package/src/utils/shell-snapshot.ts

@@ -230,32 +230,42 @@ export async function getOrCreateSnapshot(
 
 	const rcFile = getShellConfigFile(shell, env);
 
-	// Create snapshot directory with owner-only perms — the script may inline
-	// env vars referenced by captured functions (#3470) and `os.tmpdir()` is
-	// shared on Linux. `mode: 0o700` applies to a fresh mkdir; an existing dir
-	// keeps its mode, so chmod it defensively. Ignore EPERM (dir owned by
-	// another user on a shared box).
-	const snapshotDir = path.join(os.tmpdir(), "omp-shell-snapshots");
-	fs.mkdirSync(snapshotDir, { recursive: true, mode: 0o700 });
-	try {
-		fs.chmodSync(snapshotDir, 0o700);
-	} catch {
-		// best-effort
-	}
+	// Snapshot dir is per-uid. `os.tmpdir()` is shared between accounts on Linux and
+	// this dir is 0700 because the script may inline env-var values referenced by
+	// captured functions (#3470), so a single shared name hands the first account an
+	// exclusive dir and every other account's pre-create write below fails with
+	// EACCES — which used to escape into `executeBash` and break every bash call.
+	const uid = process.getuid?.();
+	const snapshotDir = path.join(os.tmpdir(), uid === undefined ? "omp-shell-snapshots" : `omp-shell-snapshots-${uid}`);
 
 	// Generate unique snapshot path
 	const shellName = shell.includes("zsh") ? "zsh" : shell.includes("bash") ? "bash" : "sh";
 	const snapshotPath = path.join(snapshotDir, `snapshot-${shellName}-${crypto.randomUUID()}.sh`);
 
-	// Pre-create the snapshot file at 0600 so the shell's `>|` (truncate) and
-	// `>>` (append) redirections inside `generateSnapshotScript` operate on an
-	// existing inode and preserve the private mode, regardless of the umask
-	// state inside the spawned shell. Without this, a `.bashrc` that sets
-	// `umask 022` (the typical interactive default) before the script's first
-	// redirection would create the file world-readable; the JS-side post-spawn
-	// chmod would tighten it, but only after the shell finished writing every
-	// captured env value to disk.
-	fs.writeFileSync(snapshotPath, "", { mode: 0o600 });
+	try {
+		fs.mkdirSync(snapshotDir, { recursive: true, mode: 0o700 });
+		// `mode` only applies to a fresh mkdir; an existing dir keeps its mode, so
+		// chmod it defensively. Ignore EPERM (dir owned by another account).
+		try {
+			fs.chmodSync(snapshotDir, 0o700);
+		} catch {
+			// best-effort
+		}
+		// Pre-create the snapshot file at 0600 so the shell's `>|` (truncate) and
+		// `>>` (append) redirections inside `generateSnapshotScript` operate on an
+		// existing inode and preserve the private mode, regardless of the umask
+		// state inside the spawned shell. Without this, a `.bashrc` that sets
+		// `umask 022` (the typical interactive default) before the script's first
+		// redirection would create the file world-readable; the JS-side post-spawn
+		// chmod would tighten it, but only after the shell finished writing every
+		// captured env value to disk.
+		fs.writeFileSync(snapshotPath, "", { mode: 0o600 });
+	} catch (err) {
+		// Unusable snapshot dir (foreign owner, read-only or full /tmp): run without
+		// a snapshot instead of failing the caller's command.
+		logger.debug("shell-snapshot: snapshot dir unusable", { dir: snapshotDir, err: String(err) });
+		return null;
+	}
 
 	// Generate and execute snapshot script
 	const script = generateSnapshotScript(shell, snapshotPath, rcFile);