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

package/src/utils/shell.ts

@@ -1,4 +1,6 @@
-import { accessSync, constants, existsSync } from "node:fs";
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { $ } from "bun";
 import { SettingsManager } from "../core/settings-manager";
 
 export interface ShellConfig {
@@ -13,9 +15,9 @@ let cachedShellConfig: ShellConfig | null = null;
 /**
  * Check if a shell binary is executable.
  */
-function isExecutable(path: string): boolean {
+async function isExecutable(path: string): Promise<boolean> {
 	try {
-		accessSync(path, constants.X_OK);
+		await access(path, constants.X_OK);
 		return true;
 	} catch {
 		return false;
@@ -59,13 +61,7 @@ function getShellPrefix(): string | undefined {
  */
 function findBashOnPath(): string | null {
 	try {
-		const result = Bun.spawnSync(["where", "bash.exe"], { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
-		if (result.exitCode === 0 && result.stdout) {
-			const firstMatch = result.stdout.toString().trim().split(/\r?\n/)[0];
-			if (firstMatch && existsSync(firstMatch)) {
-				return firstMatch;
-			}
-		}
+		return Bun.which("bash.exe");
 	} catch {
 		// Ignore errors
 	}
@@ -102,7 +98,7 @@ export async function getShellConfig(): Promise<ShellConfig> {
 
 	// 1. Check user-specified shell path
 	if (customShellPath) {
-		if (existsSync(customShellPath)) {
+		if (await Bun.file(customShellPath).exists()) {
 			cachedShellConfig = buildConfig(customShellPath);
 			return cachedShellConfig;
 		}
@@ -124,7 +120,7 @@ export async function getShellConfig(): Promise<ShellConfig> {
 		}
 
 		for (const path of paths) {
-			if (existsSync(path)) {
+			if (await Bun.file(path).exists()) {
 				cachedShellConfig = buildConfig(path);
 				return cachedShellConfig;
 			}
@@ -149,7 +145,7 @@ export async function getShellConfig(): Promise<ShellConfig> {
 	// Unix: prefer user's shell from $SHELL if it's bash/zsh and executable
 	const userShell = process.env.SHELL;
 	const isValidShell = userShell && (userShell.includes("bash") || userShell.includes("zsh"));
-	if (isValidShell && isExecutable(userShell)) {
+	if (isValidShell && (await isExecutable(userShell))) {
 		cachedShellConfig = buildConfig(userShell);
 		return cachedShellConfig;
 	}
@@ -162,7 +158,7 @@ export async function getShellConfig(): Promise<ShellConfig> {
 	for (const shellName of shellOrder) {
 		for (const dir of fallbackPaths) {
 			const shellPath = `${dir}/${shellName}`;
-			if (isExecutable(shellPath)) {
+			if (await isExecutable(shellPath)) {
 				cachedShellConfig = buildConfig(shellPath);
 				return cachedShellConfig;
 			}
@@ -181,23 +177,17 @@ export async function getShellConfig(): Promise<ShellConfig> {
 	return cachedShellConfig;
 }
 
-let pgrepAvailable: boolean | null = null;
+let pgrepAvailable: string | null | undefined;
 
 /**
  * Check if pgrep is available on this system (cached).
  */
-function hasPgrep(): boolean {
-	if (pgrepAvailable === null) {
+function hasPgrep(): string | null {
+	if (pgrepAvailable === undefined) {
 		try {
-			const result = Bun.spawnSync(["pgrep", "--version"], {
-				stdin: "ignore",
-				stdout: "ignore",
-				stderr: "ignore",
-			});
-			// pgrep exists if it ran (exit 0 or 1 are both valid)
-			pgrepAvailable = result.exitCode !== null;
+			pgrepAvailable = Bun.which("pgrep") ?? null;
 		} catch {
-			pgrepAvailable = false;
+			pgrepAvailable = null;
 		}
 	}
 	return pgrepAvailable;
@@ -206,17 +196,14 @@ function hasPgrep(): boolean {
 /**
  * Get direct children of a PID using pgrep.
  */
-function getChildrenViaPgrep(pid: number): number[] {
-	const result = Bun.spawnSync(["pgrep", "-P", String(pid)], {
-		stdin: "ignore",
-		stdout: "pipe",
-		stderr: "ignore",
-	});
-
-	if (result.exitCode !== 0 || !result.stdout) return [];
+async function getChildrenViaPgrep(pid: number): Promise<number[]> {
+	const result = await $`pgrep -P ${pid}`.quiet().nothrow();
+	if (result.exitCode !== 0) return [];
+	const output = result.stdout.toString().trim();
+	if (!output) return [];
 
 	const children: number[] = [];
-	for (const line of result.stdout.toString().trim().split("\n")) {
+	for (const line of output.split("\n")) {
 		const childPid = parseInt(line, 10);
 		if (!Number.isNaN(childPid)) children.push(childPid);
 	}
@@ -226,20 +213,16 @@ function getChildrenViaPgrep(pid: number): number[] {
 /**
  * Get direct children of a PID using /proc (Linux only).
  */
-function getChildrenViaProc(pid: number): number[] {
+async function getChildrenViaProc(pid: number): Promise<number[]> {
 	try {
-		const result = Bun.spawnSync(
-			[
-				"sh",
-				"-c",
-				`for p in /proc/[0-9]*/stat; do cat "$p" 2>/dev/null; done | awk -v ppid=${pid} '$4 == ppid { print $1 }'`,
-			],
-			{ stdin: "ignore", stdout: "pipe", stderr: "ignore" },
-		);
-		if (result.exitCode !== 0 || !result.stdout) return [];
+		const script = `for p in /proc/[0-9]*/stat; do cat "$p" 2>/dev/null; done | awk -v ppid=${pid} '$4 == ppid { print $1 }'`;
+		const result = await $`sh -c ${script}`.quiet().nothrow();
+		if (result.exitCode !== 0) return [];
+		const output = result.stdout.toString().trim();
+		if (!output) return [];
 
 		const children: number[] = [];
-		for (const line of result.stdout.toString().trim().split("\n")) {
+		for (const line of output.split("\n")) {
 			const childPid = parseInt(line, 10);
 			if (!Number.isNaN(childPid)) children.push(childPid);
 		}
@@ -253,14 +236,14 @@ function getChildrenViaProc(pid: number): number[] {
  * Collect all descendant PIDs breadth-first.
  * Returns deepest descendants first (reverse BFS order) for proper kill ordering.
  */
-function getDescendantPids(pid: number): number[] {
+async function getDescendantPids(pid: number): Promise<number[]> {
 	const getChildren = hasPgrep() ? getChildrenViaPgrep : getChildrenViaProc;
 	const descendants: number[] = [];
 	const queue = [pid];
 
 	while (queue.length > 0) {
 		const current = queue.shift()!;
-		const children = getChildren(current);
+		const children = await getChildren(current);
 		for (const child of children) {
 			descendants.push(child);
 			queue.push(child);
@@ -284,13 +267,9 @@ function tryKill(pid: number, signal: NodeJS.Signals): boolean {
  * Kill a process and all its descendants.
  * @param gracePeriodMs - Time to wait after SIGTERM before SIGKILL (0 = immediate SIGKILL)
  */
-export function killProcessTree(pid: number, gracePeriodMs = 0): void {
+export async function killProcessTree(pid: number, gracePeriodMs = 0): Promise<void> {
 	if (process.platform === "win32") {
-		Bun.spawnSync(["taskkill", "/F", "/T", "/PID", String(pid)], {
-			stdin: "ignore",
-			stdout: "ignore",
-			stderr: "ignore",
-		});
+		await $`taskkill /F /T /PID ${pid}`.quiet().nothrow();
 		return;
 	}
 
@@ -300,7 +279,7 @@ export function killProcessTree(pid: number, gracePeriodMs = 0): void {
 	try {
 		process.kill(-pid, signal);
 		if (gracePeriodMs > 0) {
-			Bun.sleepSync(gracePeriodMs);
+			await Bun.sleep(gracePeriodMs);
 			try {
 				process.kill(-pid, "SIGKILL");
 			} catch {
@@ -313,11 +292,11 @@ export function killProcessTree(pid: number, gracePeriodMs = 0): void {
 	}
 
 	// Collect descendants BEFORE killing to minimize race window
-	const allPids = [...getDescendantPids(pid), pid];
+	const allPids = [...(await getDescendantPids(pid)), pid];
 
 	if (gracePeriodMs > 0) {
 		for (const p of allPids) tryKill(p, "SIGTERM");
-		Bun.sleepSync(gracePeriodMs);
+		await Bun.sleep(gracePeriodMs);
 	}
 
 	for (const p of allPids) tryKill(p, "SIGKILL");

package/src/utils/tools-manager.ts

@@ -1,7 +1,8 @@
-import { chmodSync, createWriteStream, existsSync, mkdirSync, renameSync, rmSync } from "node:fs";
+import { chmod, mkdir, rename, rm } from "node:fs/promises";
 import { arch, platform } from "node:os";
 import { join } from "node:path";
-import chalk from "chalk";
+import { createTempDir, logger } from "@oh-my-pi/pi-utils";
+import { $ } from "bun";
 import { APP_NAME, getBinDir } from "../config";
 
 const TOOLS_DIR = getBinDir();
@@ -133,19 +134,14 @@ const PYTHON_TOOLS: Record<string, PythonToolConfig> = {
 	},
 };
 
-// Check if a command exists in PATH
-function commandExists(cmd: string): string | null {
-	return Bun.which(cmd);
-}
-
 export type ToolName = "fd" | "rg" | "sd" | "sg" | "yt-dlp" | "markitdown" | "html2text";
 
 // Get the path to a tool (system-wide or in our tools dir)
-export function getToolPath(tool: ToolName): string | null {
+export async function getToolPath(tool: ToolName): Promise<string | null> {
 	// Check Python tools first
 	const pythonConfig = PYTHON_TOOLS[tool];
 	if (pythonConfig) {
-		return commandExists(pythonConfig.binaryName);
+		return Bun.which(pythonConfig.binaryName);
 	}
 
 	const config = TOOLS[tool];
@@ -153,12 +149,12 @@ export function getToolPath(tool: ToolName): string | null {
 
 	// Check our tools directory first
 	const localPath = join(TOOLS_DIR, config.binaryName + (platform() === "win32" ? ".exe" : ""));
-	if (existsSync(localPath)) {
+	if (await Bun.file(localPath).exists()) {
 		return localPath;
 	}
 
 	// Check system PATH
-	return commandExists(config.binaryName);
+	return Bun.which(config.binaryName);
 }
 
 // Fetch latest release version from GitHub
@@ -178,27 +174,12 @@ async function getLatestVersion(repo: string): Promise<string> {
 // Download a file from URL
 async function downloadFile(url: string, dest: string): Promise<void> {
 	const response = await fetch(url);
-
 	if (!response.ok) {
 		throw new Error(`Failed to download: ${response.status}`);
-	}
-
-	if (!response.body) {
+	} else if (!response.body) {
 		throw new Error("No response body");
 	}
-
-	const fileStream = createWriteStream(dest);
-	const reader = response.body.getReader();
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		fileStream.write(Buffer.from(value));
-	}
-	fileStream.end();
-	await new Promise<void>((resolve, reject) => {
-		fileStream.on("finish", resolve);
-		fileStream.on("error", reject);
-	});
+	await Bun.write(dest, response);
 }
 
 // Download and install a tool
@@ -219,7 +200,7 @@ async function downloadTool(tool: ToolName): Promise<string> {
 	}
 
 	// Create tools directory
-	mkdirSync(TOOLS_DIR, { recursive: true });
+	await mkdir(TOOLS_DIR, { recursive: true });
 
 	const downloadUrl = `https://github.com/${config.repo}/releases/download/${config.tagPrefix}${version}/${assetName}`;
 	const binaryExt = plat === "win32" ? ".exe" : "";
@@ -229,7 +210,7 @@ async function downloadTool(tool: ToolName): Promise<string> {
 	if (config.isDirectBinary) {
 		await downloadFile(downloadUrl, binaryPath);
 		if (plat !== "win32") {
-			chmodSync(binaryPath, 0o755);
+			await chmod(binaryPath, 0o755);
 		}
 		return binaryPath;
 	}
@@ -239,74 +220,62 @@ async function downloadTool(tool: ToolName): Promise<string> {
 	await downloadFile(downloadUrl, archivePath);
 
 	// Extract
-	const extractDir = join(TOOLS_DIR, "extract_tmp");
-	mkdirSync(extractDir, { recursive: true });
+	const tmp = await createTempDir("@omp-tools-extract-");
 
 	try {
 		if (assetName.endsWith(".tar.gz")) {
-			Bun.spawnSync(["tar", "xzf", archivePath, "-C", extractDir], {
-				stdin: "ignore",
-				stdout: "pipe",
-				stderr: "pipe",
-			});
+			const archive = new Bun.Archive(await Bun.file(archivePath).arrayBuffer());
+			const files = await archive.files();
+			for (const [path, file] of files) {
+				await Bun.write(join(tmp.path, path), file);
+			}
 		} else if (assetName.endsWith(".zip")) {
-			Bun.spawnSync(["unzip", "-o", archivePath, "-d", extractDir], {
-				stdin: "ignore",
-				stdout: "pipe",
-				stderr: "pipe",
-			});
+			await mkdir(tmp.path, { recursive: true });
+			await $`unzip -o ${archivePath} -d ${tmp.path}`.quiet().nothrow();
 		}
 
 		// Find the binary in extracted files
 		// ast-grep releases the binary directly in the zip, not in a subdirectory
 		let extractedBinary: string;
 		if (tool === "sg") {
-			extractedBinary = join(extractDir, config.binaryName + binaryExt);
+			extractedBinary = join(tmp.path, config.binaryName + binaryExt);
 		} else {
-			const extractedDir = join(extractDir, assetName.replace(/\.(tar\.gz|zip)$/, ""));
+			const extractedDir = join(tmp.path, assetName.replace(/\.(tar\.gz|zip)$/, ""));
 			extractedBinary = join(extractedDir, config.binaryName + binaryExt);
 		}
 
-		if (existsSync(extractedBinary)) {
-			renameSync(extractedBinary, binaryPath);
+		if (await Bun.file(extractedBinary).exists()) {
+			await rename(extractedBinary, binaryPath);
 		} else {
 			throw new Error(`Binary not found in archive: ${extractedBinary}`);
 		}
 
 		// Make executable (Unix only)
 		if (plat !== "win32") {
-			chmodSync(binaryPath, 0o755);
+			await chmod(binaryPath, 0o755);
 		}
 	} finally {
 		// Cleanup
-		rmSync(archivePath, { force: true });
-		rmSync(extractDir, { recursive: true, force: true });
+		await tmp.remove();
+		await rm(archivePath, { force: true });
 	}
 
 	return binaryPath;
 }
 
 // Install a Python package via uv (preferred) or pip
-function installPythonPackage(pkg: string): boolean {
+async function installPythonPackage(pkg: string): Promise<boolean> {
 	// Try uv first (faster, better isolation)
-	const uv = commandExists("uv");
+	const uv = Bun.which("uv");
 	if (uv) {
-		const result = Bun.spawnSync([uv, "tool", "install", pkg], {
-			stdin: "ignore",
-			stdout: "pipe",
-			stderr: "pipe",
-		});
+		const result = await $`${uv} tool install ${pkg}`.quiet().nothrow();
 		if (result.exitCode === 0) return true;
 	}
 
 	// Fall back to pip
-	const pip = commandExists("pip3") || commandExists("pip");
+	const pip = Bun.which("pip3") || Bun.which("pip");
 	if (pip) {
-		const result = Bun.spawnSync([pip, "install", "--user", pkg], {
-			stdin: "ignore",
-			stdout: "pipe",
-			stderr: "pipe",
-		});
+		const result = await $`${pip} install --user ${pkg}`.quiet().nothrow();
 		return result.exitCode === 0;
 	}
 
@@ -316,7 +285,7 @@ function installPythonPackage(pkg: string): boolean {
 // Ensure a tool is available, downloading if necessary
 // Returns the path to the tool, or null if unavailable
 export async function ensureTool(tool: ToolName, silent: boolean = false): Promise<string | undefined> {
-	const existingPath = getToolPath(tool);
+	const existingPath = await getToolPath(tool);
 	if (existingPath) {
 		return existingPath;
 	}
@@ -325,21 +294,21 @@ export async function ensureTool(tool: ToolName, silent: boolean = false): Promi
 	const pythonConfig = PYTHON_TOOLS[tool];
 	if (pythonConfig) {
 		if (!silent) {
-			console.log(chalk.dim(`${pythonConfig.name} not found. Installing via uv/pip...`));
+			logger.debug(`${pythonConfig.name} not found. Installing via uv/pip...`);
 		}
-		const success = installPythonPackage(pythonConfig.package);
+		const success = await installPythonPackage(pythonConfig.package);
 		if (success) {
 			// Re-check for the command after installation
-			const path = commandExists(pythonConfig.binaryName);
+			const path = Bun.which(pythonConfig.binaryName);
 			if (path) {
 				if (!silent) {
-					console.log(chalk.dim(`${pythonConfig.name} installed successfully`));
+					logger.debug(`${pythonConfig.name} installed successfully`);
 				}
 				return path;
 			}
 		}
 		if (!silent) {
-			console.log(chalk.yellow(`Failed to install ${pythonConfig.name}`));
+			logger.warn(`Failed to install ${pythonConfig.name}`);
 		}
 		return undefined;
 	}
@@ -349,18 +318,20 @@ export async function ensureTool(tool: ToolName, silent: boolean = false): Promi
 
 	// Tool not found - download it
 	if (!silent) {
-		console.log(chalk.dim(`${config.name} not found. Downloading...`));
+		logger.debug(`${config.name} not found. Downloading...`);
 	}
 
 	try {
 		const path = await downloadTool(tool);
 		if (!silent) {
-			console.log(chalk.dim(`${config.name} installed to ${path}`));
+			logger.debug(`${config.name} installed to ${path}`);
 		}
 		return path;
 	} catch (e) {
 		if (!silent) {
-			console.log(chalk.yellow(`Failed to download ${config.name}: ${e instanceof Error ? e.message : e}`));
+			logger.warn(`Failed to download ${config.name}`, {
+				error: e instanceof Error ? e.message : String(e),
+			});
 		}
 		return undefined;
 	}

package/src/core/logger.ts

@@ -1,111 +0,0 @@
-/**
- * Centralized file logger for omp.
- *
- * Logs to ~/.omp/logs/ with size-based rotation, supporting concurrent omp instances.
- * Each log entry includes process.pid for traceability.
- */
-
-import { existsSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import winston from "winston";
-import DailyRotateFile from "winston-daily-rotate-file";
-
-/** Get the logs directory (~/.omp/logs/) */
-function getLogsDir(): string {
-	return join(homedir(), ".omp", "logs");
-}
-
-/** Ensure logs directory exists */
-function ensureLogsDir(): string {
-	const logsDir = getLogsDir();
-	if (!existsSync(logsDir)) {
-		mkdirSync(logsDir, { recursive: true });
-	}
-	return logsDir;
-}
-
-/** Custom format that includes pid and flattens metadata */
-const logFormat = winston.format.combine(
-	winston.format.timestamp({ format: "YYYY-MM-DDTHH:mm:ss.SSSZ" }),
-	winston.format.printf(({ timestamp, level, message, ...meta }) => {
-		const entry: Record<string, unknown> = {
-			timestamp,
-			level,
-			pid: process.pid,
-			message,
-		};
-		// Flatten metadata into entry
-		for (const [key, value] of Object.entries(meta)) {
-			if (key !== "level" && key !== "timestamp" && key !== "message") {
-				entry[key] = value;
-			}
-		}
-		return JSON.stringify(entry);
-	}),
-);
-
-/** Size-based rotating file transport */
-const fileTransport = new DailyRotateFile({
-	dirname: ensureLogsDir(),
-	filename: "omp.%DATE%.log",
-	datePattern: "YYYY-MM-DD",
-	maxSize: "10m",
-	maxFiles: 5,
-	zippedArchive: true,
-});
-
-/** The winston logger instance */
-const winstonLogger = winston.createLogger({
-	level: "debug",
-	format: logFormat,
-	transports: [fileTransport],
-	// Don't exit on error - logging failures shouldn't crash the app
-	exitOnError: false,
-});
-
-/** Logger type exposed to plugins and internal code */
-export interface Logger {
-	error(message: string, context?: Record<string, unknown>): void;
-	warn(message: string, context?: Record<string, unknown>): void;
-	debug(message: string, context?: Record<string, unknown>): void;
-}
-
-/**
- * Centralized logger for omp.
- *
- * Logs to ~/.omp/logs/omp.YYYY-MM-DD.log with size-based rotation.
- * Safe for concurrent access from multiple omp instances.
- *
- * @example
- * ```typescript
- * import { logger } from "../core/logger";
- *
- * logger.error("MCP request failed", { url, method });
- * logger.warn("Theme file invalid, using fallback", { path });
- * logger.debug("LSP fallback triggered", { reason });
- * ```
- */
-export const logger: Logger = {
-	error(message: string, context?: Record<string, unknown>): void {
-		try {
-			winstonLogger.error(message, context);
-		} catch {
-			// Silently ignore logging failures
-		}
-	},
-	warn(message: string, context?: Record<string, unknown>): void {
-		try {
-			winstonLogger.warn(message, context);
-		} catch {
-			// Silently ignore logging failures
-		}
-	},
-	debug(message: string, context?: Record<string, unknown>): void {
-		try {
-			winstonLogger.debug(message, context);
-		} catch {
-			// Silently ignore logging failures
-		}
-	},
-};

package/src/modes/cleanup.ts

@@ -1,23 +0,0 @@
-/**
- * Async cleanup registry for graceful shutdown on signals.
- */
-
-/** Registry of async cleanup callbacks to run on shutdown/signals */
-const asyncCleanupCallbacks: (() => Promise<void>)[] = [];
-
-/**
- * Register an async cleanup callback to be run on process signals (SIGINT, SIGTERM, SIGHUP).
- * Returns an unsubscribe function.
- */
-export function registerAsyncCleanup(callback: () => Promise<void>): () => void {
-	asyncCleanupCallbacks.push(callback);
-	return () => {
-		const index = asyncCleanupCallbacks.indexOf(callback);
-		if (index >= 0) asyncCleanupCallbacks.splice(index, 1);
-	};
-}
-
-/** Run all registered async cleanup callbacks, settling all promises */
-export async function runAsyncCleanup(): Promise<void> {
-	await Promise.allSettled(asyncCleanupCallbacks.map((cb) => cb()));
-}