fix(windows): handle console readiness and isolated runtime setup

Author: e2e

.github/workflows/windows.yml

@@ -67,14 +67,30 @@ jobs:
           npm run check:licenses
           if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
 
+      - name: Test Windows packaging helpers
+        id: packaging
+        run: node --test scripts/fetch-bun.test.mjs scripts/release/windows-payload.test.mjs scripts/release/windows-smoke-environment.test.mjs
+
       - name: Verify Rust core
-        run: npm run check:core
+        id: core
+        if: ${{ !cancelled() && steps.source.outcome == 'success' }}
+        run: |
+          npm run check:core 2>&1 | Tee-Object -FilePath (Join-Path $env:RUNNER_TEMP 'gajae-core-windows.log')
+          exit $LASTEXITCODE
+
+      - name: Upload failed core diagnostics
+        if: ${{ !cancelled() && steps.core.outcome == 'failure' }}
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: windows-core-diagnostics
+          path: ${{ runner.temp }}/gajae-core-windows.log
+          retention-days: 7
 
       - name: Build payload and installer
         id: build
         # Gather independent Windows failures in one run. A failed core check
         # still fails the job and prevents the final artifact upload.
-        if: ${{ !cancelled() && steps.source.outcome == 'success' }}
+        if: ${{ !cancelled() && steps.source.outcome == 'success' && steps.packaging.outcome == 'success' }}
         run: npm run desktop:build:windows
 
       - name: Test Windows runtime

native/gajae-core/tests/process_protocol.rs

@@ -1,7 +1,7 @@
 use std::io::{BufRead, BufReader, Read, Write};
 use std::path::PathBuf;
 use std::process::{Child, Command, ExitStatus, Stdio};
-use std::sync::mpsc;
+use std::sync::{Arc, Mutex, mpsc};
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 use base64::{Engine as _, engine::general_purpose::STANDARD};
@@ -28,7 +28,16 @@ impl TestDirectory {
 
 impl Drop for TestDirectory {
     fn drop(&mut self) {
-        std::fs::remove_dir_all(&self.0).unwrap();
+        // Windows may briefly retain the copied fixture executable while
+        // ConPTY exits. Never double-panic during a timeout's stack unwind.
+        for _ in 0..20 {
+            match std::fs::remove_dir_all(&self.0) {
+                Ok(()) => return,
+                Err(error) if error.kind() == std::io::ErrorKind::NotFound => return,
+                Err(_) => std::thread::sleep(Duration::from_millis(50)),
+            }
+        }
+        let _ = writeln!(std::io::stderr(), "fixture cleanup failed: {:?}", self.0);
     }
 }
 
@@ -52,6 +61,15 @@ impl CoreChild {
 
 impl Drop for CoreChild {
     fn drop(&mut self) {
+        // Closing input lets the core kill/reap its own PTY child and close
+        // ConPTY before the executable's directory is removed.
+        self.0.stdin.take();
+        for _ in 0..100 {
+            if matches!(self.0.try_wait(), Ok(Some(_))) {
+                return;
+            }
+            std::thread::sleep(Duration::from_millis(10));
+        }
         let _ = self.0.kill();
         let _ = self.0.wait();
     }
@@ -106,6 +124,10 @@ fn child_fixture() {
         std::io::stdout().flush().unwrap();
         std::process::exit(23);
     }
+    // The protocol's ready frame means the PTY exists, not that its child has
+    // finished console initialization. On ConPTY a cursor query can precede it.
+    writeln!(std::io::stdout().lock(), "fixture-ready").unwrap();
+    std::io::stdout().flush().unwrap();
     let stdin = std::io::stdin();
     for line in stdin.lock().lines() {
         // Input follows resize, so ConPTY cannot wrap the long path at its
@@ -119,6 +141,73 @@ fn child_fixture() {
     }
 }
 
+#[derive(Default)]
+struct TerminalOutput {
+    bytes: Vec<u8>,
+    answered_cursor_queries: usize,
+}
+
+impl TerminalOutput {
+    fn push(&mut self, bytes: &[u8]) -> usize {
+        self.bytes.extend_from_slice(bytes);
+        // portable-pty uses PSEUDOCONSOLE_INHERIT_CURSOR. A real terminal
+        // answers CSI 6 n; ignoring it can deadlock ResizePseudoConsole.
+        // Count over the accumulated bytes to handle split output frames.
+        let queries = self
+            .bytes
+            .windows(4)
+            .filter(|part| *part == b"\x1b[6n")
+            .count();
+        let pending = queries - self.answered_cursor_queries;
+        self.answered_cursor_queries = queries;
+        pending
+    }
+
+    fn contains(&self, text: &str) -> bool {
+        self.bytes
+            .windows(text.len())
+            .any(|part| part == text.as_bytes())
+    }
+}
+
+fn write_request(input: &mut impl Write, request: Value) {
+    writeln!(input, "{request}").unwrap();
+    input.flush().unwrap();
+}
+
+fn receive_frame(
+    receiver: &mpsc::Receiver<Result<Value, String>>,
+    deadline: Instant,
+    phase: &str,
+    output: &TerminalOutput,
+    diagnostics: &Mutex<Vec<u8>>,
+) -> Value {
+    match receiver.recv_timeout(deadline.saturating_duration_since(Instant::now())) {
+        Ok(Ok(frame)) => frame,
+        failure => {
+            let message = format!(
+                "PTY {phase} failed: {failure:?}; output={:?}; stderr={:?}",
+                String::from_utf8_lossy(&output.bytes),
+                String::from_utf8_lossy(&diagnostics.lock().unwrap()),
+            );
+            // Bypass libtest capture so timeout diagnostics survive even if
+            // another Windows cleanup failure aborts the harness.
+            let _ = writeln!(std::io::stderr().lock(), "{message}");
+            panic!("{message}");
+        }
+    }
+}
+
+#[test]
+fn terminal_answers_cursor_queries_split_across_output_frames_once() {
+    let mut terminal = TerminalOutput::default();
+    assert_eq!(terminal.push(b"\x1b["), 0);
+    assert_eq!(terminal.push(b"6nfixture-ready"), 1);
+    assert_eq!(terminal.push(b"\r\n"), 0);
+    assert_eq!(terminal.push(b"\x1b[6n"), 1);
+    assert!(terminal.contains("fixture-ready"));
+}
+
 #[test]
 fn proxy_preserves_project_cwd_binary_stdin_and_child_exit_code() {
     let directory = TestDirectory::new("proxy");
@@ -153,37 +242,81 @@ fn pty_starts_in_project_directory_and_supports_resize_input_and_shutdown() {
     let directory = TestDirectory::new("pty");
     let mut core = spawn_fixture("pty", &directory);
     let stdout = core.0.stdout.take().unwrap();
+    let mut stderr = core.0.stderr.take().unwrap();
+    let diagnostics = Arc::new(Mutex::new(Vec::new()));
+    let stderr_capture = Arc::clone(&diagnostics);
+    let stderr_reader = std::thread::spawn(move || {
+        let mut buffer = [0_u8; 4096];
+        while let Ok(count) = stderr.read(&mut buffer) {
+            if count == 0 {
+                break;
+            }
+            stderr_capture
+                .lock()
+                .unwrap()
+                .extend_from_slice(&buffer[..count]);
+        }
+    });
     let (sender, receiver) = mpsc::channel();
     let reader = std::thread::spawn(move || {
         for line in BufReader::new(stdout).lines() {
-            let frame = serde_json::from_str::<Value>(&line.unwrap()).unwrap();
+            let frame = line.map_err(|error| error.to_string()).and_then(|line| {
+                serde_json::from_str::<Value>(&line).map_err(|error| format!("{error}: {line:?}"))
+            });
             if sender.send(frame).is_err() {
                 break;
             }
         }
     });
-    let first = receiver
-        .recv_timeout(TIMEOUT)
-        .expect("PTY did not become ready");
+    let mut output = TerminalOutput::default();
+    let first = receive_frame(
+        &receiver,
+        Instant::now() + TIMEOUT,
+        "host readiness",
+        &output,
+        &diagnostics,
+    );
     assert_eq!(first, json!({"protocolVersion": 1, "kind": "ready"}));
     let mut stdin = core.0.stdin.take().unwrap();
+    // Answer terminal queries before resize: ResizePseudoConsole may block
+    // while ConPTY waits for the cursor reply on its input pipe.
+    let deadline = Instant::now() + TIMEOUT;
+    while !output.contains("fixture-ready") {
+        let frame = receive_frame(
+            &receiver,
+            deadline,
+            "child readiness",
+            &output,
+            &diagnostics,
+        );
+        assert_eq!(frame["kind"], "output", "unexpected frame: {frame}");
+        let bytes = STANDARD.decode(frame["data"].as_str().unwrap()).unwrap();
+        for _ in 0..output.push(&bytes) {
+            write_request(
+                &mut stdin,
+                json!({"protocolVersion": 1, "method": "pty.write", "data": STANDARD.encode(b"\x1b[1;1R")}),
+            );
+        }
+    }
     for request in [
         json!({"protocolVersion": 1, "method": "pty.resize", "cols": 1000, "rows": 30}),
         json!({"protocolVersion": 1, "method": "pty.write", "data": STANDARD.encode(b"native-pty-token\r")}),
     ] {
-        writeln!(stdin, "{request}").unwrap();
+        write_request(&mut stdin, request);
     }
-    let mut output = Vec::new();
     let deadline = Instant::now() + TIMEOUT;
     loop {
-        let frame = receiver
-            .recv_timeout(deadline.saturating_duration_since(Instant::now()))
-            .expect("PTY did not echo input");
+        let frame = receive_frame(&receiver, deadline, "input echo", &output, &diagnostics);
         assert_eq!(frame["kind"], "output", "unexpected frame: {frame}");
-        output.extend(STANDARD.decode(frame["data"].as_str().unwrap()).unwrap());
-        let text = String::from_utf8_lossy(&output);
-        if text.contains(&expected_cwd(&directory))
-            && text.contains("fixture-input=native-pty-token")
+        let bytes = STANDARD.decode(frame["data"].as_str().unwrap()).unwrap();
+        for _ in 0..output.push(&bytes) {
+            write_request(
+                &mut stdin,
+                json!({"protocolVersion": 1, "method": "pty.write", "data": STANDARD.encode(b"\x1b[1;1R")}),
+            );
+        }
+        if output.contains(&expected_cwd(&directory))
+            && output.contains("fixture-input=native-pty-token")
         {
             break;
         }
@@ -197,5 +330,11 @@ fn pty_starts_in_project_directory_and_supports_resize_input_and_shutdown() {
     drop(stdin);
     assert!(core.wait().success());
     reader.join().unwrap();
-    assert!(receiver.try_iter().any(|frame| frame["kind"] == "exit"));
+    stderr_reader.join().unwrap();
+    assert!(
+        receiver
+            .try_iter()
+            .any(|frame| frame.unwrap()["kind"] == "exit")
+    );
+    assert!(diagnostics.lock().unwrap().is_empty());
 }

scripts/release/smoke-windows-server.mjs

@@ -9,17 +9,24 @@ import { parseArgs } from 'node:util';
 import { BUN_VERSION } from '../fetch-bun.mjs';
 
 import { assertOutOfTree } from './out-of-tree.mjs';
-import { assertWindowsHost, assertWindowsX64Executable, NODE_VERSION, verifyManifest, windowsSmokeEnvironment } from './windows-payload.mjs';
+import { assertWindowsHost, assertWindowsX64Executable, NODE_VERSION, verifyManifest, verifyWindowsSmokeEnvironment, windowsSmokeEnvironment } from './windows-payload.mjs';
 
-export async function runGuardedSmoke({ nodePath, args, cwd, env, jobRuntime, timeoutMs = 120_000, stdout = process.stdout }) {
+export async function runGuardedSmoke({ nodePath, args, cwd, env, jobRuntime, timeoutMs = 120_000, stdout = process.stdout, stderr = process.stderr }) {
   const { createWindowsJobLaunch, killWindowsJobGuard, GJC_WINDOWS_JOB_GUARD_READY, GJC_WINDOWS_JOB_GUARD_ACK } = jobRuntime;
   const launch = createWindowsJobLaunch(nodePath, args, env, cwd);
   const child = spawn(launch.command, launch.args, {
-    cwd, env: launch.env, shell: false, windowsHide: true, stdio: ['pipe', 'pipe', 'inherit'],
+    cwd, env: launch.env, shell: false, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'],
   });
   let timer;
   let ready = false;
   let buffered = Buffer.alloc(0);
+  let diagnostics = '';
+  let failure;
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', chunk => {
+    diagnostics = (diagnostics + chunk).slice(-16_384);
+    stderr.write(chunk);
+  });
   try {
     await new Promise((resolve, reject) => {
       timer = setTimeout(() => reject(new Error('Windows payload smoke timed out.')), timeoutMs);
@@ -43,34 +50,51 @@ export async function runGuardedSmoke({ nodePath, args, cwd, env, jobRuntime, ti
         ? resolve()
         : reject(new Error(`Windows payload smoke failed (exit ${code}, Job guard ready=${ready}).`)));
     });
+  } catch (error) {
+    failure = new Error(`${error.message}${diagnostics.trim() ? `\nJob guard diagnostics:\n${diagnostics}` : ''}`);
   } finally {
     clearTimeout(timer);
     // Always reap the named Job, even if its direct child has exited: an early
     // checker exit must not leave a detached server, core, or Bun descendant.
-    await killWindowsJobGuard(child, launch);
+    try { await killWindowsJobGuard(child, launch); }
+    catch (error) {
+      // execFile errors retain the entire encoded guard command. Report the
+      // cleanup reason and native stderr without dumping that command or losing
+      // the original startup error underneath it.
+      const cause = error.cause;
+      const cleanup = new Error(`${error.message}${cause?.killed ? ' (reaper timed out)' : ''}${cause?.stderr ? `\n${String(cause.stderr).slice(-16_384)}` : ''}`);
+      failure = failure
+        ? new AggregateError([failure, cleanup], `${failure.message}\nJob cleanup also failed: ${cleanup.message}`)
+        : cleanup;
+    }
   }
+  if (failure) throw failure;
 }
 
 export async function smokeWindowsServer({ payloadDir, nodePath }) {
   assertWindowsHost();
   if (!payloadDir || !nodePath) throw new Error('Both payloadDir and nodePath are required.');
   const temporaryDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gajae-windows smoke 가재-'));
+  let failure;
   try {
     await assertOutOfTree(temporaryDir, 'Windows server smoke');
     const payloadCopy = path.join(temporaryDir, 'server payload 가재');
     const runtimeDir = path.join(temporaryDir, 'runtime space 가재');
     const stateDir = path.join(temporaryDir, 'user profile 가재');
-    await fs.cp(path.resolve(payloadDir), payloadCopy, { recursive: true, dereference: false, verbatimSymlinks: true });
     await fs.mkdir(runtimeDir, { recursive: true });
+    await fs.mkdir(payloadCopy, { recursive: true });
+    const env = windowsSmokeEnvironment(runtimeDir, stateDir);
+    for (const directory of [stateDir, env.APPDATA, env.LOCALAPPDATA, env.XDG_CONFIG_HOME, env.XDG_DATA_HOME, env.XDG_CACHE_HOME, env.TEMP, env.WORKSPACES_ROOT, env.GJC_WORKER_AGENT_DIR]) {
+      await fs.mkdir(directory, { recursive: true });
+    }
+    const environment = await verifyWindowsSmokeEnvironment(env, payloadCopy);
+    console.log(`Windows smoke environment verified: ${JSON.stringify(environment)}`);
+    await fs.cp(path.resolve(payloadDir), payloadCopy, { recursive: true, dereference: false, verbatimSymlinks: true });
     const nodeCopy = path.join(runtimeDir, 'gajae-app-server.exe');
     await fs.copyFile(path.resolve(nodePath), nodeCopy);
     await assertWindowsX64Executable(nodeCopy);
     for (const binary of ['bun.exe', 'gajae-core.exe']) await assertWindowsX64Executable(path.join(payloadCopy, 'dist-native', binary));
     await verifyManifest(payloadCopy);
-    const env = windowsSmokeEnvironment(runtimeDir, stateDir);
-    for (const directory of [stateDir, env.APPDATA, env.LOCALAPPDATA, env.XDG_CONFIG_HOME, env.XDG_DATA_HOME, env.XDG_CACHE_HOME, env.TEMP, env.WORKSPACES_ROOT, env.GJC_WORKER_AGENT_DIR]) {
-      await fs.mkdir(directory, { recursive: true });
-    }
     const checks = path.join(payloadCopy, '.gajae-windows-smoke.mjs');
     await fs.copyFile(fileURLToPath(new URL('./windows-server-smoke-checks.mjs', import.meta.url)), checks);
     await fs.copyFile(fileURLToPath(new URL('../../src-tauri/src/windows-server-bootstrap.cjs', import.meta.url)),
@@ -80,9 +104,17 @@ export async function smokeWindowsServer({ payloadDir, nodePath }) {
     await runGuardedSmoke({
       nodePath: nodeCopy, args: [checks, NODE_VERSION, BUN_VERSION], cwd: payloadCopy, env, jobRuntime,
     });
+  } catch (error) {
+    failure = error;
   } finally {
-    await fs.rm(temporaryDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
+    try { await fs.rm(temporaryDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }); }
+    catch (error) {
+      failure = failure
+        ? new AggregateError([failure, error], `${failure.message}\nSmoke directory cleanup also failed: ${error.message}`)
+        : error;
+    }
   }
+  if (failure) throw failure;
 }
 
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {