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

package/src/core/settings-manager.ts

@@ -1,11 +1,11 @@
-import { existsSync, readFileSync, renameSync } from "node:fs";
+import { rename } from "node:fs/promises";
 import { join } from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 import { type Settings as SettingsItem, settingsCapability } from "../capability/settings";
 import { getAgentDbPath, getAgentDir } from "../config";
 import { loadCapability } from "../discovery";
 import type { SymbolPreset } from "../modes/interactive/theme/theme";
 import { AgentStorage } from "./agent-storage";
-import { logger } from "./logger";
 
 export interface CompactionSettings {
 	enabled?: boolean; // default: true
@@ -125,6 +125,7 @@ export interface EditSettings {
 	fuzzyMatch?: boolean; // default: true (accept high-confidence fuzzy matches for whitespace/indentation)
 	fuzzyThreshold?: number; // default: 0.95 (similarity threshold for fuzzy matching)
 	patchMode?: boolean; // default: true (use codex-style apply-patch format instead of oldText/newText)
+	streamingAbort?: boolean; // default: false (abort streaming edit tool calls when patch preview fails)
 }
 
 export type { SymbolPreset };
@@ -322,7 +323,7 @@ const DEFAULT_SETTINGS: Settings = {
 	mcp: { enableProjectConfig: true },
 	lsp: { formatOnWrite: false, diagnosticsOnWrite: true, diagnosticsOnEdit: false },
 	python: { toolMode: "both", kernelMode: "session", sharedGateway: true },
-	edit: { fuzzyMatch: true, fuzzyThreshold: 0.95 },
+	edit: { fuzzyMatch: true, fuzzyThreshold: 0.95, streamingAbort: false },
 	ttsr: { enabled: true, contextMode: "discard", repeatMode: "once", repeatGap: 10 },
 	voice: {
 		enabled: false,
@@ -514,7 +515,7 @@ export class SettingsManager {
 	 */
 	static async create(cwd: string = process.cwd(), agentDir: string = getAgentDir()): Promise<SettingsManager> {
 		const storage = AgentStorage.open(getAgentDbPath(agentDir));
-		SettingsManager.migrateLegacySettingsFile(storage, agentDir);
+		await SettingsManager.migrateLegacySettingsFile(storage, agentDir);
 
 		// Use capability API to load user-level settings from all providers
 		const result = await loadCapability(settingsCapability.id, { cwd });
@@ -577,21 +578,21 @@ export class SettingsManager {
 		return SettingsManager.migrateSettings(settings as Record<string, unknown>);
 	}
 
-	private static migrateLegacySettingsFile(storage: AgentStorage, agentDir: string): void {
+	private static async migrateLegacySettingsFile(storage: AgentStorage, agentDir: string): Promise<void> {
 		const settingsPath = join(agentDir, "settings.json");
-		if (!existsSync(settingsPath)) return;
+		const settingsFile = Bun.file(settingsPath);
+		if (!(await settingsFile.exists())) return;
 		if (storage.getSettings() !== null) return;
 
 		try {
-			const content = readFileSync(settingsPath, "utf-8");
-			const parsed = JSON.parse(content);
+			const parsed = JSON.parse(await settingsFile.text());
 			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
 				return;
 			}
 			const migrated = SettingsManager.migrateSettings(parsed as Record<string, unknown>);
 			storage.saveSettings(migrated);
 			try {
-				renameSync(settingsPath, `${settingsPath}.bak`);
+				await rename(settingsPath, `${settingsPath}.bak`);
 			} catch (error) {
 				logger.warn("SettingsManager failed to backup settings.json", { error: String(error) });
 			}
@@ -1301,6 +1302,18 @@ export class SettingsManager {
 		await this.save();
 	}
 
+	getEditStreamingAbort(): boolean {
+		return this.settings.edit?.streamingAbort ?? false;
+	}
+
+	async setEditStreamingAbort(enabled: boolean): Promise<void> {
+		if (!this.globalSettings.edit) {
+			this.globalSettings.edit = {};
+		}
+		this.globalSettings.edit.streamingAbort = enabled;
+		await this.save();
+	}
+
 	getNormativeRewrite(): boolean {
 		return this.settings.normativeRewrite ?? false;
 	}

package/src/core/skills.ts

@@ -1,13 +1,13 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { realpath } from "node:fs/promises";
 import { basename, join } from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 import { minimatch } from "minimatch";
 import { skillCapability } from "../capability/skill";
 import type { SourceMeta } from "../capability/types";
 import type { Skill as CapabilitySkill, SkillFrontmatter as ImportedSkillFrontmatter } from "../discovery";
 import { loadCapability } from "../discovery";
 import { parseFrontmatter } from "./frontmatter";
-import { logger } from "./logger";
 import type { SkillsSettings } from "./settings-manager";
 
 // Re-export SkillFrontmatter for backward compatibility

package/src/core/ssh/connection-manager.ts

@@ -1,8 +1,9 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
+import { $ } from "bun";
 import { CONFIG_DIR_NAME } from "../../config";
-import { logger } from "../logger";
 
 export interface SSHConnectionTarget {
 	name: string;
@@ -107,32 +108,17 @@ function buildCommonArgs(host: SSHConnectionTarget): string[] {
 	return args;
 }
 
-function decodeOutput(buffer?: Uint8Array): string {
-	if (!buffer || buffer.length === 0) return "";
-	return new TextDecoder().decode(buffer).trim();
+async function runSshSync(args: string[]): Promise<{ exitCode: number | null; stderr: string }> {
+	const result = await $`ssh ${args}`.nothrow();
+	return { exitCode: result.exitCode, stderr: result.stderr.toString().trim() };
 }
 
-function runSshSync(args: string[]): { exitCode: number | null; stderr: string } {
-	const result = Bun.spawnSync(["ssh", ...args], {
-		stdin: "ignore",
-		stdout: "ignore",
-		stderr: "pipe",
-	});
-
-	return { exitCode: result.exitCode, stderr: decodeOutput(result.stderr) };
-}
-
-function runSshCaptureSync(args: string[]): { exitCode: number | null; stdout: string; stderr: string } {
-	const result = Bun.spawnSync(["ssh", ...args], {
-		stdin: "ignore",
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-
+async function runSshCaptureSync(args: string[]): Promise<{ exitCode: number | null; stdout: string; stderr: string }> {
+	const result = await $`ssh ${args}`.nothrow();
 	return {
 		exitCode: result.exitCode,
-		stdout: decodeOutput(result.stdout),
-		stderr: decodeOutput(result.stderr),
+		stdout: result.stdout.toString().trim(),
+		stderr: result.stderr.toString().trim(),
 	};
 }
 
@@ -266,7 +252,7 @@ async function persistHostInfo(host: SSHConnectionTarget, info: SSHHostInfo): Pr
 
 async function probeHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
 	const command = 'echo "$OSTYPE|$SHELL|$BASH_VERSION" 2>/dev/null || echo "%OS%|%COMSPEC%|"';
-	const result = runSshCaptureSync(buildRemoteCommand(host, command));
+	const result = await runSshCaptureSync(buildRemoteCommand(host, command));
 	if (result.exitCode !== 0 && !result.stdout) {
 		logger.debug("SSH host probe failed", { host: host.name, error: result.stderr });
 		const fallback: SSHHostInfo = {
@@ -329,11 +315,11 @@ async function probeHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
 	const hasBash = !unexpandedPosixVars && (Boolean(bashVersion) || shell === "bash");
 	let compatShell: SSHHostInfo["compatShell"];
 	if (os === "windows" && host.compat !== false) {
-		const bashProbe = runSshCaptureSync(buildRemoteCommand(host, 'bash -lc "echo OMP_BASH_OK"'));
+		const bashProbe = await runSshCaptureSync(buildRemoteCommand(host, 'bash -lc "echo OMP_BASH_OK"'));
 		if (bashProbe.exitCode === 0 && bashProbe.stdout.includes("OMP_BASH_OK")) {
 			compatShell = "bash";
 		} else {
-			const shProbe = runSshCaptureSync(buildRemoteCommand(host, 'sh -lc "echo OMP_SH_OK"'));
+			const shProbe = await runSshCaptureSync(buildRemoteCommand(host, 'sh -lc "echo OMP_SH_OK"'));
 			if (shProbe.exitCode === 0 && shProbe.stdout.includes("OMP_SH_OK")) {
 				compatShell = "sh";
 			}
@@ -406,7 +392,7 @@ export async function ensureConnection(host: SSHConnectionTarget): Promise<void>
 		validateKeyPermissions(host.keyPath);
 
 		const target = buildSshTarget(host);
-		const check = runSshSync(["-O", "check", ...buildCommonArgs(host), target]);
+		const check = await runSshSync(["-O", "check", ...buildCommonArgs(host), target]);
 		if (check.exitCode === 0) {
 			activeHosts.set(key, host);
 			if (!hostInfoCache.has(key) && !loadHostInfoFromDisk(host)) {
@@ -415,7 +401,7 @@ export async function ensureConnection(host: SSHConnectionTarget): Promise<void>
 			return;
 		}
 
-		const start = runSshSync(["-M", "-N", "-f", ...buildCommonArgs(host), target]);
+		const start = await runSshSync(["-M", "-N", "-f", ...buildCommonArgs(host), target]);
 		if (start.exitCode !== 0) {
 			const detail = start.stderr ? `: ${start.stderr}` : "";
 			throw new Error(`Failed to start SSH master for ${target}${detail}`);
@@ -435,24 +421,24 @@ export async function ensureConnection(host: SSHConnectionTarget): Promise<void>
 	}
 }
 
-function closeConnectionInternal(host: SSHConnectionTarget): void {
+async function closeConnectionInternal(host: SSHConnectionTarget): Promise<void> {
 	const target = buildSshTarget(host);
-	runSshSync(["-O", "exit", ...buildCommonArgs(host), target]);
+	await runSshSync(["-O", "exit", ...buildCommonArgs(host), target]);
 }
 
 export async function closeConnection(hostName: string): Promise<void> {
 	const host = activeHosts.get(hostName);
 	if (!host) {
-		closeConnectionInternal({ name: hostName, host: hostName });
+		await closeConnectionInternal({ name: hostName, host: hostName });
 		return;
 	}
-	closeConnectionInternal(host);
+	await closeConnectionInternal(host);
 	activeHosts.delete(hostName);
 }
 
 export async function closeAllConnections(): Promise<void> {
 	for (const [name, host] of Array.from(activeHosts.entries())) {
-		closeConnectionInternal(host);
+		await closeConnectionInternal(host);
 		activeHosts.delete(name);
 	}
 }

package/src/core/ssh/ssh-executor.ts

@@ -1,9 +1,5 @@
-import type { Subprocess } from "bun";
-import { killProcessTree } from "../../utils/shell";
-import { logger } from "../logger";
-import { OutputSink, pumpStream } from "../streaming-output";
-import { DEFAULT_MAX_BYTES } from "../tools/truncate";
-import { ScopeSignal } from "../utils";
+import { cspawn, logger, ptree } from "@oh-my-pi/pi-utils";
+import { OutputSink } from "../streaming-output";
 import { buildRemoteCommand, ensureConnection, ensureHostInfo, type SSHConnectionTarget } from "./connection-manager";
 import { hasSshfs, mountRemote } from "./sshfs-mount";
 
@@ -59,8 +55,6 @@ export async function executeSSH(
 		}
 	}
 
-	using signal = new ScopeSignal(options);
-
 	let resolvedCommand = command;
 	if (options?.compatEnabled) {
 		const info = await ensureHostInfo(host);
@@ -70,43 +64,53 @@ export async function executeSSH(
 			logger.warn("SSH compat enabled without detected compat shell", { host: host.name });
 		}
 	}
-	const child: Subprocess = Bun.spawn(["ssh", ...buildRemoteCommand(host, resolvedCommand)], {
-		stdin: "ignore",
-		stdout: "pipe",
-		stderr: "pipe",
-	});
 
-	signal.catch(() => {
-		killProcessTree(child.pid);
+	const child = cspawn(["ssh", ...buildRemoteCommand(host, resolvedCommand)], {
+		signal: options?.signal,
+		timeout: options?.timeout,
 	});
 
-	const sink = new OutputSink(DEFAULT_MAX_BYTES, DEFAULT_MAX_BYTES * 2, options?.onChunk);
+	const sink = new OutputSink({ onLine: options?.onChunk });
 
-	const writer = sink.getWriter();
 	try {
-		await Promise.all([
-			pumpStream(child.stdout as ReadableStream<Uint8Array>, writer),
-			pumpStream(child.stderr as ReadableStream<Uint8Array>, writer),
+		await Promise.allSettled([
+			child.stdout.pipeTo(sink.createWritable()),
+			child.stderr.pipeTo(sink.createWritable()),
 		]);
 	} finally {
-		await writer.close();
+		await sink.close();
 	}
 
-	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);
+	try {
+		await child.exited;
+		const exitCode = child.exitCode ?? 0;
 		return {
-			exitCode: undefined,
-			cancelled: true,
-			...sink.dump(`SSH command timed out after ${secs} seconds`),
+			exitCode,
+			cancelled: false,
+			...sink.dump(),
 		};
+	} catch (err) {
+		if (err instanceof ptree.Exception) {
+			if (err instanceof ptree.TimeoutError) {
+				return {
+					exitCode: undefined,
+					cancelled: true,
+					...sink.dump(`SSH command timed out after ${Math.round(options!.timeout! / 1000)} seconds`),
+				};
+			}
+			if (err.aborted) {
+				return {
+					exitCode: undefined,
+					cancelled: true,
+					...sink.dump(`SSH command aborted: ${err.message}`),
+				};
+			}
+			return {
+				exitCode: err.exitCode,
+				cancelled: false,
+				...sink.dump(`Unexpected error: ${err.message}`),
+			};
+		}
+		throw err;
 	}
-
-	return {
-		exitCode: cancelled ? undefined : exitCode,
-		cancelled,
-		...sink.dump(),
-	};
 }

package/src/core/ssh/sshfs-mount.ts

@@ -1,8 +1,9 @@
 import { chmodSync, existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
+import { $ } from "bun";
 import { CONFIG_DIR_NAME } from "../../config";
-import { logger } from "../logger";
 import { getControlDir, getControlPathTemplate, type SSHConnectionTarget } from "./connection-manager";
 
 const REMOTE_DIR = join(homedir(), CONFIG_DIR_NAME, "remote");
@@ -22,11 +23,6 @@ function ensureDir(path: string, mode = 0o700): void {
 	}
 }
 
-function decodeOutput(buffer?: Uint8Array): string {
-	if (!buffer || buffer.length === 0) return "";
-	return new TextDecoder().decode(buffer).trim();
-}
-
 function getMountName(host: SSHConnectionTarget): string {
 	const raw = (host.name ?? host.host).trim();
 	const sanitized = raw.replace(/[^a-zA-Z0-9._-]+/g, "_");
@@ -72,24 +68,16 @@ function buildSshfsArgs(host: SSHConnectionTarget): string[] {
 	return args;
 }
 
-function unmountPath(path: string): boolean {
+async function unmountPath(path: string): Promise<boolean> {
 	const fusermount = Bun.which("fusermount") ?? Bun.which("fusermount3");
 	if (fusermount) {
-		const result = Bun.spawnSync([fusermount, "-u", path], {
-			stdin: "ignore",
-			stdout: "ignore",
-			stderr: "pipe",
-		});
+		const result = await $`${fusermount} -u ${path}`.quiet().nothrow();
 		if (result.exitCode === 0) return true;
 	}
 
 	const umount = Bun.which("umount");
 	if (!umount) return false;
-	const result = Bun.spawnSync([umount, path], {
-		stdin: "ignore",
-		stdout: "ignore",
-		stderr: "pipe",
-	});
+	const result = await $`${umount} ${path}`.quiet().nothrow();
 	return result.exitCode === 0;
 }
 
@@ -97,14 +85,10 @@ export function hasSshfs(): boolean {
 	return Bun.which("sshfs") !== null;
 }
 
-export function isMounted(path: string): boolean {
+export async function isMounted(path: string): Promise<boolean> {
 	const mountpoint = Bun.which("mountpoint");
 	if (!mountpoint) return false;
-	const result = Bun.spawnSync([mountpoint, "-q", path], {
-		stdin: "ignore",
-		stdout: "ignore",
-		stderr: "ignore",
-	});
+	const result = await $`${mountpoint} -q ${path}`.quiet().nothrow();
 	return result.exitCode === 0;
 }
 
@@ -117,20 +101,17 @@ export async function mountRemote(host: SSHConnectionTarget, remotePath = "/"):
 	const mountPath = getMountPath(host);
 	ensureDir(mountPath);
 
-	if (isMounted(mountPath)) {
+	if (await isMounted(mountPath)) {
 		mountedPaths.add(mountPath);
 		return mountPath;
 	}
 
 	const target = `${buildSshTarget(host)}:${remotePath}`;
-	const result = Bun.spawnSync(["sshfs", ...buildSshfsArgs(host), target, mountPath], {
-		stdin: "ignore",
-		stdout: "pipe",
-		stderr: "pipe",
-	});
+	const args = buildSshfsArgs(host);
+	const result = await $`sshfs ${args} ${target} ${mountPath}`.nothrow();
 
 	if (result.exitCode !== 0) {
-		const detail = decodeOutput(result.stderr);
+		const detail = result.stderr.toString().trim();
 		const suffix = detail ? `: ${detail}` : "";
 		throw new Error(`Failed to mount ${target}${suffix}`);
 	}
@@ -141,12 +122,12 @@ export async function mountRemote(host: SSHConnectionTarget, remotePath = "/"):
 
 export async function unmountRemote(host: SSHConnectionTarget): Promise<boolean> {
 	const mountPath = getMountPath(host);
-	if (!isMounted(mountPath)) {
+	if (!(await isMounted(mountPath))) {
 		mountedPaths.delete(mountPath);
 		return false;
 	}
 
-	const success = unmountPath(mountPath);
+	const success = await unmountPath(mountPath);
 	if (success) {
 		mountedPaths.delete(mountPath);
 	}
@@ -156,7 +137,7 @@ export async function unmountRemote(host: SSHConnectionTarget): Promise<boolean>
 
 export async function unmountAll(): Promise<void> {
 	for (const mountPath of Array.from(mountedPaths)) {
-		unmountPath(mountPath);
+		await unmountPath(mountPath);
 	}
 	mountedPaths.clear();
 }

package/src/core/storage-migration.ts

@@ -4,10 +4,10 @@
  * Original JSON files are backed up to .bak and removed after successful migration.
  */
 
+import { logger } from "@oh-my-pi/pi-utils";
 import { getAgentDbPath } from "../config";
 import { AgentStorage } from "./agent-storage";
 import type { AuthCredential, AuthCredentialEntry, AuthStorageData } from "./auth-storage";
-import { logger } from "./logger";
 import type { Settings } from "./settings-manager";
 
 /** Paths configuration for the storage migration process. */