gnhf 0.1.8 → 0.1.9

package/README.md

@@ -18,10 +18,10 @@
       src="https://img.shields.io/github/actions/workflow/status/kunchenguid/gnhf/release-please.yml?style=flat-square&label=release"
   /></a>
   <a
-    href="https://img.shields.io/badge/platform-macOS%20%7C%20Linux-blue?style=flat-square"
+    href="https://img.shields.io/badge/platform-macOS%20%7C%20Linux%20%7C%20Windows-blue?style=flat-square"
     ><img
       alt="Platform"
-      src="https://img.shields.io/badge/platform-macOS%20%7C%20Linux-blue?style=flat-square"
+      src="https://img.shields.io/badge/platform-macOS%20%7C%20Linux%20%7C%20Windows-blue?style=flat-square"
   /></a>
   <a href="https://x.com/kunchenguid"
     ><img
@@ -63,6 +63,7 @@ $ gnhf "reduce complexity of the codebase without changing functionality" \
 ```
 
 Run `gnhf` from inside a Git repository with a clean working tree. If you are starting from a plain directory, run `git init` first.
+`gnhf` supports macOS, Linux, and Windows.
 
 ## Install
 
@@ -143,12 +144,13 @@ npm link
 
 ### Flags
 
-| Flag                   | Description                                                | Default                |
-| ---------------------- | ---------------------------------------------------------- | ---------------------- |
-| `--agent <agent>`      | Agent to use (`claude`, `codex`, `rovodev`, or `opencode`) | config file (`claude`) |
-| `--max-iterations <n>` | Abort after `n` total iterations                           | unlimited              |
-| `--max-tokens <n>`     | Abort after `n` total input+output tokens                  | unlimited              |
-| `--version`            | Show version                                               |                        |
+| Flag                     | Description                                                        | Default                |
+| ------------------------ | ------------------------------------------------------------------ | ---------------------- |
+| `--agent <agent>`        | Agent to use (`claude`, `codex`, `rovodev`, or `opencode`)         | config file (`claude`) |
+| `--max-iterations <n>`   | Abort after `n` total iterations                                   | unlimited              |
+| `--max-tokens <n>`       | Abort after `n` total input+output tokens                          | unlimited              |
+| `--prevent-sleep <mode>` | Prevent system sleep during the run (`on`/`off` or `true`/`false`) | config file (`on`)     |
+| `--version`              | Show version                                                       |                        |
 
 ## Configuration
 
@@ -160,11 +162,24 @@ agent: claude
 
 # Abort after this many consecutive failures
 maxConsecutiveFailures: 3
+
+# Prevent the machine from sleeping during a run
+preventSleep: true
 ```
 
 If the file does not exist yet, `gnhf` creates it on first run using the resolved defaults.
 
-CLI flags override config file values. The iteration and token caps are runtime-only flags and are not persisted in `config.yml`.
+CLI flags override config file values. `--prevent-sleep` accepts `on`/`off` as well as `true`/`false`; the config file always uses a boolean.
+The iteration and token caps are runtime-only flags and are not persisted in `config.yml`.
+When sleep prevention is enabled, `gnhf` uses the native mechanism for your OS: `caffeinate` on macOS, `systemd-inhibit` on Linux, and a small PowerShell helper backed by `SetThreadExecutionState` on Windows.
+
+## Debug Logs
+
+Set `GNHF_DEBUG_LOG_PATH` to capture lifecycle events as JSONL while debugging a run:
+
+```sh
+GNHF_DEBUG_LOG_PATH=/tmp/gnhf-debug.jsonl gnhf "ship it"
+```
 
 ## Agents
 
@@ -182,7 +197,8 @@ CLI flags override config file values. The iteration and token caps are runtime-
 ```sh
 npm run build          # Build with tsdown
 npm run dev            # Watch mode
-npm test               # Run tests (vitest)
+npm test               # Build, then run unit tests (vitest)
+npm run test:e2e       # Build, then run end-to-end tests against the mock opencode executable
 npm run lint           # ESLint
 npm run format         # Prettier
 ```

package/dist/cli.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { appendFileSync, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { appendFileSync, createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, rmdirSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import process$1 from "node:process";
 import { createInterface } from "node:readline";
 import { Command, InvalidArgumentError } from "commander";
-import { dirname, isAbsolute, join } from "node:path";
-import { homedir } from "node:os";
 import yaml from "js-yaml";
 import { execFileSync, execSync, spawn } from "node:child_process";
 import { createServer } from "node:net";
@@ -13,8 +13,28 @@ import { createHash } from "node:crypto";
 //#region src/core/config.ts
 const DEFAULT_CONFIG = {
 	agent: "claude",
-	maxConsecutiveFailures: 3
+	maxConsecutiveFailures: 3,
+	preventSleep: true
 };
+var InvalidConfigError = class extends Error {};
+function normalizePreventSleep(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string") return void 0;
+	if (value === "true") return true;
+	if (value === "false") return false;
+	if (value === "on") return true;
+	if (value === "off") return false;
+}
+function normalizeConfig(config) {
+	const normalized = { ...config };
+	const hasPreventSleep = Object.prototype.hasOwnProperty.call(config, "preventSleep");
+	const preventSleep = normalizePreventSleep(config.preventSleep);
+	if (preventSleep === void 0) {
+		if (hasPreventSleep && config.preventSleep !== void 0) throw new InvalidConfigError(`Invalid config value for preventSleep: ${String(config.preventSleep)}`);
+		delete normalized.preventSleep;
+	} else normalized.preventSleep = preventSleep;
+	return normalized;
+}
 function isMissingConfigError(error) {
 	if (!(error instanceof Error)) return false;
 	return "code" in error ? error.code === "ENOENT" : error.message.includes("ENOENT");
@@ -25,6 +45,9 @@ agent: ${config.agent}
 
 # Abort after this many consecutive failures
 maxConsecutiveFailures: ${config.maxConsecutiveFailures}
+
+# Prevent the machine from sleeping during a run
+preventSleep: ${config.preventSleep}
 `;
 }
 function loadConfig(overrides) {
@@ -34,14 +57,15 @@ function loadConfig(overrides) {
 	let shouldBootstrapConfig = false;
 	try {
 		const raw = readFileSync(configPath, "utf-8");
-		fileConfig = yaml.load(raw) ?? {};
+		fileConfig = normalizeConfig(yaml.load(raw) ?? {});
 	} catch (error) {
+		if (error instanceof InvalidConfigError) throw error;
 		if (isMissingConfigError(error)) shouldBootstrapConfig = true;
 	}
 	const resolvedConfig = {
 		...DEFAULT_CONFIG,
 		...fileConfig,
-		...overrides
+		...normalizeConfig(overrides ?? {})
 	};
 	if (shouldBootstrapConfig) try {
 		mkdirSync(configDir, { recursive: true });
@@ -50,6 +74,20 @@ function loadConfig(overrides) {
 	return resolvedConfig;
 }
 //#endregion
+//#region src/core/debug-log.ts
+function appendDebugLog(event, details = {}) {
+	const logPath = process.env.GNHF_DEBUG_LOG_PATH;
+	if (!logPath) return;
+	try {
+		appendFileSync(logPath, `${JSON.stringify({
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			pid: process.pid,
+			event,
+			...details
+		})}\n`, "utf-8");
+	} catch {}
+}
+//#endregion
 //#region src/core/git.ts
 const NOT_GIT_REPOSITORY_MESSAGE = "This command must be run inside a Git repository. Change into a repo or run \"git init\" first.";
 function translateGitError(error) {
@@ -250,6 +288,417 @@ function appendNotes(notesPath, iteration, summary, changes, learnings) {
 	].join("\n"), "utf-8");
 }
 //#endregion
+//#region src/core/stdin.ts
+async function readStdinText(input) {
+	const chunks = [];
+	for await (const chunk of input) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+	return Buffer.concat(chunks).toString("utf-8").trim();
+}
+//#endregion
+//#region src/core/agents/managed-process.ts
+const POST_SIGKILL_GRACE_MS = 100;
+function signalChildProcess(child, options) {
+	const killProcess = options.killProcess ?? process.kill.bind(process);
+	if (options.detached && child.pid) try {
+		killProcess(-child.pid, options.signal);
+		return;
+	} catch {}
+	child.kill(options.signal);
+}
+async function shutdownChildProcess(child, options) {
+	if (child.exitCode != null || child.signalCode != null) return;
+	const timeoutMs = options.timeoutMs ?? 3e3;
+	await new Promise((resolve) => {
+		let forceKillTimer = null;
+		let hardDeadlineTimer = null;
+		let settled = false;
+		const settle = () => {
+			if (settled) return;
+			settled = true;
+			if (forceKillTimer) {
+				clearTimeout(forceKillTimer);
+				forceKillTimer = null;
+			}
+			if (hardDeadlineTimer) {
+				clearTimeout(hardDeadlineTimer);
+				hardDeadlineTimer = null;
+			}
+			child.off("close", handleClose);
+			resolve();
+		};
+		const handleClose = () => {
+			settle();
+		};
+		child.on("close", handleClose);
+		try {
+			signalChildProcess(child, {
+				...options,
+				signal: "SIGTERM"
+			});
+		} catch {}
+		forceKillTimer = setTimeout(() => {
+			try {
+				signalChildProcess(child, {
+					...options,
+					signal: "SIGKILL"
+				});
+			} catch {}
+			hardDeadlineTimer = setTimeout(() => {
+				settle();
+			}, POST_SIGKILL_GRACE_MS);
+			hardDeadlineTimer.unref?.();
+		}, timeoutMs);
+		forceKillTimer.unref?.();
+	});
+}
+//#endregion
+//#region src/core/sleep.ts
+const SYSTEMD_INHIBIT_READY_TIMEOUT_MS = 5e3;
+const SYSTEMD_INHIBIT_READY_POLL_MS = 25;
+const GNHF_SLEEP_REEXEC_READY_PATH = "GNHF_SLEEP_REEXEC_READY_PATH";
+const GNHF_SLEEP_REEXEC_READY_DIR_PREFIX = "gnhf-sleep-";
+const GNHF_SLEEP_REEXEC_READY_FILENAME = "reexec-ready";
+const HELPER_STARTUP_GRACE_MS = 100;
+function getSignalExitCode$1(signal) {
+	if (signal === "SIGINT") return 130;
+	if (signal === "SIGTERM") return 143;
+	return 1;
+}
+async function waitForSpawn(child) {
+	return await new Promise((resolve) => {
+		child.once("spawn", () => resolve(true));
+		child.once("error", () => resolve(false));
+	});
+}
+async function waitForHelperStability(child, timeoutMs) {
+	return await new Promise((resolve) => {
+		let settled = false;
+		let timer = null;
+		const settle = (value) => {
+			if (settled) return;
+			settled = true;
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			resolve(value);
+		};
+		child.once("exit", () => {
+			settle(false);
+		});
+		child.once("error", () => {
+			settle(false);
+		});
+		if (child.exitCode != null || child.signalCode != null) {
+			settle(false);
+			return;
+		}
+		timer = setTimeout(() => {
+			settle(true);
+		}, timeoutMs);
+		timer.unref?.();
+	});
+}
+function isTrustedLinuxReexecReadyPath(readyPath) {
+	const resolvedReadyPath = resolve(readyPath);
+	const readyDir = dirname(resolvedReadyPath);
+	return basename(resolvedReadyPath) === GNHF_SLEEP_REEXEC_READY_FILENAME && dirname(readyDir) === resolve(tmpdir()) && basename(readyDir).startsWith(GNHF_SLEEP_REEXEC_READY_DIR_PREFIX);
+}
+function signalLinuxReexecReady(env) {
+	const readyPath = env[GNHF_SLEEP_REEXEC_READY_PATH];
+	if (!readyPath) return;
+	if (!isTrustedLinuxReexecReadyPath(readyPath)) {
+		appendDebugLog("sleep:ready-signal-failed", {
+			command: "systemd-inhibit",
+			error: "untrusted ready path"
+		});
+		return;
+	}
+	try {
+		writeFileSync(readyPath, "ready\n", {
+			encoding: "utf-8",
+			flag: "wx"
+		});
+	} catch (error) {
+		appendDebugLog("sleep:ready-signal-failed", {
+			command: "systemd-inhibit",
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+async function waitForLinuxReexecReady(readyPath, exitStatePromise, timeoutMs) {
+	if (existsSync(readyPath)) return { type: "ready" };
+	return await new Promise((resolve) => {
+		let settled = false;
+		const settle = (result) => {
+			if (settled) return;
+			settled = true;
+			clearInterval(poller);
+			clearTimeout(timeout);
+			resolve(result);
+		};
+		const poller = setInterval(() => {
+			if (existsSync(readyPath)) settle({ type: "ready" });
+		}, SYSTEMD_INHIBIT_READY_POLL_MS);
+		poller.unref?.();
+		const timeout = setTimeout(() => {
+			settle({ type: "timeout" });
+		}, timeoutMs);
+		timeout.unref?.();
+		exitStatePromise.then(({ exitCode, signal }) => {
+			settle({
+				type: "exit",
+				exitCode,
+				signal
+			});
+		});
+	});
+}
+function forwardTerminationSignalsToChild(child, detached, killProcess, processOn, processOff) {
+	const listeners = [];
+	for (const signal of ["SIGINT", "SIGTERM"]) {
+		const listener = () => {
+			try {
+				signalChildProcess(child, {
+					detached,
+					killProcess,
+					signal
+				});
+			} catch {}
+		};
+		processOn(signal, listener);
+		listeners.push([signal, listener]);
+	}
+	return () => {
+		for (const [signal, listener] of listeners) processOff(signal, listener);
+	};
+}
+function buildPowerShellCommand(parentPid) {
+	return [
+		"Add-Type @'",
+		"using System;",
+		"using System.Runtime.InteropServices;",
+		"public static class SleepBlock {",
+		"  [DllImport(\"kernel32.dll\")]",
+		"  public static extern uint SetThreadExecutionState(uint flags);",
+		"}",
+		"'@;",
+		"$ES_CONTINUOUS = 0x80000000;",
+		"$ES_SYSTEM_REQUIRED = 0x00000001;",
+		"[SleepBlock]::SetThreadExecutionState($ES_CONTINUOUS -bor $ES_SYSTEM_REQUIRED) | Out-Null;",
+		`try { Wait-Process -Id ${parentPid} } catch { } finally { [SleepBlock]::SetThreadExecutionState($ES_CONTINUOUS) | Out-Null }`
+	].join("\n");
+}
+async function startHelperProcess(command, args, spawnFn, env) {
+	const child = spawnFn(command, args, {
+		env,
+		stdio: "ignore"
+	});
+	if (!await waitForSpawn(child)) {
+		appendDebugLog("sleep:unavailable", { command });
+		return null;
+	}
+	if (!await waitForHelperStability(child, HELPER_STARTUP_GRACE_MS)) {
+		appendDebugLog("sleep:unavailable", {
+			command,
+			reason: "early-exit"
+		});
+		return null;
+	}
+	return child;
+}
+async function startSleepPrevention(argv, deps = {}) {
+	const env = deps.env ?? process.env;
+	const killProcess = deps.killProcess ?? process.kill.bind(process);
+	const pid = deps.pid ?? process.pid;
+	const platform = deps.platform ?? process.platform;
+	const processExecArgv = deps.processExecArgv ?? process.execArgv;
+	const processArgv1 = deps.processArgv1 ?? process.argv[1];
+	const processExecPath = deps.processExecPath ?? process.execPath;
+	const processOn = deps.processOn ?? process.on.bind(process);
+	const processOff = deps.processOff ?? process.off.bind(process);
+	const reexecEnv = deps.reexecEnv ?? {};
+	const spawnFn = deps.spawn ?? spawn;
+	if (platform === "linux") {
+		if (env.GNHF_SLEEP_INHIBITED === "1") {
+			signalLinuxReexecReady(env);
+			return {
+				type: "skipped",
+				reason: "already-inhibited"
+			};
+		}
+		const readyDir = mkdtempSync(join(tmpdir(), GNHF_SLEEP_REEXEC_READY_DIR_PREFIX));
+		const readyPath = join(readyDir, GNHF_SLEEP_REEXEC_READY_FILENAME);
+		const child = spawnFn("systemd-inhibit", [
+			"--what=idle:sleep",
+			"--mode=block",
+			"--who=gnhf",
+			"--why=Prevent sleep while gnhf is running",
+			processExecPath,
+			...processExecArgv,
+			processArgv1,
+			...argv
+		], {
+			detached: true,
+			env: {
+				...env,
+				...reexecEnv,
+				GNHF_SLEEP_INHIBITED: "1",
+				[GNHF_SLEEP_REEXEC_READY_PATH]: readyPath
+			},
+			stdio: "inherit"
+		});
+		const exitStatePromise = new Promise((resolve) => {
+			child.once("exit", (code, signal) => {
+				resolve({
+					exitCode: signal ? getSignalExitCode$1(signal) : code ?? 1,
+					signal
+				});
+			});
+		});
+		const stopForwardingSignals = forwardTerminationSignalsToChild(child, true, killProcess, processOn, processOff);
+		if (!await waitForSpawn(child)) {
+			stopForwardingSignals();
+			rmSync(readyDir, {
+				recursive: true,
+				force: true
+			});
+			appendDebugLog("sleep:unavailable", { command: "systemd-inhibit" });
+			return {
+				type: "skipped",
+				reason: "unavailable"
+			};
+		}
+		try {
+			const readyState = await waitForLinuxReexecReady(readyPath, exitStatePromise, SYSTEMD_INHIBIT_READY_TIMEOUT_MS);
+			try {
+				if (readyState.type === "ready") {
+					appendDebugLog("sleep:reexec", { command: "systemd-inhibit" });
+					const { exitCode } = await exitStatePromise;
+					return {
+						type: "reexeced",
+						exitCode
+					};
+				}
+				if (readyState.type === "exit") {
+					if (readyState.signal === "SIGINT" || readyState.signal === "SIGTERM") {
+						appendDebugLog("sleep:reexec", {
+							command: "systemd-inhibit",
+							signal: readyState.signal
+						});
+						return {
+							type: "reexeced",
+							exitCode: readyState.exitCode
+						};
+					}
+					if (readyState.exitCode !== 0) {
+						if (existsSync(readyPath)) {
+							appendDebugLog("sleep:reexec", {
+								command: "systemd-inhibit",
+								exitCode: readyState.exitCode,
+								readySignal: "late"
+							});
+							return {
+								type: "reexeced",
+								exitCode: readyState.exitCode
+							};
+						}
+						appendDebugLog("sleep:unavailable", {
+							command: "systemd-inhibit",
+							exitCode: readyState.exitCode
+						});
+						return {
+							type: "skipped",
+							reason: "unavailable"
+						};
+					}
+					appendDebugLog("sleep:reexec", {
+						command: "systemd-inhibit",
+						readySignal: false
+					});
+					return {
+						type: "reexeced",
+						exitCode: readyState.exitCode
+					};
+				}
+				appendDebugLog("sleep:unavailable", {
+					command: "systemd-inhibit",
+					reason: "timeout",
+					timeoutMs: SYSTEMD_INHIBIT_READY_TIMEOUT_MS
+				});
+				await shutdownChildProcess(child, {
+					detached: true,
+					killProcess,
+					timeoutMs: 1e3
+				});
+				return {
+					type: "skipped",
+					reason: "unavailable"
+				};
+			} finally {
+				stopForwardingSignals();
+			}
+		} finally {
+			rmSync(readyDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	if (platform === "darwin") {
+		const child = await startHelperProcess("caffeinate", [
+			"-i",
+			"-w",
+			String(pid)
+		], spawnFn, env);
+		if (!child) return {
+			type: "skipped",
+			reason: "unavailable"
+		};
+		appendDebugLog("sleep:active", { command: "caffeinate" });
+		return {
+			type: "active",
+			cleanup: async () => {
+				appendDebugLog("sleep:cleanup", { command: "caffeinate" });
+				await shutdownChildProcess(child, {
+					detached: false,
+					timeoutMs: 1e3
+				});
+			}
+		};
+	}
+	if (platform === "win32") {
+		const child = await startHelperProcess("powershell.exe", [
+			"-NoLogo",
+			"-NoProfile",
+			"-NonInteractive",
+			"-ExecutionPolicy",
+			"Bypass",
+			"-Command",
+			buildPowerShellCommand(pid)
+		], spawnFn, env);
+		if (!child) return {
+			type: "skipped",
+			reason: "unavailable"
+		};
+		appendDebugLog("sleep:active", { command: "powershell.exe" });
+		return {
+			type: "active",
+			cleanup: async () => {
+				appendDebugLog("sleep:cleanup", { command: "powershell.exe" });
+				await shutdownChildProcess(child, {
+					detached: false,
+					timeoutMs: 1e3
+				});
+			}
+		};
+	}
+	return {
+		type: "skipped",
+		reason: "unsupported"
+	};
+}
+//#endregion
 //#region src/core/agents/stream-utils.ts
 /**
 * Wire stderr collection, spawn-error handling, and the common close-handler
@@ -486,6 +935,21 @@ function buildPrompt(prompt) {
 		`The JSON must match this schema exactly: ${JSON.stringify(AGENT_OUTPUT_SCHEMA)}`
 	].join("\n");
 }
+/**
+* On Windows with `shell: true`, `child.pid` is the `cmd.exe` wrapper, not
+* the actual server process.  `taskkill /T` terminates the entire process
+* tree rooted at that PID so the real server doesn't survive shutdown.
+*/
+async function killWindowsProcessTree(pid) {
+	try {
+		execFileSync("taskkill", [
+			"/T",
+			"/F",
+			"/PID",
+			String(pid)
+		], { stdio: "ignore" });
+	} catch {}
+}
 function createAbortError$1() {
 	return /* @__PURE__ */ new Error("Agent was aborted");
 }
@@ -557,6 +1021,7 @@ var OpenCodeAgent = class {
 	fetchFn;
 	getPortFn;
 	killProcessFn;
+	platform;
 	spawnFn;
 	server = null;
 	closingPromise = null;
@@ -564,6 +1029,7 @@ var OpenCodeAgent = class {
 		this.fetchFn = deps.fetch ?? fetch;
 		this.getPortFn = deps.getPort ?? getAvailablePort$1;
 		this.killProcessFn = deps.killProcess ?? process.kill.bind(process);
+		this.platform = deps.platform ?? process.platform;
 		this.spawnFn = deps.spawn ?? spawn;
 	}
 	async run(prompt, cwd, options) {
@@ -609,7 +1075,8 @@ var OpenCodeAgent = class {
 			return this.server;
 		}
 		const port = await this.getPortFn();
-		const detached = process.platform !== "win32";
+		const isWindows = this.platform === "win32";
+		const detached = !isWindows;
 		const child = this.spawnFn("opencode", [
 			"serve",
 			"--hostname",
@@ -620,6 +1087,7 @@ var OpenCodeAgent = class {
 		], {
 			cwd,
 			detached,
+			shell: isWindows,
 			stdio: [
 				"ignore",
 				"pipe",
@@ -652,6 +1120,11 @@ var OpenCodeAgent = class {
 			if (this.server === server) this.server = null;
 		});
 		this.server = server;
+		appendDebugLog("opencode:spawn", {
+			cwd,
+			port,
+			detached
+		});
 		server.readyPromise = this.waitForHealthy(server, signal).catch(async (error) => {
 			await this.shutdownServer();
 			throw error;
@@ -934,37 +1407,20 @@ var OpenCodeAgent = class {
 			return;
 		}
 		const server = this.server;
-		const waitForClose = new Promise((resolve) => {
-			if (server.closed) {
-				resolve();
-				return;
-			}
-			server.child.once("close", () => resolve());
-		});
-		try {
-			this.signalServer(server, "SIGTERM");
-		} catch {}
-		const forceKill = new Promise((resolve) => {
-			setTimeout(() => {
-				if (!server.closed) try {
-					this.signalServer(server, "SIGKILL");
-				} catch {}
-				resolve();
-			}, 3e3).unref?.();
+		appendDebugLog("opencode:shutdown", {
+			cwd: server.cwd,
+			port: server.port
 		});
-		this.closingPromise = Promise.race([waitForClose, forceKill]).finally(() => {
+		this.closingPromise = (this.platform === "win32" && server.child.pid ? killWindowsProcessTree(server.child.pid) : shutdownChildProcess(server.child, {
+			detached: server.detached,
+			killProcess: this.killProcessFn,
+			timeoutMs: 3e3
+		})).finally(() => {
 			if (this.server === server) this.server = null;
 			this.closingPromise = null;
 		});
 		await this.closingPromise;
 	}
-	signalServer(server, signal) {
-		if (server.detached && server.child.pid) try {
-			this.killProcessFn(-server.child.pid, signal);
-			return;
-		} catch {}
-		server.child.kill(signal);
-	}
 	async requestJSON(server, path, options) {
 		const body = await this.requestText(server, path, options);
 		return JSON.parse(body);
@@ -1149,6 +1605,11 @@ var RovoDevAgent = class {
 			if (this.server === server) this.server = null;
 		});
 		this.server = server;
+		appendDebugLog("rovodev:spawn", {
+			cwd,
+			port,
+			detached
+		});
 		server.readyPromise = this.waitForHealthy(server, signal).catch(async (error) => {
 			await this.shutdownServer();
 			throw error;
@@ -1158,13 +1619,13 @@ var RovoDevAgent = class {
 	}
 	async waitForHealthy(server, signal) {
 		const deadline = Date.now() + 3e4;
-		let spawnError = null;
+		let spawnErrorMessage = null;
 		server.child.once("error", (error) => {
-			spawnError = error;
+			spawnErrorMessage = error.message;
 		});
 		while (Date.now() < deadline) {
 			if (signal?.aborted) throw createAbortError();
-			if (spawnError) throw new Error(`Failed to spawn rovodev: ${spawnError.message}`);
+			if (spawnErrorMessage) throw new Error(`Failed to spawn rovodev: ${spawnErrorMessage}`);
 			if (server.closed) {
 				const output = server.stderr.trim() || server.stdout.trim();
 				throw new Error(output ? `rovodev exited before becoming ready: ${output}` : "rovodev exited before becoming ready");
@@ -1372,37 +1833,20 @@ var RovoDevAgent = class {
 			return;
 		}
 		const server = this.server;
-		const waitForClose = new Promise((resolve) => {
-			if (server.closed) {
-				resolve();
-				return;
-			}
-			server.child.once("close", () => resolve());
+		appendDebugLog("rovodev:shutdown", {
+			cwd: server.cwd,
+			port: server.port
 		});
-		try {
-			this.signalServer(server, "SIGTERM");
-		} catch {}
-		const forceKill = new Promise((resolve) => {
-			setTimeout(() => {
-				if (!server.closed) try {
-					this.signalServer(server, "SIGKILL");
-				} catch {}
-				resolve();
-			}, 3e3).unref?.();
-		});
-		this.closingPromise = Promise.race([waitForClose, forceKill]).finally(() => {
+		this.closingPromise = shutdownChildProcess(server.child, {
+			detached: server.detached,
+			killProcess: this.killProcessFn,
+			timeoutMs: 3e3
+		}).finally(() => {
 			if (this.server === server) this.server = null;
 			this.closingPromise = null;
 		});
 		await this.closingPromise;
 	}
-	signalServer(server, signal) {
-		if (server.detached && server.child.pid) try {
-			this.killProcessFn(-server.child.pid, signal);
-			return;
-		} catch {}
-		server.child.kill(signal);
-	}
 	async requestJSON(server, path, options) {
 		return await (await this.request(server, path, options)).json();
 	}
@@ -1466,6 +1910,7 @@ ${params.prompt}`;
 }
 //#endregion
 //#region src/core/orchestrator.ts
+const STOP_CLOSE_AGENT_GRACE_MS = 250;
 var Orchestrator = class extends EventEmitter {
 	config;
 	agent;
@@ -1475,6 +1920,7 @@ var Orchestrator = class extends EventEmitter {
 	limits;
 	stopRequested = false;
 	stopPromise = null;
+	activeIterationPromise = null;
 	activeAbortController = null;
 	pendingAbortReason = null;
 	state = {
@@ -1510,7 +1956,23 @@ var Orchestrator = class extends EventEmitter {
 		this.activeAbortController?.abort();
 		if (this.stopPromise) return;
 		this.stopPromise = (async () => {
-			await this.closeAgent();
+			if (this.activeIterationPromise) {
+				const iterationPromise = this.activeIterationPromise.catch(() => void 0);
+				await new Promise((resolve) => {
+					let settled = false;
+					const settle = () => {
+						if (settled) return;
+						settled = true;
+						clearTimeout(timer);
+						resolve();
+					};
+					const timer = setTimeout(settle, STOP_CLOSE_AGENT_GRACE_MS);
+					timer.unref?.();
+					iterationPromise.finally(settle);
+				});
+				await this.closeAgent();
+				await iterationPromise;
+			} else await this.closeAgent();
 			resetHard(this.cwd);
 			this.state.status = "stopped";
 			this.emit("state", this.getState());
@@ -1537,7 +1999,10 @@ var Orchestrator = class extends EventEmitter {
 					runId: this.runInfo.runId,
 					prompt: this.prompt
 				});
-				const result = await this.runIteration(iterationPrompt);
+				this.activeIterationPromise = this.runIteration(iterationPrompt);
+				const result = await this.activeIterationPromise;
+				this.activeIterationPromise = null;
+				if (result.type === "stopped") break;
 				if (result.type === "aborted") {
 					this.abort(result.reason);
 					break;
@@ -1569,6 +2034,7 @@ var Orchestrator = class extends EventEmitter {
 				}
 			}
 		} finally {
+			this.activeIterationPromise = null;
 			if (this.stopPromise) await this.stopPromise;
 			else await this.closeAgent();
 		}
@@ -1600,6 +2066,7 @@ var Orchestrator = class extends EventEmitter {
 				signal: this.activeAbortController.signal,
 				logPath
 			});
+			if (this.stopRequested) return { type: "stopped" };
 			if (result.output.success) return {
 				type: "completed",
 				record: this.recordSuccess(result.output)
@@ -1616,6 +2083,7 @@ var Orchestrator = class extends EventEmitter {
 					reason: this.pendingAbortReason
 				};
 			}
+			if (this.stopRequested) return { type: "stopped" };
 			const summary = err instanceof Error ? err.message : String(err);
 			return {
 				type: "completed",
@@ -2217,14 +2685,14 @@ var Renderer = class {
 			};
 		});
 		this.orchestrator.on("stopped", () => {
-			this.stop();
+			this.stop("stopped");
 		});
 		if (process$1.stdin.isTTY) {
 			process$1.stdin.setRawMode(true);
 			process$1.stdin.resume();
 			process$1.stdin.on("data", (data) => {
 				if (data[0] === 3) {
-					this.stop();
+					this.stop("interrupted");
 					this.orchestrator.stop();
 				}
 			});
@@ -2232,7 +2700,7 @@ var Renderer = class {
 		this.interval = setInterval(() => this.render(), TICK_MS);
 		this.render();
 	}
-	stop() {
+	stop(reason = "stopped") {
 		if (this.interval) {
 			clearInterval(this.interval);
 			this.interval = null;
@@ -2242,7 +2710,7 @@ var Renderer = class {
 			process$1.stdin.pause();
 			process$1.stdin.removeAllListeners("data");
 		}
-		this.exitResolve();
+		this.exitResolve(reason);
 	}
 	waitUntilExit() {
 		return this.exitPromise;
@@ -2300,12 +2768,21 @@ function slugifyPrompt(prompt) {
 //#region src/cli.ts
 const packageVersion = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8")).version;
 const FORCE_EXIT_TIMEOUT_MS = 5e3;
+const GNHF_REEXEC_STDIN_PROMPT = "GNHF_REEXEC_STDIN_PROMPT";
+const GNHF_REEXEC_STDIN_PROMPT_FILE = "GNHF_REEXEC_STDIN_PROMPT_FILE";
+const GNHF_REEXEC_STDIN_PROMPT_DIR_PREFIX = "gnhf-stdin-";
+const GNHF_REEXEC_STDIN_PROMPT_FILENAME = "prompt.txt";
 function parseNonNegativeInteger(value) {
 	if (!/^\d+$/.test(value)) throw new InvalidArgumentError("must be a non-negative integer");
 	const parsed = Number.parseInt(value, 10);
 	if (!Number.isSafeInteger(parsed)) throw new InvalidArgumentError("must be a safe integer");
 	return parsed;
 }
+function parseOnOffBoolean(value) {
+	if (value === "on" || value === "true") return true;
+	if (value === "off" || value === "false") return false;
+	throw new InvalidArgumentError("must be one of: \"on\", \"off\", \"true\", \"false\"");
+}
 function humanizeErrorMessage(message) {
 	if (message.includes("not a git repository")) return "This command must be run inside a Git repository. Change into a repo or run \"git init\" first.";
 	return message;
@@ -2330,8 +2807,57 @@ function ask(question) {
 		});
 	});
 }
+function getSignalExitCode(signal) {
+	return signal === "SIGINT" ? 130 : 143;
+}
+function persistStdinPromptForReexec(prompt) {
+	const promptDir = mkdtempSync(join(tmpdir(), GNHF_REEXEC_STDIN_PROMPT_DIR_PREFIX));
+	const promptPath = join(promptDir, GNHF_REEXEC_STDIN_PROMPT_FILENAME);
+	writeFileSync(promptPath, prompt, {
+		encoding: "utf-8",
+		mode: 384
+	});
+	return {
+		path: promptPath,
+		cleanup: () => {
+			rmSync(promptDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+function isTrustedReexecPromptPath(promptPath) {
+	const resolvedPromptPath = resolve(promptPath);
+	const promptDir = dirname(resolvedPromptPath);
+	return basename(resolvedPromptPath) === GNHF_REEXEC_STDIN_PROMPT_FILENAME && dirname(promptDir) === resolve(tmpdir()) && basename(promptDir).startsWith(GNHF_REEXEC_STDIN_PROMPT_DIR_PREFIX);
+}
+function cleanupTrustedReexecPromptPath(promptPath) {
+	if (!isTrustedReexecPromptPath(promptPath)) return;
+	const resolvedPromptPath = resolve(promptPath);
+	rmSync(resolvedPromptPath, { force: true });
+	try {
+		rmdirSync(dirname(resolvedPromptPath));
+	} catch {}
+}
+function readReexecStdinPrompt(env) {
+	const promptPath = env[GNHF_REEXEC_STDIN_PROMPT_FILE];
+	if (promptPath !== void 0) {
+		delete env[GNHF_REEXEC_STDIN_PROMPT_FILE];
+		try {
+			return readFileSync(promptPath, "utf-8");
+		} finally {
+			cleanupTrustedReexecPromptPath(promptPath);
+		}
+	}
+	const prompt = env[GNHF_REEXEC_STDIN_PROMPT];
+	if (prompt !== void 0) {
+		delete env[GNHF_REEXEC_STDIN_PROMPT];
+		return prompt;
+	}
+}
 const program = new Command();
-program.name("gnhf").description("Before I go to bed, I tell my agents: good night, have fun").version(packageVersion).argument("[prompt]", "The objective for the coding agent").option("--agent <agent>", "Agent to use (claude, codex, rovodev, or opencode)").option("--max-iterations <n>", "Abort after N total iterations", parseNonNegativeInteger).option("--max-tokens <n>", "Abort after N total input+output tokens", parseNonNegativeInteger).option("--mock", "", false).action(async (promptArg, options) => {
+program.name("gnhf").description("Before I go to bed, I tell my agents: good night, have fun").version(packageVersion).argument("[prompt]", "The objective for the coding agent").option("--agent <agent>", "Agent to use (claude, codex, rovodev, or opencode)").option("--max-iterations <n>", "Abort after N total iterations", parseNonNegativeInteger).option("--max-tokens <n>", "Abort after N total input+output tokens", parseNonNegativeInteger).option("--prevent-sleep <mode>", "Prevent system sleep during the run (\"on\" or \"off\")", parseOnOffBoolean).option("--mock", "", false).action(async (promptArg, options) => {
 	if (options.mock) {
 		const mock = new MockOrchestrator();
 		enterAltScreen();
@@ -2342,18 +2868,28 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 		exitAltScreen();
 		return;
 	}
+	let initialSleepPrevention = null;
+	if (process$1.env.GNHF_SLEEP_INHIBITED === "1") initialSleepPrevention = await startSleepPrevention(process$1.argv.slice(2));
 	let prompt = promptArg;
-	if (!prompt && !process$1.stdin.isTTY) prompt = readFileSync("/dev/stdin", "utf-8").trim();
+	let promptFromStdin = false;
 	const agentName = options.agent;
 	if (agentName !== void 0 && agentName !== "claude" && agentName !== "codex" && agentName !== "rovodev" && agentName !== "opencode") {
 		console.error(`Unknown agent: ${options.agent}. Use "claude", "codex", "rovodev", or "opencode".`);
 		process$1.exit(1);
 	}
-	const config = loadConfig(agentName ? { agent: agentName } : void 0);
+	const config = {
+		...loadConfig(agentName ? { agent: agentName } : {}),
+		...options.preventSleep === void 0 ? {} : { preventSleep: options.preventSleep }
+	};
 	if (config.agent !== "claude" && config.agent !== "codex" && config.agent !== "rovodev" && config.agent !== "opencode") {
 		console.error(`Unknown agent: ${config.agent}. Use "claude", "codex", "rovodev", or "opencode".`);
 		process$1.exit(1);
 	}
+	if (!prompt && process$1.env.GNHF_SLEEP_INHIBITED === "1") prompt = readReexecStdinPrompt(process$1.env);
+	if (!prompt && !process$1.stdin.isTTY) {
+		prompt = await readStdinText(process$1.stdin);
+		promptFromStdin = true;
+	}
 	const cwd = process$1.cwd();
 	const currentBranch = getCurrentBranch(cwd);
 	const onGnhfBranch = currentBranch.startsWith("gnhf/");
@@ -2382,27 +2918,67 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 		}
 		runInfo = initializeNewBranch(prompt, cwd);
 	}
+	let sleepPreventionCleanup = null;
+	if (config.preventSleep) {
+		const persistedPrompt = promptFromStdin && prompt !== void 0 ? persistStdinPromptForReexec(prompt) : null;
+		let reexeced = false;
+		try {
+			const sleepPrevention = initialSleepPrevention ?? await startSleepPrevention(process$1.argv.slice(2), { reexecEnv: persistedPrompt ? { [GNHF_REEXEC_STDIN_PROMPT_FILE]: persistedPrompt.path } : void 0 });
+			if (sleepPrevention.type === "reexeced") {
+				reexeced = true;
+				process$1.exit(sleepPrevention.exitCode);
+			}
+			if (sleepPrevention.type === "active") sleepPreventionCleanup = sleepPrevention.cleanup;
+		} finally {
+			if (!reexeced) persistedPrompt?.cleanup();
+		}
+	}
+	appendDebugLog("run:start", { args: process$1.argv.slice(2) });
 	const orchestrator = new Orchestrator(config, createAgent(config.agent, runInfo), runInfo, prompt, cwd, startIteration, {
 		maxIterations: options.maxIterations,
 		maxTokens: options.maxTokens
 	});
+	let shutdownSignal = null;
 	enterAltScreen();
 	const renderer = new Renderer(orchestrator, prompt, config.agent);
 	renderer.start();
+	const requestShutdown = (signal) => {
+		if (shutdownSignal) return;
+		shutdownSignal = signal;
+		appendDebugLog(`signal:${signal}`);
+		renderer.stop();
+		orchestrator.stop();
+	};
+	const handleSigInt = () => requestShutdown("SIGINT");
+	const handleSigTerm = () => requestShutdown("SIGTERM");
+	process$1.on("SIGINT", handleSigInt);
+	process$1.on("SIGTERM", handleSigTerm);
 	const orchestratorPromise = orchestrator.start().finally(() => {
 		renderer.stop();
 	}).catch((err) => {
 		exitAltScreen();
 		die(err instanceof Error ? err.message : String(err));
 	});
-	await renderer.waitUntilExit();
-	exitAltScreen();
-	if (await Promise.race([orchestratorPromise.then(() => "done"), new Promise((resolve) => {
-		setTimeout(() => resolve("timeout"), FORCE_EXIT_TIMEOUT_MS).unref();
-	})]) === "timeout") {
-		console.error(`\n  gnhf: shutdown timed out after ${FORCE_EXIT_TIMEOUT_MS / 1e3}s, forcing exit\n`);
-		process$1.exit(130);
+	try {
+		if (await renderer.waitUntilExit() === "interrupted" && !shutdownSignal) {
+			shutdownSignal = "SIGINT";
+			appendDebugLog("signal:SIGINT");
+		}
+		exitAltScreen();
+		if (await Promise.race([orchestratorPromise.then(() => "done"), new Promise((resolve) => {
+			setTimeout(() => resolve("timeout"), FORCE_EXIT_TIMEOUT_MS).unref();
+		})]) === "timeout") {
+			appendDebugLog("run:shutdown-timeout", { timeoutMs: FORCE_EXIT_TIMEOUT_MS });
+			console.error(`\n  gnhf: shutdown timed out after ${FORCE_EXIT_TIMEOUT_MS / 1e3}s, forcing exit\n`);
+			process$1.exit(getSignalExitCode(shutdownSignal ?? "SIGINT"));
+		}
+	} finally {
+		process$1.off("SIGINT", handleSigInt);
+		process$1.off("SIGTERM", handleSigTerm);
+		await sleepPreventionCleanup?.();
 	}
+	appendDebugLog("run:complete", { signal: shutdownSignal });
+	if (shutdownSignal) process$1.exit(getSignalExitCode(shutdownSignal));
 });
 function enterAltScreen() {
 	process$1.stdout.write("\x1B[?1049h");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnhf",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Before I go to bed, I tell my agents: good night, have fun",
   "type": "module",
   "bin": {
@@ -9,12 +9,13 @@
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
-    "start": "node dist/cli.js",
+    "start": "node dist/cli.mjs",
     "lint": "eslint src",
     "format": "prettier --write src",
     "format:check": "prettier --check src",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage"
+    "test": "npm run build && vitest run",
+    "test:e2e": "npm run build && vitest run test/e2e.test.ts",
+    "test:coverage": "vitest run --coverage --exclude test/e2e.test.ts"
   },
   "dependencies": {
     "commander": "^14.0.3",