@wahack/pi-coding-agent 15.11.0

package/src/utils/lang-from-path.ts

@@ -0,0 +1,239 @@
+import * as path from "node:path";
+
+/**
+ * Extension segment → [highlight language id, LSP language id].
+ * Highlight ids match tree-sitter / native highlighter; LSP ids match Language Server Protocol.
+ */
+const EXTENSION_LANG: Record<string, readonly [string, string]> = {
+	// TypeScript / JavaScript
+	ts: ["typescript", "typescript"],
+	cts: ["typescript", "typescript"],
+	mts: ["typescript", "typescript"],
+	tsx: ["tsx", "typescriptreact"],
+	js: ["javascript", "javascript"],
+	jsx: ["javascript", "javascriptreact"],
+	mjs: ["javascript", "javascript"],
+	cjs: ["javascript", "javascript"],
+
+	// Systems
+	rs: ["rust", "rust"],
+	go: ["go", "go"],
+	c: ["c", "c"],
+	h: ["c", "c"],
+	cpp: ["cpp", "cpp"],
+	cc: ["cpp", "cpp"],
+	cxx: ["cpp", "cpp"],
+	hh: ["cpp", "cpp"],
+	hpp: ["cpp", "cpp"],
+	hxx: ["cpp", "cpp"],
+	cu: ["cpp", "cpp"],
+	ino: ["cpp", "cpp"],
+	zig: ["zig", "zig"],
+
+	// Scripting
+	py: ["python", "python"],
+	pyi: ["python", "python"],
+	rb: ["ruby", "ruby"],
+	rbw: ["ruby", "ruby"],
+	gemspec: ["ruby", "ruby"],
+	lua: ["lua", "lua"],
+	sh: ["bash", "shellscript"],
+	bash: ["bash", "shellscript"],
+	zsh: ["bash", "shellscript"],
+	ksh: ["bash", "shellscript"],
+	bats: ["bash", "shellscript"],
+	tmux: ["bash", "shellscript"],
+	cgi: ["bash", "shellscript"],
+	fcgi: ["bash", "shellscript"],
+	command: ["bash", "shellscript"],
+	tool: ["bash", "shellscript"],
+	fish: ["fish", "fish"],
+	pl: ["perl", "perl"],
+	pm: ["perl", "perl"],
+	perl: ["perl", "perl"],
+	php: ["php", "php"],
+
+	// JVM
+	java: ["java", "java"],
+	kt: ["kotlin", "kotlin"],
+	ktm: ["kotlin", "kotlin"],
+	kts: ["kotlin", "kotlin"],
+	scala: ["scala", "scala"],
+	sc: ["scala", "scala"],
+	sbt: ["scala", "scala"],
+	groovy: ["groovy", "groovy"],
+	clj: ["clojure", "clojure"],
+	cljc: ["clojure", "clojure"],
+	cljs: ["clojure", "clojure"],
+	edn: ["clojure", "clojure"],
+
+	// .NET
+	cs: ["csharp", "csharp"],
+	fs: ["fsharp", "fsharp"],
+	vb: ["vb", "vb"],
+
+	// Web
+	html: ["html", "html"],
+	htm: ["html", "html"],
+	xhtml: ["html", "html"],
+	css: ["css", "css"],
+	scss: ["scss", "scss"],
+	sass: ["sass", "sass"],
+	less: ["less", "less"],
+	vue: ["vue", "vue"],
+	svelte: ["svelte", "svelte"],
+	astro: ["astro", "astro"],
+
+	// Data
+	json: ["json", "json"],
+	jsonc: ["jsonc", "jsonc"],
+	yaml: ["yaml", "yaml"],
+	yml: ["yaml", "yaml"],
+	toml: ["toml", "toml"],
+	xml: ["xml", "xml"],
+	xsl: ["xml", "xml"],
+	xslt: ["xml", "xml"],
+	svg: ["xml", "xml"],
+	plist: ["xml", "xml"],
+	ini: ["ini", "ini"],
+
+	// Docs
+	md: ["markdown", "markdown"],
+	markdown: ["markdown", "markdown"],
+	mdx: ["markdown", "markdown"],
+	rst: ["restructuredtext", "restructuredtext"],
+	adoc: ["asciidoc", "asciidoc"],
+	tex: ["latex", "latex"],
+
+	// Other languages
+	sql: ["sql", "sql"],
+	graphql: ["graphql", "graphql"],
+	gql: ["graphql", "graphql"],
+	proto: ["protobuf", "protobuf"],
+	dockerfile: ["dockerfile", "dockerfile"],
+	containerfile: ["dockerfile", "dockerfile"],
+	tf: ["hcl", "terraform"],
+	hcl: ["hcl", "hcl"],
+	tfvars: ["hcl", "hcl"],
+	nix: ["nix", "nix"],
+	ex: ["elixir", "elixir"],
+	exs: ["elixir", "elixir"],
+	erl: ["erlang", "erlang"],
+	hrl: ["erlang", "erlang"],
+	hs: ["haskell", "haskell"],
+	ml: ["ocaml", "ocaml"],
+	mli: ["ocaml", "ocaml"],
+	swift: ["swift", "swift"],
+	r: ["r", "r"],
+	jl: ["julia", "julia"],
+	dart: ["dart", "dart"],
+	elm: ["elm", "elm"],
+	v: ["verilog", "v"],
+	nim: ["nim", "nim"],
+	cr: ["crystal", "crystal"],
+	d: ["d", "d"],
+	pas: ["pascal", "pascal"],
+	pp: ["pascal", "pascal"],
+	lisp: ["lisp", "lisp"],
+	lsp: ["lisp", "lisp"],
+	rkt: ["racket", "racket"],
+	scm: ["scheme", "scheme"],
+	ps1: ["powershell", "powershell"],
+	psm1: ["powershell", "powershell"],
+	bat: ["bat", "bat"],
+	cmd: ["bat", "bat"],
+	tla: ["tlaplus", "tlaplus"],
+	tlaplus: ["tlaplus", "tlaplus"],
+	m: ["objc", "plaintext"],
+	mm: ["objc", "plaintext"],
+	sol: ["solidity", "plaintext"],
+	odin: ["odin", "plaintext"],
+	star: ["starlark", "plaintext"],
+	bzl: ["starlark", "plaintext"],
+	sv: ["verilog", "plaintext"],
+	svh: ["verilog", "plaintext"],
+	vh: ["verilog", "plaintext"],
+	vim: ["vim", "plaintext"],
+	ipynb: ["ipynb", "plaintext"],
+	hbs: ["handlebars", "plaintext"],
+	hsb: ["handlebars", "plaintext"],
+	handlebars: ["handlebars", "plaintext"],
+	diff: ["diff", "plaintext"],
+	patch: ["diff", "plaintext"],
+	makefile: ["make", "plaintext"],
+	mk: ["make", "plaintext"],
+	mak: ["make", "plaintext"],
+	cmake: ["cmake", "cmake"],
+	justfile: ["just", "plaintext"],
+	txt: ["text", "plaintext"],
+	text: ["text", "plaintext"],
+	log: ["log", "plaintext"],
+	csv: ["csv", "plaintext"],
+	tsv: ["tsv", "plaintext"],
+	cfg: ["conf", "plaintext"],
+	conf: ["conf", "plaintext"],
+	config: ["conf", "plaintext"],
+	properties: ["conf", "plaintext"],
+	env: ["env", "plaintext"],
+	gitignore: ["conf", "plaintext"],
+	gitattributes: ["conf", "plaintext"],
+	gitmodules: ["conf", "plaintext"],
+	editorconfig: ["conf", "plaintext"],
+	npmrc: ["conf", "plaintext"],
+	prettierrc: ["conf", "plaintext"],
+	eslintrc: ["conf", "plaintext"],
+	prettierignore: ["conf", "plaintext"],
+	eslintignore: ["conf", "plaintext"],
+};
+
+/** Final segment after the last `.` in the full path (prior theme behavior). */
+function themeExtensionKey(filePath: string): string {
+	const extBeg = filePath.lastIndexOf(".");
+	return extBeg !== -1 ? filePath.slice(extBeg + 1).toLowerCase() : filePath.toLowerCase();
+}
+
+function lspExtensionKey(filePath: string): string {
+	const ext = path.extname(filePath).toLowerCase();
+	return ext.startsWith(".") ? ext.slice(1) : "";
+}
+
+/**
+ * Language id for syntax highlighting and UI (icons, read tool), or undefined if unknown.
+ */
+export function getLanguageFromPath(filePath: string): string | undefined {
+	const pair = EXTENSION_LANG[themeExtensionKey(filePath)];
+	if (pair) return pair[0];
+
+	const baseName = path.basename(filePath).toLowerCase();
+	if (baseName.startsWith(".env.")) return "env";
+	if (baseName === "dockerfile" || baseName.startsWith("dockerfile.") || baseName === "containerfile") {
+		return "dockerfile";
+	}
+	if (baseName === "justfile") return "just";
+	if (baseName === "cmakelists.txt") return "cmake";
+
+	return undefined;
+}
+
+/**
+ * LSP language identifier; falls back to `plaintext`.
+ */
+export function detectLanguageId(filePath: string): string {
+	const baseName = path.basename(filePath).toLowerCase();
+	if (baseName === "dockerfile" || baseName.startsWith("dockerfile.") || baseName === "containerfile") {
+		return "dockerfile";
+	}
+	if (baseName === "makefile" || baseName === "gnumakefile") {
+		return "makefile";
+	}
+	if (baseName === "justfile") {
+		return "just";
+	}
+
+	const lspExt = lspExtensionKey(filePath);
+	if (baseName === "cmakelists.txt" || lspExt === "cmake") {
+		return "cmake";
+	}
+
+	return EXTENSION_LANG[lspExt]?.[1] ?? "plaintext";
+}

package/src/utils/markit.ts

@@ -0,0 +1,89 @@
+import { untilAborted } from "@oh-my-pi/pi-utils";
+import type { Markit, StreamInfo } from "markit-ai";
+import { ToolAbortError } from "../tools/tool-errors";
+
+export interface MarkitConversionResult {
+	content: string;
+	ok: boolean;
+	error?: string;
+}
+
+let markit: () => Markit | Promise<Markit> = async () => {
+	const promise = import("markit-ai").then(({ Markit }) => {
+		const instance = new Markit();
+		markit = () => instance;
+		return instance;
+	});
+	markit = () => promise;
+	return promise;
+};
+
+function normalizeExtension(extension: string): string {
+	const trimmed = extension.trim().toLowerCase();
+	if (!trimmed) return ".bin";
+	return trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
+}
+
+function normalizeError(error: unknown): string {
+	if (error instanceof Error && error.message.trim().length > 0) {
+		return error.message.trim();
+	}
+	return "Conversion failed";
+}
+
+async function runMarkitConversion<T>(task: (markit: Markit) => Promise<T>, signal?: AbortSignal): Promise<T> {
+	try {
+		const instance = await markit();
+		return signal ? await untilAborted(signal, () => task(instance)) : await task(instance);
+	} catch (error) {
+		if (error instanceof ToolAbortError) {
+			throw error;
+		}
+		if (error instanceof Error && error.name === "AbortError") {
+			throw new ToolAbortError();
+		}
+		throw error;
+	}
+}
+
+function finalizeConversion(markdown?: string): MarkitConversionResult {
+	if (typeof markdown === "string" && markdown.length > 0) {
+		return { content: markdown, ok: true };
+	}
+
+	return { content: "", ok: false, error: "Conversion produced no output" };
+}
+
+export async function convertFileWithMarkit(filePath: string, signal?: AbortSignal): Promise<MarkitConversionResult> {
+	try {
+		const result = await runMarkitConversion(markit => markit.convertFile(filePath), signal);
+		return finalizeConversion(result.markdown);
+	} catch (error) {
+		if (error instanceof ToolAbortError) {
+			throw error;
+		}
+		return { content: "", ok: false, error: normalizeError(error) };
+	}
+}
+
+export async function convertBufferWithMarkit(
+	buffer: Uint8Array,
+	extension: string,
+	signal?: AbortSignal,
+): Promise<MarkitConversionResult> {
+	const normalizedExtension = normalizeExtension(extension);
+	const streamInfo: StreamInfo = {
+		extension: normalizedExtension,
+		filename: `input${normalizedExtension}`,
+	};
+
+	try {
+		const result = await runMarkitConversion(markit => markit.convert(Buffer.from(buffer), streamInfo), signal);
+		return finalizeConversion(result.markdown);
+	} catch (error) {
+		if (error instanceof ToolAbortError) {
+			throw error;
+		}
+		return { content: "", ok: false, error: normalizeError(error) };
+	}
+}

package/src/utils/open.ts

@@ -0,0 +1,55 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as url from "node:url";
+import * as piUtils from "@oh-my-pi/pi-utils";
+
+const URL_SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+
+function getExistingWslLocalPath(urlOrPath: string): string | undefined {
+	if (
+		process.platform !== "linux" ||
+		!(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) ||
+		!piUtils.$which("wslview")
+	) {
+		return undefined;
+	}
+
+	try {
+		const localPath = urlOrPath.startsWith("file://")
+			? url.fileURLToPath(urlOrPath)
+			: URL_SCHEME_PATTERN.test(urlOrPath)
+				? undefined
+				: path.resolve(urlOrPath);
+		if (!localPath || !fs.existsSync(localPath)) return undefined;
+
+		const result = Bun.spawnSync(["wslpath", "-w", localPath], { stdout: "pipe", stderr: "ignore" });
+		if (result.exitCode !== 0) return undefined;
+
+		return result.stdout.toString().trim() || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Open a URL or file path in the default browser/application. Best-effort, never throws. */
+export function openPath(urlOrPath: string): void {
+	let cmd: string[];
+	switch (process.platform) {
+		case "darwin":
+			cmd = ["open", urlOrPath];
+			break;
+		case "win32":
+			cmd = ["rundll32", "url.dll,FileProtocolHandler", urlOrPath];
+			break;
+		default: {
+			const wslPath = getExistingWslLocalPath(urlOrPath);
+			cmd = wslPath ? ["wslview", wslPath] : ["xdg-open", urlOrPath];
+			break;
+		}
+	}
+	try {
+		Bun.spawn(cmd, { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+	} catch {
+		// Best-effort: browser opening is non-critical
+	}
+}

package/src/utils/session-color.ts

@@ -0,0 +1,68 @@
+import { hslToHex, relativeLuminance } from "@oh-my-pi/pi-utils";
+
+/**
+ * Derive a stable hue (0-359) from a string using djb2 hash.
+ */
+function nameToHue(name: string): number {
+	let hash = 5381;
+	for (let i = 0; i < name.length; i++) {
+		hash = ((hash << 5) + hash) ^ name.charCodeAt(i);
+		hash = hash >>> 0; // keep 32-bit unsigned
+	}
+	return hash % 360;
+}
+
+const ACCENT_SATURATION = 0.9;
+const ACCENT_DARK_LIGHTNESS = 0.72;
+/** Minimum contrast ratio (WCAG AA large text) between a light-theme accent and its surface. */
+const ACCENT_MIN_CONTRAST = 3;
+
+/**
+ * Largest relative luminance an accent may have while still meeting
+ * {@link ACCENT_MIN_CONTRAST} against a surface of the given luminance.
+ */
+function accentLuminanceCap(surfaceLuminance: number): number {
+	return Math.max(0, (surfaceLuminance + 0.05) / ACCENT_MIN_CONTRAST - 0.05);
+}
+
+/**
+ * Derive a stable CSS hex accent color from a session name.
+ *
+ * On dark themes (`surfaceLuminance` undefined) the accent is vivid (high
+ * saturation, high lightness). On light themes the lightness is reduced until the
+ * accent's perceived luminance clears {@link ACCENT_MIN_CONTRAST} against the
+ * actual surface it renders on — so it stays legible on near-white *and* mid-light
+ * backgrounds — while keeping the same per-session hue.
+ */
+export function getSessionAccentHex(name: string, surfaceLuminance?: number): string {
+	const hue = nameToHue(name);
+	if (surfaceLuminance === undefined) {
+		return hslToHex(hue, ACCENT_SATURATION, ACCENT_DARK_LIGHTNESS);
+	}
+
+	const cap = accentLuminanceCap(surfaceLuminance);
+	const top = hslToHex(hue, ACCENT_SATURATION, ACCENT_DARK_LIGHTNESS);
+	if ((relativeLuminance(top) ?? 0) <= cap) return top;
+
+	// Bisect lightness: `lo` always yields luminance <= cap, `hi` always above it.
+	let lo = 0;
+	let hi = ACCENT_DARK_LIGHTNESS;
+	for (let i = 0; i < 20; i++) {
+		const mid = (lo + hi) / 2;
+		if ((relativeLuminance(hslToHex(hue, ACCENT_SATURATION, mid)) ?? 0) > cap) {
+			hi = mid;
+		} else {
+			lo = mid;
+		}
+	}
+	return hslToHex(hue, ACCENT_SATURATION, lo);
+}
+
+/**
+ * Convert a hex accent color to an ANSI-16m foreground escape sequence.
+ * Returns `undefined` if `hex` is nullish or Bun.color conversion fails.
+ */
+export function getSessionAccentAnsi(hex: string | undefined): string | undefined {
+	if (!hex) return undefined;
+	return Bun.color(hex, "ansi-16m") ?? undefined;
+}

package/src/utils/shell-snapshot.ts

@@ -0,0 +1,187 @@
+/**
+ * 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 * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { postmortem } from "@oh-my-pi/pi-utils";
+
+const cachedSnapshotPaths = new Map<string, string>();
+const SNAPSHOT_TIMEOUT_MS = 2_000;
+
+function sanitizeSnapshotEnv(env: Record<string, string | undefined>): Record<string, string | undefined> {
+	const sanitized = { ...env };
+	delete sanitized.BASH_ENV;
+	delete sanitized.ENV;
+	return sanitized;
+}
+
+/**
+ * Get the user's shell config file path.
+ */
+function getShellConfigFile(shell: string): string {
+	const home = os.homedir();
+	if (shell.includes("zsh")) return path.join(home, ".zshrc");
+	if (shell.includes("bash")) return path.join(home, ".bashrc");
+	return path.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 = fs.existsSync(rcFile);
+	const isZsh = shell.includes("zsh");
+	const commonToolsRegex =
+		"^(ls|dir|vdir|cat|head|tail|less|more|grep|egrep|fgrep|rg|find|fd|locate|sed|awk|perl|cp|mv|rm|mkdir|rmdir|touch|chmod|chown|ln|pwd|readlink|stat|cut|sort|uniq|xargs|tee|tr|basename|dirname)$";
+
+	// 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 '^(_|__)' | grep -vE '${commonToolsRegex}' | 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
+declare -F 2>/dev/null | cut -d' ' -f3 | grep -vE '^(_|__)' | grep -vE '${commonToolsRegex}' | while read func; do
+   declare -f "$func" >> "$SNAPSHOT_FILE" 2>/dev/null
+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 | awk '$2 == "on" && $1 !~ /^(onecmd|monitor|restricted)$/ {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 " | grep -vE '^alias (${commonToolsRegex})=' | sed 's/^alias //g' | sed 's/^/alias -- /' | head -n 1000 >> "$SNAPSHOT_FILE"
+else
+   alias 2>/dev/null | grep -vE '^alias (${commonToolsRegex})=' | 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> {
+	const cacheKey = shell;
+	// Return cached snapshot if valid
+	const cached = cachedSnapshotPaths.get(cacheKey);
+	if (cached && fs.existsSync(cached)) {
+		return cached;
+	}
+	if (cached) {
+		cachedSnapshotPaths.delete(cacheKey);
+	}
+
+	// Skip on Windows (no .bashrc in standard location)
+	if (process.platform === "win32") {
+		return null;
+	}
+
+	const rcFile = getShellConfigFile(shell);
+
+	// Create snapshot directory
+	const snapshotDir = path.join(os.tmpdir(), "omp-shell-snapshots");
+	fs.mkdirSync(snapshotDir, { recursive: true });
+
+	// Generate unique snapshot path
+	const shellName = shell.includes("zsh") ? "zsh" : shell.includes("bash") ? "bash" : "sh";
+	const snapshotPath = path.join(snapshotDir, `snapshot-${shellName}-${crypto.randomUUID()}.sh`);
+
+	// Generate and execute snapshot script
+	const script = generateSnapshotScript(shell, snapshotPath, rcFile);
+
+	try {
+		const snapshotEnv = sanitizeSnapshotEnv(env);
+		const spawnEnv: Record<string, string> = {};
+		for (const [key, value] of Object.entries(snapshotEnv)) {
+			if (value !== undefined) {
+				spawnEnv[key] = value;
+			}
+		}
+		const child = Bun.spawn([shell, "-c", script], {
+			env: spawnEnv,
+			stdin: "ignore",
+			stdout: "ignore",
+			stderr: "ignore",
+			timeout: SNAPSHOT_TIMEOUT_MS,
+			killSignal: "SIGKILL",
+		});
+
+		await child.exited;
+		if (child.exitCode === 0 && fs.existsSync(snapshotPath)) {
+			cachedSnapshotPaths.set(cacheKey, snapshotPath);
+			return snapshotPath;
+		}
+	} catch {
+		// Snapshot creation failed, proceed without it
+	}
+
+	return null;
+}
+
+postmortem.register("shell-snapshot", () => {
+	for (const snapshotPath of cachedSnapshotPaths.values()) {
+		fs.unlinkSync(snapshotPath);
+	}
+	cachedSnapshotPaths.clear();
+});