@oh-my-pi/pi-coding-agent 16.2.2 → 16.2.4

package/src/discovery/codex.ts

@@ -342,12 +342,20 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 	const codexDir = getProjectCodexDir(ctx);
 	const projectHooksDir = path.join(codexDir, "hooks");
 
+	// OMP hooks must be named `pre-<tool>.<ts|js>` or `post-<tool>.<ts|js>`.
+	// Files without that prefix are not OMP hooks (e.g. the standalone Codex
+	// hook scripts users keep alongside) — silently dropping the prefix and
+	// defaulting to `pre:<basename>` caused those scripts to be imported as
+	// extension factories and any top-level `process.exit()` killed startup
+	// (#3680).
 	const transformHook =
-		(level: "user" | "project") => (name: string, _content: string, path: string, source: SourceMeta) => {
+		(level: "user" | "project") =>
+		(name: string, _content: string, path: string, source: SourceMeta): Hook | null => {
 			const baseName = name.replace(/\.(ts|js)$/, "");
 			const match = baseName.match(/^(pre|post)-(.+)$/);
-			const hookType = (match?.[1] as "pre" | "post") || "pre";
-			const toolName = match?.[2] || baseName;
+			if (!match) return null;
+			const hookType = match[1] as "pre" | "post";
+			const toolName = match[2];
 			return {
 				name,
 				path,
@@ -359,11 +367,11 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 		};
 
 	const results = await Promise.all([
-		loadFilesFromDir(ctx, userHooksDir, PROVIDER_ID, "user", {
+		loadFilesFromDir<Hook>(ctx, userHooksDir, PROVIDER_ID, "user", {
 			extensions: ["ts", "js"],
 			transform: transformHook("user"),
 		}),
-		loadFilesFromDir(ctx, projectHooksDir, PROVIDER_ID, "project", {
+		loadFilesFromDir<Hook>(ctx, projectHooksDir, PROVIDER_ID, "project", {
 			extensions: ["ts", "js"],
 			transform: transformHook("project"),
 		}),

package/src/edit/hashline/diff.ts

@@ -9,6 +9,7 @@
  * match is accepted even when the tag was minted by a source that did not keep
  * history, and stale tags recover through the session snapshot store when possible.
  */
+import * as path from "node:path";
 import {
 	type ApplyResult,
 	applyEdits,
@@ -30,6 +31,7 @@ import {
 } from "@oh-my-pi/hashline";
 import { resolveToCwd } from "../../tools/path-utils";
 import { generateDiffString } from "../diff";
+import { canonicalSnapshotKey } from "../file-snapshot-store";
 import { readEditFileText } from "../read-file";
 import { nativeBlockResolver } from "./block-resolver";
 
@@ -90,6 +92,54 @@ async function readSectionTextCached(absolutePath: string, sectionPath: string):
 	return rawContent;
 }
 
+/**
+ * Resolve a missing authored path to a file read this session by matching its
+ * basename and snapshot tag, mirroring {@link Patcher}'s apply-time recovery so
+ * a bare/wrong-directory `[basename#tag]` header previews against the same file
+ * the edit will land on. Returns `undefined` when no unique basename+tag match
+ * exists, leaving the caller to surface the original read error.
+ */
+function recoverSectionPathFromTag(
+	section: PatchSection,
+	authoredAbsolutePath: string,
+	snapshots: SnapshotStore,
+): string | undefined {
+	if (section.fileHash === undefined) return undefined;
+	const authoredName = path.basename(section.path);
+	const authoredKey = canonicalSnapshotKey(authoredAbsolutePath);
+	const candidates = [
+		...new Set(
+			snapshots
+				.findByHash(section.fileHash)
+				.filter(snapshot => path.basename(snapshot.path) === authoredName)
+				.map(snapshot => snapshot.path),
+		),
+	].filter(candidate => candidate !== authoredKey);
+	return candidates.length === 1 ? candidates[0] : undefined;
+}
+
+/**
+ * Read the section's target file for a preview, recovering a bare/mis-typed
+ * `[basename#tag]` path onto the file its tag uniquely names. Recovery fires
+ * only when the authored path is absent — matching {@link Patcher}'s apply-time
+ * order — so a permission/parse error on an existing file surfaces against the
+ * authored path instead of silently previewing a different tagged file. Returns
+ * the path actually read so callers key snapshot lookups off the same file.
+ */
+async function readSectionForPreview(
+	section: PatchSection,
+	authoredAbsolutePath: string,
+	snapshots: SnapshotStore,
+	streaming: boolean | undefined,
+): Promise<{ absolutePath: string; rawContent: string }> {
+	const read = streaming ? readSectionTextCached : readSectionText;
+	const recovered = (await Bun.file(authoredAbsolutePath).exists())
+		? undefined
+		: recoverSectionPathFromTag(section, authoredAbsolutePath, snapshots);
+	const target = recovered ?? authoredAbsolutePath;
+	return { absolutePath: target, rawContent: await read(target, section.path) };
+}
+
 function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => {
 		if (edit.kind === "delete") return true;
@@ -258,10 +308,13 @@ export async function computeHashlineSectionDiff(
 	options: HashlineDiffOptions = {},
 ): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
 	try {
-		const absolutePath = resolveToCwd(section.path, cwd);
-		const rawContent = options.streaming
-			? await readSectionTextCached(absolutePath, section.path)
-			: await readSectionText(absolutePath, section.path);
+		const authoredPath = resolveToCwd(section.path, cwd);
+		const { absolutePath, rawContent } = await readSectionForPreview(
+			section,
+			authoredPath,
+			snapshots,
+			options.streaming,
+		);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
 		// Streaming favors a stable, monotonic preview over an exact unified

package/src/eval/__tests__/julia-prelude.test.ts

@@ -9,7 +9,7 @@ const OWNER_ID = "julia-prelude-tests";
 describe.skipIf(!HAS_JULIA)("eval Julia prelude helpers", () => {
 	afterEach(async () => {
 		await disposeJuliaKernelSessionsByOwner(OWNER_ID);
-	});
+	}, 30_000);
 
 	it("supports output ranges, JSON queries, metadata, and ANSI stripping", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-julia-output-");
@@ -44,7 +44,7 @@ nothing
 		expect(result.output).toContain("STRIPPED=red");
 		expect(result.output).toContain("META=alpha:true");
 		expect(result.output).toContain("MULTI=2:alpha:json");
-	}, 30_000);
+	}, 60_000);
 
 	it("surfaces the exception type and message in the error output, not just stack frames", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-julia-error-");

package/src/eval/js/shared/local-module-loader.ts

@@ -29,6 +29,7 @@ export class LocalModuleLoader {
 	#externalModules = new Map<string, Promise<vm.Module>>();
 	#requireCache = new Map<string, NodeJS.Require>();
 	#modulePaths = new WeakMap<vm.Module, string>();
+	#linkChain: Promise<void> = Promise.resolve();
 
 	constructor(sessionId: string) {
 		this.#context = vm.createContext(globalThis);
@@ -147,7 +148,17 @@ export class LocalModuleLoader {
 	async #linkAndEvaluate(entry: LocalModuleEntry, modulePath: string): Promise<void> {
 		const { module } = entry;
 		try {
-			if (module.status === "unlinked") await module.link(this.#linkResolve);
+			// Serialize the link phase across every graph root. Bun's node:vm linker
+			// segfaults (getImportedModule on a null record) when two link passes
+			// instantiate overlapping module instances concurrently — e.g.
+			// Promise.all([import("./a"), import("./b")]) over a graph that shares
+			// dependencies. Holding the lock for the whole module.link() (including its
+			// async resolver callbacks) guarantees the linker is never re-entered
+			// mid-instantiation. The lock is released before evaluate(), so a dynamic
+			// import during evaluation can re-acquire it without deadlock.
+			await this.#serializeLink(async () => {
+				if (module.status === "unlinked") await module.link(this.#linkResolve);
+			});
 			if (module.status === "linked") await module.evaluate();
 		} catch (error) {
 			this.#invalidateFailedLoad(modulePath);
@@ -159,6 +170,17 @@ export class LocalModuleLoader {
 		}
 	}
 
+	// Promise-chain mutex serializing node:vm link passes (see #linkAndEvaluate).
+	// #linkChain is kept non-rejecting so a failed link never wedges the queue.
+	#serializeLink<T>(run: () => Promise<T>): Promise<T> {
+		const result = this.#linkChain.then(run);
+		this.#linkChain = result.then(
+			() => undefined,
+			() => undefined,
+		);
+		return result;
+	}
+
 	// Shared static-link resolver for `module.link()`. node:vm passes the referencing
 	// module and reuses this one resolver for the entire graph, so the referrer path is
 	// recovered from `#modulePaths`. Local dependencies are constructed but NOT linked or

package/src/export/html/template.js

@@ -1236,7 +1236,7 @@
         let html = `
           <div class="header">
             <h1>Session: ${escapeHtml(header?.id || 'unknown')}</h1>
-            <div class="help-bar">Ctrl+T toggle thinking · Ctrl+O toggle tools</div>
+            <div class="help-bar">T toggle thinking · O toggle tools</div>
             <div class="header-info">
               <div class="info-item"><span class="info-label">Date:</span><span class="info-value">${header?.timestamp ? new Date(header.timestamp).toLocaleString() : 'unknown'}</span></div>
               <div class="info-item"><span class="info-label">Models:</span><span class="info-value">${globalStats.models.join(', ') || 'unknown'}</span></div>
@@ -1580,13 +1580,19 @@
           searchQuery = '';
           navigateTo(leafId, 'bottom');
         }
-        if (e.ctrlKey && e.key === 't') {
+        if (e.key === 't' || e.key === 'T' || e.key === 'o' || e.key === 'O') {
+          // Skip when typing in the sidebar search (or any other editable target)
+          // so the chord can't fire on a user's letter input. Avoid Ctrl/Cmd-based
+          // chords entirely — every major browser reserves Ctrl+T (new tab) and
+          // Ctrl+O (open file), so the shortcut would never reach the page.
+          const t = e.target;
+          const editable =
+            t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.isContentEditable);
+          if (editable) return;
+          if (e.ctrlKey || e.metaKey || e.altKey) return;
           e.preventDefault();
-          toggleThinking();
-        }
-        if (e.ctrlKey && e.key === 'o') {
-          e.preventDefault();
-          toggleToolOutputs();
+          if (e.key === 't' || e.key === 'T') toggleThinking();
+          else toggleToolOutputs();
         }
       });
 

package/src/extensibility/extensions/loader.ts

@@ -24,7 +24,7 @@ import { installLegacyPiSpecifierShim, loadLegacyPiModule } from "../plugins/leg
 import { getAllPluginExtensionPaths } from "../plugins/loader";
 import * as TypeBox from "../typebox";
 
-import { resolvePath } from "../utils";
+import { resolvePath, withExitGuard } from "../utils";
 import type {
 	AssistantThinkingRenderer,
 	Extension,
@@ -290,7 +290,7 @@ async function loadExtension(
 ): Promise<{ extension: Extension | null; error: string | null }> {
 	const resolvedPath = resolvePath(extensionPath, cwd);
 	try {
-		const module = (await loadLegacyPiModule(resolvedPath)) as LoadedExtensionModule;
+		const module = (await withExitGuard(() => loadLegacyPiModule(resolvedPath))) as LoadedExtensionModule;
 		const factory = getExtensionFactory(module);
 
 		if (typeof factory !== "function") {
@@ -302,7 +302,9 @@ async function loadExtension(
 
 		const extension = createExtension(extensionPath, resolvedPath);
 		const api = new ConcreteExtensionAPI(PiCodingAgent, extension, runtime, cwd, eventBus);
-		await factory(api);
+		await withExitGuard(async () => {
+			await factory(api);
+		});
 
 		return { extension, error: null };
 	} catch (err) {

package/src/extensibility/extensions/wrapper.ts

@@ -6,7 +6,7 @@ import type { ImageContent, Static, TextContent, TSchema } from "@oh-my-pi/pi-ai
 import type { Settings } from "../../config/settings";
 import type { Theme } from "../../modes/theme/theme";
 import { type ApprovalMode, formatApprovalPrompt, requiresApproval } from "../../tools/approval";
-import { normalizeToolEventInput } from "../tool-event-input";
+import { normalizeToolEventInput, resolveToolEventInput } from "../tool-event-input";
 import { applyToolProxy } from "../tool-proxy";
 import type { ExtensionRunner } from "./runner";
 import type { RegisteredTool, ToolCallEventResult } from "./types";
@@ -186,7 +186,10 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 					type: "tool_call",
 					toolName: this.tool.name,
 					toolCallId,
-					input: normalizeToolEventInput(this.tool.name, params as Record<string, unknown>),
+					input: normalizeToolEventInput(
+						this.tool.name,
+						resolveToolEventInput(this.tool, params as Record<string, unknown>),
+					),
 				})) as ToolCallEventResult | undefined;
 
 				if (callResult?.block) {
@@ -221,7 +224,10 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 				type: "tool_result",
 				toolName: this.tool.name,
 				toolCallId,
-				input: normalizeToolEventInput(this.tool.name, params as Record<string, unknown>),
+				input: normalizeToolEventInput(
+					this.tool.name,
+					resolveToolEventInput(this.tool, params as Record<string, unknown>),
+				),
 				content: result.content,
 				details: result.details,
 				isError: !!executionError,

package/src/extensibility/hooks/loader.ts

@@ -12,7 +12,7 @@ import { loadCapability } from "../../discovery";
 import * as PiCodingAgent from "../../index";
 import type { HookMessage } from "../../session/messages";
 import * as typebox from "../typebox";
-import { resolvePath } from "../utils";
+import { resolvePath, withExitGuard } from "../utils";
 import { execCommand } from "./runner";
 import type { ExecOptions, HookAPI, HookFactory, HookMessageRenderer, RegisteredCommand } from "./types";
 
@@ -149,7 +149,7 @@ async function loadHook(hookPath: string, cwd: string): Promise<{ hook: LoadedHo
 
 	try {
 		// Import the module using native Bun import
-		const module = await import(resolvedPath);
+		const module = await withExitGuard(() => import(resolvedPath));
 		const factory = module.default as HookFactory;
 
 		if (typeof factory !== "function") {
@@ -164,7 +164,7 @@ async function loadHook(hookPath: string, cwd: string): Promise<{ hook: LoadedHo
 		);
 
 		// Call factory to register handlers
-		factory(api);
+		await withExitGuard(async () => factory(api));
 
 		return {
 			hook: {

package/src/extensibility/hooks/tool-wrapper.ts

@@ -3,7 +3,7 @@
  */
 import type { AgentTool, AgentToolContext, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Static, TSchema } from "@oh-my-pi/pi-ai";
-import { normalizeToolEventInput } from "../tool-event-input";
+import { normalizeToolEventInput, resolveToolEventInput } from "../tool-event-input";
 import { applyToolProxy } from "../tool-proxy";
 import type { HookRunner } from "./runner";
 import type { ToolCallEventResult, ToolResultEventResult } from "./types";
@@ -47,7 +47,10 @@ export class HookToolWrapper<TParameters extends TSchema = TSchema, TDetails = u
 					type: "tool_call",
 					toolName: this.tool.name,
 					toolCallId,
-					input: normalizeToolEventInput(this.tool.name, params as Record<string, unknown>),
+					input: normalizeToolEventInput(
+						this.tool.name,
+						resolveToolEventInput(this.tool, params as Record<string, unknown>),
+					),
 				})) as ToolCallEventResult | undefined;
 
 				if (callResult?.block) {
@@ -73,7 +76,10 @@ export class HookToolWrapper<TParameters extends TSchema = TSchema, TDetails = u
 					type: "tool_result",
 					toolName: this.tool.name,
 					toolCallId,
-					input: normalizeToolEventInput(this.tool.name, params as Record<string, unknown>),
+					input: normalizeToolEventInput(
+						this.tool.name,
+						resolveToolEventInput(this.tool, params as Record<string, unknown>),
+					),
 					content: result.content,
 					details: result.details,
 					isError: false,
@@ -96,7 +102,10 @@ export class HookToolWrapper<TParameters extends TSchema = TSchema, TDetails = u
 					type: "tool_result",
 					toolName: this.tool.name,
 					toolCallId,
-					input: normalizeToolEventInput(this.tool.name, params as Record<string, unknown>),
+					input: normalizeToolEventInput(
+						this.tool.name,
+						resolveToolEventInput(this.tool, params as Record<string, unknown>),
+					),
 					content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
 					details: undefined,
 					isError: true,

package/src/extensibility/plugins/manager.ts

@@ -11,6 +11,7 @@ import {
 	isEnoent,
 	logger,
 } from "@oh-my-pi/pi-utils";
+import { withExitGuard } from "../utils";
 import { type GitSource, parseGitUrl } from "./git-url";
 import { installLegacyPiSpecifierShim, loadLegacyPiModule } from "./legacy-pi-compat";
 import { resolvePluginManifestEntries } from "./loader";
@@ -363,7 +364,7 @@ export class PluginManager {
 			installLegacyPiSpecifierShim();
 			for (const extensionPath of loadable) {
 				try {
-					const module = await loadLegacyPiModule(extensionPath);
+					const module = await withExitGuard(() => loadLegacyPiModule(extensionPath));
 					if (!hasExtensionFactoryExport(module)) {
 						errors.push(`${extensionPath}: extension does not export a valid factory function`);
 					}

package/src/extensibility/tool-event-input.ts

@@ -1,6 +1,29 @@
 const HASHLINE_FILE_PREFIX = "¶";
 const HASHLINE_FILE_TAG_RE = /#[0-9a-fA-F]{4}$/u;
 
+interface ToolEventInputResolver {
+	name: string;
+	resolveEventInput?: (input: string) => string;
+}
+
+/** Resolves mode-specific textual tool input before extension/hook event normalization. */
+export function resolveToolEventInput(
+	tool: ToolEventInputResolver,
+	input: Record<string, unknown>,
+): Record<string, unknown> {
+	if (tool.name !== "edit" || typeof tool.resolveEventInput !== "function") return input;
+	let resolved = input;
+	for (const key of ["input", "_input"] as const) {
+		const value = stringField(resolved, key);
+		if (value === undefined) continue;
+		const nextValue = tool.resolveEventInput(value);
+		if (nextValue === value) continue;
+		if (resolved === input) resolved = { ...input };
+		resolved[key] = nextValue;
+	}
+	return resolved;
+}
+
 function stringField(input: Record<string, unknown>, key: string): string | undefined {
 	const value = input[key];
 	return typeof value === "string" && value.length > 0 ? value : undefined;

package/src/extensibility/utils.ts

@@ -42,3 +42,77 @@ export function createNoOpUIContext(): HookUIContext {
 		},
 	};
 }
+
+/**
+ * Raised by {@link withExitGuard} when a guarded callback synchronously
+ * attempts to terminate the host process. Callers catch this like any other
+ * load-time failure so the extension/hook is skipped with a logged error
+ * instead of taking the CLI down with it.
+ */
+export class ExtensionExitError extends Error {
+	readonly code: number | string | undefined;
+	constructor(
+		code: number | string | undefined,
+		readonly alias = "process.exit",
+	) {
+		super(
+			`Module called ${alias}(${code === undefined ? "" : String(code)}) during guarded extension/hook loading; ` +
+				`OMP extension/hook modules must not terminate the host process.`,
+		);
+		this.name = "ExtensionExitError";
+		this.code = code;
+	}
+}
+
+type ExitAliasName = "process.exit" | "process.reallyExit";
+
+let exitGuardDepth = 0;
+let exitGuardOriginalProcessExit: typeof process.exit | null = null;
+let exitGuardOriginalReallyExit: typeof process.reallyExit | null = null;
+
+/**
+ * Run `fn` with hard-exit APIs patched so any synchronous attempt to terminate
+ * the host raises {@link ExtensionExitError} instead. Restored in `finally`.
+ *
+ * Guards the dynamic-import and factory-invocation sites that load third-party
+ * extension / hook modules — a `process.exit(0)` or `process.reallyExit(0)` in
+ * a stranger's script (e.g. a Codex hook script that happens to live next to
+ * OMP-shaped modules) would otherwise kill OMP during startup with no error
+ * surface, since `try/catch` cannot intercept a synchronous exit.
+ *
+ * Nested and concurrent guard windows are safe: only the outermost guard
+ * restores the real hard-exit APIs.
+ */
+function guardedExit(alias: ExitAliasName): (code?: number | string) => never {
+	return (code?: number | string): never => {
+		throw new ExtensionExitError(code, alias);
+	};
+}
+
+export async function withExitGuard<T>(fn: () => Promise<T>): Promise<T> {
+	if (exitGuardDepth === 0) {
+		exitGuardOriginalProcessExit = process.exit;
+		process.exit = guardedExit("process.exit") as typeof process.exit;
+
+		if (typeof process.reallyExit === "function") {
+			exitGuardOriginalReallyExit = process.reallyExit;
+			process.reallyExit = guardedExit("process.reallyExit") as typeof process.reallyExit;
+		}
+	}
+	exitGuardDepth++;
+	try {
+		return await fn();
+	} finally {
+		exitGuardDepth--;
+		if (exitGuardDepth === 0) {
+			if (exitGuardOriginalProcessExit) {
+				process.exit = exitGuardOriginalProcessExit;
+				exitGuardOriginalProcessExit = null;
+			}
+			if (exitGuardOriginalReallyExit) {
+				process.reallyExit = exitGuardOriginalReallyExit;
+				exitGuardOriginalReallyExit = null;
+			}
+		}
+	}
+}