@oh-my-pi/pi-coding-agent 16.1.7 → 16.1.9

package/src/tools/puppeteer/12_stealth_codecs.txt

@@ -15,25 +15,27 @@ const parseInput = (arg) => {
 };
 
 const originalCanPlayType = HTMLMediaElement.prototype.canPlayType;
+const proxiedCanPlayType = new Window_Proxy(originalCanPlayType, {
+	apply(target, ctx, args) {
+		if (!args || !args.length) {
+			return Reflect_apply(target, ctx, args);
+		}
+		const { mime, codecs } = parseInput(args[0]);
+		if (mime === "video/mp4" && codecs.includes("avc1.42E01E")) {
+			return "probably";
+		}
+		if (mime === "audio/x-m4a" && !codecs.length) {
+			return "maybe";
+		}
+		if (mime === "audio/aac" && !codecs.length) {
+			return "probably";
+		}
+		return Reflect_apply(target, ctx, args);
+	},
+});
+patchToString(proxiedCanPlayType, "canPlayType");
 Object_defineProperty(HTMLMediaElement.prototype, "canPlayType", {
-	value: new Window_Proxy(originalCanPlayType, {
-		apply(target, ctx, args) {
-			if (!args || !args.length) {
-				return Reflect_apply(target, ctx, args);
-			}
-			const { mime, codecs } = parseInput(args[0]);
-			if (mime === "video/mp4" && codecs.includes("avc1.42E01E")) {
-				return "probably";
-			}
-			if (mime === "audio/x-m4a" && !codecs.length) {
-				return "maybe";
-			}
-			if (mime === "audio/aac" && !codecs.length) {
-				return "probably";
-			}
-				return Reflect_apply(target, ctx, args);
-		},
-	}),
+	value: proxiedCanPlayType,
 	writable: true,
 	configurable: true,
 	enumerable: true,

package/src/tools/puppeteer/13_stealth_worker.txt

@@ -1,52 +1,214 @@
 const patchWorkerConstructor = (name, OriginalWorker) => {
 	if (typeof OriginalWorker !== "function") return;
 
-	const buildWrappedUrl = (scriptURL, options) => {
-		const ua = navigator.userAgent;
-		const platform = navigator.platform;
-		const uaData = navigator.userAgentData && typeof navigator.userAgentData.toJSON === "function"
-			? navigator.userAgentData.toJSON()
-			: navigator.userAgentData;
-
-		const preludeLines = [
-			"try {",
-			`const ua = ${JSON.stringify(ua)};`,
-			`const platform = ${JSON.stringify(platform)};`,
-			"Object_defineProperty(self.navigator, 'userAgent', { get: () => ua, configurable: true });",
-			"Object_defineProperty(self.navigator, 'platform', { get: () => platform, configurable: true });",
-		];
-
-		if (uaData) {
-			preludeLines.push(`const uaData = ${JSON.stringify(uaData)};`);
-			preludeLines.push(
-				"Object_defineProperty(self.navigator, 'userAgentData', { get: () => uaData, configurable: true });",
-			);
+	const windowDescriptor = Object_getOwnPropertyDescriptor(window, name);
+	if (windowDescriptor && windowDescriptor.configurable === false) return;
+
+	const NativeURL = window.URL;
+	const URL_createObjectURL = NativeURL && NativeURL.createObjectURL;
+	const URL_revokeObjectURL = NativeURL && NativeURL.revokeObjectURL;
+	if (
+		typeof NativeURL !== "function" ||
+		typeof URL_createObjectURL !== "function" ||
+		typeof URL_revokeObjectURL !== "function"
+	) {
+		return;
+	}
+
+	const sharedWorkerUrls = name === "SharedWorker" ? new Map() : undefined;
+
+	const revokeUrl = (url) => {
+		try {
+			Reflect_apply(URL_revokeObjectURL, NativeURL, [url]);
+		} catch {}
+	};
+
+	const scheduleWorkerUrlRevoke = (worker, url) => {
+		let revoked = false;
+		const revokeOnce = () => {
+			if (revoked) return;
+			revoked = true;
+			revokeUrl(url);
+		};
+		try {
+			if (typeof worker.addEventListener === "function") {
+				Reflect_apply(worker.addEventListener, worker, ["error", revokeOnce, { once: true }]);
+			}
+		} catch {}
+		Window_setTimeout(revokeOnce, 1000);
+	};
+
+	if (sharedWorkerUrls) {
+		try {
+			window.addEventListener("pagehide", (event) => {
+				if (event && event.persisted) return;
+				for (const url of sharedWorkerUrls.values()) {
+					revokeUrl(url);
+				}
+				sharedWorkerUrls.clear();
+			});
+		} catch {}
+	}
+
+	const canWrapArguments = (args) => {
+		if (!args || args.length !== 1) {
+			return name === "SharedWorker" && args && args.length === 2 && typeof args[1] === "string";
+		}
+		return true;
+	};
+
+	const resolveWorkerUrl = (scriptURL) => {
+		const baseUrl = document.baseURI || window.location.href;
+		const scriptUrlString =
+			typeof scriptURL === "string"
+				? scriptURL
+				: scriptURL instanceof NativeURL
+					? scriptURL.href
+					: undefined;
+		if (scriptUrlString === undefined) return undefined;
+		let absoluteUrl;
+		try {
+			absoluteUrl = new NativeURL(scriptUrlString, baseUrl);
+		} catch {
+			return undefined;
+		}
+		if (absoluteUrl.origin !== window.location.origin) return undefined;
+		if (absoluteUrl.protocol !== "http:" && absoluteUrl.protocol !== "https:") return undefined;
+		if (absoluteUrl.username || absoluteUrl.password) return undefined;
+		return absoluteUrl.href;
+	};
+
+	const buildWorkerPrelude = () => {
+		const values = [];
+		const addNavigatorString = (prop) => {
+			try {
+				const value = navigator[prop];
+				if (typeof value === "string") values.push([prop, value]);
+			} catch {}
+		};
+		addNavigatorString("userAgent");
+		addNavigatorString("platform");
+		if (!values.length) return "";
+
+		return `(() => {
+	try {
+		const values = ${JSON.stringify(values)};
+		const nav = self.navigator;
+		if (!nav) return;
+		const defineProperty = Object.defineProperty;
+		const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+		const getPrototypeOf = Object.getPrototypeOf;
+		const Reflect_apply = Reflect.apply;
+		const nativeFunctionToString = Function.prototype.toString;
+		const nativeSources = new WeakMap();
+		const WeakMap_get = WeakMap.prototype.get;
+		const WeakMap_has = WeakMap.prototype.has;
+		const WeakMap_set = WeakMap.prototype.set;
+		const rememberNative = (fn, source) => {
+			if (typeof fn === "function") Reflect_apply(WeakMap_set, nativeSources, [fn, source]);
+			return fn;
+		};
+		const findDescriptor = (prop) => {
+			let owner = nav;
+			while (owner) {
+				const descriptor = getOwnPropertyDescriptor(owner, prop);
+				if (descriptor) return [owner, descriptor];
+				owner = getPrototypeOf(owner);
+			}
+			return [getPrototypeOf(nav) || nav, undefined];
+		};
+		let patched = false;
+		for (let i = 0; i < values.length; i += 1) {
+			const prop = values[i][0];
+			const value = values[i][1];
+			try {
+				if (nav[prop] === value) continue;
+			} catch (_) {}
+			const found = findDescriptor(prop);
+			const owner = found[0];
+			const descriptor = found[1];
+			if (!owner || (descriptor && descriptor.configurable === false)) continue;
+			const getterDescriptor = getOwnPropertyDescriptor({ get [prop]() { return value; } }, prop);
+			const getter = getterDescriptor && getterDescriptor.get;
+			if (typeof getter !== "function") continue;
+			rememberNative(getter, "function get " + prop + "() { [native code] }");
+			defineProperty(owner, prop, {
+				get: getter,
+				enumerable: descriptor ? descriptor.enumerable : true,
+				configurable: true,
+			});
+			patched = true;
 		}
+		if (!patched) return;
+		const toStringDescriptor = getOwnPropertyDescriptor(Function.prototype, "toString");
+		if (toStringDescriptor && toStringDescriptor.configurable === false) return;
+		const functionToString = new Proxy(nativeFunctionToString, {
+			apply(target, thisArg, args) {
+				if (Reflect_apply(WeakMap_has, nativeSources, [thisArg])) return Reflect_apply(WeakMap_get, nativeSources, [thisArg]);
+				return Reflect_apply(target, thisArg, args);
+			},
+		});
+		rememberNative(functionToString, "function toString() { [native code] }");
+		defineProperty(Function.prototype, "toString", {
+			value: functionToString,
+			writable: toStringDescriptor ? toStringDescriptor.writable : true,
+			configurable: toStringDescriptor ? toStringDescriptor.configurable : true,
+			enumerable: toStringDescriptor ? toStringDescriptor.enumerable : false,
+		});
+	} catch (_) {}
+})();`;
+	};
 
-		preludeLines.push("} catch (e) {};");
-		const prelude = preludeLines.join("\n");
-		const importLine = options?.type === "module"
-			? `import ${JSON.stringify(String(scriptURL))};`
-			: `importScripts(${JSON.stringify(String(scriptURL))});`;
-		const blob = new Window_Blob([prelude, "\n", importLine], { type: "application/javascript" });
-		const url = URL.createObjectURL(blob);
-		return url;
+	const buildWrappedUrl = (scriptURL) => {
+		const originalUrl = resolveWorkerUrl(scriptURL);
+		if (!originalUrl) return undefined;
+		if (sharedWorkerUrls) {
+			const cachedUrl = sharedWorkerUrls.get(originalUrl);
+			if (cachedUrl) return { url: cachedUrl, cacheKey: originalUrl };
+		}
+
+		const prelude = buildWorkerPrelude();
+		if (!prelude) return undefined;
+
+		try {
+			const blob = new Window_Blob(
+				[prelude, "\n", `importScripts(${JSON.stringify(originalUrl)});`],
+				{ type: "application/javascript" },
+			);
+			const url = Reflect_apply(URL_createObjectURL, NativeURL, [blob]);
+			if (sharedWorkerUrls) sharedWorkerUrls.set(originalUrl, url);
+			return { url, cacheKey: sharedWorkerUrls ? originalUrl : undefined };
+		} catch {
+			return undefined;
+		}
 	};
 
 	const handler = {
-		construct(target, args) {
+		construct(target, args, newTarget) {
+			if (!canWrapArguments(args)) {
+				return Reflect_construct(target, args || [], newTarget);
+			}
+
+			const wrapped = buildWrappedUrl(args[0]);
+			if (!wrapped) {
+				return Reflect_construct(target, args || [], newTarget);
+			}
+
+			const wrappedArgs = [wrapped.url];
+			for (let i = 1; i < args.length; i += 1) {
+				wrappedArgs[i] = args[i];
+			}
+
 			try {
-				const scriptURL = args?.[0];
-				const options = args?.[1];
-				if (!scriptURL) {
-					return new target(...(args || []));
+				const worker = Reflect_construct(target, wrappedArgs, newTarget);
+				if (!sharedWorkerUrls) {
+					scheduleWorkerUrlRevoke(worker, wrapped.url);
 				}
-				const wrappedUrl = buildWrappedUrl(scriptURL, options);
-				const worker = new target(wrappedUrl, options);
-				URL.revokeObjectURL(wrappedUrl);
 				return worker;
 			} catch {
-				return new target(...(args || []));
+				if (wrapped.cacheKey && sharedWorkerUrls) sharedWorkerUrls.delete(wrapped.cacheKey);
+				revokeUrl(wrapped.url);
+				return Reflect_construct(target, args || [], newTarget);
 			}
 		},
 		apply(target, thisArg, args) {
@@ -55,16 +217,15 @@ const patchWorkerConstructor = (name, OriginalWorker) => {
 	};
 
 	const proxied = new Window_Proxy(OriginalWorker, handler);
+	patchToString(proxied, name);
 	Object_defineProperty(window, name, {
 		value: proxied,
-		writable: true,
-		configurable: true,
-	});
-	Object_defineProperty(window[name], "toString", {
-		value: Function_toString.bind(OriginalWorker),
-		writable: false,
-		configurable: true,
-		enumerable: false,
+		writable:
+			windowDescriptor && "writable" in windowDescriptor
+				? windowDescriptor.writable
+				: true,
+		configurable: windowDescriptor ? windowDescriptor.configurable : true,
+		enumerable: windowDescriptor ? windowDescriptor.enumerable : false,
 	});
 };
 

package/src/tools/search.ts

@@ -278,6 +278,15 @@ interface InternalSearchInputResolution {
 	virtualScopePath?: string;
 }
 
+function isImmutableSourcePath(filePath: string, immutableSourcePaths: ReadonlySet<string>): boolean {
+	for (const immutablePath of immutableSourcePaths) {
+		if (filePath === immutablePath || filePath.startsWith(`${immutablePath}${path.sep}`)) {
+			return true;
+		}
+	}
+	return false;
+}
+
 interface IndexedContentLines {
 	lines: string[];
 	starts: number[];
@@ -1131,7 +1140,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					for (const relativePath of fileList) {
 						if (archiveDisplaySet.has(relativePath) || virtualPathSet.has(relativePath)) continue;
 						const absoluteFilePath = path.resolve(this.session.cwd, relativePath);
-						if (immutableSourcePaths.has(absoluteFilePath)) continue;
+						if (isImmutableSourcePath(absoluteFilePath, immutableSourcePaths)) continue;
 						// Mint a whole-file content tag so any anchor validates while the
 						// file is unchanged; over-cap / unreadable files get no tag (and
 						// therefore plain, non-editable line output).

package/src/tools/sqlite-reader.ts

@@ -21,7 +21,19 @@ const MAX_QUERY_LIMIT = 500;
 export const MAX_RAW_QUERY_ROWS = 1000;
 const MAX_RENDER_WIDTH = 120;
 const MAX_COLUMN_WIDTH = 40;
-const MIN_COLUMN_WIDTH = 1;
+/**
+ * Floor for each ASCII-table column. At width 2 (or 1) every multi-char cell
+ * collapses to a lone ellipsis, so the renderer keeps each column wide enough
+ * to show at least one real glyph alongside the ellipsis (e.g. `Fo…`). When a
+ * row has too many columns to honor this floor inside `MAX_RENDER_WIDTH`,
+ * `buildAsciiTable` falls back to per-row vertical blocks via
+ * {@link buildVerticalBlocks} — issue #3107.
+ */
+const MIN_COLUMN_WIDTH = 3;
+/** Separator overhead per column in the ASCII table (`" | "`). */
+const COLUMN_SEPARATOR_WIDTH = 3;
+/** Constant frame overhead added once to every row (leading `"|"` + trailing `" |"` after the per-column accounting). */
+const TABLE_FRAME_WIDTH = 1;
 /**
  * Upper bound on rows scanned when counting a table for the listing. SQLite has
  * no stored row count, so `COUNT(*)` is a full b-tree scan — multi-second on a
@@ -142,10 +154,53 @@ function padCell(value: string, width: number): string {
 	return `${truncated}${" ".repeat(width - visibleWidth)}`;
 }
 
+/**
+ * Width budget the ASCII layout needs at the floor (each column at
+ * `MIN_COLUMN_WIDTH`). When this exceeds `MAX_RENDER_WIDTH`, no choice of
+ * per-column widths can fit the header inside the budget — every cell is then
+ * forced down to width 1 by the shrink loop, rendering as a lone ellipsis, and
+ * the right edge is still chopped by the final per-line truncation (#3107).
+ */
+function tableFitsAtMinimum(columnCount: number): boolean {
+	return MIN_COLUMN_WIDTH * columnCount + COLUMN_SEPARATOR_WIDTH * columnCount + TABLE_FRAME_WIDTH <= MAX_RENDER_WIDTH;
+}
+
+/**
+ * Vertical fallback used when a table has too many columns to fit horizontally
+ * (>19 at the default 120-cell budget). Each row becomes a labelled block of
+ * `column: value` lines, mirroring `psql`'s expanded display mode. Column
+ * names are right-padded so colons align; the value is left raw and the whole
+ * line is truncated at `MAX_RENDER_WIDTH`.
+ */
+function buildVerticalBlocks(columns: string[], rows: SqliteRow[]): string {
+	if (rows.length === 0) {
+		return "(no rows)";
+	}
+	let nameWidth = MIN_COLUMN_WIDTH;
+	for (const column of columns) {
+		nameWidth = Math.max(nameWidth, Bun.stringWidth(sanitizeCell(column)));
+	}
+	nameWidth = Math.min(MAX_COLUMN_WIDTH, nameWidth);
+	return rows
+		.map((row, index) => {
+			const block = [`── Row ${index + 1} ──`];
+			for (const column of columns) {
+				const name = padCell(column, nameWidth);
+				const value = sanitizeCell(stringifySqliteValue(row[column]));
+				block.push(truncateToWidth(`${name}: ${value}`, MAX_RENDER_WIDTH));
+			}
+			return block.join("\n");
+		})
+		.join("\n\n");
+}
+
 function buildAsciiTable(columns: string[], rows: SqliteRow[]): string {
 	if (columns.length === 0) {
 		return rows.length === 0 ? "(no rows)" : "(rows returned without named columns)";
 	}
+	if (!tableFitsAtMinimum(columns.length)) {
+		return buildVerticalBlocks(columns, rows);
+	}
 
 	const widths = columns.map(column =>
 		Math.max(MIN_COLUMN_WIDTH, Math.min(MAX_COLUMN_WIDTH, Bun.stringWidth(sanitizeCell(column)))),
@@ -157,7 +212,8 @@ function buildAsciiTable(columns: string[], rows: SqliteRow[]): string {
 		}
 	}
 
-	let totalWidth = widths.reduce((sum, width) => sum + width, 0) + columns.length * 3 + 1;
+	const overhead = columns.length * COLUMN_SEPARATOR_WIDTH + TABLE_FRAME_WIDTH;
+	let totalWidth = widths.reduce((sum, width) => sum + width, 0) + overhead;
 	while (totalWidth > MAX_RENDER_WIDTH) {
 		let widestIndex = -1;
 		let widestWidth = MIN_COLUMN_WIDTH;
@@ -169,7 +225,7 @@ function buildAsciiTable(columns: string[], rows: SqliteRow[]): string {
 		}
 		if (widestIndex === -1) break;
 		widths[widestIndex] = Math.max(MIN_COLUMN_WIDTH, (widths[widestIndex] ?? MIN_COLUMN_WIDTH) - 1);
-		totalWidth = widths.reduce((sum, width) => sum + width, 0) + columns.length * 3 + 1;
+		totalWidth = widths.reduce((sum, width) => sum + width, 0) + overhead;
 	}
 
 	const header = `| ${columns.map((column, index) => padCell(column, widths[index] ?? MIN_COLUMN_WIDTH)).join(" | ")} |`;

package/src/tools/todo.ts

@@ -11,6 +11,7 @@ import todoDescription from "../prompts/tools/todo.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import type { SessionEntry } from "../session/session-entries";
 import { framedBlock, renderStatusLine, renderTreeList } from "../tui";
+import { normalizePathLikeInput, resolveToCwd } from "./path-utils";
 import { formatErrorDetail, PREVIEW_LIMITS } from "./render-utils";
 
 // =============================================================================
@@ -428,6 +429,11 @@ const STATUS_TO_MARKER: Record<TodoStatus, string> = {
 	abandoned: "-",
 };
 
+export function resolveTodoMarkdownPath(input: string, cwd: string): string {
+	const raw = normalizePathLikeInput(input) || "TODO.md";
+	return resolveToCwd(raw, cwd);
+}
+
 /** Render todo phases as a Markdown checklist suitable for editing/copying. */
 export function phasesToMarkdown(phases: TodoPhase[]): string {
 	if (phases.length === 0) return "# Todos\n";

package/src/tools/write.ts

@@ -1068,14 +1068,12 @@ export const writeToolRenderer = {
 		const lang = getLanguageFromPath(rawPath) ?? "text";
 		const langIcon = uiTheme.fg("muted", uiTheme.getLangIcon(lang));
 		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
-		// Static pending icon, never the animated glyph: the header is the head
-		// row of the framed block, and native-scrollback commits are prefix-only
-		// — an animating head row would pin the commit boundary at the top and
-		// keep a tall expanded preview from scroll-appending mid-stream. The
-		// liveness cue rides the trailing "(streaming)" line instead.
+		// No status icon on the head row: it's the head of the framed block, and
+		// native-scrollback commits are prefix-only — an animated glyph would pin
+		// the commit boundary at the top, and the pending hourglass just adds
+		// noise. The liveness cue rides the trailing "(streaming)" line instead.
 		const header = renderStatusLine(
 			{
-				icon: "pending",
 				title: "Write",
 				description: `${langIcon} ${pathDisplay}`,
 			},

package/src/utils/thinking-display.ts

@@ -9,3 +9,81 @@ export function canonicalizeMessage(text: string | null | undefined): string {
 	}
 	return "";
 }
+
+export function formatThinkingForDisplay(text: string, proseOnly: boolean): string {
+	if (!proseOnly || !text) return text;
+
+	const lines = text.split("\n");
+	const resultLines: string[] = [];
+	let inFence = false;
+	let fenceChar = "";
+	let fenceLen = 0;
+
+	const FENCE = /^( {0,3})([`~]{3,})/;
+	const appendEllipsis = () => {
+		let lastLineIdx = resultLines.length - 1;
+		while (lastLineIdx >= 0 && resultLines[lastLineIdx]!.trim() === "") {
+			lastLineIdx--;
+		}
+
+		if (lastLineIdx >= 0) {
+			const lastLine = resultLines[lastLineIdx]!;
+			const trimmed = lastLine.trimEnd();
+			if (trimmed.endsWith("...")) {
+				resultLines[lastLineIdx] = trimmed;
+			} else if (trimmed.endsWith(".")) {
+				resultLines[lastLineIdx] = `${trimmed.slice(0, -1)}...`;
+			} else {
+				resultLines[lastLineIdx] = `${trimmed}...`;
+			}
+		} else {
+			resultLines.push("...");
+		}
+	};
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i]!;
+		const open = FENCE.exec(line);
+
+		if (inFence) {
+			// A closing fence is the same char, at least as long, with nothing else on the line.
+			if (
+				open &&
+				open[2]![0] === fenceChar &&
+				open[2]!.length >= fenceLen &&
+				line.slice(open[1]!.length + open[2]!.length).trim() === ""
+			) {
+				inFence = false;
+				fenceChar = "";
+				fenceLen = 0;
+			}
+			// We skip all internal lines of a code fence.
+		} else if (open) {
+			const marker = open[2]!;
+			const ch = marker[0]!;
+			// A backtick fence's info string may not contain a backtick.
+			if (!(ch === "`" && line.slice(open[1]!.length + marker.length).includes("`"))) {
+				inFence = true;
+				fenceChar = ch;
+				fenceLen = marker.length;
+				appendEllipsis();
+			} else {
+				resultLines.push(line);
+			}
+		} else {
+			resultLines.push(line);
+		}
+	}
+
+	const formatted = resultLines.join("\n");
+	return formatted;
+}
+
+export function hasDisplayableThinking(
+	text: string | null | undefined,
+	formattedText: string | null | undefined,
+): boolean {
+	if (!text) return false;
+	if (!formattedText) return false;
+	return formattedText.length > 0 && canonicalizeMessage(text).length > 0;
+}