@oh-my-pi/pi-coding-agent 1.337.0

package/src/utils/shell.ts

@@ -0,0 +1,276 @@
+import { existsSync } from "node:fs";
+import { SettingsManager } from "../core/settings-manager.js";
+
+let cachedShellConfig: { shell: string; args: string[] } | null = null;
+
+/**
+ * Find bash executable on PATH (Windows)
+ */
+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;
+			}
+		}
+	} catch {
+		// Ignore errors
+	}
+	return null;
+}
+
+/**
+ * Get shell configuration based on platform.
+ * Resolution order:
+ * 1. User-specified shellPath in settings.json
+ * 2. On Windows: Git Bash in known locations, then bash on PATH
+ * 3. On Unix: /bin/bash
+ * 4. Fallback: sh
+ */
+export function getShellConfig(): { shell: string; args: string[] } {
+	if (cachedShellConfig) {
+		return cachedShellConfig;
+	}
+
+	const settings = SettingsManager.create();
+	const customShellPath = settings.getShellPath();
+
+	// 1. Check user-specified shell path
+	if (customShellPath) {
+		if (existsSync(customShellPath)) {
+			cachedShellConfig = { shell: customShellPath, args: ["-c"] };
+			return cachedShellConfig;
+		}
+		throw new Error(
+			`Custom shell path not found: ${customShellPath}\nPlease update shellPath in ~/.pi/agent/settings.json`,
+		);
+	}
+
+	if (process.platform === "win32") {
+		// 2. Try Git Bash in known locations
+		const paths: string[] = [];
+		const programFiles = process.env.ProgramFiles;
+		if (programFiles) {
+			paths.push(`${programFiles}\\Git\\bin\\bash.exe`);
+		}
+		const programFilesX86 = process.env["ProgramFiles(x86)"];
+		if (programFilesX86) {
+			paths.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
+		}
+
+		for (const path of paths) {
+			if (existsSync(path)) {
+				cachedShellConfig = { shell: path, args: ["-c"] };
+				return cachedShellConfig;
+			}
+		}
+
+		// 3. Fallback: search bash.exe on PATH (Cygwin, MSYS2, WSL, etc.)
+		const bashOnPath = findBashOnPath();
+		if (bashOnPath) {
+			cachedShellConfig = { shell: bashOnPath, args: ["-c"] };
+			return cachedShellConfig;
+		}
+
+		throw new Error(
+			`No bash shell found. Options:\n` +
+				`  1. Install Git for Windows: https://git-scm.com/download/win\n` +
+				`  2. Add your bash to PATH (Cygwin, MSYS2, etc.)\n` +
+				`  3. Set shellPath in ~/.pi/agent/settings.json\n\n` +
+				`Searched Git Bash in:\n${paths.map((p) => `  ${p}`).join("\n")}`,
+		);
+	}
+
+	// Unix: prefer bash over sh
+	if (existsSync("/bin/bash")) {
+		cachedShellConfig = { shell: "/bin/bash", args: ["-c"] };
+		return cachedShellConfig;
+	}
+
+	cachedShellConfig = { shell: "sh", args: ["-c"] };
+	return cachedShellConfig;
+}
+
+/**
+ * Sanitize binary output for display/storage.
+ * Removes characters that crash string-width or cause display issues:
+ * - Control characters (except tab, newline, carriage return)
+ * - Lone surrogates
+ * - Unicode Format characters (crash string-width due to a bug)
+ * - Characters with undefined code points
+ */
+export function sanitizeBinaryOutput(str: string): string {
+	// Use Array.from to properly iterate over code points (not code units)
+	// This handles surrogate pairs correctly and catches edge cases where
+	// codePointAt() might return undefined
+	return Array.from(str)
+		.filter((char) => {
+			// Filter out characters that cause string-width to crash
+			// This includes:
+			// - Unicode format characters
+			// - Lone surrogates (already filtered by Array.from)
+			// - Control chars except \t \n \r
+			// - Characters with undefined code points
+
+			const code = char.codePointAt(0);
+
+			// Skip if code point is undefined (edge case with invalid strings)
+			if (code === undefined) return false;
+
+			// Allow tab, newline, carriage return
+			if (code === 0x09 || code === 0x0a || code === 0x0d) return true;
+
+			// Filter out control characters (0x00-0x1F, except 0x09, 0x0a, 0x0x0d)
+			if (code <= 0x1f) return false;
+
+			// Filter out Unicode format characters
+			if (code >= 0xfff9 && code <= 0xfffb) return false;
+
+			return true;
+		})
+		.join("");
+}
+
+let pgrepAvailable: boolean | null = null;
+
+/**
+ * Check if pgrep is available on this system (cached).
+ */
+function hasPgrep(): boolean {
+	if (pgrepAvailable === null) {
+		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;
+		} catch {
+			pgrepAvailable = false;
+		}
+	}
+	return pgrepAvailable;
+}
+
+/**
+ * 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 [];
+
+	const children: number[] = [];
+	for (const line of result.stdout.toString().trim().split("\n")) {
+		const childPid = parseInt(line, 10);
+		if (!Number.isNaN(childPid)) children.push(childPid);
+	}
+	return children;
+}
+
+/**
+ * Get direct children of a PID using /proc (Linux only).
+ */
+function getChildrenViaProc(pid: number): 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 children: number[] = [];
+		for (const line of result.stdout.toString().trim().split("\n")) {
+			const childPid = parseInt(line, 10);
+			if (!Number.isNaN(childPid)) children.push(childPid);
+		}
+		return children;
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Collect all descendant PIDs breadth-first.
+ * Returns deepest descendants first (reverse BFS order) for proper kill ordering.
+ */
+function getDescendantPids(pid: number): number[] {
+	const getChildren = hasPgrep() ? getChildrenViaPgrep : getChildrenViaProc;
+	const descendants: number[] = [];
+	const queue = [pid];
+
+	while (queue.length > 0) {
+		const current = queue.shift()!;
+		const children = getChildren(current);
+		for (const child of children) {
+			descendants.push(child);
+			queue.push(child);
+		}
+	}
+
+	// Reverse so deepest children are killed first
+	return descendants.reverse();
+}
+
+function tryKill(pid: number, signal: NodeJS.Signals): boolean {
+	try {
+		process.kill(pid, signal);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * 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 {
+	if (process.platform === "win32") {
+		Bun.spawnSync(["taskkill", "/F", "/T", "/PID", String(pid)], {
+			stdin: "ignore",
+			stdout: "ignore",
+			stderr: "ignore",
+		});
+		return;
+	}
+
+	const signal = gracePeriodMs > 0 ? "SIGTERM" : "SIGKILL";
+
+	// Fast path: process group kill (works if pid is group leader)
+	try {
+		process.kill(-pid, signal);
+		if (gracePeriodMs > 0) {
+			Bun.sleepSync(gracePeriodMs);
+			try {
+				process.kill(-pid, "SIGKILL");
+			} catch {
+				// Already dead
+			}
+		}
+		return;
+	} catch {
+		// Not a process group leader, fall through
+	}
+
+	// Collect descendants BEFORE killing to minimize race window
+	const allPids = [...getDescendantPids(pid), pid];
+
+	if (gracePeriodMs > 0) {
+		for (const p of allPids) tryKill(p, "SIGTERM");
+		Bun.sleepSync(gracePeriodMs);
+	}
+
+	for (const p of allPids) tryKill(p, "SIGKILL");
+}

package/src/utils/tools-manager.ts

@@ -0,0 +1,274 @@
+import { chmodSync, createWriteStream, existsSync, mkdirSync, renameSync, rmSync } from "node:fs";
+import { arch, platform } from "node:os";
+import { join } from "node:path";
+import chalk from "chalk";
+import { APP_NAME, getToolsDir } from "../config.js";
+
+const TOOLS_DIR = getToolsDir();
+
+interface ToolConfig {
+	name: string;
+	repo: string; // GitHub repo (e.g., "sharkdp/fd")
+	binaryName: string; // Name of the binary inside the archive
+	tagPrefix: string; // Prefix for tags (e.g., "v" for v1.0.0, "" for 1.0.0)
+	getAssetName: (version: string, plat: string, architecture: string) => string | null;
+}
+
+const TOOLS: Record<string, ToolConfig> = {
+	fd: {
+		name: "fd",
+		repo: "sharkdp/fd",
+		binaryName: "fd",
+		tagPrefix: "v",
+		getAssetName: (version, plat, architecture) => {
+			if (plat === "darwin") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `fd-v${version}-${archStr}-apple-darwin.tar.gz`;
+			} else if (plat === "linux") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `fd-v${version}-${archStr}-unknown-linux-gnu.tar.gz`;
+			} else if (plat === "win32") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `fd-v${version}-${archStr}-pc-windows-msvc.zip`;
+			}
+			return null;
+		},
+	},
+	rg: {
+		name: "ripgrep",
+		repo: "BurntSushi/ripgrep",
+		binaryName: "rg",
+		tagPrefix: "",
+		getAssetName: (version, plat, architecture) => {
+			if (plat === "darwin") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `ripgrep-${version}-${archStr}-apple-darwin.tar.gz`;
+			} else if (plat === "linux") {
+				if (architecture === "arm64") {
+					return `ripgrep-${version}-aarch64-unknown-linux-gnu.tar.gz`;
+				}
+				return `ripgrep-${version}-x86_64-unknown-linux-musl.tar.gz`;
+			} else if (plat === "win32") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `ripgrep-${version}-${archStr}-pc-windows-msvc.zip`;
+			}
+			return null;
+		},
+	},
+	sd: {
+		name: "sd",
+		repo: "chmln/sd",
+		binaryName: "sd",
+		tagPrefix: "v",
+		getAssetName: (version, plat, architecture) => {
+			if (plat === "darwin") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `sd-v${version}-${archStr}-apple-darwin.tar.gz`;
+			} else if (plat === "linux") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `sd-v${version}-${archStr}-unknown-linux-musl.tar.gz`;
+			} else if (plat === "win32") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `sd-v${version}-${archStr}-pc-windows-msvc.zip`;
+			}
+			return null;
+		},
+	},
+	sg: {
+		name: "ast-grep",
+		repo: "ast-grep/ast-grep",
+		binaryName: "sg",
+		tagPrefix: "",
+		getAssetName: (_version, plat, architecture) => {
+			if (plat === "darwin") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `ast-grep-${archStr}-apple-darwin.zip`;
+			} else if (plat === "linux") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `ast-grep-${archStr}-unknown-linux-gnu.zip`;
+			} else if (plat === "win32") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `ast-grep-${archStr}-pc-windows-msvc.zip`;
+			}
+			return null;
+		},
+	},
+};
+
+// Check if a command exists in PATH by trying to run it
+function commandExists(cmd: string): boolean {
+	try {
+		const proc = Bun.spawnSync([cmd, "--version"], { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+		return proc.exitCode !== null;
+	} catch {
+		return false;
+	}
+}
+
+// Get the path to a tool (system-wide or in our tools dir)
+export function getToolPath(tool: "fd" | "rg" | "sd" | "sg"): string | null {
+	const config = TOOLS[tool];
+	if (!config) return null;
+
+	// Check our tools directory first
+	const localPath = join(TOOLS_DIR, config.binaryName + (platform() === "win32" ? ".exe" : ""));
+	if (existsSync(localPath)) {
+		return localPath;
+	}
+
+	// Check system PATH - if found, just return the command name (it's in PATH)
+	if (commandExists(config.binaryName)) {
+		return config.binaryName;
+	}
+
+	return null;
+}
+
+// Fetch latest release version from GitHub
+async function getLatestVersion(repo: string): Promise<string> {
+	const response = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
+		headers: { "User-Agent": `${APP_NAME}-coding-agent` },
+	});
+
+	if (!response.ok) {
+		throw new Error(`GitHub API error: ${response.status}`);
+	}
+
+	const data = (await response.json()) as { tag_name: string };
+	return data.tag_name.replace(/^v/, "");
+}
+
+// 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) {
+		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);
+	});
+}
+
+// Download and install a tool
+async function downloadTool(tool: "fd" | "rg" | "sd" | "sg"): Promise<string> {
+	const config = TOOLS[tool];
+	if (!config) throw new Error(`Unknown tool: ${tool}`);
+
+	const plat = platform();
+	const architecture = arch();
+
+	// Get latest version
+	const version = await getLatestVersion(config.repo);
+
+	// Get asset name for this platform
+	const assetName = config.getAssetName(version, plat, architecture);
+	if (!assetName) {
+		throw new Error(`Unsupported platform: ${plat}/${architecture}`);
+	}
+
+	// Create tools directory
+	mkdirSync(TOOLS_DIR, { recursive: true });
+
+	const downloadUrl = `https://github.com/${config.repo}/releases/download/${config.tagPrefix}${version}/${assetName}`;
+	const archivePath = join(TOOLS_DIR, assetName);
+	const binaryExt = plat === "win32" ? ".exe" : "";
+	const binaryPath = join(TOOLS_DIR, config.binaryName + binaryExt);
+
+	// Download
+	await downloadFile(downloadUrl, archivePath);
+
+	// Extract
+	const extractDir = join(TOOLS_DIR, "extract_tmp");
+	mkdirSync(extractDir, { recursive: true });
+
+	try {
+		if (assetName.endsWith(".tar.gz")) {
+			Bun.spawnSync(["tar", "xzf", archivePath, "-C", extractDir], {
+				stdin: "ignore",
+				stdout: "pipe",
+				stderr: "pipe",
+			});
+		} else if (assetName.endsWith(".zip")) {
+			Bun.spawnSync(["unzip", "-o", archivePath, "-d", extractDir], {
+				stdin: "ignore",
+				stdout: "pipe",
+				stderr: "pipe",
+			});
+		}
+
+		// 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);
+		} else {
+			const extractedDir = join(extractDir, assetName.replace(/\.(tar\.gz|zip)$/, ""));
+			extractedBinary = join(extractedDir, config.binaryName + binaryExt);
+		}
+
+		if (existsSync(extractedBinary)) {
+			renameSync(extractedBinary, binaryPath);
+		} else {
+			throw new Error(`Binary not found in archive: ${extractedBinary}`);
+		}
+
+		// Make executable (Unix only)
+		if (plat !== "win32") {
+			chmodSync(binaryPath, 0o755);
+		}
+	} finally {
+		// Cleanup
+		rmSync(archivePath, { force: true });
+		rmSync(extractDir, { recursive: true, force: true });
+	}
+
+	return binaryPath;
+}
+
+// Ensure a tool is available, downloading if necessary
+// Returns the path to the tool, or null if unavailable
+export async function ensureTool(
+	tool: "fd" | "rg" | "sd" | "sg",
+	silent: boolean = false,
+): Promise<string | undefined> {
+	const existingPath = getToolPath(tool);
+	if (existingPath) {
+		return existingPath;
+	}
+
+	const config = TOOLS[tool];
+	if (!config) return undefined;
+
+	// Tool not found - download it
+	if (!silent) {
+		console.log(chalk.dim(`${config.name} not found. Downloading...`));
+	}
+
+	try {
+		const path = await downloadTool(tool);
+		if (!silent) {
+			console.log(chalk.dim(`${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}`));
+		}
+		return undefined;
+	}
+}