@oh-my-pi/pi-coding-agent 17.3.7 → 17.3.8

package/src/utils/git.ts

@@ -21,6 +21,8 @@ export interface GitCommandResult {
 	exitCode: number;
 	stdout: string;
 	stderr: string;
+	/** True when stdout or stderr hit {@link GIT_COMMAND_OUTPUT_LIMIT_BYTES} and the captured text is incomplete. */
+	truncated: boolean;
 }
 
 export interface GitRepository {
@@ -66,6 +68,7 @@ export interface DiffOptions {
 	readonly numstat?: boolean;
 	readonly signal?: AbortSignal;
 	readonly stat?: boolean;
+	readonly requireComplete?: boolean;
 }
 
 export interface StatusOptions {
@@ -173,6 +176,29 @@ export class GitCommandError extends Error {
 	}
 }
 
+/**
+ * A git subprocess produced more output than {@link GIT_COMMAND_OUTPUT_LIMIT_BYTES}
+ * and its captured stdout was truncated. Thrown only for callers that opt into
+ * completeness via `diff({ requireComplete: true })`, where operating on a partial
+ * diff would silently corrupt downstream parsing — e.g. the split-commit builder,
+ * which would otherwise throw a misleading "No diff found" for files sorting after
+ * a large binary blob whose base85 payload pushed the diff past the cap.
+ */
+export class GitOutputTruncatedError extends Error {
+	readonly args: readonly string[];
+	readonly result: GitCommandResult;
+
+	constructor(args: readonly string[], result: GitCommandResult) {
+		const limitMiB = Math.round(GIT_COMMAND_OUTPUT_LIMIT_BYTES / (1024 * 1024));
+		super(
+			`git ${args.join(" ")} produced more than ${limitMiB} MiB of output; the captured result is truncated and incomplete.`,
+		);
+		this.name = "GitOutputTruncatedError";
+		this.args = [...args];
+		this.result = result;
+	}
+}
+
 // ════════════════════════════════════════════════════════════════════════════
 // Internal: Core execution
 // ════════════════════════════════════════════════════════════════════════════
@@ -312,7 +338,10 @@ async function waitForExitWithTimeout(
 	}
 }
 
-async function readCappedText(stream: ReadableStream<Uint8Array>, maxBytes: number): Promise<string> {
+async function readCappedText(
+	stream: ReadableStream<Uint8Array>,
+	maxBytes: number,
+): Promise<{ text: string; truncated: boolean }> {
 	const reader = stream.getReader();
 	const decoder = new TextDecoder();
 	const chunks: string[] = [];
@@ -335,7 +364,7 @@ async function readCappedText(stream: ReadableStream<Uint8Array>, maxBytes: numb
 		}
 		chunks.push(decoder.decode());
 		if (truncated) chunks.push(GIT_OUTPUT_TRUNCATED_MARKER);
-		return chunks.join("");
+		return { text: chunks.join(""), truncated };
 	} finally {
 		reader.releaseLock();
 	}
@@ -372,10 +401,15 @@ async function collectSubprocessResult(
 		void stdoutPromise.catch(() => undefined);
 		void stderrPromise.catch(() => undefined);
 		await Promise.all([cancelOutput(stdoutStream), cancelOutput(stderrStream)]);
-		return { exitCode: GIT_COMMAND_TIMEOUT_EXIT_CODE, stdout: "", stderr: exit.stderr };
+		return { exitCode: GIT_COMMAND_TIMEOUT_EXIT_CODE, stdout: "", stderr: exit.stderr, truncated: false };
 	}
 	const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
-	return { exitCode: exit.exitCode ?? 0, stdout, stderr };
+	return {
+		exitCode: exit.exitCode ?? 0,
+		stdout: stdout.text,
+		stderr: stderr.text,
+		truncated: stdout.truncated || stderr.truncated,
+	};
 }
 
 interface CommandOptions {
@@ -496,7 +530,7 @@ async function git(cwd: string, args: readonly string[], options: CommandOptions
 			// A deleted/nonexistent cwd also surfaces as a spawn ENOENT; only blame
 			// the binary when the working directory actually exists.
 			const stderr = fs.existsSync(cwd) ? "git is not installed." : `working directory does not exist: ${cwd}`;
-			return { exitCode: GIT_SPAWN_ENOENT_EXIT_CODE, stdout: "", stderr };
+			return { exitCode: GIT_SPAWN_ENOENT_EXIT_CODE, stdout: "", stderr, truncated: false };
 		}
 		throw err;
 	}
@@ -1240,7 +1274,11 @@ export const diff = Object.assign(
 		if (options.allowFailure) {
 			return (await git(cwd, args, { env: options.env, readOnly: true, signal: options.signal })).stdout;
 		}
-		return runText(cwd, args, { env: options.env, readOnly: true, signal: options.signal });
+		const result = await runChecked(cwd, args, { env: options.env, readOnly: true, signal: options.signal });
+		if (options.requireComplete && result.truncated) {
+			throw new GitOutputTruncatedError(args, result);
+		}
+		return result.stdout;
 	},
 	{
 		/** List changed file paths. */
@@ -2005,12 +2043,17 @@ export const patch = {
 		}
 	},
 
-	/** Join patch parts into a single patch string. */
+	/**
+	 * Join patch parts into a single patch string.
+	 *
+	 * Each part is terminated with a single `\n` if it lacks one, then parts are
+	 * concatenated verbatim — matching git's native multi-file diff layout. Parts
+	 * are NOT separated by an extra blank line and trailing newlines are NOT
+	 * stripped: a `GIT binary patch` block ends in a blank line that
+	 * `git apply --binary` requires, and stripping it corrupts the patch (#8899).
+	 */
 	join(parts: string[]): string {
-		return `${parts
-			.map(part => (part.endsWith("\n") ? part : `${part}\n`))
-			.join("\n")
-			.replace(/\n+$/, "")}\n`;
+		return parts.map(part => (part.endsWith("\n") ? part : `${part}\n`)).join("");
 	},
 };
 

package/src/web/search/providers/browser-page.ts

@@ -34,6 +34,13 @@ export interface BrowserFetchOptions {
 	browser?: BrowserFallbackOptions;
 }
 
+/**
+ * Upper bound on `page.close()` during teardown. A dead CDP session leaves
+ * puppeteer's close pending forever; `.catch()` only covers rejection, not a
+ * hang, so cleanup needs its own deadline (issue #8865).
+ */
+const PAGE_CLOSE_TIMEOUT_MS = 5_000;
+
 async function fetchHtmlPage(url: string, options: BrowserFetchOptions, fetchImpl: FetchImpl): Promise<LoadedHtmlPage> {
 	const response = await fetchImpl(url, {
 		...options.init,
@@ -74,8 +81,14 @@ async function browseHtmlPage(
 	try {
 		const activePage = await untilAborted(signal, () => handle.browser.newPage());
 		page = activePage;
-		await applyViewport(activePage);
-		await applyStealthPatches(handle.browser, activePage, handle.stealth);
+		// Viewport and stealth setup talk to the same CDP session as the
+		// navigations below but were previously awaited raw. When the shared
+		// daemon or the page's target dies mid-setup, those puppeteer calls
+		// never settle and the provider promise hangs past
+		// SEARCH_HARD_TIMEOUT_MS — the abort signal had no listener at these
+		// await points (issue #8865).
+		await untilAborted(signal, () => applyViewport(activePage));
+		await untilAborted(signal, () => applyStealthPatches(handle.browser, activePage, handle.stealth));
 		if (homeUrl) {
 			await untilAborted(signal, () =>
 				activePage.goto(homeUrl, { waitUntil: "domcontentloaded", timeout: timeoutMs }),
@@ -102,7 +115,12 @@ async function browseHtmlPage(
 		}
 		throw new Error("Browser fallback exhausted without a response");
 	} finally {
-		await page?.close().catch(() => undefined);
+		// Teardown must complete even when the caller's signal already fired
+		// (navigating away from a dead session leaves `close()` pending), so
+		// bound it with a fresh deadline instead of reusing `signal`.
+		if (page) {
+			await untilAborted(AbortSignal.timeout(PAGE_CLOSE_TIMEOUT_MS), () => page!.close()).catch(() => undefined);
+		}
 		await releaseBrowser(handle, { kill: false });
 	}
 }

package/src/web/search/providers/tinyfish.ts

@@ -35,6 +35,10 @@ export interface TinyFishSearchParams {
 	page?: number;
 	include_domains?: string[];
 	exclude_domains?: string[];
+	/** ISO 3166-1 alpha-2 region, e.g. `IT`. Geolocates results. */
+	location?: string;
+	/** ISO 639-1 language, e.g. `it`. */
+	language?: string;
 	signal?: AbortSignal;
 	timeoutMs?: number;
 	fetch?: FetchImpl;
@@ -74,6 +78,12 @@ async function callTinyFishSearch(apiKey: string, params: TinyFishSearchParams):
 	if (params.exclude_domains?.length) {
 		url.searchParams.set("exclude_domains", params.exclude_domains.join(","));
 	}
+	if (params.location) {
+		url.searchParams.set("location", params.location);
+	}
+	if (params.language) {
+		url.searchParams.set("language", params.language);
+	}
 	if (params.num_results !== undefined) {
 		url.searchParams.set("num_results", String(params.num_results));
 	}
@@ -133,6 +143,19 @@ function siteHosts(sites: readonly string[]): string[] {
 	return [...hosts];
 }
 
+/**
+ * Derive TinyFish `location` (ISO 3166-1 alpha-2, uppercase) and `language`
+ * (ISO 639-1, lowercase) from a parsed `lang:` directive. The region subtag is
+ * optional: `lang:it` yields language only, `lang:it-it` yields both. Non-region
+ * subtags (e.g. the script in `zh-hans`) never become a location.
+ */
+function tinyFishLocale(lang: string | undefined): { location?: string; language?: string } {
+	if (!lang) return {};
+	const match = /^([a-z]{2})(?:[-_]([a-z]{2}))?(?:[-_]|$)/.exec(lang.toLowerCase());
+	if (!match) return {};
+	return { language: match[1], location: match[2]?.toUpperCase() };
+}
+
 /** Execute TinyFish web search. */
 export async function searchTinyFish(params: SearchParams): Promise<SearchResponse> {
 	const numResults = clampNumResults(params.numSearchResults ?? params.limit, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
@@ -152,6 +175,9 @@ export async function searchTinyFish(params: SearchParams): Promise<SearchRespon
 		if (includeDomains.length > 0) tinyFishParams.include_domains = includeDomains;
 		if (excludeDomains.length > 0) tinyFishParams.exclude_domains = excludeDomains;
 	}
+	const { location, language } = tinyFishLocale(parsed.lang);
+	if (location) tinyFishParams.location = location;
+	if (language) tinyFishParams.language = language;
 	const keyOrResolver: ApiKey = params.authStorage.resolver("tinyfish", {
 		sessionId: params.sessionId,
 	});