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

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;
+			}
+		}
+	}
+}