github-router 0.3.110 → 0.3.111

package/dist/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { a as removeOwnClaudeConfigMirror, i as isUnderClaudeConfigMirror, l as writeRuntimeFileSecure, n as ensureClaudeConfigMirror, r as ensurePaths, t as PATHS } from "./paths-C8zBV5RE.js";
-import { c as resolveExecutable, d as runManagedExeCapture, l as runCommandCapture, n as isPidAlive, o as trackChild, r as registerColbertExitHandlers, s as parseBoolEnv, t as getColbertInstanceUuid, u as runCommandVoid } from "./lifecycle-BFBvekpf.js";
-import { a as sweepRegistry, i as registerExitHandlers, n as getInstanceUuid, r as recordWorkerRepo, t as WorktreeRegistry } from "./lifecycle-yl1T7iQf.js";
+import { a as removeOwnClaudeConfigMirror, i as isUnderClaudeConfigMirror, l as writeRuntimeFileSecure, n as ensureClaudeConfigMirror, r as ensurePaths, t as PATHS } from "./paths-CDWhYOdp.js";
+import { c as parseBoolEnv, d as runCommandVoid, f as runManagedExeCapture, l as resolveExecutable, n as isPidAlive, o as trackChild, r as registerColbertExitHandlers, s as killManagedTree, t as getColbertInstanceUuid, u as runCommandCapture } from "./lifecycle-DzJicg68.js";
+import { a as sweepRegistry, i as registerExitHandlers$1, n as getInstanceUuid, r as recordWorkerRepo, t as WorktreeRegistry } from "./lifecycle-D6zt0iH_.js";
 import { createRequire } from "node:module";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
@@ -5761,7 +5761,7 @@ function semanticSearchOptedIn() {
 function colbertSearchEnabled() {
 	return semanticSearchOptedIn() && colbertArtifactsPresent() && colbertSmokeOk();
 }
-let _started = false;
+let _started$1 = false;
 /**
 * Fire-and-forget provision + background-index. Never throws; safe to
 * `void`-call from a launcher right after the server is listening.
@@ -5769,8 +5769,8 @@ let _started = false;
 */
 async function provisionAndIndexColbert(opts = {}) {
 	if (!semanticSearchOptedIn()) return;
-	if (_started) return;
-	_started = true;
+	if (_started$1) return;
+	_started$1 = true;
 	registerColbertExitHandlers();
 	let provisioned = false;
 	try {
@@ -7102,7 +7102,7 @@ function logAudit$1(record) {
 		try {
 			const fs$2 = await import("node:fs/promises");
 			const path$1 = await import("node:path");
-			const { PATHS: PATHS$1 } = await import("./paths-0Vw8oIDa.js");
+			const { PATHS: PATHS$1 } = await import("./paths-DNVIKCZP.js");
 			const dir = path$1.join(PATHS$1.APP_DIR, "browser-mcp");
 			await fs$2.mkdir(dir, { recursive: true });
 			const line = JSON.stringify({
@@ -17471,7 +17471,7 @@ async function createWorktree(workspaceAbs, opts) {
 * Exported solely for the test helpers in this file to reach.
 */
 const WORKTREE_REGISTRY = new WorktreeRegistry();
-registerExitHandlers(WORKTREE_REGISTRY);
+registerExitHandlers$1(WORKTREE_REGISTRY);
 /** Default model + thinking for the READ-ONLY worker modes (`explore`,
 *  `review`). `gemini-3.5-flash` at `high` (its top reasoning tier) — fast,
 *  1M-context, tool-call-capable.
@@ -22160,6 +22160,249 @@ async function exposedCommands(binDir) {
 	return out;
 }
 
+//#endregion
+//#region src/lib/keep-awake/flags.ts
+/**
+* True unless the operator opted out via `GH_ROUTER_DISABLE_KEEP_AWAKE`.
+* Keep-awake is ON BY DEFAULT (the win32-only platform gate is applied
+* separately in `keepAwakeEnabled()`). Mirrors the colbert opt-out idiom
+* (`parseBoolEnv(...) !== true`) so on/off semantics don't drift.
+*/
+function keepAwakeOptedIn() {
+	return parseBoolEnv(process$1.env.GH_ROUTER_DISABLE_KEEP_AWAKE) !== true;
+}
+/**
+* True iff the operator opted IN to keeping the DISPLAY awake too via
+* `GH_ROUTER_KEEP_DISPLAY_ON=1`. Default OFF: the machine stays awake
+* (`ES_SYSTEM_REQUIRED`) but the panel is allowed to sleep.
+*/
+function keepDisplayOn() {
+	return parseBoolEnv(process$1.env.GH_ROUTER_KEEP_DISPLAY_ON) === true;
+}
+
+//#endregion
+//#region src/lib/keep-awake/helper.ts
+const ES_CONTINUOUS = 2147483648;
+const ES_SYSTEM_REQUIRED = 1;
+const ES_DISPLAY_REQUIRED = 2;
+/** Default time to wait for the helper's `OK` readiness line. */
+const DEFAULT_READY_TIMEOUT_MS = 5e3;
+/**
+* The execution-state flags to assert. Always `ES_CONTINUOUS |
+* ES_SYSTEM_REQUIRED` (machine stays awake); adds `ES_DISPLAY_REQUIRED`
+* (screen stays on) when `displayRequired`. `>>> 0` forces an unsigned
+* 32-bit value so the hex literal handed to PowerShell is positive.
+*/
+function executionStateFlags(displayRequired) {
+	let flags = ES_CONTINUOUS | ES_SYSTEM_REQUIRED;
+	if (displayRequired) flags |= ES_DISPLAY_REQUIRED;
+	return flags >>> 0;
+}
+/** Format a uint32 as a PowerShell `[uint32]<decimal>` literal.
+*
+* Decimal, NOT hex: in Windows PowerShell a hex literal like `0x80000001`
+* parses as a *negative* Int32 (`-2147483647`) and fails to convert to
+* the `uint` parameter ("Value was either too large or too small for a
+* UInt32"). A decimal literal over Int32.MaxValue auto-promotes to a
+* positive Int64, and the explicit `[uint32]` cast then fits. Verified
+* against a real win32 host before shipping. */
+function psUint32(n) {
+	return `[uint32]${n >>> 0}`;
+}
+/**
+* Build the PowerShell script the persistent helper runs. PURE — the
+* flag value is our own constant templated as a numeric literal, so
+* there is no injection surface. The script:
+*   1. P/Invokes `SetThreadExecutionState` with the requested flags.
+*   2. Prints `OK` once the assertion succeeds (the readiness signal;
+*      no `OK` => `Add-Type` was CLM-blocked or the call returned 0).
+*   3. Blocks reading stdin so it self-exits on parent death (pipe EOF).
+*   4. Clears the assertion (`ES_CONTINUOUS` only) on the way out.
+*
+* The C# member-definition is a PowerShell SINGLE-quoted string so its
+* embedded `"kernel32.dll"` double-quotes need no escaping.
+*/
+function buildKeepAwakeScript(displayRequired) {
+	const assert = psUint32(executionStateFlags(displayRequired));
+	const clear = psUint32(ES_CONTINUOUS);
+	return [
+		`Add-Type -Name P -Namespace W -MemberDefinition '[System.Runtime.InteropServices.DllImport("kernel32.dll")] public static extern uint SetThreadExecutionState(uint e);'`,
+		`if ([W.P]::SetThreadExecutionState(${assert}) -ne 0) { [Console]::Out.WriteLine('OK'); [Console]::Out.Flush() }`,
+		`while ($null -ne [Console]::In.ReadLine()) {}`,
+		`[void][W.P]::SetThreadExecutionState(${clear})`
+	].join("\n");
+}
+/** The argv passed to powershell.exe (excluding the executable itself). */
+function buildHelperArgs(displayRequired) {
+	return [
+		"-NoProfile",
+		"-NonInteractive",
+		"-Command",
+		buildKeepAwakeScript(displayRequired)
+	];
+}
+/**
+* Spawn the persistent helper. Returns a null handle (and `ready` →
+* `false`) when powershell.exe can't be resolved or spawn throws — both
+* clean no-op degradations. The helper's stdout is piped only to detect
+* the `OK` readiness line; stderr is ignored.
+*/
+function spawnHelper(opts) {
+	const ps = resolveExecutable("powershell.exe");
+	if (!ps) return {
+		handle: null,
+		ready: Promise.resolve(false)
+	};
+	let child;
+	try {
+		child = spawn(ps, buildHelperArgs(opts.displayRequired), {
+			stdio: [
+				"pipe",
+				"pipe",
+				"ignore"
+			],
+			windowsHide: true,
+			shell: false
+		});
+	} catch {
+		return {
+			handle: null,
+			ready: Promise.resolve(false)
+		};
+	}
+	child.on("error", () => {});
+	return {
+		handle: { child },
+		ready: new Promise((resolve) => {
+			let settled = false;
+			let buf = "";
+			const done = (v) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				resolve(v);
+			};
+			const timer = setTimeout(() => done(false), opts.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS);
+			timer.unref?.();
+			child.stdout?.on("data", (c) => {
+				if (settled || buf.length > 256) return;
+				buf += c.toString("utf8");
+				if (buf.includes("OK")) done(true);
+			});
+			child.stdout?.on("error", () => {});
+			child.once("exit", () => done(false));
+			child.once("error", () => done(false));
+		})
+	};
+}
+/**
+* Release the assertion: close the helper's stdin (→ pipe EOF → the
+* helper clears `ES_*` and exits) then `taskkill /T /F` as a
+* belt-and-suspenders reap. Windows also releases the assertion on the
+* helper's process death regardless. Best-effort; never throws.
+*/
+function killHelper(handle) {
+	const { child } = handle;
+	try {
+		child.stdin?.end();
+	} catch {}
+	try {
+		killManagedTree(child);
+	} catch {}
+}
+
+//#endregion
+//#region src/lib/keep-awake/index.ts
+/**
+* True iff keep-awake should run THIS launch: win32 AND not opted out.
+* Non-win32 short-circuits before anything else (no spawn, no flags read
+* beyond the opt-out, no handler registration). `platform` is injectable
+* for tests; production callers use the default `process.platform`.
+*/
+function keepAwakeEnabled(platform$1 = process$1.platform) {
+	return platform$1 === "win32" && keepAwakeOptedIn();
+}
+let _handle = null;
+let _started = false;
+/** Synchronously release the assertion + drop the handle. Idempotent.
+* Also clears the `_started` latch so a transient failure never
+* permanently disables a later start. */
+function releaseSync() {
+	const h = _handle;
+	_handle = null;
+	_started = false;
+	if (h) try {
+		killHelper(h);
+	} catch {}
+}
+let _registered = false;
+let _exitHandler = null;
+let _sigintHandler = null;
+let _sigtermHandler = null;
+/**
+* Wire SIGINT/SIGTERM/exit handlers that release the assertion.
+* Idempotent. The signal handlers re-raise after releasing (remove self
+* + `process.kill(self)`) so Node's default terminate-on-signal is
+* restored — otherwise merely attaching a listener cancels the default
+* and Ctrl-C would clean but not exit. This is load-bearing for the
+* `start` subcommand, which has no `launchChild`/`onShutdown` of its own.
+*/
+function registerExitHandlers() {
+	if (_registered) return;
+	_registered = true;
+	_exitHandler = () => releaseSync();
+	_sigintHandler = () => {
+		releaseSync();
+		if (_sigintHandler) process$1.off("SIGINT", _sigintHandler);
+		process$1.kill(process$1.pid, "SIGINT");
+	};
+	_sigtermHandler = () => {
+		releaseSync();
+		if (_sigtermHandler) process$1.off("SIGTERM", _sigtermHandler);
+		process$1.kill(process$1.pid, "SIGTERM");
+	};
+	process$1.on("SIGINT", _sigintHandler);
+	process$1.on("SIGTERM", _sigtermHandler);
+	process$1.on("exit", _exitHandler);
+}
+/**
+* Start keeping the machine awake. Synchronous, fire-and-forget,
+* idempotent within a run. No-op off win32 or when opted out. Never
+* throws.
+*/
+function startKeepAwake() {
+	if (!keepAwakeEnabled()) return;
+	if (_started) return;
+	_started = true;
+	try {
+		const { handle, ready } = spawnHelper({ displayRequired: keepDisplayOn() });
+		if (!handle) {
+			_started = false;
+			consola.debug("keep-awake: inactive (powershell.exe not resolvable)");
+			return;
+		}
+		_handle = handle;
+		handle.child.once("exit", () => {
+			if (_handle === handle) _handle = null;
+		});
+		registerExitHandlers();
+		ready.then((ok) => {
+			consola.debug(ok ? "keep-awake: holding SetThreadExecutionState assertion (system sleep prevented)" : "keep-awake: inactive (helper did not confirm — Constrained Language Mode or PowerShell unavailable)");
+		});
+	} catch (err) {
+		_started = false;
+		_handle = null;
+		consola.debug("keep-awake: failed to start (continuing):", err);
+	}
+}
+/**
+* Release the assertion / reap the helper. Idempotent; safe to `await`
+* from a subcommand's `onShutdown` chain. Never throws.
+*/
+async function stopKeepAwake() {
+	releaseSync();
+}
+
 //#endregion
 //#region src/lib/proxy.ts
 function initProxyFromEnv() {
@@ -22209,7 +22452,7 @@ function initProxyFromEnv() {
 //#endregion
 //#region package.json
 var name = "github-router";
-var version$1 = "0.3.110";
+var version$1 = "0.3.111";
 
 //#endregion
 //#region src/lib/approval.ts
@@ -24328,8 +24571,10 @@ const claude = defineCommand({
 			}
 		}
 		provisionAndIndexColbert();
+		startKeepAwake();
 		if (browserToolsEnabled()) provisionBrowserAssets().catch((err) => consola.debug("Browser extension provisioning failed:", err));
 		const baseShutdown = async () => {
+			await stopKeepAwake();
 			await removeOwnClaudeConfigMirror();
 		};
 		let onShutdown = baseShutdown;
@@ -24451,6 +24696,7 @@ const codex = defineCommand({
 		runSelfUpdate({ selfUpdate: args["self-update"] !== false });
 		if (toolbeltEnabled()) provisionToolbelt().catch(() => {});
 		provisionAndIndexColbert();
+		startKeepAwake();
 		if ((state.browseEnabled || process$1.env.GH_ROUTER_ENABLE_BROWSE === "1") && hasSupportedBrowserInstalled()) provisionBrowserAssets().catch((err) => consola.debug("Browser extension provisioning failed:", err));
 		const usingDefault = !args.model;
 		const requestedModel = args.model ?? DEFAULT_CODEX_MODEL;
@@ -24882,6 +25128,7 @@ const start = defineCommand({
 		});
 		runSelfUpdate({ selfUpdate: args["self-update"] !== false });
 		provisionAndIndexColbert();
+		startKeepAwake();
 		if (browserToolsEnabled()) provisionBrowserAssets().catch((err) => consola.debug("Browser extension provisioning failed:", err));
 		if (args.cc) generateClaudeCodeCommand(serverUrl, args.model);
 		if (args.cx) generateCodexCommand(serverUrl, args.model);