@wahack/pi-coding-agent 15.11.0

package/src/exec/bash-executor.ts

@@ -0,0 +1,419 @@
+/**
+ * Bash command execution with streaming support and cancellation.
+ *
+ * Uses brush-core via native bindings for shell execution.
+ */
+import * as fs from "node:fs/promises";
+import { ExponentialYield } from "@oh-my-pi/pi-agent-core/utils/yield";
+import { executeShell, type MinimizerOptions, Shell, type ShellRunResult } from './stubs/natives/index.ts';
+import { isExecutable, type ShellConfig } from "@oh-my-pi/pi-utils/procmgr";
+import { Settings, type ShellMinimizerSettings } from "../config/settings";
+import { OutputSink } from "../session/streaming-output";
+import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../tools/output-meta";
+import { getOrCreateSnapshot } from "../utils/shell-snapshot";
+import { NON_INTERACTIVE_ENV } from "./non-interactive-env";
+
+export interface BashExecutorOptions {
+	cwd?: string;
+	timeout?: number;
+	onChunk?: (chunk: string) => void;
+	chunkThrottleMs?: number;
+	signal?: AbortSignal;
+	/** Session key suffix to isolate shell sessions per agent */
+	sessionKey?: string;
+	/** Additional environment variables to inject */
+	env?: Record<string, string>;
+	/** Run through the configured user shell instead of brush parsing directly. */
+	useUserShell?: boolean;
+	/** Artifact path/id for full output storage */
+	artifactPath?: string;
+	artifactId?: string;
+	/**
+	 * Invoked when the native minimizer rewrote the command's output, giving
+	 * the caller a chance to persist the lossless original capture (typically
+	 * via the session's `ArtifactManager`). The returned id is spliced into
+	 * the sink output as `artifact://<id>` so the agent can retrieve the raw
+	 * bytes. Return `undefined` to skip the footer.
+	 */
+	onMinimizedSave?: (
+		originalText: string,
+		info: { filter: string; inputBytes: number; outputBytes: number },
+	) => Promise<string | undefined>;
+}
+
+export interface BashResult {
+	output: string;
+	exitCode: number | undefined;
+	cancelled: boolean;
+	truncated: boolean;
+	totalLines: number;
+	totalBytes: number;
+	outputLines: number;
+	outputBytes: number;
+	artifactId?: string;
+}
+
+const shellSessions = new Map<string, Shell>();
+const brokenShellSessions = new Set<string>();
+const shellSessionQuarantines = new Map<string, Promise<unknown>>();
+
+function quarantineShellSession(
+	sessionKey: string,
+	runPromise: Promise<ShellRunResult>,
+	abortCleanupPromise: Promise<void> | undefined,
+): void {
+	brokenShellSessions.add(sessionKey);
+	const cleanup = abortCleanupPromise
+		? Promise.allSettled([runPromise, abortCleanupPromise])
+		: Promise.allSettled([runPromise]);
+	shellSessionQuarantines.set(sessionKey, cleanup);
+	void cleanup
+		.finally(() => {
+			if (shellSessionQuarantines.get(sessionKey) === cleanup) {
+				shellSessionQuarantines.delete(sessionKey);
+				brokenShellSessions.delete(sessionKey);
+			}
+		})
+		.catch(() => undefined);
+}
+
+async function resolveShellCwd(cwd: string | undefined): Promise<string | undefined> {
+	if (!cwd) return undefined;
+
+	try {
+		// Brush preserves the working directory string verbatim, so resolve symlinks
+		// up front to keep `pwd` aligned with tools like `git worktree list`.
+		return await fs.realpath(cwd);
+	} catch {
+		return cwd;
+	}
+}
+
+/** Translate `ShellMinimizerSettings` into native `MinimizerOptions`, or `undefined` when disabled. */
+export function buildMinimizerOptions(group: ShellMinimizerSettings): MinimizerOptions | undefined {
+	if (!group.enabled) return undefined;
+	return {
+		enabled: true,
+		settingsPath: group.settingsPath || undefined,
+		only: group.only.length > 0 ? group.only : undefined,
+		except: group.except.length > 0 ? group.except : undefined,
+		maxCaptureBytes: group.maxCaptureBytes,
+		sourceOutlineLevel: group.sourceOutlineLevel === "default" ? undefined : group.sourceOutlineLevel,
+		legacyFilters: group.legacyFilters,
+	};
+}
+
+function shellBasename(shell: string): string {
+	return shell.replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? "";
+}
+
+function isBashShell(shell: string): boolean {
+	const basename = shellBasename(shell);
+	return basename.includes("bash");
+}
+
+function needsInteractiveShellArg(shell: string): boolean {
+	const basename = shellBasename(shell);
+	return basename.includes("zsh");
+}
+
+function supportsAutoUserShell(shell: string): boolean {
+	const basename = shellBasename(shell);
+	return basename.includes("bash") || basename.includes("zsh") || basename.includes("fish");
+}
+
+function hasInteractiveShellArg(args: string[]): boolean {
+	return args.some(arg => arg === "--interactive" || /^-[^-]*i/.test(arg));
+}
+
+function ensureInteractiveShellArgs(shell: string, args: string[]): string[] {
+	if (!needsInteractiveShellArg(shell) || hasInteractiveShellArg(args)) return args;
+
+	const commandIndex = args.findIndex(arg => arg === "-c" || arg === "--command");
+	if (commandIndex !== -1) {
+		return [...args.slice(0, commandIndex), "-i", ...args.slice(commandIndex)];
+	}
+
+	const compactCommandIndex = args.findIndex(arg => /^-[^-]*c[^-]*$/.test(arg));
+	if (compactCommandIndex !== -1) {
+		return args.map((arg, index) => (index === compactCommandIndex ? arg.replace("c", "ic") : arg));
+	}
+
+	return [...args, "-i"];
+}
+
+function quoteShellArg(value: string): string {
+	return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+function buildUserShellCommand(shell: string, args: string[], command: string): string {
+	return [shell, ...ensureInteractiveShellArgs(shell, args), command].map(quoteShellArg).join(" ");
+}
+
+function resolveUserShellConfig(settings: Settings, baseConfig: ShellConfig): ShellConfig {
+	const customShellPath = settings.get("shellPath");
+	const envShell = Bun.env.SHELL;
+	if (customShellPath || process.platform === "win32" || !envShell || envShell === baseConfig.shell) {
+		return baseConfig;
+	}
+	if (!supportsAutoUserShell(envShell) || !isExecutable(envShell)) {
+		return baseConfig;
+	}
+
+	return {
+		...baseConfig,
+		shell: envShell,
+		env: {
+			...baseConfig.env,
+			SHELL: envShell,
+		},
+	};
+}
+
+export async function executeBash(command: string, options?: BashExecutorOptions): Promise<BashResult> {
+	const settings = await Settings.init();
+	const baseShellConfig = settings.getShellConfig();
+	const shellConfig =
+		options?.useUserShell === true ? resolveUserShellConfig(settings, baseShellConfig) : baseShellConfig;
+	const { shell, args, env: shellEnv, prefix } = shellConfig;
+	const bashShell = isBashShell(shell);
+	const snapshotPath = bashShell ? await getOrCreateSnapshot(shell, shellEnv) : null;
+
+	const minimizer = buildMinimizerOptions(settings.getGroup("shellMinimizer"));
+
+	const commandCwd = await resolveShellCwd(options?.cwd);
+	const commandEnv = options?.env ? { ...NON_INTERACTIVE_ENV, ...options.env } : NON_INTERACTIVE_ENV;
+
+	// Apply command prefix if configured
+	const prefixedCommand = prefix ? `${prefix} ${command}` : command;
+	const finalCommand =
+		options?.useUserShell === true && !bashShell
+			? buildUserShellCommand(shell, args, prefixedCommand)
+			: prefixedCommand;
+
+	// Create output sink for truncation and artifact handling
+	const sink = new OutputSink({
+		onChunk: options?.onChunk,
+		artifactPath: options?.artifactPath,
+		artifactId: options?.artifactId,
+		headBytes: resolveOutputSinkHeadBytes(settings),
+		maxColumns: resolveOutputMaxColumns(settings),
+		chunkThrottleMs: options?.onChunk ? (options.chunkThrottleMs ?? 50) : 0,
+	});
+
+	// sink.push() is synchronous — buffer management, counters, and onChunk
+	// all run inline. File writes (artifact path) are handled asynchronously
+	// inside the sink. No promise chain needed.
+	let acceptingChunks = true;
+	const enqueueChunk = (chunk: string) => {
+		if (acceptingChunks) sink.push(chunk);
+	};
+
+	if (options?.signal?.aborted) {
+		return {
+			exitCode: undefined,
+			cancelled: true,
+			...(await sink.dump("Command cancelled")),
+		};
+	}
+
+	const sessionKey = buildSessionKey(shell, prefix, snapshotPath, shellEnv, options?.sessionKey, minimizer);
+	const persistentSessionBroken = brokenShellSessions.has(sessionKey);
+	if (persistentSessionBroken) {
+		shellSessions.delete(sessionKey);
+	}
+
+	let shellSession = persistentSessionBroken ? undefined : shellSessions.get(sessionKey);
+	if (!shellSession && !persistentSessionBroken) {
+		shellSession = new Shell({
+			sessionEnv: shellEnv,
+			snapshotPath: snapshotPath ?? undefined,
+			minimizer,
+		});
+		shellSessions.set(sessionKey, shellSession);
+	}
+	const userSignal = options?.signal;
+	const runAbortController = new AbortController();
+	let abortCleanupPromise: Promise<void> | undefined;
+	const abortCurrentExecution = () => {
+		if (!runAbortController.signal.aborted) {
+			runAbortController.abort();
+		}
+		if (shellSession && !abortCleanupPromise) {
+			abortCleanupPromise = shellSession.abort().catch(() => undefined);
+		}
+	};
+	const abortDeferred = Promise.withResolvers<"abort">();
+	const abortHandler = () => {
+		abortCurrentExecution();
+		abortDeferred.resolve("abort");
+	};
+	if (userSignal) {
+		userSignal.addEventListener("abort", abortHandler, { once: true });
+	}
+
+	let timeoutTimer: NodeJS.Timeout | undefined;
+	const timeoutDeferred = Promise.withResolvers<"timeout">();
+	const baseTimeoutMs = Math.max(1_000, options?.timeout ?? 300_000);
+	timeoutTimer = setTimeout(() => {
+		abortCurrentExecution();
+		timeoutDeferred.resolve("timeout");
+	}, baseTimeoutMs);
+
+	let resetSession = false;
+
+	try {
+		const runPromise = shellSession
+			? shellSession.run(
+					{
+						command: finalCommand,
+						cwd: commandCwd,
+						env: commandEnv,
+						timeoutMs: options?.timeout,
+						signal: runAbortController.signal,
+					},
+					(err, chunk) => {
+						if (!err) {
+							enqueueChunk(chunk);
+						}
+					},
+				)
+			: executeShell(
+					{
+						command: finalCommand,
+						cwd: commandCwd,
+						env: commandEnv,
+						sessionEnv: shellEnv,
+						snapshotPath: snapshotPath ?? undefined,
+						minimizer,
+						timeoutMs: options?.timeout,
+						signal: runAbortController.signal,
+					},
+					(err, chunk) => {
+						if (!err) {
+							enqueueChunk(chunk);
+						}
+					},
+				);
+
+		const ey = new ExponentialYield();
+		const winner = await ey.race<
+			{ kind: "result"; result: ShellRunResult } | { kind: "timeout" } | { kind: "abort" }
+		>([
+			runPromise.then(result => ({ kind: "result" as const, result })),
+			timeoutDeferred.promise.then(kind => ({ kind })),
+			abortDeferred.promise.then(kind => ({ kind })),
+		]);
+
+		if (winner.kind === "timeout" || winner.kind === "abort") {
+			acceptingChunks = false;
+			if (shellSession) {
+				resetSession = true;
+				quarantineShellSession(sessionKey, runPromise, abortCleanupPromise);
+			} else {
+				void runPromise.catch(() => undefined);
+			}
+			return {
+				exitCode: undefined,
+				cancelled: true,
+				...(await sink.dump(
+					winner.kind === "timeout"
+						? `Command timed out after ${Math.round(baseTimeoutMs / 1000)} seconds`
+						: "Command cancelled",
+				)),
+			};
+		}
+		if (timeoutTimer) {
+			clearTimeout(timeoutTimer);
+			timeoutTimer = undefined;
+		}
+
+		// Handle timeout
+		if (winner.result.timedOut) {
+			const annotation = options?.timeout
+				? `Command timed out after ${Math.round(options.timeout / 1000)} seconds`
+				: "Command timed out";
+			resetSession = true;
+			if (shellSession) {
+				quarantineShellSession(sessionKey, runPromise, abortCleanupPromise);
+			}
+			return {
+				exitCode: undefined,
+				cancelled: true,
+				...(await sink.dump(annotation)),
+			};
+		}
+
+		// Handle cancellation
+		if (winner.result.cancelled) {
+			resetSession = true;
+			if (shellSession) {
+				quarantineShellSession(sessionKey, runPromise, abortCleanupPromise);
+			}
+			return {
+				exitCode: undefined,
+				cancelled: true,
+				...(await sink.dump("Command cancelled")),
+			};
+		}
+
+		// When the native minimizer rewrote the output, swap the sink's accumulated
+		// raw stream for the minimized text, persist the original as a session
+		// artifact, and splice an `artifact://<id>` footer into the visible text so
+		// the agent can retrieve the raw bytes losslessly.
+		const minimized = winner.result.minimized;
+		if (minimized && minimized.text !== minimized.originalText) {
+			sink.replace(minimized.text);
+			if (options?.onMinimizedSave) {
+				const artifactId = await options.onMinimizedSave(minimized.originalText, {
+					filter: minimized.filter,
+					inputBytes: minimized.inputBytes,
+					outputBytes: minimized.outputBytes,
+				});
+				if (artifactId) {
+					const sep = minimized.text.endsWith("\n") ? "" : "\n";
+					sink.push(`${sep}[raw output: artifact://${artifactId}]\n`);
+				}
+			}
+		}
+
+		// Normal completion
+		return {
+			exitCode: winner.result.exitCode,
+			cancelled: false,
+			...(await sink.dump()),
+		};
+	} catch (err) {
+		resetSession = true;
+		throw err;
+	} finally {
+		if (timeoutTimer) {
+			clearTimeout(timeoutTimer);
+		}
+		if (userSignal) {
+			userSignal.removeEventListener("abort", abortHandler);
+		}
+		if (resetSession || options?.sessionKey?.includes(":async:")) {
+			// `:async:` keys are per-job (jobId is unique), so the Shell would
+			// otherwise stay in the process-global map forever after completion.
+			shellSessions.delete(sessionKey);
+		}
+	}
+}
+
+function buildSessionKey(
+	shell: string,
+	prefix: string | undefined,
+	snapshotPath: string | null,
+	env: Record<string, string>,
+	agentSessionKey?: string,
+	minimizer?: MinimizerOptions,
+): string {
+	const entries = Object.entries(env);
+	entries.sort(([a], [b]) => a.localeCompare(b));
+	const envSerialized = entries.map(([key, value]) => `${key}=${value}`).join("\n");
+	const minimizerSerialized = minimizer ? JSON.stringify(minimizer) : "";
+	return [agentSessionKey ?? "", shell, prefix ?? "", snapshotPath ?? "", envSerialized, minimizerSerialized].join(
+		"\n",
+	);
+}

package/src/exec/exec.ts

@@ -0,0 +1,53 @@
+/**
+ * Shared command execution utilities for hooks and custom tools.
+ */
+import { ptree } from "@oh-my-pi/pi-utils";
+
+/**
+ * Options for executing shell commands.
+ */
+export interface ExecOptions {
+	/** AbortSignal to cancel the command */
+	signal?: AbortSignal;
+	/** Timeout in milliseconds */
+	timeout?: number;
+	/** Working directory */
+	cwd?: string;
+}
+
+/**
+ * Result of executing a shell command.
+ */
+export interface ExecResult {
+	stdout: string;
+	stderr: string;
+	code: number;
+	killed: boolean;
+}
+
+/**
+ * Execute a shell command and return stdout/stderr/code.
+ * Supports timeout and abort signal.
+ */
+export async function execCommand(
+	command: string,
+	args: string[],
+	cwd: string,
+	options?: ExecOptions,
+): Promise<ExecResult> {
+	const result = await ptree.exec([command, ...args], {
+		cwd,
+		signal: options?.signal,
+		timeout: options?.timeout,
+		allowNonZero: true,
+		allowAbort: true,
+		stderr: "full",
+	});
+
+	return {
+		stdout: result.stdout,
+		stderr: result.stderr,
+		code: result.exitCode ?? 0,
+		killed: Boolean(result.exitError?.aborted),
+	};
+}

package/src/exec/non-interactive-env.ts

@@ -0,0 +1,48 @@
+export const NON_INTERACTIVE_ENV: Readonly<Record<string, string>> = {
+	// Disable pagers so commands don't block on interactive views.
+	PAGER: "cat",
+	GIT_PAGER: "cat",
+	MANPAGER: "cat",
+	SYSTEMD_PAGER: "cat",
+	BAT_PAGER: "cat",
+	DELTA_PAGER: "cat",
+	GH_PAGER: "cat",
+	GLAB_PAGER: "cat",
+	PSQL_PAGER: "cat",
+	MYSQL_PAGER: "cat",
+	AWS_PAGER: "",
+	HOMEBREW_PAGER: "cat",
+	LESS: "FRX",
+	// Disable terminal features that can block the process.
+	TERM: "dumb",
+	GPG_TTY: "not a tty",
+	NO_COLOR: "1",
+	PYTHONUNBUFFERED: "1",
+	// Disable editor and terminal credential prompts.
+	GIT_EDITOR: "true",
+	VISUAL: "true",
+	EDITOR: "true",
+	GIT_TERMINAL_PROMPT: "0",
+	SSH_ASKPASS: "/usr/bin/false",
+	CI: "1",
+	// Package manager defaults for unattended execution.
+	npm_config_yes: "true",
+	npm_config_update_notifier: "false",
+	npm_config_fund: "false",
+	npm_config_audit: "false",
+	npm_config_progress: "false",
+	PNPM_DISABLE_SELF_UPDATE_CHECK: "true",
+	PNPM_UPDATE_NOTIFIER: "false",
+	YARN_ENABLE_TELEMETRY: "0",
+	YARN_ENABLE_PROGRESS_BARS: "0",
+	// Cross-language/tooling non-interactive defaults.
+	CARGO_TERM_PROGRESS_WHEN: "never",
+	DEBIAN_FRONTEND: "noninteractive",
+	PIP_NO_INPUT: "1",
+	PIP_DISABLE_PIP_VERSION_CHECK: "1",
+	TF_INPUT: "0",
+	TF_IN_AUTOMATION: "1",
+	GH_PROMPT_DISABLED: "1",
+	COMPOSER_NO_INTERACTION: "1",
+	CLOUDSDK_CORE_DISABLE_PROMPTS: "1",
+};

package/src/export/custom-share.ts

@@ -0,0 +1,65 @@
+/**
+ * Custom share script loader.
+ *
+ * Allows users to define a custom share handler at ~/.omp/agent/share.ts
+ * that will be used instead of the default GitHub Gist sharing.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAgentDir } from "@oh-my-pi/pi-utils";
+
+export interface CustomShareResult {
+	/** URL to display/open (optional - script may handle everything itself) */
+	url?: string;
+	/** Additional message to show the user */
+	message?: string;
+}
+
+export type CustomShareFn = (htmlPath: string) => Promise<CustomShareResult | string | undefined>;
+
+interface LoadedCustomShare {
+	path: string;
+	fn: CustomShareFn;
+}
+
+const SHARE_SCRIPT_CANDIDATES = ["share.ts", "share.js", "share.mjs"];
+
+/**
+ * Get the path to the custom share script if it exists.
+ */
+export function getCustomSharePath(): string | null {
+	const agentDir = getAgentDir();
+
+	for (const candidate of SHARE_SCRIPT_CANDIDATES) {
+		const scriptPath = path.join(agentDir, candidate);
+		if (fs.existsSync(scriptPath)) {
+			return scriptPath;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Load the custom share script if it exists.
+ */
+export async function loadCustomShare(): Promise<LoadedCustomShare | null> {
+	const scriptPath = getCustomSharePath();
+	if (!scriptPath) {
+		return null;
+	}
+
+	try {
+		const module = await import(scriptPath);
+		const fn = module.default;
+
+		if (typeof fn !== "function") {
+			throw new Error("share script must export a default function");
+		}
+
+		return { path: scriptPath, fn };
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to load share script: ${message}`);
+	}
+}