@kr78/pi-coding-agent 17.2.10

package/src/exec/direnv.ts

@@ -0,0 +1,145 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { $which, logger } from "@oh-my-pi/pi-utils";
+
+/** Default cap on a single `direnv` invocation. The first export for a devenv
+ *  `.envrc` can build a shell; callers may raise this via `bash.direnvLoadTimeoutMs`. */
+export const DEFAULT_DIRENV_TIMEOUT_MS = 30_000;
+
+/** Walk up from `startDir` to the nearest directory containing an `.envrc`. */
+export async function findEnvrc(startDir: string): Promise<string | null> {
+	let dir = path.resolve(startDir);
+	for (;;) {
+		const candidate = path.join(dir, ".envrc");
+		try {
+			if ((await fs.stat(candidate)).isFile()) return candidate;
+		} catch {
+			// no .envrc here — keep walking up
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+
+export interface DirenvExportDiff {
+	/** Variables direnv sets to a concrete value. */
+	set: Record<string, string>;
+	/** Variables direnv removes (JSON `null`). */
+	unset: string[];
+}
+
+/** Parse `direnv export json` output (`{VAR: value|null}`) into set/unset halves. */
+export function parseDirenvExport(jsonText: string): DirenvExportDiff {
+	const trimmed = jsonText.trim();
+	if (trimmed.length === 0) return { set: {}, unset: [] };
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch {
+		return { set: {}, unset: [] };
+	}
+	const set: Record<string, string> = {};
+	const unset: string[] = [];
+	if (parsed && typeof parsed === "object") {
+		for (const [key, value] of Object.entries(parsed as Record<string, unknown>)) {
+			if (value === null) unset.push(key);
+			else if (typeof value === "string") set[key] = value;
+		}
+	}
+	return { set, unset };
+}
+
+let direnvLookup: { bin: string | null } | undefined;
+function direnvBinary(): string | null {
+	if (!direnvLookup) direnvLookup = { bin: $which("direnv") };
+	return direnvLookup.bin;
+}
+
+/** direnv computes its diff relative to the spawning env; strip any inherited
+ *  direnv state so it loads the target `.envrc` from a clean baseline. */
+function cleanSpawnEnv(): Record<string, string> {
+	const out: Record<string, string> = {};
+	for (const [key, value] of Object.entries(Bun.env)) {
+		if (value !== undefined && !key.startsWith("DIRENV_")) out[key] = value;
+	}
+	return out;
+}
+
+async function runDirenv(
+	bin: string,
+	args: string[],
+	cwd: string,
+	timeoutMs: number,
+	env: Record<string, string>,
+	signal?: AbortSignal,
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+	// Bail on the caller's cancellation as well as the per-invocation cap so a
+	// cold `.envrc` load can't outlive an aborted / short-timeout bash call.
+	const abortSignal = signal
+		? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)])
+		: AbortSignal.timeout(timeoutMs);
+	const proc = Bun.spawn([bin, ...args], {
+		cwd,
+		env,
+		stdout: "pipe",
+		stderr: "pipe",
+		signal: abortSignal,
+	});
+	// Drain stdout AND stderr concurrently: a cold `use devenv`/Nix load emits
+	// enough diagnostics to fill the stderr pipe and block the child forever if
+	// only stdout is read (it would then wait out `timeoutMs`).
+	const [stdout, stderr] = await Promise.all([
+		new Response(proc.stdout as ReadableStream<Uint8Array>).text(),
+		new Response(proc.stderr as ReadableStream<Uint8Array>).text(),
+	]);
+	const exitCode = await proc.exited;
+	return { exitCode, stdout, stderr };
+}
+
+/**
+ * Resolve the nearest `.envrc` from `cwd` and return its `direnv export` diff
+ * (variables to set, and variables direnv removes). Returns `null` when there
+ * is no `.envrc`, `direnv` is not installed, the `.envrc` is not on direnv's
+ * allow list, or the export fails/times out.
+ *
+ * direnv's own allow list is honored — an `.envrc` the user has not
+ * `direnv allow`ed is NEVER executed or auto-allowed. This keeps OMP's trust
+ * boundary identical to the user's own shell: cloning a repo with a poisoned
+ * `.envrc` grants it nothing until the user explicitly allows it.
+ *
+ * Always re-invokes `direnv export json` rather than serving a cached diff:
+ * direnv is fast once warm, and its own watch/mtime invalidation is the
+ * authoritative freshness signal (a content-hash cache here would go stale when
+ * a `watch_file` target changes without the `.envrc` text changing).
+ */
+export async function loadDirenvEnv(
+	cwd: string,
+	opts?: { timeoutMs?: number; signal?: AbortSignal },
+): Promise<DirenvExportDiff | null> {
+	const envrcPath = await findEnvrc(cwd);
+	if (!envrcPath) return null;
+	const bin = direnvBinary();
+	if (!bin) return null;
+
+	const dir = path.dirname(envrcPath);
+	const timeoutMs = opts?.timeoutMs ?? DEFAULT_DIRENV_TIMEOUT_MS;
+	const env = cleanSpawnEnv();
+	try {
+		const { exitCode, stdout, stderr } = await runDirenv(bin, ["export", "json"], dir, timeoutMs, env, opts?.signal);
+		if (exitCode !== 0) {
+			// A not-yet-allowed .envrc is an expected steady state (the user opted
+			// out by never running `direnv allow`), not an error worth warning on.
+			if (stderr.includes("is blocked")) {
+				logger.debug("direnv .envrc not allowed; skipping", { dir });
+			} else {
+				logger.warn("direnv export failed", { dir, exitCode });
+			}
+			return null;
+		}
+		return parseDirenvExport(stdout);
+	} catch (err) {
+		logger.warn("direnv load failed", { dir, error: err instanceof Error ? err.message : String(err) });
+		return null;
+	}
+}

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,118 @@
+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",
+	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",
+};
+
+const WINDOWS_UTF8_ENV_DEFAULT_GROUPS: ReadonlyArray<ReadonlyArray<readonly [key: string, value: string]>> = [
+	[
+		["PYTHONIOENCODING", "utf-8"],
+		["PYTHONUTF8", "1"],
+	],
+	[
+		["LANG", "C.UTF-8"],
+		["LC_ALL", "C.UTF-8"],
+	],
+];
+
+function hasEnvValue(
+	env: Record<string, string | undefined> | undefined,
+	key: string,
+	platform: NodeJS.Platform,
+): boolean {
+	if (!env) return false;
+	if (platform !== "win32") return env[key] !== undefined;
+
+	for (const [existingKey, value] of Object.entries(env)) {
+		if (value !== undefined && existingKey.toLowerCase() === key.toLowerCase()) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function hasLocaleEnvValue(env: Record<string, string | undefined> | undefined, platform: NodeJS.Platform): boolean {
+	if (!env) return false;
+	for (const [key, value] of Object.entries(env)) {
+		if (value === undefined) continue;
+		const normalizedKey = platform === "win32" ? key.toUpperCase() : key;
+		if (normalizedKey === "LANG" || normalizedKey.startsWith("LC_")) return true;
+	}
+	return false;
+}
+
+function hasEnvGroupValue(
+	env: Record<string, string | undefined> | undefined,
+	group: ReadonlyArray<readonly [key: string, value: string]>,
+	platform: NodeJS.Platform,
+): boolean {
+	if (group.some(([key]) => key === "LC_ALL") && hasLocaleEnvValue(env, platform)) return true;
+	for (const [key] of group) {
+		if (hasEnvValue(env, key, platform)) return true;
+	}
+	return false;
+}
+
+/** Builds the per-command environment for non-interactive child processes. */
+export function buildNonInteractiveEnv(
+	overrides?: Record<string, string>,
+	baseEnv: Record<string, string | undefined> = Bun.env,
+	platform: NodeJS.Platform = process.platform,
+): Record<string, string> {
+	if (platform !== "win32") {
+		return overrides ? { ...NON_INTERACTIVE_ENV, ...overrides } : NON_INTERACTIVE_ENV;
+	}
+
+	const env: Record<string, string> = { ...NON_INTERACTIVE_ENV };
+	for (const group of WINDOWS_UTF8_ENV_DEFAULT_GROUPS) {
+		if (hasEnvGroupValue(baseEnv, group, platform) || hasEnvGroupValue(overrides, group, platform)) {
+			continue;
+		}
+		for (const [key, value] of group) {
+			env[key] = value;
+		}
+	}
+	return overrides ? { ...env, ...overrides } : env;
+}

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>;
+
+export 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}`);
+	}
+}

package/src/export/html/args.ts

@@ -0,0 +1,20 @@
+/**
+ * `/export` argument parsing, split from `./index.ts` so slash-command
+ * registries can parse arguments without eagerly loading the export module's
+ * embedded template/tool-view text.
+ */
+
+/** Dark and light TUI theme names bundled into a dual-theme export. */
+export interface ExportThemeNames {
+	dark: string;
+	light: string;
+}
+
+/** Parse `/export [--themes] [path]`; paths containing spaces were never supported. */
+export function parseExportArgs(args: string): { outputPath?: string; useUserThemes: boolean } {
+	const parts = args.trim().split(/\s+/).filter(Boolean);
+	const useUserThemes = parts.includes("--themes");
+	const paths = parts.filter(part => part !== "--themes");
+	if (paths.length > 1) throw new Error("Usage: /export [--themes] [path]");
+	return { outputPath: paths[0], useUserThemes };
+}