@oh-my-pi/pi-utils 17.1.6 → 17.1.8

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [17.1.8] - 2026-07-28
+
+### Added
+
+- Added `setProcessName` utility to set the OS-visible process name on Linux via `bun:ffi`, bypassing Bun's `process.title` limitations.
+
+### Fixed
+
+- Fixed child shell environment filtering to drop launch-directory `.env` values in addition to Bun-autoloaded `.env.local` values.
+
 ## [17.1.5] - 2026-07-27
 
 ### Fixed

package/dist/types/env.d.ts

@@ -17,13 +17,12 @@ export declare function isSafeEnvName(name: string): boolean;
 export declare function isSafeEnvValue(value: string): boolean;
 export declare function isMacosMallocStackLoggingEnvName(name: string): boolean;
 export declare function filterProcessEnv(env: Record<string, string | undefined>): Record<string, string>;
-/** Filters process env for child shells without launch-cwd `.env.local` values. */
+/** Filters process env for child shells without launch-cwd dotenv values. */
 export declare function filterChildShellEnv(env: Record<string, string | undefined>, cwd?: string): Record<string, string>;
 /**
- * Parses a .env file synchronously and extracts key-value string pairs.
- * Ignores lines that are empty or start with '#'. Trims whitespace.
- * Allows values to be quoted with single or double quotes.
- * Returns an object of key-value pairs.
+ * Parses a .env file synchronously into key-value string pairs using
+ * {@link parseEnvLine} for Bun-compatible line semantics, then mirrors valid
+ * `OMP_` variables to their `PI_` aliases.
  */
 export declare function parseEnvFile(filePath: string): Record<string, string>;
 /**

package/dist/types/index.d.ts

@@ -19,6 +19,7 @@ export * from "./path.js";
 export * from "./path-tree.js";
 export * from "./peek-file.js";
 export * as postmortem from "./postmortem.js";
+export * from "./process-name.js";
 export * as procmgr from "./procmgr.js";
 export * as prompt from "./prompt.js";
 export * as ptree from "./ptree.js";

package/dist/types/process-name.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Set both the JS `process.title` and — on Linux — the kernel `comm` name.
+ *
+ * Never throws: `bun:ffi` unavailability or a failed syscall degrades silently
+ * to the `process.title`-only behavior, so it is safe to call at startup.
+ */
+export declare function setProcessName(name: string): void;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-utils",
-	"version": "17.1.6",
+	"version": "17.1.8",
 	"description": "Shared utilities for pi packages",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -31,7 +31,7 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "17.1.6",
+		"@oh-my-pi/pi-natives": "17.1.8",
 		"handlebars": "^4.7.9",
 		"winston": "^3.19.0",
 		"winston-daily-rotate-file": "^5.0.0"

package/src/env.ts

@@ -52,50 +52,132 @@ export function filterProcessEnv(env: Record<string, string | undefined>): Recor
 	}
 	return result;
 }
+// Bun autoloads the project's dotenv files into `process.env` before user code
+// runs — including inside `bun build --compile` binaries — so a snapshot of
+// `Bun.env` is only pre-dotenv when autoloading was explicitly disabled. Linux
+// keeps the original exec environment in procfs, which is authoritative.
+function readLaunchEnv(): ReadonlyMap<string, string> | undefined {
+	if (process.platform === "linux") {
+		try {
+			const values = new Map<string, string>();
+			for (const entry of fs.readFileSync("/proc/self/environ", "utf8").split("\0")) {
+				const separator = entry.indexOf("=");
+				if (separator > 0) values.set(entry.slice(0, separator), entry.slice(separator + 1));
+			}
+			return values;
+		} catch {}
+	}
+	if (!process.execArgv.includes("--no-env-file")) return undefined;
+	const values = new Map<string, string>();
+	for (const key in Bun.env) {
+		const value = Bun.env[key];
+		if (value !== undefined) values.set(key, value);
+	}
+	return values;
+}
 
-/** Filters process env for child shells without launch-cwd `.env.local` values. */
+const launchEnvValues = readLaunchEnv();
+const projectEnvNamesLoadedByOmp = new Set<string>();
+
+function expandDotenvValues(values: Record<string, string>, env: Record<string, string>): Record<string, string> {
+	const expanded: Record<string, string> = {};
+	for (const key in values) {
+		expanded[key] = values[key].replace(
+			/(\\)?\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/g,
+			(match, escaped: string | undefined, braced: string | undefined, bare: string | undefined) => {
+				if (escaped) return match.slice(1);
+				const name = braced ?? bare;
+				if (!name) return match;
+				return env[name] ?? expanded[name] ?? "";
+			},
+		);
+	}
+	return expanded;
+}
+
+/** Filters process env for child shells without launch-cwd dotenv values. */
 export function filterChildShellEnv(
 	env: Record<string, string | undefined>,
 	cwd: string = process.cwd(),
 ): Record<string, string> {
 	const result = filterProcessEnv(env);
-	const launchLocalEnv = parseEnvFile(path.join(cwd, ".env.local"));
-	for (const key in launchLocalEnv) {
-		if (result[key] === launchLocalEnv[key]) delete result[key];
+	const projectEnv = parseEnvFile(path.join(cwd, ".env"));
+	const nodeEnvName = `.env.${env.NODE_ENV || "development"}`;
+	const modeEnv = parseEnvFile(path.join(cwd, nodeEnvName));
+	const localEnv = parseEnvFile(path.join(cwd, ".env.local"));
+	const launchEnv = { ...projectEnv, ...modeEnv, ...localEnv };
+	const expandedLaunchEnv = {
+		...expandDotenvValues(projectEnv, result),
+		...expandDotenvValues(modeEnv, result),
+		...expandDotenvValues(localEnv, result),
+	};
+	for (const key in launchEnv) {
+		const launchValue = launchEnvValues?.get(key);
+		if (launchValue !== undefined) {
+			// Launcher-owned name: it keeps the launcher's own value. Bun overwrites
+			// an empty launcher value with the dotenv one, so restore the launcher
+			// value whenever what survived is exactly what the dotenv file defines.
+			if (
+				result[key] !== launchValue &&
+				(result[key] === launchEnv[key] || result[key] === expandedLaunchEnv[key])
+			) {
+				result[key] = launchValue;
+			}
+			continue;
+		}
+		if (launchEnvValues || projectEnvNamesLoadedByOmp.has(key)) {
+			// Strong provenance: the launch environment is known and this name is
+			// absent from it, or OMP itself injected the value — either way it came
+			// from a project dotenv file, not the parent shell.
+			delete result[key];
+		} else if (result[key] === launchEnv[key] || result[key] === expandedLaunchEnv[key]) {
+			// No launch-env snapshot (dotenv autoloaded without procfs): best-effort
+			// value match against the Bun-parsed dotenv.
+			delete result[key];
+		}
 	}
 	return result;
 }
 
 /**
- * Parses a .env file synchronously and extracts key-value string pairs.
- * Ignores lines that are empty or start with '#'. Trims whitespace.
- * Allows values to be quoted with single or double quotes.
- * Returns an object of key-value pairs.
+ * Parse one dotenv line with Bun-compatible semantics: an optional `export`
+ * prefix, full-line `#` comments, inline `#` comments after whitespace on
+ * unquoted values, and single/double/backtick quoting (a `#` inside quotes
+ * stays literal). Returns undefined for blank lines, comments, and malformed
+ * names.
+ */
+function parseEnvLine(line: string): { key: string; value: string } | undefined {
+	const trimmed = line.trim();
+	if (!trimmed || trimmed.startsWith("#")) return undefined;
+	const eqIndex = trimmed.indexOf("=");
+	if (eqIndex === -1) return undefined;
+	let key = trimmed.slice(0, eqIndex).trim();
+	const exported = key.match(/^export[ \t]+(.*)$/);
+	if (exported) key = exported[1].trim();
+	if (!isValidEnvName(key)) return undefined;
+	const raw = trimmed.slice(eqIndex + 1).replace(/^[ \t]+/, "");
+	const quote = raw[0];
+	if (quote === '"' || quote === "'" || quote === "`") {
+		let close = raw.indexOf(quote, 1);
+		while (close !== -1 && raw[close - 1] === "\\") close = raw.indexOf(quote, close + 1);
+		return { key, value: close === -1 ? raw.slice(1) : raw.slice(1, close) };
+	}
+	const commentIndex = raw.search(/[ \t]#/);
+	return { key, value: (commentIndex === -1 ? raw : raw.slice(0, commentIndex)).trimEnd() };
+}
+
+/**
+ * Parses a .env file synchronously into key-value string pairs using
+ * {@link parseEnvLine} for Bun-compatible line semantics, then mirrors valid
+ * `OMP_` variables to their `PI_` aliases.
  */
 export function parseEnvFile(filePath: string): Record<string, string> {
 	const result: Record<string, string> = {};
 	try {
 		const content = fs.readFileSync(filePath, "utf-8");
 		for (const line of content.split("\n")) {
-			const trimmed = line.trim();
-			// Skip comments and blank lines
-			if (!trimmed || trimmed.startsWith("#")) continue;
-
-			const eqIndex = trimmed.indexOf("=");
-			if (eqIndex === -1) continue;
-
-			const key = trimmed.slice(0, eqIndex).trim();
-			if (!isValidEnvName(key)) continue;
-
-			let value = trimmed.slice(eqIndex + 1).trim();
-
-			// Remove surrounding quotes (" or ')
-			if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-				value = value.slice(1, -1);
-			}
-			if (!isSafeEnvValue(value)) continue;
-
-			result[key] = value;
+			const parsed = parseEnvLine(line);
+			if (parsed && isSafeEnvValue(parsed.value)) result[parsed.key] = parsed.value;
 		}
 	} catch {
 		// File doesn't exist or can't be read - return empty result
@@ -128,6 +210,7 @@ for (const file of [projectEnv, agentEnv, piEnv, homeEnv]) {
 	for (const key in file) {
 		if (!isMacosMallocStackLoggingEnvName(key) && !Bun.env[key]) {
 			Bun.env[key] = file[key];
+			if (file === projectEnv) projectEnvNamesLoadedByOmp.add(key);
 		}
 	}
 }

package/src/index.ts

@@ -19,6 +19,7 @@ export * from "./path";
 export * from "./path-tree";
 export * from "./peek-file";
 export * as postmortem from "./postmortem";
+export * from "./process-name";
 export * as procmgr from "./procmgr";
 export * as prompt from "./prompt";
 export * as ptree from "./ptree";

package/src/process-name.ts

@@ -0,0 +1,57 @@
+/**
+ * Set the OS-visible process name (`/proc/self/comm`) so `omp` shows up as
+ * `omp` — not `bun` — in `ps`, `pgrep`, `killall`, `top`, `htop`, and systemd.
+ *
+ * Bun's `process.title` setter only stores the value on the JS side; unlike
+ * Node/libuv it never calls `prctl(PR_SET_NAME)`, so the kernel's `comm` stays
+ * `bun` and process-name-based tooling can't target omp (and `pkill bun` becomes
+ * a footgun that kills every Bun process on the machine). We keep the
+ * `process.title` assignment (correct getter, future-proof if Bun ever fixes the
+ * setter) and additionally drive `prctl` via `bun:ffi` on Linux, mirroring the
+ * libc-FFI pattern in `ttyid.ts` / `stderr-guard.ts`.
+ *
+ * macOS has no clean userspace equivalent for the shebang-run path, and on
+ * Windows / compiled binaries the kernel derives the name from the exec'd file,
+ * so those paths already report correctly; there we only set `process.title`.
+ */
+import { dlopen, FFIType, ptr } from "bun:ffi";
+import * as os from "node:os";
+
+/** `prctl(2)` option that sets the calling thread's `comm` name. */
+const PR_SET_NAME = 15;
+
+/**
+ * Set both the JS `process.title` and — on Linux — the kernel `comm` name.
+ *
+ * Never throws: `bun:ffi` unavailability or a failed syscall degrades silently
+ * to the `process.title`-only behavior, so it is safe to call at startup.
+ */
+export function setProcessName(name: string): void {
+	try {
+		process.title = name;
+	} catch {}
+
+	if (os.platform() !== "linux") return;
+
+	// glibc first, then the generic soname for musl-style layouts (see stderr-guard.ts).
+	for (const soname of ["libc.so.6", "libc.so"]) {
+		try {
+			const libc = dlopen(soname, {
+				prctl: {
+					args: [FFIType.i32, FFIType.ptr, FFIType.u64, FFIType.u64, FFIType.u64],
+					returns: FFIType.i32,
+				},
+			});
+			try {
+				// TASK_COMM_LEN is 16 (name + NUL); the kernel truncates the rest.
+				const buf = Buffer.from(`${name}\0`, "utf8");
+				libc.symbols.prctl(PR_SET_NAME, ptr(buf), 0n, 0n, 0n);
+			} finally {
+				libc.close();
+			}
+			return;
+		} catch {
+			// bun:ffi unavailable or this soname missing; try the next candidate.
+		}
+	}
+}