@oh-my-pi/pi-coding-agent 16.1.14 → 16.1.16

package/src/internal-urls/local-protocol.ts

@@ -157,7 +157,7 @@ export function resolveLocalUrlToPath(
 }
 
 /**
- * On-disk roots the eval helpers (`read`/`write`/`append`) substitute for
+ * On-disk roots the eval helpers (`read`/`write`) substitute for
  * internal-URL schemes so e.g. `write("local://x.md")` lands where a later
  * `read local://x.md` resolves — instead of a literal `local:/` directory under
  * the cwd (a stdlib `pathlib.Path`/`path.resolve` collapses `local://` to
@@ -169,6 +169,96 @@ export function buildEvalUrlRoots(options: LocalProtocolOptions): Record<string,
 	return { local: resolveLocalRoot(options) };
 }
 
+const LOCAL_WRITE_NOTE = "Use write path local://<file> to persist large intermediate artifacts across turns.";
+
+type ResolvedLocalTarget =
+	| { kind: "listing"; root: string }
+	| { kind: "directory"; path: string }
+	| { kind: "file"; path: string; size: number };
+
+/**
+ * Resolve a local:// URL to its on-disk target with realpath + containment
+ * checks on the root, parent, and target so symlinks cannot escape the session
+ * local root. Does NOT read or decode file contents — callers decide how to
+ * consume the resolved path. Shared by {@link LocalProtocolHandler.resolve} and
+ * {@link resolveLocalUrlToFile}.
+ */
+async function resolveLocalTarget(url: InternalUrl, opts: LocalProtocolOptions): Promise<ResolvedLocalTarget> {
+	const localRoot = path.resolve(resolveLocalRoot(opts));
+	await fs.mkdir(localRoot, { recursive: true });
+
+	let resolvedRoot: string;
+	try {
+		resolvedRoot = await fs.realpath(localRoot);
+	} catch (error) {
+		if (isEnoent(error)) {
+			throw new Error("Unable to initialize local:// root");
+		}
+		throw error;
+	}
+
+	const relativePath = extractRelativePath(url);
+	const targetPath = relativePath ? path.resolve(resolvedRoot, relativePath) : resolvedRoot;
+	ensureWithinRoot(targetPath, resolvedRoot);
+
+	if (targetPath === resolvedRoot) {
+		return { kind: "listing", root: resolvedRoot };
+	}
+
+	const parentDir = path.dirname(targetPath);
+	try {
+		const realParent = await fs.realpath(parentDir);
+		ensureWithinRoot(realParent, resolvedRoot);
+	} catch (error) {
+		if (!isEnoent(error)) throw error;
+	}
+
+	let realTargetPath: string;
+	try {
+		realTargetPath = await fs.realpath(targetPath);
+	} catch (error) {
+		if (isEnoent(error)) {
+			throw new Error(`Local file not found: ${url.href}`);
+		}
+		throw error;
+	}
+
+	ensureWithinRoot(realTargetPath, resolvedRoot);
+
+	const stat = await fs.stat(realTargetPath);
+	if (stat.isDirectory()) {
+		return { kind: "directory", path: realTargetPath };
+	}
+	if (!stat.isFile()) {
+		throw new Error(`local:// URL must resolve to a file or directory: ${url.href}`);
+	}
+	return { kind: "file", path: realTargetPath, size: stat.size };
+}
+
+/**
+ * Resolve a local:// URL to a regular on-disk file, applying the same
+ * realpath + containment guarantees as {@link LocalProtocolHandler.resolve}
+ * but WITHOUT reading or UTF-8-decoding its contents. Returns null when there
+ * is no active session or when the URL targets the root listing or a directory;
+ * throws the handler's not-found and "escapes local root" errors for missing
+ * files and symlink escapes.
+ *
+ * Options are resolved via {@link LocalProtocolHandler.resolveOptions} so the
+ * caller-options → override → registry order matches router resolution exactly.
+ * The read tool uses this to detect and emit image files from their real path
+ * before the text-only resource contract would decode the binary into mojibake.
+ */
+export async function resolveLocalUrlToFile(
+	input: string | InternalUrl,
+	context?: ResolveContext,
+): Promise<{ path: string; size: number } | null> {
+	const opts = LocalProtocolHandler.resolveOptions(context);
+	if (!opts) return null;
+	const url = typeof input === "string" ? parseLocalUrl(input) : input;
+	const resolved = await resolveLocalTarget(url, opts);
+	return resolved.kind === "file" ? { path: resolved.path, size: resolved.size } : null;
+}
+
 /**
  * Protocol handler for local:// URLs.
  *
@@ -238,65 +328,22 @@ export class LocalProtocolHandler implements ProtocolHandler {
 			throw new Error("No session - local:// unavailable");
 		}
 
-		const localRoot = path.resolve(resolveLocalRoot(opts));
-		await fs.mkdir(localRoot, { recursive: true });
-
-		let resolvedRoot: string;
-		try {
-			resolvedRoot = await fs.realpath(localRoot);
-		} catch (error) {
-			if (isEnoent(error)) {
-				throw new Error("Unable to initialize local:// root");
-			}
-			throw error;
-		}
-
-		const relativePath = extractRelativePath(url);
-		const targetPath = relativePath ? path.resolve(resolvedRoot, relativePath) : resolvedRoot;
-		ensureWithinRoot(targetPath, resolvedRoot);
-
-		if (targetPath === resolvedRoot) {
-			return buildListing(url, resolvedRoot);
-		}
-
-		const parentDir = path.dirname(targetPath);
-		try {
-			const realParent = await fs.realpath(parentDir);
-			ensureWithinRoot(realParent, resolvedRoot);
-		} catch (error) {
-			if (!isEnoent(error)) throw error;
-		}
-
-		let realTargetPath: string;
-		try {
-			realTargetPath = await fs.realpath(targetPath);
-		} catch (error) {
-			if (isEnoent(error)) {
-				throw new Error(`Local file not found: ${url.href}`);
-			}
-			throw error;
-		}
-
-		ensureWithinRoot(realTargetPath, resolvedRoot);
-
-		const stat = await fs.stat(realTargetPath);
-		if (stat.isDirectory()) {
-			return buildDirectoryResource(url.href, realTargetPath, [
-				"Use write path local://<file> to persist large intermediate artifacts across turns.",
-			]);
+		const resolved = await resolveLocalTarget(url, opts);
+		if (resolved.kind === "listing") {
+			return buildListing(url, resolved.root);
 		}
-		if (!stat.isFile()) {
-			throw new Error(`local:// URL must resolve to a file or directory: ${url.href}`);
+		if (resolved.kind === "directory") {
+			return buildDirectoryResource(url.href, resolved.path, [LOCAL_WRITE_NOTE]);
 		}
 
-		const content = await Bun.file(realTargetPath).text();
+		const content = await Bun.file(resolved.path).text();
 		return {
 			url: url.href,
 			content,
-			contentType: getContentType(realTargetPath),
+			contentType: getContentType(resolved.path),
 			size: Buffer.byteLength(content, "utf-8"),
-			sourcePath: realTargetPath,
-			notes: ["Use write path local://<file> to persist large intermediate artifacts across turns."],
+			sourcePath: resolved.path,
+			notes: [LOCAL_WRITE_NOTE],
 		};
 	}
 

package/src/main.ts

@@ -945,6 +945,7 @@ async function buildSessionOptions(
 interface RunRootCommandDependencies {
 	createAgentSession?: typeof createAgentSession;
 	discoverAuthStorage?: typeof discoverAuthStorage;
+	selectSession?: typeof selectSession;
 	runAcpMode?: RunAcpMode;
 	settings?: Settings;
 	forceSetupWizard?: boolean;
@@ -1131,7 +1132,8 @@ export async function runRootCommand(
 	// (see issue #1668).
 	if (typeof parsedArgs.resume === "string" && !sessionManager) {
 		writeStartupNotice(parsedArgs, `${chalk.dim("Resume cancelled: session is in another project.")}\n`);
-		return;
+		stopStartupWatchdog();
+		process.exit(0);
 	}
 
 	// Handle --resume (no value): show session picker
@@ -1147,17 +1149,26 @@ export async function runRootCommand(
 			preloadedAllSessions = await logger.time("SessionManager.listAll", SessionManager.listAll);
 			if (preloadedAllSessions.length === 0) {
 				writeStartupNotice(parsedArgs, `${chalk.dim("No sessions found")}\n`);
-				return;
+				stopStartupWatchdog();
+				process.exit(0);
 			}
 		}
 		pauseStartupWatchdog();
-		const selected = await logger.time("selectSession", selectSession, folderSessions, {
+		const selected = await logger.time("selectSession", deps.selectSession ?? selectSession, folderSessions, {
 			allSessions: preloadedAllSessions,
 		});
 		resumeStartupWatchdog();
 		if (!selected) {
 			writeStartupNotice(parsedArgs, `${chalk.dim("No session selected")}\n`);
-			return;
+			// Quit instead of returning: startup already armed long-lived handles
+			// (theme watcher + SIGWINCH/macOS appearance listeners via initTheme,
+			// settings save timer, model registry) that keep the event loop alive,
+			// so a bare return hangs the process after the picker leaves the alt
+			// screen. No session was built here, so there is nothing to flush. The
+			// in-session `/resume` picker (selector-controller.ts) takes a different
+			// onCancel that just closes the overlay — only this startup path exits.
+			stopStartupWatchdog();
+			process.exit(0);
 		}
 		// Resuming a session from another project: switch the process into that
 		// project's directory and refresh cwd-derived caches before the session is

package/src/mcp/transports/stdio.ts

@@ -212,7 +212,18 @@ function buildCmdExeCommand(command: string, args: readonly string[]): string {
 	return `"${quotedCommand}"`;
 }
 
-/** Resolve the subprocess argv used to launch an MCP stdio server. */
+/**
+ * Resolve the subprocess argv used to launch an MCP stdio server.
+ *
+ * On Windows, our PATH/PATHEXT walk may return `null` for a bare command
+ * (e.g. `npx`) — `Bun.env.PATH` empty under a restricted parent process,
+ * UNC/network mounts that reject `fs.access`, locked-down shells. The
+ * legacy fallback handed `Bun.spawn` the bare name, but `CreateProcess`
+ * only appends `.exe` for extensionless names — `.cmd`/`.bat` are never
+ * tried, so `npx` (which exists only as `npx.cmd` on Windows) crashes the
+ * subprocess immediately. When the resolver can't pin the command down,
+ * route through `cmd.exe /d /s /c` so Windows's own PATHEXT lookup runs.
+ */
 export async function resolveStdioSpawnCommand(
 	config: MCPStdioServerConfig,
 	options: ResolveStdioSpawnOptions,
@@ -220,11 +231,16 @@ export async function resolveStdioSpawnCommand(
 	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;
+	const resolved = await resolveWindowsCommandPath(config.command, options.cwd, options.env);
+	const resolvedCommand = resolved ?? config.command;
 	const npmShimCommand = await resolveWindowsNpmShimCommand(resolvedCommand, args, options.cwd);
 	if (npmShimCommand) return npmShimCommand;
-	if (!isWindowsBatchCommand(resolvedCommand)) return { cmd: [resolvedCommand, ...args] };
+
+	// Direct-spawn only when we resolved to a concrete file AND its extension
+	// is not a batch script. Everything else (resolved .cmd/.bat, or an
+	// unresolved extensionless command) goes through cmd.exe so PATHEXT runs.
+	const needsCmdExe = resolved === null || isWindowsBatchCommand(resolvedCommand);
+	if (!needsCmdExe) return { cmd: [resolvedCommand, ...args] };
 
 	return {
 		cmd: [resolveComSpec(options.env), "/d", "/s", "/c", buildCmdExeCommand(resolvedCommand, args)],

package/src/modes/acp/acp-event-mapper.ts

@@ -468,8 +468,13 @@ function buildEvalStartText(args: unknown): string | undefined {
 	if (typeof args !== "object" || args === null || Array.isArray(args)) {
 		return undefined;
 	}
-	const cells = (args as EvalCellContainer).cells;
-	if (!Array.isArray(cells) || cells.length === 0) {
+	const container = args as EvalCellContainer & EvalCellLike;
+	const cells = Array.isArray(container.cells)
+		? container.cells
+		: typeof container.code === "string"
+			? [container]
+			: [];
+	if (cells.length === 0) {
 		return undefined;
 	}
 	const lines: string[] = [];

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

@@ -3,6 +3,7 @@ import { $ } from "bun";
 import { getEditorTheme, initTheme } from "../theme/theme";
 import {
 	CustomEditor,
+	extractBracketedImagePastePaths,
 	SPACE_HOLD_MECHANICAL_RUN,
 	SPACE_HOLD_RELEASE_MS,
 	SPACE_REPEAT_MAX_GAP_MS,
@@ -21,6 +22,12 @@ function makeEditor() {
 const REPEAT_GAP_MS = 30;
 /** A gap above the threshold — looks like a deliberate keypress. */
 const TAP_GAP_MS = SPACE_REPEAT_MAX_GAP_MS + 80;
+const BRACKETED_PASTE_START = "\x1b[200~";
+const BRACKETED_PASTE_END = "\x1b[201~";
+
+function bracketedPaste(text: string): string {
+	return `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
+}
 
 /** Feed `count` spaces `gapMs` apart on the fake clock. The first space of a run has no prior
  *  space, so its gap is effectively infinite and it always reads as a deliberate tap. */
@@ -66,6 +73,21 @@ describe("CustomEditor placeholder decoration", () => {
 	});
 });
 
+describe("CustomEditor bracketed image-path paste", () => {
+	it("leaves a pasted bare .png filename on the normal text path", () => {
+		expect(extractBracketedImagePastePaths(bracketedPaste("icon-photo-default.png"))).toBeUndefined();
+	});
+
+	it("extracts explicit local image paths for attachment", () => {
+		expect(extractBracketedImagePastePaths(bracketedPaste("/tmp/icon-photo-default.png"))).toEqual([
+			"/tmp/icon-photo-default.png",
+		]);
+		expect(extractBracketedImagePastePaths(bracketedPaste("C:\\Users\\me\\icon-photo-default.png"))).toEqual([
+			"C:\\Users\\me\\icon-photo-default.png",
+		]);
+	});
+});
+
 describe("CustomEditor space-hold push-to-talk", () => {
 	beforeAll(async () => {
 		await initTheme();

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

@@ -64,6 +64,9 @@ 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;
+const URI_SCHEME_REGEX = /^[a-z][a-z0-9+.-]*:/i;
+const FILE_URI_REGEX = /^file:\/\//i;
+const WINDOWS_DRIVE_PATH_REGEX = /^[a-z]:[\\/]/i;
 
 /** Max gap (ms) between two spaces for the later one to count as OS key auto-repeat rather than a
  *  deliberate press. OS auto-repeat is fast; a deliberate tap (even a fast one) is slower. */
@@ -118,6 +121,12 @@ function normalizePastedImagePath(path: string): string {
 	return unquoted.replace(SHELL_ESCAPED_PATH_CHAR_REGEX, "$1");
 }
 
+function isExplicitPastedImagePath(path: string): boolean {
+	if (WINDOWS_DRIVE_PATH_REGEX.test(path) || FILE_URI_REGEX.test(path)) return true;
+	if (URI_SCHEME_REGEX.test(path)) return false;
+	return path.includes("/") || path.includes("\\");
+}
+
 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);
@@ -139,7 +148,7 @@ export function extractBracketedImagePastePaths(data: string): string[] | undefi
 		if (boundaryEnd === undefined) continue;
 
 		const path = normalizePastedImagePath(pasted.slice(segmentStart, boundaryEnd));
-		if (!path || !BRACKETED_IMAGE_PATH_REGEX.test(path)) return undefined;
+		if (!path || !BRACKETED_IMAGE_PATH_REGEX.test(path) || !isExplicitPastedImagePath(path)) return undefined;
 		paths.push(path);
 
 		segmentStart = boundaryEnd;

package/src/modes/components/footer.ts

@@ -142,7 +142,8 @@ export class FooterComponent implements Component {
 		// After compaction, tokens are unknown until the next LLM response.
 		const contextUsage = this.session.getContextUsage();
 		const contextWindow = contextUsage?.contextWindow ?? state.model?.contextWindow ?? 0;
-		const contextPercentValue = contextUsage?.percent ?? 0;
+		const contextTokens = contextUsage?.tokens ?? 0;
+		const contextPercentValue = contextWindow > 0 ? (contextUsage?.percent ?? 0) : null;
 
 		// Replace home directory with ~
 		let pwd = shortenPath(getProjectDir());
@@ -186,8 +187,8 @@ export class FooterComponent implements Component {
 		// Colorize context percentage based on usage
 		let contextPercentStr: string;
 		const autoIndicator = this.#autoCompactEnabled ? " (auto)" : "";
-		const contextPercentDisplay = `${formatContextUsage(contextPercentValue, contextWindow)}${autoIndicator}`;
-		if (contextUsage) {
+		const contextPercentDisplay = `${formatContextUsage(contextPercentValue, contextWindow, contextTokens)}${autoIndicator}`;
+		if (contextUsage && contextPercentValue !== null) {
 			const color = getContextUsageThemeColor(getContextUsageLevel(contextPercentValue, contextWindow));
 			contextPercentStr =
 				color === "statusLineContext" ? contextPercentDisplay : theme.fg(color, contextPercentDisplay);

package/src/modes/components/plugin-settings.ts

@@ -11,6 +11,7 @@
 import {
 	Container,
 	Input,
+	matchesKey,
 	type SelectItem,
 	SelectList,
 	type SettingItem,
@@ -36,13 +37,18 @@ import { DynamicBorder } from "./dynamic-border";
 
 /**
  * Forwards a keystroke to `input`, but cancels via `onCancel` when the user presses Escape.
+ *
+ * Escape is decoded via `matchesKey` rather than a raw `\x1b` compare: inside the
+ * fullscreen settings overlay the kitty keyboard protocol is active (ghostty/kitty),
+ * where the Escape key arrives as the CSI-u sequence `\x1b[27u`, not a bare `\x1b`.
+ * The literal fallbacks preserve legacy single/double-escape on terminals without it.
  */
 export function handleInputOrEscape(
 	data: string,
 	input: { handleInput(data: string): void },
 	onCancel: () => void,
 ): void {
-	if (data === "\x1b" || data === "\x1b\x1b") {
+	if (data === "\x1b" || data === "\x1b\x1b" || matchesKey(data, "escape")) {
 		onCancel();
 		return;
 	}