@lenylvt/pi-coding-agent 0.64.0

package/src/utils/shell.ts

@@ -0,0 +1,202 @@
+import { existsSync } from "node:fs";
+import { delimiter } from "node:path";
+import { spawn, spawnSync } from "child_process";
+import { getBinDir, getSettingsPath } from "../config.js";
+import { SettingsManager } from "../core/settings-manager.js";
+
+let cachedShellConfig: { shell: string; args: string[] } | null = null;
+
+/**
+ * Find bash executable on PATH (cross-platform)
+ */
+function findBashOnPath(): string | null {
+	if (process.platform === "win32") {
+		// Windows: Use 'where' and verify file exists (where can return non-existent paths)
+		try {
+			const result = spawnSync("where", ["bash.exe"], { encoding: "utf-8", timeout: 5000 });
+			if (result.status === 0 && result.stdout) {
+				const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+				if (firstMatch && existsSync(firstMatch)) {
+					return firstMatch;
+				}
+			}
+		} catch {
+			// Ignore errors
+		}
+		return null;
+	}
+
+	// Unix: Use 'which' and trust its output (handles Termux and special filesystems)
+	try {
+		const result = spawnSync("which", ["bash"], { encoding: "utf-8", timeout: 5000 });
+		if (result.status === 0 && result.stdout) {
+			const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+			if (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, then bash on PATH, then fallback to 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 ${getSettingsPath()}`,
+		);
+	}
+
+	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 ${getSettingsPath()}\n\n` +
+				`Searched Git Bash in:\n${paths.map((p) => `  ${p}`).join("\n")}`,
+		);
+	}
+
+	// Unix: try /bin/bash, then bash on PATH, then fallback to sh
+	if (existsSync("/bin/bash")) {
+		cachedShellConfig = { shell: "/bin/bash", args: ["-c"] };
+		return cachedShellConfig;
+	}
+
+	const bashOnPath = findBashOnPath();
+	if (bashOnPath) {
+		cachedShellConfig = { shell: bashOnPath, args: ["-c"] };
+		return cachedShellConfig;
+	}
+
+	cachedShellConfig = { shell: "sh", args: ["-c"] };
+	return cachedShellConfig;
+}
+
+export function getShellEnv(): NodeJS.ProcessEnv {
+	const binDir = getBinDir();
+	const pathKey = Object.keys(process.env).find((key) => key.toLowerCase() === "path") ?? "PATH";
+	const currentPath = process.env[pathKey] ?? "";
+	const pathEntries = currentPath.split(delimiter).filter(Boolean);
+	const hasBinDir = pathEntries.includes(binDir);
+	const updatedPath = hasBinDir ? currentPath : [binDir, currentPath].filter(Boolean).join(delimiter);
+
+	return {
+		...process.env,
+		[pathKey]: updatedPath,
+	};
+}
+
+/**
+ * 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("");
+}
+
+/**
+ * Kill a process and all its children (cross-platform)
+ */
+export function killProcessTree(pid: number): void {
+	if (process.platform === "win32") {
+		// Use taskkill on Windows to kill process tree
+		try {
+			spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+				stdio: "ignore",
+				detached: true,
+			});
+		} catch {
+			// Ignore errors if taskkill fails
+		}
+	} else {
+		// Use SIGKILL on Unix/Linux/Mac
+		try {
+			process.kill(-pid, "SIGKILL");
+		} catch {
+			// Fallback to killing just the child if process group kill fails
+			try {
+				process.kill(pid, "SIGKILL");
+			} catch {
+				// Process already dead
+			}
+		}
+	}
+}

package/src/utils/sleep.ts

@@ -0,0 +1,18 @@
+/**
+ * Sleep helper that respects abort signal.
+ */
+export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new Error("Aborted"));
+			return;
+		}
+
+		const timeout = setTimeout(resolve, ms);
+
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timeout);
+			reject(new Error("Aborted"));
+		});
+	});
+}

package/src/utils/tools-manager.ts

@@ -0,0 +1,287 @@
+import chalk from "chalk";
+import { spawnSync } from "child_process";
+import extractZip from "extract-zip";
+import { chmodSync, createWriteStream, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from "fs";
+import { arch, platform } from "os";
+import { join } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { APP_NAME, getBinDir } from "../config.js";
+
+const TOOLS_DIR = getBinDir();
+const NETWORK_TIMEOUT_MS = 10_000;
+const DOWNLOAD_TIMEOUT_MS = 120_000;
+
+function isOfflineModeEnabled(): boolean {
+	const value = process.env.PI_OFFLINE;
+	if (!value) return false;
+	return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
+}
+
+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;
+		},
+	},
+};
+
+// Check if a command exists in PATH by trying to run it
+function commandExists(cmd: string): boolean {
+	try {
+		const result = spawnSync(cmd, ["--version"], { stdio: "pipe" });
+		// Check for ENOENT error (command not found)
+		return result.error === undefined || result.error === null;
+	} catch {
+		return false;
+	}
+}
+
+// Get the path to a tool (system-wide or in our tools dir)
+export function getToolPath(tool: "fd" | "rg"): 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` },
+		signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
+	});
+
+	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, {
+		signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS),
+	});
+
+	if (!response.ok) {
+		throw new Error(`Failed to download: ${response.status}`);
+	}
+
+	if (!response.body) {
+		throw new Error("No response body");
+	}
+
+	const fileStream = createWriteStream(dest);
+	await pipeline(Readable.fromWeb(response.body as any), fileStream);
+}
+
+function findBinaryRecursively(rootDir: string, binaryFileName: string): string | null {
+	const stack: string[] = [rootDir];
+
+	while (stack.length > 0) {
+		const currentDir = stack.pop();
+		if (!currentDir) continue;
+
+		const entries = readdirSync(currentDir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = join(currentDir, entry.name);
+			if (entry.isFile() && entry.name === binaryFileName) {
+				return fullPath;
+			}
+			if (entry.isDirectory()) {
+				stack.push(fullPath);
+			}
+		}
+	}
+
+	return null;
+}
+
+// Download and install a tool
+async function downloadTool(tool: "fd" | "rg"): 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 into a unique temp directory. fd and rg downloads can run concurrently
+	// during startup, so sharing a fixed directory causes races.
+	const extractDir = join(
+		TOOLS_DIR,
+		`extract_tmp_${config.binaryName}_${process.pid}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+	);
+	mkdirSync(extractDir, { recursive: true });
+
+	try {
+		if (assetName.endsWith(".tar.gz")) {
+			const extractResult = spawnSync("tar", ["xzf", archivePath, "-C", extractDir], { stdio: "pipe" });
+			if (extractResult.error || extractResult.status !== 0) {
+				const errMsg = extractResult.error?.message ?? extractResult.stderr?.toString().trim() ?? "unknown error";
+				throw new Error(`Failed to extract ${assetName}: ${errMsg}`);
+			}
+		} else if (assetName.endsWith(".zip")) {
+			await extractZip(archivePath, { dir: extractDir });
+		} else {
+			throw new Error(`Unsupported archive format: ${assetName}`);
+		}
+
+		// Find the binary in extracted files. Some archives contain files directly
+		// at root, others nest under a versioned subdirectory.
+		const binaryFileName = config.binaryName + binaryExt;
+		const extractedDir = join(extractDir, assetName.replace(/\.(tar\.gz|zip)$/, ""));
+		const extractedBinaryCandidates = [join(extractedDir, binaryFileName), join(extractDir, binaryFileName)];
+		let extractedBinary = extractedBinaryCandidates.find((candidate) => existsSync(candidate));
+
+		if (!extractedBinary) {
+			extractedBinary = findBinaryRecursively(extractDir, binaryFileName) ?? undefined;
+		}
+
+		if (extractedBinary) {
+			renameSync(extractedBinary, binaryPath);
+		} else {
+			throw new Error(`Binary not found in archive: expected ${binaryFileName} under ${extractDir}`);
+		}
+
+		// Make executable (Unix only)
+		if (plat !== "win32") {
+			chmodSync(binaryPath, 0o755);
+		}
+	} finally {
+		// Cleanup
+		rmSync(archivePath, { force: true });
+		rmSync(extractDir, { recursive: true, force: true });
+	}
+
+	return binaryPath;
+}
+
+// Termux package names for tools
+const TERMUX_PACKAGES: Record<string, string> = {
+	fd: "fd",
+	rg: "ripgrep",
+};
+
+// 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", silent: boolean = false): Promise<string | undefined> {
+	const existingPath = getToolPath(tool);
+	if (existingPath) {
+		return existingPath;
+	}
+
+	const config = TOOLS[tool];
+	if (!config) return undefined;
+
+	if (isOfflineModeEnabled()) {
+		if (!silent) {
+			console.log(chalk.yellow(`${config.name} not found. Offline mode enabled, skipping download.`));
+		}
+		return undefined;
+	}
+
+	// On Android/Termux, Linux binaries don't work due to Bionic libc incompatibility.
+	// Users must install via pkg.
+	if (platform() === "android") {
+		const pkgName = TERMUX_PACKAGES[tool] ?? tool;
+		if (!silent) {
+			console.log(chalk.yellow(`${config.name} not found. Install with: pkg install ${pkgName}`));
+		}
+		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;
+	}
+}