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

package/src/utils/shell-snapshot.ts

@@ -0,0 +1,218 @@
+/**
+ * Shell environment snapshot for preserving user aliases, functions, and options.
+ *
+ * Creates a snapshot file that captures the user's shell environment from their
+ * .bashrc/.zshrc, which can be sourced before each command to provide a familiar
+ * shell experience.
+ */
+
+import { existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+
+let cachedSnapshotPath: string | null = null;
+let cleanupRegistered = false;
+
+/**
+ * Get the user's shell config file path.
+ */
+function getShellConfigFile(shell: string): string {
+	const home = homedir();
+	if (shell.includes("zsh")) return join(home, ".zshrc");
+	if (shell.includes("bash")) return join(home, ".bashrc");
+	return join(home, ".profile");
+}
+
+/**
+ * Generate the snapshot creation script.
+ * This script sources the user's rc file and extracts functions, aliases, and options.
+ * Matches Claude Code's snapshot generation logic.
+ */
+function generateSnapshotScript(shell: string, snapshotPath: string, rcFile: string): string {
+	const hasRcFile = existsSync(rcFile);
+	const isZsh = shell.includes("zsh");
+
+	// Escape the snapshot path for shell
+	const escapedPath = snapshotPath.replace(/'/g, "'\\''");
+
+	// Function extraction differs between bash and zsh
+	const functionScript = isZsh
+		? `
+echo "# Functions" >> "$SNAPSHOT_FILE"
+# Force autoload all functions first
+typeset -f > /dev/null 2>&1
+# Get user function names - filter system/private ones
+typeset +f 2>/dev/null | grep -vE '^(_|__)' | while read func; do
+   typeset -f "$func" >> "$SNAPSHOT_FILE" 2>/dev/null
+done
+`
+		: `
+echo "# Functions" >> "$SNAPSHOT_FILE"
+# Force autoload all functions first
+declare -f > /dev/null 2>&1
+# Get user function names - filter system/private ones, use base64 for special chars
+declare -F 2>/dev/null | cut -d' ' -f3 | grep -vE '^(_|__)' | while read func; do
+   encoded_func=$(declare -f "$func" | base64)
+   echo "eval \\"\\$(echo '$encoded_func' | base64 -d)\\" > /dev/null 2>&1" >> "$SNAPSHOT_FILE"
+done
+`;
+
+	// Shell options extraction
+	const optionsScript = isZsh
+		? `
+echo "# Shell Options" >> "$SNAPSHOT_FILE"
+setopt 2>/dev/null | sed 's/^/setopt /' | head -n 1000 >> "$SNAPSHOT_FILE"
+`
+		: `
+echo "# Shell Options" >> "$SNAPSHOT_FILE"
+shopt -p 2>/dev/null | head -n 1000 >> "$SNAPSHOT_FILE"
+set -o 2>/dev/null | grep "on" | awk '{print "set -o " $1}' | head -n 1000 >> "$SNAPSHOT_FILE"
+echo "shopt -s expand_aliases" >> "$SNAPSHOT_FILE"
+`;
+
+	return `
+SNAPSHOT_FILE='${escapedPath}'
+
+# Source user's rc file if it exists
+${hasRcFile ? `source "${rcFile}" < /dev/null 2>/dev/null` : "# No user config file to source"}
+
+# Create/clear the snapshot file
+echo "# Shell snapshot - generated by omp agent" >| "$SNAPSHOT_FILE"
+
+# Unalias everything first to avoid conflicts when sourced
+echo "unalias -a 2>/dev/null || true" >> "$SNAPSHOT_FILE"
+
+${functionScript}
+
+${optionsScript}
+
+# Export aliases (limit to 1000)
+echo "# Aliases" >> "$SNAPSHOT_FILE"
+# Filter out winpty aliases on Windows to avoid "stdin is not a tty" errors
+if [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "cygwin" ]]; then
+   alias 2>/dev/null | grep -v "='winpty " | sed 's/^alias //g' | sed 's/^/alias -- /' | head -n 1000 >> "$SNAPSHOT_FILE"
+else
+   alias 2>/dev/null | sed 's/^alias //g' | sed 's/^/alias -- /' | head -n 1000 >> "$SNAPSHOT_FILE"
+fi
+
+# Export PATH
+echo "export PATH='$PATH'" >> "$SNAPSHOT_FILE"
+
+# Verify snapshot was created
+if [ ! -f "$SNAPSHOT_FILE" ]; then
+   echo "Error: Snapshot file was not created" >&2
+   exit 1
+fi
+`.trim();
+}
+
+/**
+ * Create a shell snapshot, caching the result.
+ * Returns the path to the snapshot file, or null if creation failed.
+ */
+export async function getOrCreateSnapshot(
+	shell: string,
+	env: Record<string, string | undefined>,
+): Promise<string | null> {
+	// Return cached snapshot if valid
+	if (cachedSnapshotPath && existsSync(cachedSnapshotPath)) {
+		return cachedSnapshotPath;
+	}
+
+	// Skip on Windows (no .bashrc in standard location)
+	if (process.platform === "win32") {
+		return null;
+	}
+
+	const rcFile = getShellConfigFile(shell);
+
+	// Create snapshot directory
+	const snapshotDir = join(tmpdir(), "omp-shell-snapshots");
+	try {
+		mkdirSync(snapshotDir, { recursive: true });
+	} catch {
+		return null;
+	}
+
+	// Generate unique snapshot path
+	const timestamp = Date.now();
+	const random = Math.random().toString(36).substring(2, 8);
+	const shellName = shell.includes("zsh") ? "zsh" : shell.includes("bash") ? "bash" : "sh";
+	const snapshotPath = join(snapshotDir, `snapshot-${shellName}-${timestamp}-${random}.sh`);
+
+	// Generate and execute snapshot script
+	const script = generateSnapshotScript(shell, snapshotPath, rcFile);
+
+	try {
+		const result = Bun.spawnSync([shell, "-l", "-c", script], {
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe",
+			env,
+			timeout: 10000, // 10 second timeout
+		});
+
+		if (result.exitCode === 0 && existsSync(snapshotPath)) {
+			cachedSnapshotPath = snapshotPath;
+			registerCleanup();
+			return snapshotPath;
+		}
+	} catch {
+		// Snapshot creation failed, proceed without it
+	}
+
+	return null;
+}
+
+/**
+ * Get the command prefix to source the snapshot.
+ * Returns empty string if no snapshot available.
+ */
+export function getSnapshotSourceCommand(snapshotPath: string | null): string {
+	if (!snapshotPath) return "";
+	// Escape for shell
+	const escaped = snapshotPath.replace(/'/g, "'\\''");
+	return `source '${escaped}' 2>/dev/null && `;
+}
+
+/**
+ * Register cleanup handler to delete snapshot on process exit.
+ */
+function registerCleanup(): void {
+	if (cleanupRegistered) return;
+	cleanupRegistered = true;
+
+	const cleanup = () => {
+		if (cachedSnapshotPath && existsSync(cachedSnapshotPath)) {
+			try {
+				unlinkSync(cachedSnapshotPath);
+			} catch {
+				// Ignore cleanup errors
+			}
+		}
+	};
+
+	process.on("exit", cleanup);
+	process.on("SIGINT", () => {
+		cleanup();
+		process.exit(130);
+	});
+	process.on("SIGTERM", () => {
+		cleanup();
+		process.exit(143);
+	});
+}
+
+/**
+ * Clear the cached snapshot (for testing or forced refresh).
+ */
+export function clearSnapshotCache(): void {
+	if (cachedSnapshotPath && existsSync(cachedSnapshotPath)) {
+		try {
+			unlinkSync(cachedSnapshotPath);
+		} catch {
+			// Ignore
+		}
+	}
+	cachedSnapshotPath = null;
+}

package/src/utils/shell.ts

@@ -0,0 +1,364 @@
+import { accessSync, constants, existsSync } from "node:fs";
+import { SettingsManager } from "../core/settings-manager";
+
+export interface ShellConfig {
+	shell: string;
+	args: string[];
+	env: Record<string, string | undefined>;
+	prefix: string | undefined;
+}
+
+let cachedShellConfig: ShellConfig | null = null;
+
+/**
+ * Check if a shell binary is executable.
+ */
+function isExecutable(path: string): boolean {
+	try {
+		accessSync(path, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Build the spawn environment (cached).
+ */
+function buildSpawnEnv(shell: string): Record<string, string | undefined> {
+	const noCI = process.env.OMP_BASH_NO_CI || process.env.CLAUDE_BASH_NO_CI;
+	return {
+		...process.env,
+		SHELL: shell,
+		GIT_EDITOR: "true",
+		GPG_TTY: "not a tty",
+		OMPCODE: "1",
+		CLAUDECODE: "1",
+		...(noCI ? {} : { CI: "true" }),
+	};
+}
+
+/**
+ * Get shell args, optionally including login shell flag.
+ * Supports OMP_BASH_NO_LOGIN and CLAUDE_BASH_NO_LOGIN to skip -l.
+ */
+function getShellArgs(): string[] {
+	const noLogin = process.env.OMP_BASH_NO_LOGIN || process.env.CLAUDE_BASH_NO_LOGIN;
+	return noLogin ? ["-c"] : ["-l", "-c"];
+}
+
+/**
+ * Get shell prefix for wrapping commands (profilers, strace, etc.).
+ */
+function getShellPrefix(): string | undefined {
+	return process.env.OMP_SHELL_PREFIX || process.env.CLAUDE_CODE_SHELL_PREFIX;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Build full shell config from a shell path.
+ */
+function buildConfig(shell: string): ShellConfig {
+	return {
+		shell,
+		args: getShellArgs(),
+		env: buildSpawnEnv(shell),
+		prefix: getShellPrefix(),
+	};
+}
+
+/**
+ * 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: $SHELL if bash/zsh, then fallback paths
+ * 4. Fallback: sh
+ */
+export function getShellConfig(): ShellConfig {
+	if (cachedShellConfig) {
+		return cachedShellConfig;
+	}
+
+	const settings = SettingsManager.create();
+	const customShellPath = settings.getShellPath();
+
+	// 1. Check user-specified shell path
+	if (customShellPath) {
+		if (existsSync(customShellPath)) {
+			cachedShellConfig = buildConfig(customShellPath);
+			return cachedShellConfig;
+		}
+		throw new Error(
+			`Custom shell path not found: ${customShellPath}\nPlease update shellPath in ~/.omp/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 = buildConfig(path);
+				return cachedShellConfig;
+			}
+		}
+
+		// 3. Fallback: search bash.exe on PATH (Cygwin, MSYS2, WSL, etc.)
+		const bashOnPath = findBashOnPath();
+		if (bashOnPath) {
+			cachedShellConfig = buildConfig(bashOnPath);
+			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 ~/.omp/agent/settings.json\n\n` +
+				`Searched Git Bash in:\n${paths.map((p) => `  ${p}`).join("\n")}`,
+		);
+	}
+
+	// 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)) {
+		cachedShellConfig = buildConfig(userShell);
+		return cachedShellConfig;
+	}
+
+	// Fallback paths (Claude's approach: check known locations)
+	const fallbackPaths = ["/bin", "/usr/bin", "/usr/local/bin", "/opt/homebrew/bin"];
+	const preferZsh = !userShell?.includes("bash");
+	const shellOrder = preferZsh ? ["zsh", "bash"] : ["bash", "zsh"];
+
+	for (const shellName of shellOrder) {
+		for (const dir of fallbackPaths) {
+			const shellPath = `${dir}/${shellName}`;
+			if (isExecutable(shellPath)) {
+				cachedShellConfig = buildConfig(shellPath);
+				return cachedShellConfig;
+			}
+		}
+	}
+
+	// Last resort: use Bun.which
+	const bashPath = Bun.which("bash");
+	if (bashPath) {
+		cachedShellConfig = buildConfig(bashPath);
+		return cachedShellConfig;
+	}
+
+	const shPath = Bun.which("sh");
+	cachedShellConfig = buildConfig(shPath || "sh");
+	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");
+}