@oh-my-pi/pi-coding-agent 15.10.8 → 15.10.9

package/src/mcp/transports/stdio.ts

@@ -5,6 +5,9 @@
  * Messages are newline-delimited JSON.
  */
 
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
 import { getProjectDir, readJsonl, Snowflake } from "@oh-my-pi/pi-utils";
 import { type Subprocess, spawn } from "bun";
 import type {
@@ -19,6 +22,134 @@ import type {
 import { toJsonRpcError } from "../../mcp/types";
 import { isMCPTimeoutEnabled, resolveMCPTimeoutMs } from "../timeout";
 
+/** Subprocess argv for launching an MCP stdio server. */
+export interface StdioSpawnCommand {
+	cmd: string[];
+}
+
+/** Inputs used to resolve platform-specific stdio spawn behavior. */
+export interface ResolveStdioSpawnOptions {
+	cwd: string;
+	env: Record<string, string | undefined>;
+	platform?: NodeJS.Platform;
+}
+
+const DEFAULT_WINDOWS_PATHEXT = [".COM", ".EXE", ".BAT", ".CMD"];
+const WINDOWS_BATCH_EXTENSIONS = new Set([".bat", ".cmd"]);
+
+function getCaseInsensitiveEnv(env: Record<string, string | undefined>, name: string): string | undefined {
+	const direct = env[name];
+	if (direct !== undefined) return direct;
+	const normalized = name.toLowerCase();
+	for (const [key, value] of Object.entries(env)) {
+		if (key.toLowerCase() === normalized) return value;
+	}
+	return undefined;
+}
+
+function getWindowsPathExt(env: Record<string, string | undefined>): string[] {
+	const raw = getCaseInsensitiveEnv(env, "PATHEXT");
+	if (!raw) return DEFAULT_WINDOWS_PATHEXT;
+	const extensions: string[] = [];
+	for (const part of raw.split(";")) {
+		const trimmed = part.trim();
+		if (!trimmed) continue;
+		extensions.push(trimmed.startsWith(".") ? trimmed : `.${trimmed}`);
+	}
+	return extensions.length > 0 ? extensions : DEFAULT_WINDOWS_PATHEXT;
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function hasPathSegment(command: string): boolean {
+	return command.includes("/") || command.includes("\\") || path.isAbsolute(command);
+}
+
+function hasExecutableExtension(command: string, extensions: string[]): boolean {
+	const ext = path.extname(command).toLowerCase();
+	if (!ext) return false;
+	return extensions.some(candidate => candidate.toLowerCase() === ext);
+}
+
+async function resolveWindowsCommandPath(
+	command: string,
+	cwd: string,
+	env: Record<string, string | undefined>,
+): Promise<string | null> {
+	const extensions = getWindowsPathExt(env);
+	if (hasExecutableExtension(command, extensions)) return command;
+
+	const candidates = extensions.map(ext => `${command}${ext}`);
+	if (hasPathSegment(command)) {
+		for (const candidate of candidates) {
+			const resolved = path.isAbsolute(candidate) ? candidate : path.resolve(cwd, candidate);
+			if (await fileExists(resolved)) return resolved;
+		}
+		return null;
+	}
+
+	const pathValue = getCaseInsensitiveEnv(env, "PATH");
+	if (!pathValue) return null;
+	for (const dir of pathValue.split(";")) {
+		if (!dir) continue;
+		for (const candidate of candidates) {
+			const resolved = path.join(dir, candidate);
+			if (await fileExists(resolved)) return resolved;
+		}
+	}
+	return null;
+}
+
+function quoteCmdArg(value: string): string {
+	if (value.length === 0) return '""';
+	let result = '"';
+	for (const char of value) {
+		if (char === '"') {
+			result += '^"';
+		} else if (char === "^") {
+			result += "^^";
+		} else if (char === "%") {
+			result += "^%";
+		} else {
+			result += char;
+		}
+	}
+	return `${result}"`;
+}
+
+function isWindowsBatchCommand(command: string): boolean {
+	return WINDOWS_BATCH_EXTENSIONS.has(path.extname(command).toLowerCase());
+}
+
+function resolveComSpec(env: Record<string, string | undefined>): string {
+	const comspec = getCaseInsensitiveEnv(env, "COMSPEC");
+	return comspec && comspec.length > 0 ? comspec : "cmd.exe";
+}
+
+/** Resolve the subprocess argv used to launch an MCP stdio server. */
+export async function resolveStdioSpawnCommand(
+	config: MCPStdioServerConfig,
+	options: ResolveStdioSpawnOptions,
+): Promise<StdioSpawnCommand> {
+	const args = config.args ?? [];
+	if (options.platform !== "win32") return { cmd: [config.command, ...args] };
+
+	const resolvedCommand =
+		(await resolveWindowsCommandPath(config.command, options.cwd, options.env)) ?? config.command;
+	if (!isWindowsBatchCommand(resolvedCommand)) return { cmd: [resolvedCommand, ...args] };
+
+	return {
+		cmd: [resolveComSpec(options.env), "/d", "/s", "/c", [resolvedCommand, ...args].map(quoteCmdArg).join(" ")],
+	};
+}
+
 /** Minimal write surface of `Subprocess.stdin` we need for framed sends. */
 interface FrameSink {
 	write(chunk: string): unknown;
@@ -100,15 +231,20 @@ export class StdioTransport implements MCPTransport {
 	async connect(): Promise<void> {
 		if (this.#connected) return;
 
-		const args = this.config.args ?? [];
 		const env = {
 			...Bun.env,
 			...this.config.env,
 		};
+		const cwd = this.config.cwd ?? getProjectDir();
+		const spawnCommand = await resolveStdioSpawnCommand(this.config, {
+			cwd,
+			env,
+			platform: process.platform,
+		});
 
 		this.#process = spawn({
-			cmd: [this.config.command, ...args],
-			cwd: this.config.cwd ?? getProjectDir(),
+			cmd: spawnCommand.cmd,
+			cwd,
 			env,
 			stdin: "pipe",
 			stdout: "pipe",

package/src/modes/components/custom-editor.ts

@@ -58,16 +58,72 @@ function buildMatchKeys(keys: readonly KeyId[]): Set<string> {
 const BRACKETED_PASTE_START = "\x1b[200~";
 const BRACKETED_PASTE_END = "\x1b[201~";
 const BRACKETED_IMAGE_PATH_REGEX = /\.(?:png|jpe?g|gif|webp)$/i;
+const BRACKETED_IMAGE_PATH_BOUNDARY_REGEX = /\.(?:png|jpe?g|gif|webp)(?=$|["']?\s)/gi;
+const SHELL_ESCAPED_PATH_CHAR_REGEX = /\\([\\\s'"()[\]{}&;<>|?*!$`])/g;
 
-export function extractBracketedImagePastePath(data: string): string | undefined {
+function isPastedPathSeparator(char: string | undefined): boolean {
+	return char === undefined || char === " " || char === "\t" || char === "\r" || char === "\n";
+}
+
+function imagePathBoundaryEnd(payload: string, segmentStart: number, extensionEnd: number): number | undefined {
+	const quote = payload[segmentStart];
+	const afterExtension = payload[extensionEnd];
+	if (quote === '"' || quote === "'") {
+		return afterExtension === quote && isPastedPathSeparator(payload[extensionEnd + 1])
+			? extensionEnd + 1
+			: undefined;
+	}
+	if (isPastedPathSeparator(afterExtension)) return extensionEnd;
+	return undefined;
+}
+
+function normalizePastedImagePath(path: string): string {
+	const trimmed = path.trim();
+	const first = trimmed[0];
+	const last = trimmed[trimmed.length - 1];
+	const unquoted =
+		trimmed.length > 1 && (first === '"' || first === "'") && last === first ? trimmed.slice(1, -1) : trimmed;
+	return unquoted.replace(SHELL_ESCAPED_PATH_CHAR_REGEX, "$1");
+}
+
+export function extractBracketedImagePastePaths(data: string): string[] | undefined {
 	if (!data.startsWith(BRACKETED_PASTE_START)) return undefined;
 	const endIndex = data.indexOf(BRACKETED_PASTE_END, BRACKETED_PASTE_START.length);
 	if (endIndex === -1 || endIndex + BRACKETED_PASTE_END.length !== data.length) return undefined;
 
 	const pasted = data.slice(BRACKETED_PASTE_START.length, endIndex).trim();
-	if (!pasted || /[\r\n]/.test(pasted)) return undefined;
-	if (!BRACKETED_IMAGE_PATH_REGEX.test(pasted)) return undefined;
-	return pasted;
+	if (!pasted) return undefined;
+
+	const paths: string[] = [];
+	let segmentStart = 0;
+	BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.lastIndex = 0;
+	for (
+		let match = BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.exec(pasted);
+		match;
+		match = BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.exec(pasted)
+	) {
+		const extensionEnd = match.index + match[0].length;
+		const boundaryEnd = imagePathBoundaryEnd(pasted, segmentStart, extensionEnd);
+		if (boundaryEnd === undefined) continue;
+
+		const path = normalizePastedImagePath(pasted.slice(segmentStart, boundaryEnd));
+		if (!path || !BRACKETED_IMAGE_PATH_REGEX.test(path)) return undefined;
+		paths.push(path);
+
+		segmentStart = boundaryEnd;
+		while (segmentStart < pasted.length && isPastedPathSeparator(pasted[segmentStart])) {
+			segmentStart++;
+		}
+		BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.lastIndex = segmentStart;
+	}
+
+	if (paths.length === 0 || segmentStart !== pasted.length) return undefined;
+	return paths;
+}
+
+export function extractBracketedImagePastePath(data: string): string | undefined {
+	const paths = extractBracketedImagePastePaths(data);
+	return paths?.length === 1 ? paths[0] : undefined;
 }
 
 /**
@@ -111,8 +167,8 @@ export class CustomEditor extends Editor {
 	onCopyPrompt?: () => void;
 	/** Called when the configured image-paste shortcut is pressed. */
 	onPasteImage?: () => Promise<boolean>;
-	/** Called when a bracketed paste contains exactly one image-file path. */
-	onPasteImagePath?: (path: string) => void;
+	/** Called when a bracketed paste contains one or more image-file paths. */
+	onPasteImagePath?: (path: string) => void | Promise<void>;
 	/** Called when the configured raw text-paste shortcut is pressed. */
 	onPasteTextRaw?: () => void;
 	/** Called when the configured dequeue shortcut is pressed. */
@@ -188,9 +244,13 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
-		const pastedImagePath = extractBracketedImagePastePath(data);
-		if (pastedImagePath && this.onPasteImagePath) {
-			this.onPasteImagePath(pastedImagePath);
+		const pastedImagePaths = extractBracketedImagePastePaths(data);
+		if (pastedImagePaths && this.onPasteImagePath) {
+			void (async () => {
+				for (const path of pastedImagePaths) {
+					await this.onPasteImagePath?.(path);
+				}
+			})();
 			return;
 		}
 

package/src/modes/components/transcript-container.ts

@@ -7,7 +7,11 @@ interface FrozenRender {
 	lines: string[];
 	generation: number;
 	appendOnly: boolean;
-	volatile: boolean;
+	/**
+	 * Frames remaining until a block that rewrote an interior row may re-earn
+	 * append-only status. `0` means the block is not under rewrite suspicion.
+	 */
+	volatileCooldown: number;
 }
 
 interface SnapshotCarrier {
@@ -51,10 +55,41 @@ function stripPlainBlankEdges(lines: string[]): string[] {
 
 interface LiveCommitState {
 	appendOnly: boolean;
-	volatile: boolean;
+	volatileCooldown: number;
 	safeLength: number;
 }
 
+/**
+ * Render frames a block must stay clean (static or append-shaped) after an
+ * interior rewrite before its rows become committable again. A one-off
+ * re-layout (a codespan finalizing across a wrap boundary, a paragraph
+ * re-parsed as a heading) only suspends commits briefly — the pinned emitter
+ * appends from the stalled high-water mark, so the gap backfills contiguously
+ * once the block re-earns append-only. Periodic animations (a spinner rewrites
+ * its row every few frames) keep resetting the countdown and never re-earn it,
+ * so genuinely volatile blocks stay deferred. Frames arrive at most at the
+ * TUI's 30 Hz render cadence, so 30 frames ≈ 1s of clean streaming.
+ */
+const VOLATILE_REARM_FRAMES = 30;
+
+/**
+ * Visible-content form of a row: SGR/OSC bytes and trailing pad spaces are
+ * write framing, not content. A styled line's closing escape moves when the
+ * line stops being the last of its span (a wrapped thinking paragraph growing
+ * by one row), and width-padded rows shift their trailing spaces as text
+ * grows; both leave the on-screen cells identical and must not count as a
+ * rewrite of a committed-candidate row. Committed scrollback rows are written
+ * with a full SGR/OSC reset terminator, so escape-placement drift between
+ * visually identical renders cannot bleed styles across rows.
+ */
+function normalizeRow(line: string): string {
+	return Bun.stripANSI(line).trimEnd();
+}
+
+function rowsVisiblyEqual(prev: string, cur: string): boolean {
+	return prev === cur || normalizeRow(prev) === normalizeRow(cur);
+}
+
 function hasValidSnapshot(
 	snapshot: FrozenRender | undefined,
 	width: number,
@@ -66,14 +101,14 @@ function hasValidSnapshot(
 function commonPrefixLength(prev: string[], cur: string[]): number {
 	const limit = Math.min(prev.length, cur.length);
 	let i = 0;
-	while (i < limit && prev[i] === cur[i]) i++;
+	while (i < limit && rowsVisiblyEqual(prev[i]!, cur[i]!)) i++;
 	return i;
 }
 
 function commonSuffixLength(prev: string[], cur: string[], prefixLength: number): number {
 	const limit = Math.min(prev.length - prefixLength, cur.length - prefixLength);
 	let i = 0;
-	while (i < limit && prev[prev.length - 1 - i] === cur[cur.length - 1 - i]) i++;
+	while (i < limit && rowsVisiblyEqual(prev[prev.length - 1 - i]!, cur[cur.length - 1 - i]!)) i++;
 	return i;
 }
 
@@ -84,42 +119,56 @@ function deriveLiveCommitState(
 	generation: number,
 ): LiveCommitState {
 	let appendOnly = false;
-	let volatile = false;
+	let volatileCooldown = 0;
 	if (hasValidSnapshot(previous, width, generation)) {
 		appendOnly = previous.appendOnly;
-		volatile = previous.volatile;
+		volatileCooldown = previous.volatileCooldown;
 
 		const prefixLength = commonPrefixLength(previous.lines, current);
 		const staticRender = prefixLength === previous.lines.length && prefixLength === current.length;
+		let cleanFrame = true;
 		if (!staticRender) {
 			const suffixLength = commonSuffixLength(previous.lines, current, prefixLength);
 			// Append-only growth never rewrites a row that may already have scrolled
-			// into native scrollback; it only grows the block at/near its tail. Three
+			// into native scrollback; it only grows the block at/near its tail. Four
 			// shapes qualify: a pure bottom append, an insertion above stable trailing
-			// chrome (a streaming tool's footer/border), and an in-place extension of
-			// the current line by one streamed token (line count unchanged). The first
-			// two preserve every previous row across a matching prefix + suffix; the
-			// last leaves a single divergent previous row that the current row merely
-			// lengthens. A divergent interior row that is genuinely rewritten means the
-			// block re-laid-out committed content — volatile, and never committed.
+			// chrome (a streaming tool's footer/border), an in-place extension of the
+			// current line by one streamed token (line count unchanged), and a
+			// wrap-shrink of the current line where its last word grew past the wrap
+			// column and moved down onto an appended row. The first two preserve every
+			// previous row across a matching prefix + suffix; the last two leave a
+			// single divergent previous row — the block's in-flight bottom line, which
+			// cannot have been committed (commits stop at the viewport top and the
+			// bottom line is by definition on screen). Any other divergent interior
+			// row means the block re-laid-out committed-candidate content — a rewrite,
+			// which suspends commits until the block re-earns append-only.
 			const preservedEveryRow = prefixLength + suffixLength >= previous.lines.length;
-			const tailExtendedInPlace =
+			let tailExtendedInPlace = false;
+			if (
+				!preservedEveryRow &&
 				prefixLength + suffixLength === previous.lines.length - 1 &&
-				prefixLength < current.length &&
-				current[prefixLength]!.startsWith(previous.lines[prefixLength]!);
-			if ((preservedEveryRow || tailExtendedInPlace) && current.length >= previous.lines.length && !volatile) {
-				appendOnly = true;
-			} else if (!preservedEveryRow && !tailExtendedInPlace) {
-				volatile = true;
+				prefixLength < current.length
+			) {
+				const prevTail = normalizeRow(previous.lines[prefixLength]!);
+				const curTail = normalizeRow(current[prefixLength]!);
+				tailExtendedInPlace =
+					curTail.startsWith(prevTail) || (current.length > previous.lines.length && prevTail.startsWith(curTail));
+			}
+			if ((preservedEveryRow || tailExtendedInPlace) && current.length >= previous.lines.length) {
+				if (volatileCooldown === 0) appendOnly = true;
+			} else {
+				cleanFrame = false;
 				appendOnly = false;
+				volatileCooldown = VOLATILE_REARM_FRAMES;
 			}
 		}
+		if (cleanFrame && volatileCooldown > 0) volatileCooldown--;
 	}
 
 	return {
 		appendOnly,
-		volatile,
-		safeLength: volatile ? 0 : appendOnly ? current.length : 0,
+		volatileCooldown,
+		safeLength: appendOnly ? current.length : 0,
 	};
 }
 
@@ -163,8 +212,11 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 	#nativeScrollbackLiveRegionStart: number | undefined;
 	// Local line index up to which the leading run of live blocks is safe to
 	// commit. Finalized blocks contribute their full frozen body; still-live
-	// blocks contribute only after their stripped render has been observed
-	// growing without changing a previously rendered interior row.
+	// blocks contribute only while their render has been observed growing
+	// without visibly rewriting a previously rendered interior row (escape
+	// placement and pad drift are ignored). A rewrite suspends the block's
+	// contribution until it re-earns append-only via VOLATILE_REARM_FRAMES
+	// clean frames; the pinned emitter then backfills the stalled gap.
 	#nativeScrollbackCommitSafeEnd: number | undefined;
 
 	override invalidate(): void {
@@ -265,7 +317,7 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 						lines: contribution,
 						generation: this.#generation,
 						appendOnly: liveCommitState?.appendOnly ?? false,
-						volatile: liveCommitState?.volatile ?? false,
+						volatileCooldown: liveCommitState?.volatileCooldown ?? 0,
 					};
 				}
 			}

package/src/modes/controllers/input-controller.ts

@@ -191,7 +191,7 @@ export class InputController {
 			this.ctx.keybindings.getKeys("app.clipboard.pasteImage"),
 		);
 		this.ctx.editor.onPasteImage = () => this.handleImagePaste();
-		this.ctx.editor.onPasteImagePath = path => void this.handleImagePathPaste(path);
+		this.ctx.editor.onPasteImagePath = path => this.handleImagePathPaste(path);
 		this.ctx.editor.setActionKeys(
 			"app.clipboard.pasteTextRaw",
 			this.ctx.keybindings.getKeys("app.clipboard.pasteTextRaw"),

package/src/modes/controllers/mcp-command-controller.ts

@@ -36,7 +36,7 @@ import {
 import type { MCPAuthConfig, MCPServerConfig, MCPServerConnection } from "../../mcp/types";
 import type { OAuthCredential } from "../../session/auth-storage";
 import { shortenPath } from "../../tools/render-utils";
-import { urlHyperlink } from "../../tui";
+import { urlHyperlinkAlways } from "../../tui";
 import { openPath } from "../../utils/open";
 import { ChatBlock } from "../components/chat-block";
 import { MCPAddWizard } from "../components/mcp-add-wizard";
@@ -63,7 +63,7 @@ export class MCPAuthorizationLinkPrompt implements Component {
 	invalidate(): void {}
 
 	render(_width: number): string[] {
-		const link = urlHyperlink(this.#url, "Click here to authorize");
+		const link = urlHyperlinkAlways(this.#url, "Click here to authorize");
 		return [
 			` ${theme.fg("success", "Open authorization URL:")}`,
 			` ${theme.fg("accent", link)}`,