Fix Windows daemon captured start

Author: logi-cmd

crates/agent-guardrails-cli/src/daemon.rs

@@ -144,21 +144,7 @@ fn run_start(args: &[String]) -> Result<i32, String> {
     }
 
     ensure_guardrails_dir(&repo_root)?;
-    let current_exe =
-        env::current_exe().map_err(|error| format!("failed to resolve current exe: {error}"))?;
-    let mut command = Command::new(current_exe);
-    command
-        .arg("daemon-worker")
-        .arg("--repo-root")
-        .arg(repo_root.to_string_lossy().to_string())
-        .stdin(Stdio::null())
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .current_dir(&repo_root);
-    detach_daemon_command(&mut command);
-    command
-        .spawn()
-        .map_err(|error| format!("failed to spawn daemon worker: {error}"))?;
+    spawn_daemon_worker(&repo_root)?;
 
     let status = wait_for_running_status(&repo_root, daemon_start_timeout());
     let ok = status.running;
@@ -505,15 +491,71 @@ fn stop_process(pid: u32) -> bool {
     }
 }
 
+fn spawn_daemon_worker(repo_root: &Path) -> Result<(), String> {
+    let current_exe =
+        env::current_exe().map_err(|error| format!("failed to resolve current exe: {error}"))?;
+
+    spawn_daemon_worker_for_platform(current_exe, repo_root)
+}
+
 #[cfg(windows)]
-fn detach_daemon_command(command: &mut Command) {
-    use std::os::windows::process::CommandExt;
+fn spawn_daemon_worker_for_platform(current_exe: PathBuf, repo_root: &Path) -> Result<(), String> {
+    let exe = powershell_single_quote(&current_exe.to_string_lossy());
+    let repo = powershell_single_quote(&repo_root.to_string_lossy());
+    // Hidden Start-Process gives the daemon worker fresh stdio handles. Direct
+    // Command::spawn can leave a captured caller stdout pipe open on Windows.
+    let script = format!(
+        "$ErrorActionPreference='Stop'; Start-Process -FilePath '{exe}' -ArgumentList @('daemon-worker','--repo-root','{repo}') -WorkingDirectory '{repo}' -WindowStyle Hidden"
+    );
+    let status = Command::new("powershell.exe")
+        .arg("-NoProfile")
+        .arg("-NonInteractive")
+        .arg("-WindowStyle")
+        .arg("Hidden")
+        .arg("-ExecutionPolicy")
+        .arg("Bypass")
+        .arg("-Command")
+        .arg(script)
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .current_dir(repo_root)
+        .status()
+        .map_err(|error| format!("failed to launch daemon worker via PowerShell: {error}"))?;
+    if status.success() {
+        Ok(())
+    } else {
+        Err(format!(
+            "failed to launch daemon worker via PowerShell: exit code {}",
+            status
+                .code()
+                .map(|code| code.to_string())
+                .unwrap_or_else(|| "unknown".to_string())
+        ))
+    }
+}
 
-    const DETACHED_PROCESS: u32 = 0x0000_0008;
-    const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200;
-    const CREATE_NO_WINDOW: u32 = 0x0800_0000;
+#[cfg(windows)]
+fn powershell_single_quote(value: &str) -> String {
+    value.replace('\'', "''")
+}
 
-    command.creation_flags(DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW);
+#[cfg(not(windows))]
+fn spawn_daemon_worker_for_platform(current_exe: PathBuf, repo_root: &Path) -> Result<(), String> {
+    let mut command = Command::new(current_exe);
+    command
+        .arg("daemon-worker")
+        .arg("--repo-root")
+        .arg(repo_root.to_string_lossy().to_string())
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .current_dir(repo_root);
+    detach_daemon_command(&mut command);
+    command
+        .spawn()
+        .map(|_| ())
+        .map_err(|error| format!("failed to spawn daemon worker: {error}"))
 }
 
 #[cfg(not(windows))]

lib/cli.js

@@ -226,7 +226,7 @@ export async function runCli(argv) {
   if (command === "start") {
     const startRuntime = selectStartRuntime();
     if (startRuntime.kind === "rust") {
-      await runRustRuntime("start", argv.slice(1), { binary: startRuntime.binary });
+      await runRustRuntime("start", argv.slice(1), { binary: startRuntime.binary, stdio: "pipe" });
       return;
     }
     await startDaemon(resolveRepoRoot(process.cwd()), { locale, foreground: flags.foreground || false });
@@ -236,7 +236,7 @@ export async function runCli(argv) {
   if (command === "stop") {
     const stopRuntime = selectStopRuntime();
     if (stopRuntime.kind === "rust") {
-      await runRustRuntime("stop", argv.slice(1), { binary: stopRuntime.binary });
+      await runRustRuntime("stop", argv.slice(1), { binary: stopRuntime.binary, stdio: "pipe" });
       return;
     }
     stopDaemon(resolveRepoRoot(process.cwd()), { locale });
@@ -246,7 +246,7 @@ export async function runCli(argv) {
   if (command === "status") {
     const statusRuntime = selectStatusRuntime();
     if (statusRuntime.kind === "rust") {
-      await runRustRuntime("status", argv.slice(1), { binary: statusRuntime.binary });
+      await runRustRuntime("status", argv.slice(1), { binary: statusRuntime.binary, stdio: "pipe" });
       return;
     }
     showDaemonStatus(resolveRepoRoot(process.cwd()), { locale });

lib/rust-runtime.js

@@ -211,7 +211,11 @@ const forwardedSignalExitCodes = new Map([
   ["SIGTERM", 143]
 ]);
 
-export async function runRustRuntime(command, commandArgs, { env = process.env, root = packageRoot, binary = null } = {}) {
+export async function runRustRuntime(
+  command,
+  commandArgs,
+  { env = process.env, root = packageRoot, binary = null, stdio = "inherit" } = {}
+) {
   const resolvedBinary = binary ?? resolveRustCheckRuntime({ env, root });
   const childEnv = {
     ...env,
@@ -223,10 +227,19 @@ export async function runRustRuntime(command, commandArgs, { env = process.env,
     const child = spawn(resolvedBinary, [command, ...commandArgs], {
       cwd: process.cwd(),
       env: childEnv,
-      stdio: "inherit",
+      stdio,
       windowsHide: true
     });
 
+    if (stdio === "pipe") {
+      child.stdout?.on("data", (chunk) => {
+        process.stdout.write(chunk);
+      });
+      child.stderr?.on("data", (chunk) => {
+        process.stderr.write(chunk);
+      });
+    }
+
     const onParentExit = () => {
       if (!child.killed) {
         child.kill();

tests/rust-installed-runtime-smoke.js

@@ -66,7 +66,7 @@ function runNpm(args, cwd, env = {}) {
   return run(npm.command, [...npm.prefixArgs, ...args], cwd, env);
 }
 
-function runProcess(command, args, cwd, env = {}) {
+function runProcess(command, args, cwd, env = {}, timeoutMs = 120_000) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd,
@@ -76,14 +76,22 @@ function runProcess(command, args, cwd, env = {}) {
     });
     let stdout = "";
     let stderr = "";
+    const timeout = setTimeout(() => {
+      child.kill();
+      reject(new Error(`Process timed out after ${timeoutMs}ms: ${command} ${args.join(" ")}\nstdout:\n${stdout}\nstderr:\n${stderr}`));
+    }, timeoutMs);
     child.stdout.on("data", (chunk) => {
       stdout += chunk.toString("utf8");
     });
     child.stderr.on("data", (chunk) => {
       stderr += chunk.toString("utf8");
     });
-    child.on("error", reject);
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
     child.on("exit", (code, signal) => {
+      clearTimeout(timeout);
       resolve({ code: code ?? 1, signal, stdout, stderr });
     });
   });
@@ -315,6 +323,17 @@ async function assertInstalledDaemonUsesRustDefault(cliPath, repoDir, env) {
     const finalStatus = parseJsonCommand(process.execPath, [cliPath, "status", "--json"], repoDir, env);
     trace("daemon final status returned");
     assert.equal(finalStatus.status.running, false);
+
+    const humanStart = await runProcess(process.execPath, [cliPath, "start", "--lang", "en"], repoDir, env, 15_000);
+    assert.equal(
+      humanStart.code,
+      0,
+      `installed Rust human start should exit successfully when stdout is captured\nstdout:\n${humanStart.stdout}\nstderr:\n${humanStart.stderr}\n` +
+        `diagnostics:\n${JSON.stringify(installedDaemonDiagnostics(repoDir), null, 2)}`
+    );
+    assert.match(humanStart.stdout, /daemon started/i);
+    const humanStop = parseJsonCommand(process.execPath, [cliPath, "stop", "--json"], repoDir, env);
+    assert.equal(humanStop.ok, true);
   } finally {
     try {
       run(process.execPath, [cliPath, "stop", "--json"], repoDir, env);