@oh-my-pi/pi-coding-agent 15.11.0 → 15.11.2

package/src/tools/browser/attach.ts

@@ -1,6 +1,6 @@
 import * as net from "node:net";
 import { Process, ProcessStatus } from "@oh-my-pi/pi-natives";
-import type { Browser, Page } from "puppeteer-core";
+import { type Browser, type Page, TargetType } from "puppeteer-core";
 import { ToolError, throwIfAborted } from "../tool-errors";
 
 const ATTACH_TARGET_SKIP_PATTERN =
@@ -119,22 +119,41 @@ export async function findReusableCdp(
 }
 
 /**
- * Pick the best page target on an attached browser. Without a matcher, prefer
- * a page that doesn't look like a helper window (devtools, request handler,
- * background pages); with a matcher, return the first url+title substring hit.
+ * Pick the best page target on an attached browser. Prefer discoverable page
+ * targets first so Chromium/Edge attach flows that hide pages from
+ * `browser.pages()` can still return a usable tab.
  */
 export async function pickElectronTarget(browser: Browser, matcher?: string): Promise<Page> {
-	const pages = await browser.pages();
-	if (!pages.length) {
+	const discoveredPages = await Promise.all(
+		browser.targets().map(async target => {
+			if (target.type() !== TargetType.PAGE) return null;
+			return await target.page().catch(() => null);
+		}),
+	);
+	const usablePages = discoveredPages.filter((page): page is Page => page !== null);
+	if (usablePages.length > 0) {
+		return pickPageFromList(usablePages, matcher);
+	}
+
+	const fallbackPages = await browser.pages();
+	if (!fallbackPages.length) {
 		throw new ToolError("No page targets available on the attached browser");
 	}
-	const enriched = await Promise.all(
+	return pickPageFromList(fallbackPages, matcher);
+}
+
+async function enrichPages(pages: Page[]): Promise<Array<{ page: Page; url: string; title: string }>> {
+	return await Promise.all(
 		pages.map(async page => ({
 			page,
 			url: page.url(),
 			title: ((await page.title().catch(() => "")) ?? "").trim(),
 		})),
 	);
+}
+
+async function pickPageFromList(pages: Page[], matcher?: string): Promise<Page> {
+	const enriched = await enrichPages(pages);
 	if (matcher) {
 		const needle = matcher.toLowerCase();
 		const hit = enriched.find(p => p.url.toLowerCase().includes(needle) || p.title.toLowerCase().includes(needle));

package/src/tools/browser/registry.ts

@@ -58,6 +58,16 @@ export async function acquireBrowser(kind: BrowserKind, opts: AcquireBrowserOpti
 	return handle;
 }
 
+export function normalizeConnectedCdpUrl(rawCdpUrl: string): string {
+	const cdpUrl = rawCdpUrl.replace(/\/+$/, "");
+	if (/^wss?:\/\//i.test(cdpUrl)) {
+		throw new ToolError(
+			"browser app.cdp_url must be the HTTP CDP discovery endpoint (for example http://127.0.0.1:9222), not a ws:// browser websocket URL.",
+		);
+	}
+	return cdpUrl;
+}
+
 async function openBrowserHandle(kind: BrowserKind, opts: AcquireBrowserOptions): Promise<BrowserHandle> {
 	if (kind.kind === "headless") {
 		const browser = await launchHeadlessBrowser({ headless: kind.headless, viewport: opts.viewport });
@@ -70,7 +80,7 @@ async function openBrowserHandle(kind: BrowserKind, opts: AcquireBrowserOptions)
 		};
 	}
 	if (kind.kind === "connected") {
-		const cdpUrl = kind.cdpUrl.replace(/\/+$/, "");
+		const cdpUrl = normalizeConnectedCdpUrl(kind.cdpUrl);
 		await waitForCdp(cdpUrl, 5_000, opts.signal);
 		const puppeteer = await loadPuppeteer();
 		const browser = await puppeteer.connect({

package/src/tools/irc.ts

@@ -234,7 +234,15 @@ export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 			// through the bus unfiltered so parked recipients are revived.
 			const targets = isBroadcast ? registry.listVisibleTo(senderId).map(ref => ref.id) : [to];
 			const receipts = await Promise.all(
-				targets.map(target => bus.send({ from: senderId, to: target, body: message, replyTo: params.replyTo })),
+				targets.map(target =>
+					bus.send(
+						{ from: senderId, to: target, body: message, replyTo: params.replyTo },
+						// Awaited sends mark the sender as blocked on an answer so a
+						// busy recipient that cannot reach a step boundary (async
+						// disabled) auto-replies instead of stranding the sender.
+						params.await ? { expectsReply: true } : undefined,
+					),
+				),
 			);
 
 			const lines: string[] = [];
@@ -457,13 +465,14 @@ function callMeta(args: IrcRenderArgs | undefined): string[] {
 
 /**
  * Display-only transcript card for live IRC traffic: `irc:incoming` DMs
- * delivered to this session and `irc:relay` observations of agent↔agent
+ * delivered to this session, `irc:autoreply` side-channel replies sent on
+ * this session's behalf, and `irc:relay` observations of agent↔agent
  * traffic. Shares the tool renderer's glyph + quote-border conventions so
  * cards and `irc` tool output look identical in the transcript.
  */
 export function createIrcMessageCard(
 	card: {
-		kind: "incoming" | "relay";
+		kind: "incoming" | "autoreply" | "relay";
 		from?: string;
 		to?: string;
 		body?: string;
@@ -477,9 +486,12 @@ export function createIrcMessageCard(
 	const title =
 		card.kind === "incoming"
 			? `IRC ${uiTheme.nav.back} ${from}`
-			: `IRC ${from} ${uiTheme.nav.selected} ${card.to?.trim() || "?"}`;
+			: card.kind === "autoreply"
+				? `IRC ${uiTheme.nav.selected} ${card.to?.trim() || "?"}`
+				: `IRC ${from} ${uiTheme.nav.selected} ${card.to?.trim() || "?"}`;
 	const body = card.body ?? "";
 	const meta: string[] = [];
+	if (card.kind === "autoreply") meta.push("auto");
 	if (card.replyTo) meta.push("reply");
 	const age = messageAge(card.timestamp);
 	if (age) meta.push(age);

package/src/tools/job.ts

@@ -449,17 +449,21 @@ export const jobToolRenderer = {
 		const counts = { completed: 0, failed: 0, cancelled: 0, running: 0 };
 		for (const job of jobs) counts[job.status]++;
 
+		// The title already carries the running count, so meta lists only the
+		// settled categories — "waiting on 19 of 19 · 19 running" read awkward.
 		const meta: string[] = [];
 		if (counts.completed > 0) meta.push(uiTheme.fg("success", `${counts.completed} done`));
 		if (counts.failed > 0) meta.push(uiTheme.fg("error", `${counts.failed} failed`));
 		if (counts.cancelled > 0) meta.push(uiTheme.fg("warning", `${counts.cancelled} cancelled`));
-		if (counts.running > 0) meta.push(uiTheme.fg("accent", `${counts.running} running`));
 
 		const headerIcon: ToolUIStatus = counts.failed > 0 ? "warning" : counts.running > 0 ? "info" : "success";
+		const jobsNoun = jobs.length === 1 ? "job" : "jobs";
 		const description =
 			counts.running > 0
-				? `waiting on ${counts.running} of ${jobs.length}`
-				: `${jobs.length} ${jobs.length === 1 ? "job" : "jobs"} settled`;
+				? counts.running === jobs.length
+					? `waiting on ${jobs.length} ${jobsNoun}`
+					: `waiting on ${counts.running} of ${jobs.length} ${jobsNoun}`
+				: `${jobs.length} ${jobsNoun} settled`;
 
 		const header = renderStatusLine(
 			{

package/src/tools/path-utils.ts

@@ -398,6 +398,11 @@ export function formatPathRelativeToCwd(
 export function stripOuterDoubleQuotes(input: string): string {
 	return input.startsWith('"') && input.endsWith('"') && input.length > 1 ? input.slice(1, -1) : input;
 }
+function normalizePathSeparators(input: string): string {
+	if (isInternalUrlPath(input)) return input;
+	if (!input.includes("\\")) return input;
+	return input.replace(/\\/g, "/");
+}
 
 export function normalizePathLikeInput(input: string): string {
 	return stripOuterDoubleQuotes(input.trim());
@@ -582,19 +587,20 @@ export interface ResolvedMultiFindPattern {
 	targets: ResolvedFindTarget[];
 	scopePath: string;
 }
-
-/**
- * Split a user path into a base path + glob pattern for tools that delegate to
- * APIs accepting separate `path` and `glob` arguments.
- */
 export function parseSearchPath(filePath: string): ParsedSearchPath {
-	const normalizedPath = filePath.replace(/\\/g, "/");
-	if (!hasGlobPathChars(normalizedPath)) {
-		return { basePath: filePath };
+	const normalizedPath = normalizePathSeparators(filePath);
+	const segments = normalizedPath.split("/");
+	let firstGlobIndex = -1;
+	for (let i = 0; i < segments.length; i++) {
+		if (hasGlobPathChars(segments[i])) {
+			firstGlobIndex = i;
+			break;
+		}
 	}
 
-	const segments = normalizedPath.split("/");
-	const firstGlobIndex = segments.findIndex(segment => hasGlobPathChars(segment));
+	if (firstGlobIndex === -1) {
+		return { basePath: normalizedPath };
+	}
 
 	if (firstGlobIndex <= 0) {
 		return { basePath: ".", glob: normalizedPath };
@@ -617,7 +623,7 @@ export async function parseSearchPathPreferringLiteral(filePath: string, cwd: st
 	if (!hasGlobPathChars(filePath) || isInternalUrlPath(filePath)) return parseSearchPath(filePath);
 	try {
 		await fs.promises.stat(resolveToCwd(filePath, cwd));
-		return { basePath: filePath };
+		return { basePath: normalizePathSeparators(filePath) };
 	} catch {
 		return parseSearchPath(filePath);
 	}
@@ -632,7 +638,8 @@ export async function parseSearchPathPreferringLiteral(filePath: string, cwd: st
 //   /abs/path/**/\*.ts -> { basePath: "/abs/path", globPattern: "**/*.ts", hasGlob: true }
 //   src/app -> { basePath: "src/app", globPattern: "**/*", hasGlob: false }
 export function parseFindPattern(pattern: string): ParsedFindPattern {
-	const segments = pattern.split("/");
+	const normalizedPattern = normalizePathSeparators(pattern);
+	const segments = normalizedPattern.split("/");
 	let firstGlobIndex = -1;
 	for (let i = 0; i < segments.length; i++) {
 		if (hasGlobPathChars(segments[i])) {
@@ -642,14 +649,14 @@ export function parseFindPattern(pattern: string): ParsedFindPattern {
 	}
 
 	if (firstGlobIndex === -1) {
-		return { basePath: pattern, globPattern: "**/*", hasGlob: false };
+		return { basePath: normalizedPattern, globPattern: "**/*", hasGlob: false };
 	}
 
 	if (firstGlobIndex === 0) {
-		const needsRecursive = !pattern.startsWith("**/");
+		const needsRecursive = !normalizedPattern.startsWith("**/");
 		return {
 			basePath: ".",
-			globPattern: needsRecursive ? `**/${pattern}` : pattern,
+			globPattern: needsRecursive ? `**/${normalizedPattern}` : normalizedPattern,
 			hasGlob: true,
 		};
 	}

package/src/tools/render-utils.ts

@@ -779,6 +779,62 @@ export function createCachedComponent(
 	};
 }
 
+/**
+ * Single-slot memo for an expensive rendered string (syntax highlighting, diff
+ * coloring) keyed by the exact inputs that shape the bytes: theme instance,
+ * expanded state, a caller-chosen salt (path/language), and the source content.
+ * Field-wise comparison instead of a concatenated key string: a cache hit costs
+ * one string value-compare (engines short-circuit on length) and a miss never
+ * allocates a key. Comparing the {@link Theme} by reference is sound because
+ * theme switches replace the instance wholesale (`setTheme`/`previewTheme`/
+ * `setSymbolPreset` in modes/theme/theme.ts) — themes are never mutated in
+ * place.
+ */
+export interface RenderedStringCache {
+	theme: Theme | null;
+	expanded: boolean;
+	salt: string;
+	content: string;
+	value: string;
+}
+
+export function createRenderedStringCache(): RenderedStringCache {
+	return { theme: null, expanded: false, salt: "", content: "", value: "" };
+}
+
+/** Drop the memo so the next lookup re-renders (e.g. the render function identity changed). */
+export function invalidateRenderedStringCache(cache: RenderedStringCache): void {
+	cache.theme = null;
+}
+
+export function cachedRenderedString(
+	cache: RenderedStringCache | undefined,
+	theme: Theme,
+	expanded: boolean,
+	salt: string,
+	content: string,
+	render: () => string,
+): string {
+	if (
+		cache !== undefined &&
+		cache.theme === theme &&
+		cache.expanded === expanded &&
+		cache.salt === salt &&
+		cache.content === content
+	) {
+		return cache.value;
+	}
+	const value = render();
+	if (cache !== undefined) {
+		cache.theme = theme;
+		cache.expanded = expanded;
+		cache.salt = salt;
+		cache.content = content;
+		cache.value = value;
+	}
+	return value;
+}
+
 /**
  * Append the indented bullet list of parse errors (capped at
  * {@link PARSE_ERRORS_LIMIT}) to `lines`, with an overflow summary line if the

package/src/tools/write.ts

@@ -37,12 +37,15 @@ import { type OutputMeta, outputMeta } from "./output-meta";
 import { formatPathRelativeToCwd, isInternalUrlPath } from "./path-utils";
 import { enforcePlanModeWrite, resolvePlanPath } from "./plan-mode-guard";
 import {
+	cachedRenderedString,
+	createRenderedStringCache,
 	formatDiagnostics,
 	formatErrorDetail,
 	formatExpandHint,
 	formatMoreItems,
 	formatStatusIcon,
 	getLspBatchRequest,
+	type RenderedStringCache,
 	replaceTabs,
 	shortenPath,
 } from "./render-utils";
@@ -1042,37 +1045,40 @@ function formatStreamingContent(
 	language: string | undefined,
 	uiTheme: Theme,
 	spinnerFrame?: number,
+	cache?: RenderedStringCache,
 ): string {
 	if (!content) return "";
-	const lines = normalizeDisplayText(content).split("\n");
-	const totalLines = lines.length;
-	// Collapsed: follow the streaming edge with a bounded tail window so the box
-	// stays short enough not to strand its scrolled-off head above the viewport
-	// while the block is volatile. `Ctrl+O` (expanded) lifts the cap for a
-	// deliberate full view — matching the eval streaming preview.
-	const startIndex = expanded ? 0 : Math.max(0, totalLines - WRITE_STREAMING_PREVIEW_LINES);
-	const visibleLines = lines.slice(startIndex);
-	const hidden = startIndex;
-	const highlighted = highlightCode(visibleLines.join("\n"), language);
-	const lineNumberWidth = Math.max(WRITE_GUTTER_MIN_WIDTH, String(totalLines).length);
-
-	let text = "\n\n";
-	if (hidden > 0) {
-		text += `${uiTheme.fg("dim", `… (${hidden} earlier line${hidden === 1 ? "" : "s"})`)}\n`;
-	}
-	for (let i = 0; i < highlighted.length; i++) {
-		const lineNum = startIndex + i + 1;
-		const gutter = uiTheme.fg("dim", `${String(lineNum).padStart(lineNumberWidth, " ")} `);
-		const body = replaceTabs(highlighted[i] ?? "");
-		text += `${gutter}${body}\n`;
-	}
+	const bodyText = cachedRenderedString(cache, uiTheme, expanded, language ?? "", content, () => {
+		const lines = normalizeDisplayText(content).split("\n");
+		const totalLines = lines.length;
+		// Collapsed: follow the streaming edge with a bounded tail window so the box
+		// stays short enough not to strand its scrolled-off head above the viewport
+		// while the block is volatile. `Ctrl+O` (expanded) lifts the cap for a
+		// deliberate full view — matching the eval streaming preview.
+		const startIndex = expanded ? 0 : Math.max(0, totalLines - WRITE_STREAMING_PREVIEW_LINES);
+		const visibleLines = lines.slice(startIndex);
+		const hidden = startIndex;
+		const highlighted = highlightCode(visibleLines.join("\n"), language);
+		const lineNumberWidth = Math.max(WRITE_GUTTER_MIN_WIDTH, String(totalLines).length);
+
+		let text = "\n\n";
+		if (hidden > 0) {
+			text += `${uiTheme.fg("dim", `… (${hidden} earlier line${hidden === 1 ? "" : "s"})`)}\n`;
+		}
+		for (let i = 0; i < highlighted.length; i++) {
+			const lineNum = startIndex + i + 1;
+			const gutter = uiTheme.fg("dim", `${String(lineNum).padStart(lineNumberWidth, " ")} `);
+			const body = replaceTabs(highlighted[i] ?? "");
+			text += `${gutter}${body}\n`;
+		}
+		return text;
+	});
 	// The animated glyph lives on this trailing line — inside the transcript's
 	// volatile-tail holdback — never in the header: an animating head row pins
 	// the native-scrollback commit boundary at the top of the block, so a long
 	// expanded preview could never scroll-append mid-stream.
 	const spinner = spinnerFrame !== undefined ? `${formatStatusIcon("running", uiTheme, spinnerFrame)} ` : "";
-	text += `${spinner}${uiTheme.fg("dim", `… (streaming)`)}`;
-	return text;
+	return `${bodyText}${spinner}${uiTheme.fg("dim", `… (streaming)`)}`;
 }
 
 function renderContentPreview(
@@ -1080,29 +1086,32 @@ function renderContentPreview(
 	expanded: boolean,
 	language: string | undefined,
 	uiTheme: Theme,
+	cache?: RenderedStringCache,
 ): string {
 	if (!content) return "";
-	const rawLines = normalizeDisplayText(content).split("\n");
-	const totalLines = rawLines.length;
-	const maxLines = expanded ? totalLines : Math.min(totalLines, WRITE_PREVIEW_LINES);
-	const visibleLines = rawLines.slice(0, maxLines);
-	const highlighted = highlightCode(visibleLines.join("\n"), language);
-	const lineNumberWidth = Math.max(WRITE_GUTTER_MIN_WIDTH, String(totalLines).length);
-	const hidden = totalLines - maxLines;
-
-	let text = "\n\n";
-	for (let i = 0; i < highlighted.length; i++) {
-		const lineNum = i + 1;
-		const gutter = uiTheme.fg("dim", `${String(lineNum).padStart(lineNumberWidth, " ")} `);
-		const body = replaceTabs(highlighted[i] ?? "");
-		text += `${gutter}${body}\n`;
-	}
-	if (!expanded && hidden > 0) {
-		const hint = formatExpandHint(uiTheme, expanded, hidden > 0);
-		const moreLine = `${formatMoreItems(hidden, "line")}${hint ? ` ${hint}` : ""}`;
-		text += uiTheme.fg("dim", moreLine);
-	}
-	return text.trimEnd();
+	return cachedRenderedString(cache, uiTheme, expanded, language ?? "", content, () => {
+		const rawLines = normalizeDisplayText(content).split("\n");
+		const totalLines = rawLines.length;
+		const maxLines = expanded ? totalLines : Math.min(totalLines, WRITE_PREVIEW_LINES);
+		const visibleLines = rawLines.slice(0, maxLines);
+		const highlighted = highlightCode(visibleLines.join("\n"), language);
+		const lineNumberWidth = Math.max(WRITE_GUTTER_MIN_WIDTH, String(totalLines).length);
+		const hidden = totalLines - maxLines;
+
+		let text = "\n\n";
+		for (let i = 0; i < highlighted.length; i++) {
+			const lineNum = i + 1;
+			const gutter = uiTheme.fg("dim", `${String(lineNum).padStart(lineNumberWidth, " ")} `);
+			const body = replaceTabs(highlighted[i] ?? "");
+			text += `${gutter}${body}\n`;
+		}
+		if (!expanded && hidden > 0) {
+			const hint = formatExpandHint(uiTheme, expanded, hidden > 0);
+			const moreLine = `${formatMoreItems(hidden, "line")}${hint ? ` ${hint}` : ""}`;
+			text += uiTheme.fg("dim", moreLine);
+		}
+		return text.trimEnd();
+	});
 }
 
 export const writeToolRenderer = {
@@ -1125,9 +1134,17 @@ export const writeToolRenderer = {
 			},
 			uiTheme,
 		);
+		const streamingCache = createRenderedStringCache();
 		return framedBlock(uiTheme, width => {
 			const body = args.content
-				? formatStreamingContent(args.content, Boolean(options?.expanded), lang, uiTheme, options?.spinnerFrame)
+				? formatStreamingContent(
+						args.content,
+						Boolean(options?.expanded),
+						lang,
+						uiTheme,
+						options?.spinnerFrame,
+						streamingCache,
+					)
 				: "";
 			const bodyLines = body ? body.split("\n") : [];
 			while (bodyLines.length > 0 && bodyLines[0].trim() === "") bodyLines.shift();
@@ -1189,9 +1206,10 @@ export const writeToolRenderer = {
 		);
 		const diagnostics = result.details?.diagnostics;
 
+		const previewCache = createRenderedStringCache();
 		return framedBlock(uiTheme, width => {
 			const { expanded } = options;
-			let body = renderContentPreview(fileContent, expanded, lang, uiTheme);
+			let body = renderContentPreview(fileContent, expanded, lang, uiTheme, previewCache);
 			if (diagnostics) {
 				const diagText = formatDiagnostics(diagnostics, expanded, uiTheme, fp =>
 					uiTheme.getLangIcon(getLanguageFromPath(fp)),

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

@@ -14,6 +14,7 @@ import {
 	buildAnthropicSystemBlocks,
 	buildAnthropicUrl,
 	type FetchImpl,
+	resolveAnthropicMetadataUserId,
 	stripClaudeToolPrefix,
 	withAuth,
 	wrapFetchForCch,
@@ -82,6 +83,7 @@ function buildSystemBlocks(
  * @param auth - Authentication configuration (API key or OAuth)
  * @param model - Model identifier to use
  * @param query - Search query from the user
+ * @param metadataUserId - Optional Anthropic Messages metadata.user_id (already shaped for OAuth)
  * @param systemPrompt - Optional system prompt for guiding response style
  * @returns Raw API response from Anthropic
  * @throws {SearchProviderError} If the API request fails
@@ -90,6 +92,7 @@ async function callSearch(
 	auth: AnthropicAuthConfig,
 	model: string,
 	query: string,
+	metadataUserId?: string,
 	systemPrompt?: string,
 	maxTokens?: number,
 	temperature?: number,
@@ -113,6 +116,10 @@ async function callSearch(
 		],
 	};
 
+	if (metadataUserId) {
+		body.metadata = { user_id: metadataUserId };
+	}
+
 	if (temperature !== undefined) {
 		body.temperature = temperature;
 	}
@@ -273,19 +280,37 @@ export async function searchAnthropic(
 	const model = getModel();
 	const systemPrompt = "authStorage" in params ? params.systemPrompt : params.system_prompt;
 	const maxTokens = "authStorage" in params ? params.maxOutputTokens : params.max_tokens;
+	const callerSessionId = "authStorage" in params ? params.sessionId : undefined;
+	const accountId =
+		"authStorage" in params ? params.authStorage.getOAuthAccountId("anthropic", params.sessionId) : undefined;
 	const response = await withAuth(
 		keyOrResolver,
-		key =>
-			callSearch(
-				buildAnthropicAuthConfig(key, searchBaseUrl),
+		key => {
+			const auth = buildAnthropicAuthConfig(key, searchBaseUrl);
+			// Mirror the main Messages path: OAuth requests need a Claude-Code-shaped
+			// metadata.user_id (`{session_id, account_uuid?, device_id}`) so the
+			// CC billing header + system fingerprint installed by
+			// `buildAnthropicSearchHeaders`/`buildSystemBlocks` line up with the
+			// attribution Anthropic and enterprise gateways expect. API-key tokens
+			// forward the raw session id verbatim.
+			const metadataUserId = resolveAnthropicMetadataUserId(
+				callerSessionId,
+				auth.isOAuth,
+				callerSessionId,
+				accountId,
+			);
+			return callSearch(
+				auth,
 				model,
 				params.query,
+				metadataUserId,
 				systemPrompt,
 				maxTokens,
 				params.temperature,
 				params.signal,
 				params.fetch,
-			),
+			);
+		},
 		{
 			signal: params.signal,
 			missingKeyMessage: