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

package/src/modes/interactive/controllers/extension-ui-controller.ts

@@ -1,5 +1,6 @@
 import type { Component, TUI } from "@oh-my-pi/pi-tui";
 import { Spacer, Text } from "@oh-my-pi/pi-tui";
+import { logger } from "@oh-my-pi/pi-utils";
 import type {
 	ExtensionActions,
 	ExtensionCommandContextActions,
@@ -8,7 +9,6 @@ import type {
 	ExtensionUIContext,
 } from "../../../core/extensions/index";
 import { KeybindingsManager } from "../../../core/keybindings";
-import { logger } from "../../../core/logger";
 import { setTerminalTitle } from "../../../core/title-generator";
 import { HookEditorComponent } from "../components/hook-editor";
 import { HookInputComponent } from "../components/hook-input";
@@ -483,26 +483,26 @@ export class ExtensionUiController {
 	 * Show a selector for hooks.
 	 */
 	showHookSelector(title: string, options: string[], initialIndex?: number): Promise<string | undefined> {
-		return new Promise((resolve) => {
-			this.ctx.hookSelector = new HookSelectorComponent(
-				title,
-				options,
-				(option) => {
-					this.hideHookSelector();
-					resolve(option);
-				},
-				() => {
-					this.hideHookSelector();
-					resolve(undefined);
-				},
-				{ initialIndex },
-			);
+		const { promise, resolve } = Promise.withResolvers<string | undefined>();
+		this.ctx.hookSelector = new HookSelectorComponent(
+			title,
+			options,
+			(option) => {
+				this.hideHookSelector();
+				resolve(option);
+			},
+			() => {
+				this.hideHookSelector();
+				resolve(undefined);
+			},
+			{ initialIndex },
+		);
 
-			this.ctx.editorContainer.clear();
-			this.ctx.editorContainer.addChild(this.ctx.hookSelector);
-			this.ctx.ui.setFocus(this.ctx.hookSelector);
-			this.ctx.ui.requestRender();
-		});
+		this.ctx.editorContainer.clear();
+		this.ctx.editorContainer.addChild(this.ctx.hookSelector);
+		this.ctx.ui.setFocus(this.ctx.hookSelector);
+		this.ctx.ui.requestRender();
+		return promise;
 	}
 
 	/**
@@ -528,25 +528,25 @@ export class ExtensionUiController {
 	 * Show a text input for hooks.
 	 */
 	showHookInput(title: string, placeholder?: string): Promise<string | undefined> {
-		return new Promise((resolve) => {
-			this.ctx.hookInput = new HookInputComponent(
-				title,
-				placeholder,
-				(value) => {
-					this.hideHookInput();
-					resolve(value);
-				},
-				() => {
-					this.hideHookInput();
-					resolve(undefined);
-				},
-			);
+		const { promise, resolve } = Promise.withResolvers<string | undefined>();
+		this.ctx.hookInput = new HookInputComponent(
+			title,
+			placeholder,
+			(value) => {
+				this.hideHookInput();
+				resolve(value);
+			},
+			() => {
+				this.hideHookInput();
+				resolve(undefined);
+			},
+		);
 
-			this.ctx.editorContainer.clear();
-			this.ctx.editorContainer.addChild(this.ctx.hookInput);
-			this.ctx.ui.setFocus(this.ctx.hookInput);
-			this.ctx.ui.requestRender();
-		});
+		this.ctx.editorContainer.clear();
+		this.ctx.editorContainer.addChild(this.ctx.hookInput);
+		this.ctx.ui.setFocus(this.ctx.hookInput);
+		this.ctx.ui.requestRender();
+		return promise;
 	}
 
 	/**
@@ -564,26 +564,26 @@ export class ExtensionUiController {
 	 * Show a multi-line editor for hooks (with Ctrl+G support).
 	 */
 	showHookEditor(title: string, prefill?: string): Promise<string | undefined> {
-		return new Promise((resolve) => {
-			this.ctx.hookEditor = new HookEditorComponent(
-				this.ctx.ui,
-				title,
-				prefill,
-				(value) => {
-					this.hideHookEditor();
-					resolve(value);
-				},
-				() => {
-					this.hideHookEditor();
-					resolve(undefined);
-				},
-			);
+		const { promise, resolve } = Promise.withResolvers<string | undefined>();
+		this.ctx.hookEditor = new HookEditorComponent(
+			this.ctx.ui,
+			title,
+			prefill,
+			(value) => {
+				this.hideHookEditor();
+				resolve(value);
+			},
+			() => {
+				this.hideHookEditor();
+				resolve(undefined);
+			},
+		);
 
-			this.ctx.editorContainer.clear();
-			this.ctx.editorContainer.addChild(this.ctx.hookEditor);
-			this.ctx.ui.setFocus(this.ctx.hookEditor);
-			this.ctx.ui.requestRender();
-		});
+		this.ctx.editorContainer.clear();
+		this.ctx.editorContainer.addChild(this.ctx.hookEditor);
+		this.ctx.ui.setFocus(this.ctx.hookEditor);
+		this.ctx.ui.requestRender();
+		return promise;
 	}
 
 	/**
@@ -624,27 +624,27 @@ export class ExtensionUiController {
 		const savedText = this.ctx.editor.getText();
 		const keybindings = KeybindingsManager.inMemory();
 
-		return new Promise((resolve) => {
-			let component: Component & { dispose?(): void };
+		const { promise, resolve } = Promise.withResolvers<T>();
+		let component: Component & { dispose?(): void };
 
-			const close = (result: T) => {
-				component.dispose?.();
-				this.ctx.editorContainer.clear();
-				this.ctx.editorContainer.addChild(this.ctx.editor);
-				this.ctx.editor.setText(savedText);
-				this.ctx.ui.setFocus(this.ctx.editor);
-				this.ctx.ui.requestRender();
-				resolve(result);
-			};
-
-			Promise.resolve(factory(this.ctx.ui, theme, keybindings, close)).then((c) => {
-				component = c;
-				this.ctx.editorContainer.clear();
-				this.ctx.editorContainer.addChild(component);
-				this.ctx.ui.setFocus(component);
-				this.ctx.ui.requestRender();
-			});
+		const close = (result: T) => {
+			component.dispose?.();
+			this.ctx.editorContainer.clear();
+			this.ctx.editorContainer.addChild(this.ctx.editor);
+			this.ctx.editor.setText(savedText);
+			this.ctx.ui.setFocus(this.ctx.editor);
+			this.ctx.ui.requestRender();
+			resolve(result);
+		};
+
+		Promise.try(() => factory(this.ctx.ui, theme, keybindings, close)).then((c) => {
+			component = c;
+			this.ctx.editorContainer.clear();
+			this.ctx.editorContainer.addChild(component);
+			this.ctx.ui.setFocus(component);
+			this.ctx.ui.requestRender();
 		});
+		return promise;
 	}
 
 	/**

package/src/modes/interactive/controllers/input-controller.ts

@@ -1,4 +1,4 @@
-import * as fs from "node:fs";
+import { rm } from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
@@ -56,11 +56,11 @@ export class InputController {
 		this.ctx.editor.onAltP = () => this.ctx.showModelSelector({ temporaryOnly: true });
 
 		// Global debug handler on TUI (works regardless of focus)
-		this.ctx.ui.onDebug = () => this.ctx.handleDebugCommand();
+		this.ctx.ui.onDebug = () => void this.ctx.handleDebugCommand();
 		this.ctx.editor.onCtrlL = () => this.ctx.showModelSelector();
 		this.ctx.editor.onCtrlR = () => this.ctx.showHistorySearch();
 		this.ctx.editor.onCtrlT = () => this.ctx.toggleTodoExpansion();
-		this.ctx.editor.onCtrlG = () => this.openExternalEditor();
+		this.ctx.editor.onCtrlG = () => void this.openExternalEditor();
 		this.ctx.editor.onQuestionMark = () => this.ctx.handleHotkeysCommand();
 		this.ctx.editor.onCtrlV = () => this.handleImagePaste();
 
@@ -246,7 +246,7 @@ export class InputController {
 				return;
 			}
 			if (text === "/debug") {
-				this.ctx.handleDebugCommand();
+				void this.ctx.handleDebugCommand();
 				this.ctx.editor.setText("");
 				return;
 			}
@@ -276,7 +276,7 @@ export class InputController {
 					this.ctx.editor.addToHistory(text);
 					this.ctx.editor.setText("");
 					try {
-						const content = fs.readFileSync(skillPath, "utf-8");
+						const content = await Bun.file(skillPath).text();
 						const body = content.replace(/^---\n[\s\S]*?\n---\n/, "").trim();
 						const metaLines = [`Skill: ${skillPath}`];
 						if (args) {
@@ -587,7 +587,7 @@ export class InputController {
 		this.ctx.showStatus(`Thinking blocks: ${this.ctx.hideThinkingBlock ? "hidden" : "visible"}`);
 	}
 
-	openExternalEditor(): void {
+	async openExternalEditor(): Promise<void> {
 		// Determine editor (respect $VISUAL, then $EDITOR)
 		const editorCmd = process.env.VISUAL || process.env.EDITOR;
 		if (!editorCmd) {
@@ -600,7 +600,7 @@ export class InputController {
 
 		try {
 			// Write current content to temp file
-			fs.writeFileSync(tmpFile, currentText, "utf-8");
+			await Bun.write(tmpFile, currentText);
 
 			// Stop TUI to release terminal
 			this.ctx.ui.stop();
@@ -609,22 +609,23 @@ export class InputController {
 			const [editor, ...editorArgs] = editorCmd.split(" ");
 
 			// Spawn editor synchronously with inherited stdio for interactive editing
-			const result = Bun.spawnSync([editor, ...editorArgs, tmpFile], {
+			const child = Bun.spawn([editor, ...editorArgs, tmpFile], {
 				stdin: "inherit",
 				stdout: "inherit",
 				stderr: "inherit",
 			});
+			const exitCode = await child.exited;
 
 			// On successful exit (exitCode 0), replace editor content
-			if (result.exitCode === 0) {
-				const newContent = fs.readFileSync(tmpFile, "utf-8").replace(/\n$/, "");
+			if (exitCode === 0) {
+				const newContent = (await Bun.file(tmpFile).text()).replace(/\n$/, "");
 				this.ctx.editor.setText(newContent);
 			}
 			// On non-zero exit, keep original text (no action needed)
 		} finally {
 			// Clean up temp file
 			try {
-				fs.unlinkSync(tmpFile);
+				await rm(tmpFile, { force: true });
 			} catch {
 				// Ignore cleanup errors
 			}

package/src/modes/interactive/interactive-mode.ts

@@ -16,13 +16,13 @@ import {
 	Text,
 	TUI,
 } from "@oh-my-pi/pi-tui";
+import { logger, postmortem } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import type { AgentSession, AgentSessionEvent } from "../../core/agent-session";
 import type { ExtensionUIContext } from "../../core/extensions/index";
 import type { CompactOptions } from "../../core/extensions/types";
 import { HistoryStorage } from "../../core/history-storage";
 import { KeybindingsManager } from "../../core/keybindings";
-import { logger } from "../../core/logger";
 import type { SessionContext, SessionManager } from "../../core/session-manager";
 import { getRecentSessions } from "../../core/session-manager";
 import type { SettingsManager } from "../../core/settings-manager";
@@ -30,7 +30,6 @@ import { loadSlashCommands } from "../../core/slash-commands";
 import { setTerminalTitle } from "../../core/title-generator";
 import { getArtifactsDir } from "../../core/tools/task/artifacts";
 import { VoiceSupervisor } from "../../core/voice-supervisor";
-import { registerAsyncCleanup } from "../cleanup";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
 import { CustomEditor } from "./components/custom-editor";
@@ -268,7 +267,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.keybindings = await KeybindingsManager.create();
 
 		// Register session manager flush for signal handlers (SIGINT, SIGTERM, SIGHUP)
-		this.cleanupUnsubscribe = registerAsyncCleanup(() => this.sessionManager.flush());
+		this.cleanupUnsubscribe = postmortem.register("session-manager-flush", () => this.sessionManager.flush());
 
 		// Load and convert file commands to SlashCommand format (async)
 		const fileCommands = await loadSlashCommands({ cwd: process.cwd() });
@@ -394,12 +393,12 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	async getUserInput(): Promise<{ text: string; images?: ImageContent[] }> {
-		return new Promise((resolve) => {
-			this.onInputCallback = (input) => {
-				this.onInputCallback = undefined;
-				resolve(input);
-			};
-		});
+		const { promise, resolve } = Promise.withResolvers<{ text: string; images?: ImageContent[] }>();
+		this.onInputCallback = (input) => {
+			this.onInputCallback = undefined;
+			resolve(input);
+		};
+		return promise;
 	}
 
 	updateEditorBorderColor(): void {
@@ -664,8 +663,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.commandController.handleClearCommand();
 	}
 
-	handleDebugCommand(): void {
-		this.commandController.handleDebugCommand();
+	handleDebugCommand(): Promise<void> {
+		return this.commandController.handleDebugCommand();
 	}
 
 	handleArminSaysHi(): void {

package/src/modes/interactive/theme/theme.ts

@@ -1,12 +1,12 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { EditorTheme, MarkdownTheme, SelectListTheme, SymbolTheme } from "@oh-my-pi/pi-tui";
+import { logger } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { TypeCompiler } from "@sinclair/typebox/compiler";
 import chalk from "chalk";
 import { highlight, supportsLanguage } from "cli-highlight";
 import { getCustomThemesDir } from "../../../config";
-import { logger } from "../../../core/logger";
 // Embed theme JSON files at build time
 import darkThemeJson from "./dark.json" with { type: "json" };
 import { defaultThemes } from "./defaults";

package/src/modes/interactive/types.ts

@@ -141,7 +141,7 @@ export interface InteractiveModeContext {
 	handleHotkeysCommand(): void;
 	handleDumpCommand(): Promise<void>;
 	handleClearCommand(): Promise<void>;
-	handleDebugCommand(): void;
+	handleDebugCommand(): Promise<void>;
 	handleArminSaysHi(): void;
 	handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
 	handleCompactCommand(customInstructions?: string): Promise<void>;

package/src/modes/rpc/rpc-client.ts

@@ -6,16 +6,12 @@
 
 import type { AgentEvent, AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import type { Subprocess } from "bun";
+import { createSanitizerStream, createSplitterStream, createTextDecoderStream, ptree } from "@oh-my-pi/pi-utils";
 import type { SessionStats } from "../../core/agent-session";
 import type { BashResult } from "../../core/bash-executor";
 import type { CompactionResult } from "../../core/compaction/index";
 import type { RpcCommand, RpcResponse, RpcSessionState } from "./rpc-types";
 
-// ============================================================================
-// Types
-// ============================================================================
-
 /** Distributive Omit that works with union types */
 type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
 
@@ -51,13 +47,12 @@ export type RpcEventListener = (event: AgentEvent) => void;
 // ============================================================================
 
 export class RpcClient {
-	private process: Subprocess | null = null;
-	private lineReader: ReadableStreamDefaultReader<string> | null = null;
+	private process: ptree.ChildProcess | null = null;
+	private lineReader: ReadableStream<string> | null = null;
 	private eventListeners: RpcEventListener[] = [];
 	private pendingRequests: Map<string, { resolve: (response: RpcResponse) => void; reject: (error: Error) => void }> =
 		new Map();
 	private requestId = 0;
-	private stderr = "";
 
 	constructor(private options: RpcClientOptions = {}) {}
 
@@ -82,65 +77,39 @@ export class RpcClient {
 			args.push(...this.options.args);
 		}
 
-		this.process = Bun.spawn(["bun", cliPath, ...args], {
+		this.process = ptree.cspawn(["bun", cliPath, ...args], {
 			cwd: this.options.cwd,
 			env: { ...process.env, ...this.options.env },
 			stdin: "pipe",
-			stdout: "pipe",
-			stderr: "pipe",
 		});
 
-		// Collect stderr for debugging
-		(async () => {
-			const reader = (this.process!.stderr as ReadableStream<Uint8Array>).getReader();
-			const decoder = new TextDecoder();
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				this.stderr += decoder.decode(value);
-			}
-		})();
-
-		// Set up line reader for stdout
-		const textStream = (this.process.stdout as ReadableStream<Uint8Array>).pipeThrough(new TextDecoderStream());
-		this.lineReader = textStream
-			.pipeThrough(
-				new TransformStream<string, string>({
-					transform(chunk, controller) {
-						const lines = chunk.split("\n");
-						for (const line of lines) {
-							if (line.trim()) {
-								controller.enqueue(line);
-							}
-						}
-					},
-				}),
-			)
-			.getReader() as ReadableStreamDefaultReader<string>;
-
 		// Process lines in background
-		(async () => {
+		const lines = this.process.stdout
+			.pipeThrough(createTextDecoderStream())
+			.pipeThrough(createSanitizerStream())
+			.pipeThrough(createSplitterStream("\n"));
+		this.lineReader = lines;
+		void (async () => {
 			try {
-				while (true) {
-					const { done, value } = await this.lineReader!.read();
-					if (done) break;
-					this.handleLine(value);
+				for await (const line of lines) {
+					this.handleLine(line);
 				}
 			} catch {
 				// Stream closed
+			} finally {
+				lines.cancel();
 			}
 		})();
 
 		// Wait a moment for process to initialize
-		await new Promise((resolve) => setTimeout(resolve, 100));
+		await Bun.sleep(100);
 
 		try {
-			const exitCode = await Promise.race([
-				this.process.exited,
-				new Promise<null>((resolve) => setTimeout(() => resolve(null), 50)),
-			]);
+			const exitCode = await Promise.race([this.process.exited, Bun.sleep(50).then(() => null)]);
 			if (exitCode !== null) {
-				throw new Error(`Agent process exited immediately with code ${exitCode}. Stderr: ${this.stderr}`);
+				throw new Error(
+					`Agent process exited immediately with code ${exitCode}. Stderr: ${this.process.peekStderr()}`,
+				);
 			}
 		} catch {
 			// Process still running, which is what we want
@@ -154,22 +123,7 @@ export class RpcClient {
 		if (!this.process) return;
 
 		this.lineReader?.cancel();
-		this.process.kill();
-
-		// Wait for process to exit
-		await Promise.race([
-			this.process.exited,
-			new Promise<void>((resolve) => {
-				setTimeout(() => {
-					try {
-						this.process?.kill(9);
-					} catch {
-						// Already dead
-					}
-					resolve();
-				}, 1000);
-			}),
-		]);
+		await this.process.killAndWait();
 
 		this.process = null;
 		this.lineReader = null;
@@ -193,7 +147,7 @@ export class RpcClient {
 	 * Get collected stderr output (useful for debugging).
 	 */
 	getStderr(): string {
-		return this.stderr;
+		return this.process?.peekStderr() ?? "";
 	}
 
 	// =========================================================================
@@ -416,42 +370,50 @@ export class RpcClient {
 	 * Resolves when agent_end event is received.
 	 */
 	waitForIdle(timeout = 60000): Promise<void> {
-		return new Promise((resolve, reject) => {
-			const timer = setTimeout(() => {
+		const { promise, resolve, reject } = Promise.withResolvers<void>();
+		let settled = false;
+		const unsubscribe = this.onEvent((event) => {
+			if (event.type === "agent_end") {
+				settled = true;
 				unsubscribe();
-				reject(new Error(`Timeout waiting for agent to become idle. Stderr: ${this.stderr}`));
-			}, timeout);
-
-			const unsubscribe = this.onEvent((event) => {
-				if (event.type === "agent_end") {
-					clearTimeout(timer);
-					unsubscribe();
-					resolve();
-				}
-			});
+				resolve();
+			}
 		});
+
+		void (async () => {
+			await Bun.sleep(timeout);
+			if (settled) return;
+			settled = true;
+			unsubscribe();
+			reject(new Error(`Timeout waiting for agent to become idle. Stderr: ${this.process?.peekStderr() ?? ""}`));
+		})();
+		return promise;
 	}
 
 	/**
 	 * Collect events until agent becomes idle.
 	 */
 	collectEvents(timeout = 60000): Promise<AgentEvent[]> {
-		return new Promise((resolve, reject) => {
-			const events: AgentEvent[] = [];
-			const timer = setTimeout(() => {
+		const { promise, resolve, reject } = Promise.withResolvers<AgentEvent[]>();
+		const events: AgentEvent[] = [];
+		let settled = false;
+		const unsubscribe = this.onEvent((event) => {
+			events.push(event);
+			if (event.type === "agent_end") {
+				settled = true;
 				unsubscribe();
-				reject(new Error(`Timeout collecting events. Stderr: ${this.stderr}`));
-			}, timeout);
-
-			const unsubscribe = this.onEvent((event) => {
-				events.push(event);
-				if (event.type === "agent_end") {
-					clearTimeout(timer);
-					unsubscribe();
-					resolve(events);
-				}
-			});
+				resolve(events);
+			}
 		});
+
+		void (async () => {
+			await Bun.sleep(timeout);
+			if (settled) return;
+			settled = true;
+			unsubscribe();
+			reject(new Error(`Timeout collecting events. Stderr: ${this.process?.peekStderr() ?? ""}`));
+		})();
+		return promise;
 	}
 
 	/**
@@ -495,37 +457,45 @@ export class RpcClient {
 
 		const id = `req_${++this.requestId}`;
 		const fullCommand = { ...command, id } as RpcCommand;
+		const { promise, resolve, reject } = Promise.withResolvers<RpcResponse>();
+		let settled = false;
+		void (async () => {
+			await Bun.sleep(30000);
+			if (settled) return;
+			this.pendingRequests.delete(id);
+			settled = true;
+			reject(
+				new Error(`Timeout waiting for response to ${command.type}. Stderr: ${this.process?.peekStderr() ?? ""}`),
+			);
+		})();
 
-		return new Promise((resolve, reject) => {
-			const timeout = setTimeout(() => {
+		this.pendingRequests.set(id, {
+			resolve: (response) => {
+				if (settled) return;
+				settled = true;
+				resolve(response);
+			},
+			reject: (error) => {
+				if (settled) return;
+				settled = true;
+				reject(error);
+			},
+		});
+
+		// Write to stdin after registering the handler
+		const stdin = this.process!.stdin as import("bun").FileSink;
+		stdin.write(new TextEncoder().encode(`${JSON.stringify(fullCommand)}\n`));
+		// flush() returns number | Promise<number> - handle both cases
+		const flushResult = stdin.flush();
+		if (flushResult instanceof Promise) {
+			flushResult.catch((err: Error) => {
 				this.pendingRequests.delete(id);
-				reject(new Error(`Timeout waiting for response to ${command.type}. Stderr: ${this.stderr}`));
-			}, 30000);
-
-			this.pendingRequests.set(id, {
-				resolve: (response) => {
-					clearTimeout(timeout);
-					resolve(response);
-				},
-				reject: (error) => {
-					clearTimeout(timeout);
-					reject(error);
-				},
+				if (settled) return;
+				settled = true;
+				reject(err);
 			});
-
-			// Write to stdin after registering the handler
-			const stdin = this.process!.stdin as import("bun").FileSink;
-			stdin.write(new TextEncoder().encode(`${JSON.stringify(fullCommand)}\n`));
-			// flush() returns number | Promise<number> - handle both cases
-			const flushResult = stdin.flush();
-			if (flushResult instanceof Promise) {
-				flushResult.catch((err: Error) => {
-					this.pendingRequests.delete(id);
-					clearTimeout(timeout);
-					reject(err);
-				});
-			}
-		});
+		}
+		return promise;
 	}
 
 	private getData<T>(response: RpcResponse): T {