@oh-my-pi/pi-coding-agent 16.1.18 → 16.1.20

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as url from "node:url";
 import { isCompiledBinary } from "@oh-my-pi/pi-utils";
+import { BUNDLED_PI_REGISTRY_KEYS } from "./legacy-pi-bundled-keys";
 
 const IS_COMPILED_BINARY = isCompiledBinary();
 
@@ -344,20 +345,34 @@ export function __validateLegacyPiPackageRootOverrides(
 	);
 }
 
-const LEGACY_PI_PACKAGE_ROOT_OVERRIDES = __validateLegacyPiPackageRootOverrides({
-	[`${CANONICAL_PI_SCOPE}/pi-ai`]: LEGACY_PI_AI_SHIM_PATH,
-	[`${CANONICAL_PI_SCOPE}/pi-coding-agent`]: LEGACY_PI_CODING_AGENT_SHIM_PATH,
-	...(IS_COMPILED_BINARY
-		? {
-				[`${CANONICAL_PI_SCOPE}/pi-agent-core`]: bundledRegistryVirtualSpecifier(
-					`${CANONICAL_PI_SCOPE}/pi-agent-core`,
-				),
-				[`${CANONICAL_PI_SCOPE}/pi-natives`]: bundledRegistryVirtualSpecifier(`${CANONICAL_PI_SCOPE}/pi-natives`),
-				[`${CANONICAL_PI_SCOPE}/pi-tui`]: bundledRegistryVirtualSpecifier(`${CANONICAL_PI_SCOPE}/pi-tui`),
-				[`${CANONICAL_PI_SCOPE}/pi-utils`]: bundledRegistryVirtualSpecifier(`${CANONICAL_PI_SCOPE}/pi-utils`),
-			}
-		: {}),
-});
+/**
+ * Compute the override map keyed by every canonical specifier the host serves
+ * directly: the pi-ai / pi-coding-agent roots (compat shims that re-attach
+ * legacy helpers) plus, in compiled-binary mode, every other canonical pi-*
+ * package root AND every non-wildcard subpath registered in the bundled
+ * registry (see `legacy-pi-bundled-keys.ts`). Subpath coverage is what stops
+ * `@(scope)/pi-ai/oauth` and friends from falling through to the extension's
+ * own — possibly absent — peer install when bunfs filesystem walks fail
+ * (issue #3442 follow-up to #3423). Exported as a test seam so the
+ * compiled-binary branch is verifiable from dev tests.
+ */
+export function __buildLegacyPiPackageRootOverrides(isCompiled: boolean): Record<string, string> {
+	const candidates: Record<string, string> = {
+		[`${CANONICAL_PI_SCOPE}/pi-ai`]: LEGACY_PI_AI_SHIM_PATH,
+		[`${CANONICAL_PI_SCOPE}/pi-coding-agent`]: LEGACY_PI_CODING_AGENT_SHIM_PATH,
+	};
+	if (isCompiled) {
+		for (const key of BUNDLED_PI_REGISTRY_KEYS) {
+			// Shim-bearing roots above already mapped to their compat surface;
+			// the bundled typebox shim has a dedicated TYPEBOX_SHIM_PATH route.
+			if (key in candidates || key === TYPEBOX_BUNDLED_REGISTRY_KEY) continue;
+			candidates[key] = bundledRegistryVirtualSpecifier(key);
+		}
+	}
+	return __validateLegacyPiPackageRootOverrides(candidates);
+}
+
+const LEGACY_PI_PACKAGE_ROOT_OVERRIDES = __buildLegacyPiPackageRootOverrides(IS_COMPILED_BINARY);
 
 let isLegacyPiSpecifierShimInstalled = false;
 

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

@@ -49,6 +49,121 @@ function getContentType(filePath: string): InternalResource["contentType"] {
 	return "text/plain";
 }
 
+const LOCAL_TEXT_SNIFF_BYTES = 8 * 1024;
+const LOCAL_TEXT_RESOURCE_MAX_BYTES = 1024 * 1024;
+const BINARY_FILE_EXTENSIONS = new Set([
+	".7z",
+	".avi",
+	".bmp",
+	".bz2",
+	".db",
+	".doc",
+	".docx",
+	".gif",
+	".gz",
+	".ico",
+	".jpeg",
+	".jpg",
+	".m4v",
+	".mkv",
+	".mov",
+	".mp4",
+	".pdf",
+	".png",
+	".ppt",
+	".pptx",
+	".rar",
+	".sqlite",
+	".tgz",
+	".webm",
+	".webp",
+	".wmv",
+	".xls",
+	".xlsx",
+	".xz",
+	".zip",
+]);
+
+function formatLocalByteSize(bytes: number): string {
+	if (bytes < 1024) return `${bytes} B`;
+	const kib = bytes / 1024;
+	if (kib < 1024) return `${kib.toFixed(1)} KiB`;
+	const mib = kib / 1024;
+	if (mib < 1024) return `${mib.toFixed(1)} MiB`;
+	return `${(mib / 1024).toFixed(1)} GiB`;
+}
+
+function buildNonTextLocalResource(url: InternalUrl, filePath: string, size: number, reason: string): InternalResource {
+	const content = `[Cannot read binary local:// file '${url.href}' (${formatLocalByteSize(size)}): ${reason}. This resource is not text. Use a metadata/key-frame/video-specific workflow instead.]`;
+	return {
+		url: url.href,
+		content,
+		contentType: "text/plain",
+		size: Buffer.byteLength(content, "utf-8"),
+		sourcePath: filePath,
+		notes: [LOCAL_WRITE_NOTE],
+	};
+}
+
+function buildLargeLocalTextResource(url: InternalUrl, filePath: string, size: number): InternalResource {
+	const content = `[Cannot materialize local:// file '${url.href}' as an internal text resource (${formatLocalByteSize(size)} exceeds ${formatLocalByteSize(LOCAL_TEXT_RESOURCE_MAX_BYTES)}). Use the read tool's filesystem path handling or a line selector so content is streamed with file-size safeguards.]`;
+	return {
+		url: url.href,
+		content,
+		contentType: "text/plain",
+		size: Buffer.byteLength(content, "utf-8"),
+		sourcePath: filePath,
+		notes: [LOCAL_WRITE_NOTE],
+	};
+}
+
+async function readFilePrefix(filePath: string, maxBytes: number): Promise<Uint8Array> {
+	if (maxBytes <= 0) return new Uint8Array();
+	const handle = await fs.open(filePath, "r");
+	try {
+		const buffer = Buffer.allocUnsafe(maxBytes);
+		const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+		return buffer.subarray(0, bytesRead);
+	} finally {
+		await handle.close();
+	}
+}
+
+function isUtf8Text(bytes: Uint8Array): boolean {
+	if (bytes.indexOf(0) !== -1) return false;
+	try {
+		new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function buildFileResource(
+	url: InternalUrl,
+	resolved: Extract<ResolvedLocalTarget, { kind: "file" }>,
+): Promise<InternalResource> {
+	if (BINARY_FILE_EXTENSIONS.has(path.extname(resolved.path).toLowerCase())) {
+		return buildNonTextLocalResource(url, resolved.path, resolved.size, "extension is a known binary/container type");
+	}
+	const sniffBytes = await readFilePrefix(resolved.path, Math.min(resolved.size, LOCAL_TEXT_SNIFF_BYTES));
+	if (!isUtf8Text(sniffBytes)) {
+		return buildNonTextLocalResource(url, resolved.path, resolved.size, "content is not valid UTF-8 text");
+	}
+	if (resolved.size > LOCAL_TEXT_RESOURCE_MAX_BYTES) {
+		return buildLargeLocalTextResource(url, resolved.path, resolved.size);
+	}
+	const content = await Bun.file(resolved.path).text();
+	return {
+		url: url.href,
+		content,
+		contentType: getContentType(resolved.path),
+		size: Buffer.byteLength(content, "utf-8"),
+		sourcePath: resolved.path,
+		notes: [LOCAL_WRITE_NOTE],
+	};
+}
+
 async function listFilesRecursively(rootPath: string): Promise<string[]> {
 	const pending = [""];
 	const files: string[] = [];
@@ -336,15 +451,7 @@ export class LocalProtocolHandler implements ProtocolHandler {
 			return buildDirectoryResource(url.href, resolved.path, [LOCAL_WRITE_NOTE]);
 		}
 
-		const content = await Bun.file(resolved.path).text();
-		return {
-			url: url.href,
-			content,
-			contentType: getContentType(resolved.path),
-			size: Buffer.byteLength(content, "utf-8"),
-			sourcePath: resolved.path,
-			notes: [LOCAL_WRITE_NOTE],
-		};
+		return buildFileResource(url, resolved);
 	}
 
 	async complete(_query?: string, context?: ResolveContext): Promise<UrlCompletion[]> {

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

@@ -13,7 +13,7 @@ import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import { getActiveSkills } from "../extensibility/skills";
 import { buildDirectoryResource } from "./filesystem-resource";
-import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
 
 function getContentType(filePath: string): InternalResource["contentType"] {
 	const ext = path.extname(filePath).toLowerCase();
@@ -42,8 +42,8 @@ export class SkillProtocolHandler implements ProtocolHandler {
 	readonly scheme = "skill";
 	readonly immutable = true;
 
-	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const skills = getActiveSkills();
+	async resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		const skills = context?.skills ?? getActiveSkills();
 
 		const skillName = url.rawHost || url.hostname;
 		if (!skillName) {

package/src/internal-urls/types.ts

@@ -5,6 +5,7 @@
  * providing access to agent outputs and server resources without exposing filesystem paths.
  */
 
+import type { Skill } from "../extensibility/skills";
 import type { LocalProtocolOptions } from "./local-protocol";
 
 /**
@@ -90,6 +91,8 @@ export interface ResolveContext {
 	 * [#1608](https://github.com/can1357/oh-my-pi/issues/1608).
 	 */
 	localProtocolOptions?: LocalProtocolOptions;
+	/** Calling session's loaded skills. Prefer this over process-global skill state. */
+	skills?: readonly Skill[];
 }
 
 /**

package/src/main.ts

@@ -140,6 +140,7 @@ const HOST_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	"advisor.subagents",
 	"advisor.syncBacklog",
 	"advisor.immuneTurns",
+	"serviceTierAdvisor",
 ];
 
 const RPC_BACKGROUND_DEFAULTED_SETTING_PATHS: SettingPath[] = [

package/src/mcp/transports/stdio.ts

@@ -340,6 +340,10 @@ export class StdioTransport implements MCPTransport {
 			platform: process.platform,
 		});
 
+		// Spawn in a new session (detached → setsid) so the MCP process tree has
+		// no controlling terminal. Otherwise terminal job-control signals (Ctrl+Z
+		// SIGTSTP, background-read SIGTTIN) can stop stdio servers such as
+		// chrome-devtools-mcp and leave our read loop blocked on silent pipes.
 		this.#process = spawn({
 			cmd: spawnCommand.cmd,
 			cwd,
@@ -348,6 +352,7 @@ export class StdioTransport implements MCPTransport {
 			stdout: "pipe",
 			stderr: "pipe",
 			windowsHide: spawnCommand.windowsHide,
+			detached: true,
 		});
 
 		this.#connected = true;

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

@@ -93,15 +93,17 @@ describe("CustomEditor bracketed path paste", () => {
 		expect(extractBracketedImagePastePaths(bracketedPaste("/tmp/report.csv"))).toBeUndefined();
 	});
 
-	it("routes non-image path pastes through the file-path hook", async () => {
+	it("inserts non-image path pastes as literal text instead of attaching them", () => {
 		const { editor } = makeEditor();
-		const pasted = Promise.withResolvers<string>();
-		editor.onPasteFilePath = path => pasted.resolve(path);
+		let imagePathCalls = 0;
+		editor.onPasteImagePath = () => {
+			imagePathCalls++;
+		};
 
 		editor.handleInput(bracketedPaste("/tmp/report.csv"));
 
-		expect(await pasted.promise).toBe("/tmp/report.csv");
-		expect(editor.getText()).toBe("");
+		expect(editor.getText()).toBe("/tmp/report.csv");
+		expect(imagePathCalls).toBe(0);
 	});
 });
 

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

@@ -318,8 +318,6 @@ export class CustomEditor extends Editor {
 	onPasteImage?: () => Promise<boolean>;
 	/** Called when a bracketed paste contains one or more image-file paths. */
 	onPasteImagePath?: (path: string) => void | Promise<void>;
-	/** Called when a bracketed paste contains one or more non-image file paths. */
-	onPasteFilePath?: (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. */
@@ -505,20 +503,12 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
-		const pastedPaths = extractBracketedPastePaths(data);
-		if (pastedPaths) {
-			const canHandlePaths = pastedPaths.every(path =>
-				isImagePath(path) ? this.onPasteImagePath !== undefined : this.onPasteFilePath !== undefined,
-			);
-			if (canHandlePaths) {
-				void (async () => {
-					for (const path of pastedPaths) {
-						if (isImagePath(path)) await this.onPasteImagePath?.(path);
-						else await this.onPasteFilePath?.(path);
-					}
-				})();
-				return;
-			}
+		const pastedImagePaths = extractBracketedImagePastePaths(data);
+		if (pastedImagePaths && this.onPasteImagePath) {
+			void (async () => {
+				for (const path of pastedImagePaths) await this.onPasteImagePath?.(path);
+			})();
+			return;
 		}
 
 		const parsedKey = parseKey(data);