@oh-my-pi/pi-coding-agent 6.7.670 → 6.8.0

package/src/core/bash-executor.ts

@@ -1,179 +1,137 @@
 /**
  * Bash command execution with streaming support and cancellation.
  *
- * This module provides a unified bash execution implementation used by:
- * - AgentSession.executeBash() for interactive and RPC modes
- * - Direct calls from modes that need bash execution
+ * Provides unified bash execution for AgentSession.executeBash() and direct calls.
  */
 
-import type { Subprocess } from "bun";
-import { getShellConfig, killProcessTree } from "../utils/shell";
+import { cspawn, Exception } from "@oh-my-pi/pi-utils";
+import { getShellConfig } from "../utils/shell";
 import { getOrCreateSnapshot, getSnapshotSourceCommand } from "../utils/shell-snapshot";
-import { OutputSink, pumpStream } from "./streaming-output";
+import { OutputSink } from "./streaming-output";
 import type { BashOperations } from "./tools/bash";
-import { DEFAULT_MAX_BYTES } from "./tools/truncate";
-import { ScopeSignal } from "./utils";
-
-// ============================================================================
-// Types
-// ============================================================================
 
 export interface BashExecutorOptions {
-	/** Working directory for command execution */
 	cwd?: string;
-	/** Timeout in milliseconds */
 	timeout?: number;
-	/** Callback for streaming output chunks (already sanitized) */
 	onChunk?: (chunk: string) => void;
-	/** AbortSignal for cancellation */
 	signal?: AbortSignal;
 }
 
 export interface BashResult {
-	/** Combined stdout + stderr output (sanitized, possibly truncated) */
 	output: string;
-	/** Process exit code (undefined if killed/cancelled) */
 	exitCode: number | undefined;
-	/** Whether the command was cancelled via signal */
 	cancelled: boolean;
-	/** Whether the output was truncated */
 	truncated: boolean;
-	/** Path to temp file containing full output (if output exceeded truncation threshold) */
 	fullOutputPath?: string;
 }
 
-// ============================================================================
-// Implementation
-// ============================================================================
-
-/**
- * Execute a bash command with optional streaming and cancellation support.
- *
- * Features:
- * - Streams sanitized output via onChunk callback
- * - Writes large output to temp file for later retrieval
- * - Supports cancellation via AbortSignal
- * - Sanitizes output (strips ANSI, removes binary garbage, normalizes newlines)
- * - Truncates output if it exceeds the default max bytes
- *
- * @param command - The bash command to execute
- * @param options - Optional streaming callback and abort signal
- * @returns Promise resolving to execution result
- */
 export async function executeBash(command: string, options?: BashExecutorOptions): Promise<BashResult> {
 	const { shell, args, env, prefix } = await getShellConfig();
 
-	// Get or create shell snapshot (for aliases, functions, options)
 	const snapshotPath = await getOrCreateSnapshot(shell, env);
 	const snapshotPrefix = getSnapshotSourceCommand(snapshotPath);
 
-	// Build final command: snapshot + prefix + command
 	const prefixedCommand = prefix ? `${prefix} ${command}` : command;
 	const finalCommand = `${snapshotPrefix}${prefixedCommand}`;
 
-	using signal = new ScopeSignal(options);
+	const stream = new OutputSink({ onLine: options?.onChunk });
 
-	const child: Subprocess = Bun.spawn([shell, ...args, finalCommand], {
+	const child = cspawn([shell, ...args, finalCommand], {
 		cwd: options?.cwd,
-		stdin: "ignore",
-		stdout: "pipe",
-		stderr: "pipe",
 		env,
+		signal: options?.signal,
+		timeout: options?.timeout,
 	});
 
-	signal.catch(() => {
-		killProcessTree(child.pid);
-	});
+	// Pump streams - errors during abort/timeout are expected
+	await Promise.allSettled([
+		child.stdout.pipeTo(stream.createWritable()),
+		child.stderr.pipeTo(stream.createWritable()),
+	])
+		.then(() => stream.close())
+		.catch(() => {});
 
-	const sink = new OutputSink(DEFAULT_MAX_BYTES, DEFAULT_MAX_BYTES * 2, options?.onChunk);
-
-	const writer = sink.getWriter();
+	// Wait for process exit
 	try {
-		await Promise.all([
-			pumpStream(child.stdout as ReadableStream<Uint8Array>, writer),
-			pumpStream(child.stderr as ReadableStream<Uint8Array>, writer),
-		]);
-	} finally {
-		await writer.close();
-	}
-
-	// Non-zero exit codes or signal-killed processes are considered cancelled if killed via signal
-	const exitCode = await child.exited;
-
-	const cancelled = exitCode === null || (exitCode !== 0 && (options?.signal?.aborted ?? false));
-
-	if (signal.timedOut()) {
-		const secs = Math.round(options!.timeout! / 1000);
+		await child.exited;
 		return {
-			exitCode: undefined,
-			cancelled: true,
-			...sink.dump(`Command timed out after ${secs} seconds`),
+			exitCode: child.exitCode ?? 0,
+			cancelled: false,
+			...stream.dump(),
 		};
-	}
+	} catch (err) {
+		// Exception covers NonZeroExitError, AbortError, TimeoutError
+		if (err instanceof Exception) {
+			if (err.aborted) {
+				const isTimeout = err.message.includes("timed out");
+				const annotation = isTimeout
+					? `Command timed out after ${Math.round((options?.timeout ?? 0) / 1000)} seconds`
+					: undefined;
+				return {
+					exitCode: undefined,
+					cancelled: true,
+					...stream.dump(annotation),
+				};
+			}
+
+			// NonZeroExitError
+			return {
+				exitCode: err.exitCode,
+				cancelled: false,
+				...stream.dump(),
+			};
+		}
 
-	return {
-		exitCode: cancelled ? undefined : exitCode,
-		cancelled,
-		...sink.dump(),
-	};
+		throw err;
+	}
 }
 
-/**
- * Execute a bash command using custom BashOperations.
- * Used for remote execution (SSH, containers, etc.).
- */
 export async function executeBashWithOperations(
 	command: string,
 	cwd: string,
 	operations: BashOperations,
 	options?: BashExecutorOptions,
 ): Promise<BashResult> {
-	const sink = new OutputSink(DEFAULT_MAX_BYTES, DEFAULT_MAX_BYTES * 2, options?.onChunk);
-	const writer = sink.getWriter();
-
-	// Create a ReadableStream from the callback-based operations.exec
-	let streamController: ReadableStreamDefaultController<Uint8Array>;
-	const dataStream = new ReadableStream<Uint8Array>({
-		start(controller) {
-			streamController = controller;
-		},
-	});
-
-	const onData = (data: Buffer) => {
-		streamController.enqueue(new Uint8Array(data));
+	const stream = new OutputSink({ onLine: options?.onChunk });
+	const writable = stream.createWritable();
+	const writer = writable.getWriter();
+
+	const closeStreams = async () => {
+		try {
+			await writer.close();
+		} catch {}
+		try {
+			await writable.close();
+		} catch {}
+		try {
+			await stream.close();
+		} catch {}
 	};
 
-	// Start pumping the stream (will complete when stream closes)
-	const pumpPromise = pumpStream(dataStream, writer);
-
 	try {
 		const result = await operations.exec(command, cwd, {
-			onData,
+			onData: (data) => writer.write(data),
 			signal: options?.signal,
 			timeout: options?.timeout,
 		});
 
-		streamController!.close();
-		await pumpPromise;
-		await writer.close();
+		await closeStreams();
 
 		const cancelled = options?.signal?.aborted ?? false;
 
 		return {
 			exitCode: cancelled ? undefined : (result.exitCode ?? undefined),
 			cancelled,
-			...sink.dump(),
+			...stream.dump(),
 		};
 	} catch (err) {
-		streamController!.close();
-		await pumpPromise;
-		await writer.close();
+		await closeStreams();
 
 		if (options?.signal?.aborted) {
 			return {
 				exitCode: undefined,
 				cancelled: true,
-				...sink.dump(),
+				...stream.dump(),
 			};
 		}
 

package/src/core/custom-commands/loader.ts

@@ -7,11 +7,11 @@
 
 import { type Dirent, existsSync, readdirSync } from "node:fs";
 import * as path from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 import * as typebox from "@sinclair/typebox";
 import { getAgentDir, getConfigDirs } from "../../config";
 import * as piCodingAgent from "../../index";
 import { execCommand } from "../exec";
-import { logger } from "../logger";
 import { ReviewCommand } from "./bundled/review";
 import { WorktreeCommand } from "./bundled/wt";
 import type {

package/src/core/custom-tools/loader.ts

@@ -6,6 +6,7 @@
  */
 
 import * as path from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 import * as typebox from "@sinclair/typebox";
 import { toolCapability } from "../../capability/tool";
 import { type CustomTool, loadCapability } from "../../discovery";
@@ -15,7 +16,6 @@ import { theme } from "../../modes/interactive/theme/theme";
 import type { ExecOptions } from "../exec";
 import { execCommand } from "../exec";
 import type { HookUIContext } from "../hooks/types";
-import { logger } from "../logger";
 import { getAllPluginToolPaths } from "../plugins/loader";
 import type { CustomToolAPI, CustomToolFactory, LoadedCustomTool, ToolLoadError } from "./types";
 

package/src/core/custom-tools/types.ts

@@ -12,7 +12,6 @@ import type { Static, TSchema } from "@sinclair/typebox";
 import type { Theme } from "../../modes/interactive/theme/theme";
 import type { ExecOptions, ExecResult } from "../exec";
 import type { HookUIContext } from "../hooks/types";
-import type { Logger } from "../logger";
 import type { ModelRegistry } from "../model-registry";
 import type { ReadonlySessionManager } from "../session-manager";
 
@@ -36,7 +35,7 @@ export interface CustomToolAPI {
 	/** Whether UI is available (false in print/RPC mode) */
 	hasUI: boolean;
 	/** File logger for error/warning/debug messages */
-	logger: Logger;
+	logger: typeof import("@oh-my-pi/pi-utils").logger;
 	/** Injected @sinclair/typebox module */
 	typebox: typeof import("@sinclair/typebox");
 	/** Injected pi-coding-agent exports */

package/src/core/exec.ts

@@ -2,8 +2,7 @@
  * Shared command execution utilities for hooks and custom tools.
  */
 
-import type { Subprocess } from "bun";
-import { logger } from "./logger";
+import { ptree } from "@oh-my-pi/pi-utils";
 
 /**
  * Options for executing shell commands.
@@ -37,103 +36,20 @@ export async function execCommand(
 	cwd: string,
 	options?: ExecOptions,
 ): Promise<ExecResult> {
-	return new Promise((resolve) => {
-		const proc: Subprocess = Bun.spawn([command, ...args], {
-			cwd,
-			stdin: "ignore",
-			stdout: "pipe",
-			stderr: "pipe",
-		});
-
-		let stdout = "";
-		let stderr = "";
-		let killed = false;
-		let timeoutId: Timer | undefined;
-
-		const killProcess = () => {
-			if (!killed) {
-				killed = true;
-				proc.kill();
-				// Force kill after 5 seconds if first kill doesn't work
-				setTimeout(() => {
-					try {
-						proc.kill(9);
-					} catch {
-						// Ignore if already dead
-					}
-				}, 5000);
-			}
-		};
-
-		// Handle abort signal
-		if (options?.signal) {
-			if (options.signal.aborted) {
-				killProcess();
-			} else {
-				options.signal.addEventListener("abort", killProcess, { once: true });
-			}
-		}
-
-		// Handle timeout
-		if (options?.timeout && options.timeout > 0) {
-			timeoutId = setTimeout(() => {
-				killProcess();
-			}, options.timeout);
-		}
-
-		// Read streams asynchronously
-		(async () => {
-			try {
-				const stdoutReader = (proc.stdout as ReadableStream<Uint8Array>).getReader();
-				const stderrReader = (proc.stderr as ReadableStream<Uint8Array>).getReader();
-
-				// Read both streams and wait for process exit
-				const [stdoutResult, stderrResult, exitCode] = await Promise.all([
-					(async () => {
-						const chunks: Uint8Array[] = [];
-						try {
-							while (true) {
-								const { done, value } = await stdoutReader.read();
-								if (done) break;
-								chunks.push(value);
-							}
-						} finally {
-							stdoutReader.releaseLock();
-						}
-						return Buffer.concat(chunks).toString();
-					})(),
-					(async () => {
-						const chunks: Uint8Array[] = [];
-						try {
-							while (true) {
-								const { done, value } = await stderrReader.read();
-								if (done) break;
-								chunks.push(value);
-							}
-						} finally {
-							stderrReader.releaseLock();
-						}
-						return Buffer.concat(chunks).toString();
-					})(),
-					proc.exited,
-				]);
-
-				stdout = stdoutResult;
-				stderr = stderrResult;
-
-				if (timeoutId) clearTimeout(timeoutId);
-				if (options?.signal) {
-					options.signal.removeEventListener("abort", killProcess);
-				}
-				resolve({ stdout, stderr, code: exitCode ?? 0, killed });
-			} catch (err) {
-				logger.debug("Process stream error", { error: String(err) });
-				if (timeoutId) clearTimeout(timeoutId);
-				if (options?.signal) {
-					options.signal.removeEventListener("abort", killProcess);
-				}
-				resolve({ stdout, stderr, code: 1, killed });
-			}
-		})();
+	const proc = ptree.cspawn([command, ...args], {
+		cwd,
+		signal: options?.signal,
+		timeout: options?.timeout,
 	});
+	try {
+		await proc.exited;
+	} catch {
+		// ChildProcess rejects on non-zero exit; we handle it below
+	}
+	return {
+		stdout: await proc.stdout.text(),
+		stderr: await proc.stderr.text(),
+		code: proc.exitCode ?? 0,
+		killed: proc.exitReason instanceof ptree.AbortError,
+	};
 }

package/src/core/extensions/index.ts

@@ -110,10 +110,4 @@ export {
 	isReadToolResult,
 	isWriteToolResult,
 } from "./types";
-export {
-	ExtensionToolWrapper,
-	RegisteredToolAdapter,
-	wrapRegisteredTool,
-	wrapRegisteredTools,
-	wrapToolWithExtensions,
-} from "./wrapper";
+export { ExtensionToolWrapper, RegisteredToolAdapter, wrapRegisteredTool, wrapRegisteredTools } from "./wrapper";

package/src/core/extensions/loader.ts

@@ -7,6 +7,7 @@ import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Model, TextContent } from "@oh-my-pi/pi-ai";
 import type { KeyId } from "@oh-my-pi/pi-tui";
+import { logger } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import * as TypeBox from "@sinclair/typebox";
 import { type ExtensionModule, extensionModuleCapability } from "../../capability/extension-module";
@@ -16,7 +17,6 @@ import * as piCodingAgent from "../../index";
 import { EventBus } from "../event-bus";
 import type { ExecOptions } from "../exec";
 import { execCommand } from "../exec";
-import { logger } from "../logger";
 import type { CustomMessage } from "../messages";
 import type {
 	Extension,

package/src/core/extensions/runner.ts

@@ -5,8 +5,8 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type { KeyId } from "@oh-my-pi/pi-tui";
+import { logger } from "@oh-my-pi/pi-utils";
 import { type Theme, theme } from "../../modes/interactive/theme/theme";
-import { logger } from "../logger";
 import type { ModelRegistry } from "../model-registry";
 import type { SessionManager } from "../session-manager";
 import type {

package/src/core/extensions/types.ts

@@ -33,8 +33,8 @@ import type { BashOperations } from "../tools/bash";
 import type { EditToolDetails } from "../tools/patch";
 
 export type { ExecOptions, ExecResult } from "../exec";
-export type { AgentToolResult, AgentToolUpdateCallback };
 export type { AppAction, KeybindingsManager } from "../keybindings";
+export type { AgentToolResult, AgentToolUpdateCallback };
 
 // ============================================================================
 // UI Context
@@ -633,7 +633,7 @@ export interface ExtensionAPI {
 	// =========================================================================
 
 	/** File logger for error/warning/debug messages */
-	logger: typeof import("../logger").logger;
+	logger: typeof import("@oh-my-pi/pi-utils").logger;
 
 	/** Injected @sinclair/typebox module for defining tool parameters */
 	typebox: typeof import("@sinclair/typebox");

package/src/core/extensions/wrapper.ts

@@ -4,6 +4,7 @@
 
 import type { AgentTool, AgentToolContext, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import type { Static, TSchema } from "@sinclair/typebox";
 import type { Theme } from "../../modes/interactive/theme/theme";
 import type { ExtensionRunner } from "./runner";
 import type { RegisteredTool, ToolCallEventResult, ToolResultEventResult } from "./types";
@@ -70,16 +71,18 @@ export function wrapRegisteredTools(registeredTools: RegisteredTool[], runner: E
  * - Emits tool_call event before execution (can block)
  * - Emits tool_result event after execution (can modify result)
  */
-export class ExtensionToolWrapper<T> implements AgentTool<any, T> {
+export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetails = unknown>
+	implements AgentTool<TParameters, TDetails>
+{
 	name: string;
 	label: string;
 	description: string;
-	parameters: unknown;
-	renderCall?: AgentTool["renderCall"];
-	renderResult?: AgentTool["renderResult"];
+	parameters: TParameters;
+	renderCall?: AgentTool<TParameters, TDetails>["renderCall"];
+	renderResult?: AgentTool<TParameters, TDetails>["renderResult"];
 
 	constructor(
-		private tool: AgentTool<any, T>,
+		private tool: AgentTool<TParameters, TDetails>,
 		private runner: ExtensionRunner,
 	) {
 		this.name = tool.name;
@@ -92,9 +95,9 @@ export class ExtensionToolWrapper<T> implements AgentTool<any, T> {
 
 	async execute(
 		toolCallId: string,
-		params: Record<string, unknown>,
+		params: Static<TParameters>,
 		signal?: AbortSignal,
-		onUpdate?: AgentToolUpdateCallback<T>,
+		onUpdate?: AgentToolUpdateCallback<TDetails, TParameters>,
 		context?: AgentToolContext,
 	) {
 		// Emit tool_call event - extensions can block execution
@@ -104,7 +107,7 @@ export class ExtensionToolWrapper<T> implements AgentTool<any, T> {
 					type: "tool_call",
 					toolName: this.tool.name,
 					toolCallId,
-					input: params,
+					input: params as Record<string, unknown>,
 				})) as ToolCallEventResult | undefined;
 
 				if (callResult?.block) {
@@ -120,7 +123,7 @@ export class ExtensionToolWrapper<T> implements AgentTool<any, T> {
 		}
 
 		// Execute the actual tool
-		let result: { content: any; details?: T };
+		let result: { content: any; details?: TDetails };
 		let executionError: Error | undefined;
 
 		try {
@@ -129,7 +132,7 @@ export class ExtensionToolWrapper<T> implements AgentTool<any, T> {
 			executionError = err instanceof Error ? err : new Error(String(err));
 			result = {
 				content: [{ type: "text", text: executionError.message }],
-				details: undefined as T,
+				details: undefined as TDetails,
 			};
 		}
 
@@ -139,7 +142,7 @@ export class ExtensionToolWrapper<T> implements AgentTool<any, T> {
 				type: "tool_result",
 				toolName: this.tool.name,
 				toolCallId,
-				input: params,
+				input: params as Record<string, unknown>,
 				content: result.content,
 				details: result.details,
 				isError: !!executionError,
@@ -147,7 +150,7 @@ export class ExtensionToolWrapper<T> implements AgentTool<any, T> {
 
 			if (resultResult) {
 				const modifiedContent: (TextContent | ImageContent)[] = resultResult.content ?? result.content;
-				const modifiedDetails = (resultResult.details ?? result.details) as T;
+				const modifiedDetails = (resultResult.details ?? result.details) as TDetails;
 
 				// Extension can override error status
 				if (resultResult.isError === true && !executionError) {
@@ -176,11 +179,3 @@ export class ExtensionToolWrapper<T> implements AgentTool<any, T> {
 		return result;
 	}
 }
-
-/**
- * Wrap a tool with extension callbacks for interception.
- * @deprecated Use `new ExtensionToolWrapper()` directly
- */
-export function wrapToolWithExtensions<T>(tool: AgentTool<any, T>, runner: ExtensionRunner): AgentTool<any, T> {
-	return new ExtensionToolWrapper(tool, runner);
-}

package/src/core/frontmatter.ts

@@ -1,5 +1,5 @@
+import { logger } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
-import { logger } from "./logger";
 
 function stripHtmlComments(content: string): string {
 	return content.replace(/<!--[\s\S]*?-->/g, "");

package/src/core/history-storage.ts

@@ -1,7 +1,8 @@
 import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 import { getAgentDir } from "../config";
-import { logger } from "./logger";
 
 export interface HistoryEntry {
 	id: number;
@@ -134,11 +135,7 @@ END;
 
 	private ensureDir(dbPath: string): void {
 		const dir = dirname(dbPath);
-		const result = Bun.spawnSync(["mkdir", "-p", dir]);
-		if (result.exitCode !== 0) {
-			const stderr = result.stderr ? new TextDecoder().decode(result.stderr) : "";
-			throw new Error(`Failed to create history directory: ${dir} ${stderr}`.trim());
-		}
+		mkdirSync(dir, { recursive: true });
 	}
 
 	private normalizeLimit(limit: number): number {

package/src/core/hooks/index.ts

@@ -1,4 +1,5 @@
 // biome-ignore assist/source/organizeImports: biome is not smart
+export type { ReadonlySessionManager, UsageStatistics } from "../session-manager";
 export {
 	discoverAndLoadHooks,
 	loadHooks,
@@ -11,6 +12,5 @@ export {
 	type SendMessageHandler,
 } from "./loader";
 export { execCommand, HookRunner, type HookErrorListener } from "./runner";
-export { HookToolWrapper, wrapToolsWithHooks, wrapToolWithHooks } from "./tool-wrapper";
+export { HookToolWrapper } from "./tool-wrapper";
 export * from "./types";
-export type { UsageStatistics, ReadonlySessionManager } from "../session-manager";

package/src/core/hooks/loader.ts

@@ -3,13 +3,13 @@
  */
 
 import * as path from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 import * as typebox from "@sinclair/typebox";
 import { hookCapability } from "../../capability/hook";
 import type { Hook } from "../../discovery";
 import { loadCapability } from "../../discovery";
 import { expandPath } from "../../discovery/helpers";
 import * as piCodingAgent from "../../index";
-import { logger } from "../logger";
 import type { HookMessage } from "../messages";
 import type { SessionManager } from "../session-manager";
 import { execCommand } from "./runner";