Fix two crashes that broke the WSL backend on a fresh install

- Bootstrap reader: attach an error listener to the readline Interface so
  the EAGAIN that the Linux pty bridge surfaces after stdin closes does not
  bubble up as an unhandled error and exit the backend with code 1 right
  after parsing the envelope. Guard the resume path so a late error fired
  before cleanup runs is a no-op.

- node-pty Linux prebuild: node-pty's npm tarball ships prebuilds for
  darwin/win32 only, so a Windows-side install has no pty.node the inner
  Linux process can load. On WSL backend startup, probe whether node-pty
  loads inside the distro and, if not, run \`node-gyp rebuild\` once via
  wsl.exe and stage the result in prebuilds/linux-x64/. Pipe the script
  through stdin to avoid wsl.exe's quote re-escaping.

Author: Jgratton24

apps/desktop/src/main.ts

@@ -58,6 +58,7 @@ import { showDesktopConfirmDialog } from "./confirmDialog.ts";
 import { resolveDesktopServerExposure } from "./serverExposure.ts";
 import {
   DISTRO_NAME_PATTERN,
+  ensureWslNodePty,
   extractDistroFromUncPath,
   isWslAvailable,
   listWslDistrosAsync,
@@ -1421,9 +1422,19 @@ async function startBackend(): Promise<boolean> {
     backendStartInFlight = new Promise<void>((resolve) => {
       resolveStartInFlight = resolve;
     });
-    let linuxEntry: string | null;
+    let linuxEntry: string | null = null;
+    let nodePtyError: string | null = null;
     try {
       linuxEntry = await windowsToWslPathAsync(wslConfig.distro, windowsEntry);
+      // node-pty's npm tarball ships prebuilds for darwin/win32 only, so a
+      // Windows-side install has no Linux pty.node. Build it once via
+      // node-gyp inside WSL before launching the backend.
+      if (!app.isPackaged) {
+        const result = await ensureWslNodePty(wslConfig.distro, ROOT_DIR);
+        if (!result.ok) {
+          nodePtyError = result.reason;
+        }
+      }
     } finally {
       backendStartInFlight = null;
       resolveStartInFlight();
@@ -1433,6 +1444,10 @@ async function startBackend(): Promise<boolean> {
       scheduleBackendRestart("wslpath conversion failed for backend entry");
       return false;
     }
+    if (nodePtyError !== null) {
+      scheduleBackendRestart(`WSL node-pty unavailable: ${nodePtyError}`);
+      return false;
+    }
 
     const wslForwardedEnv: Record<string, string> = {};
     const wslForwardedEnvNames: string[] = [];

apps/desktop/src/wsl.ts

@@ -172,6 +172,117 @@ export function resolveWslPickFolderDefaultPath(
   return homePath;
 }
 
+interface RunWslShellResult {
+  readonly exitCode: number;
+  readonly stderr: string;
+}
+
+// wsl.exe re-escapes args before forwarding them to the Linux side, which
+// mangles quotes inside `bash -lc "<script>"`. Pipe the script via stdin to
+// avoid passing it on the command line at all.
+function runWslShell(
+  distro: string | null,
+  bashScript: string,
+  timeoutMs: number,
+): Promise<RunWslShellResult> {
+  const distroArgs = distro ? ["-d", distro] : [];
+  return new Promise((resolve) => {
+    let child: ChildProcess.ChildProcess;
+    try {
+      child = ChildProcess.spawn(
+        "wsl.exe",
+        // -l so nvm/profile-managed tools (node, node-gyp) are on PATH;
+        // -s so bash reads the script from stdin instead of the command line.
+        [...distroArgs, "--", "bash", "-l", "-s"],
+        { stdio: ["pipe", "ignore", "pipe"], windowsHide: true },
+      );
+    } catch (error) {
+      resolve({ exitCode: 127, stderr: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+
+    let stderr = "";
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk: string) => {
+      stderr += chunk;
+    });
+
+    let settled = false;
+    const settle = (exitCode: number, extraStderr?: string) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolve({ exitCode, stderr: extraStderr ? `${stderr}${extraStderr}` : stderr });
+    };
+
+    const timeout = setTimeout(() => {
+      child.kill();
+      settle(124, "\n[timeout]");
+    }, timeoutMs);
+    timeout.unref();
+
+    child.on("error", (error) => settle(127, `\n${error.message}`));
+    child.on("close", (code) => settle(code ?? 1));
+
+    if (child.stdin) {
+      child.stdin.write(bashScript);
+      child.stdin.end();
+    } else {
+      settle(127, "\n[stdin pipe unavailable]");
+    }
+  });
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+export type EnsureWslNodePtyResult = { ok: true } | { ok: false; reason: string };
+
+// node-pty ships prebuilds for darwin/win32 only — Linux installs build from
+// source via node-gyp. When the desktop runs on Windows but launches the
+// backend through WSL, the inner Linux node loads modules from the Windows
+// node_modules tree, which has no Linux pty.node. This helper probes the
+// inner Linux side and, if missing, runs `node-gyp rebuild` once and stages
+// the result alongside the existing Windows/macOS prebuilds.
+export async function ensureWslNodePty(
+  distro: string | null,
+  windowsRepoRoot: string,
+): Promise<EnsureWslNodePtyResult> {
+  const linuxRepoRoot = await windowsToWslPathAsync(distro, windowsRepoRoot);
+  if (linuxRepoRoot === null) {
+    return { ok: false, reason: `wslpath conversion failed for ${windowsRepoRoot}` };
+  }
+
+  // node-pty lives in the apps/server workspace's node_modules; resolve from
+  // there rather than the monorepo root, where Bun's hoist layout omits it.
+  const linuxServerDir = `${linuxRepoRoot}/apps/server`;
+  const probe = await runWslShell(
+    distro,
+    `cd ${shellQuote(linuxServerDir)} && node -e 'require("node-pty")' >/dev/null 2>&1`,
+    10_000,
+  );
+  if (probe.exitCode === 0) return { ok: true };
+
+  const buildScript = [
+    "set -e",
+    `cd ${shellQuote(linuxServerDir)}`,
+    `pkg_dir=$(node -p "require('node:path').dirname(require.resolve('node-pty/package.json'))")`,
+    `cd "$pkg_dir"`,
+    "npx --yes node-gyp rebuild",
+    "mkdir -p prebuilds/linux-x64",
+    "cp build/Release/pty.node prebuilds/linux-x64/pty.node",
+  ].join("\n");
+
+  const build = await runWslShell(distro, buildScript, 5 * 60_000);
+  if (build.exitCode === 0) return { ok: true };
+  const trimmed = build.stderr.trim().slice(-500);
+  return {
+    ok: false,
+    reason: `node-pty Linux build failed (exit ${build.exitCode}): ${trimmed || "no stderr captured"}`,
+  };
+}
+
 export async function listWslDistrosAsync(): Promise<WslDistro[]> {
   if (process.platform !== "win32") return [];
   return new Promise((resolve) => {

apps/server/src/bootstrap.ts

@@ -31,8 +31,16 @@ export const readBootstrapEnvelope = Effect.fn("readBootstrapEnvelope")(function
       crlfDelay: Infinity,
     });
 
+    let settled = false;
+    const safeResume = (effect: Effect.Effect<Option.Option<A>, BootstrapError>) => {
+      if (settled) return;
+      settled = true;
+      resume(effect);
+    };
+
     const cleanup = () => {
       stream.removeListener("error", handleError);
+      input.removeListener("error", handleError);
       input.removeListener("line", handleLine);
       input.removeListener("close", handleClose);
       input.close();
@@ -41,10 +49,10 @@ export const readBootstrapEnvelope = Effect.fn("readBootstrapEnvelope")(function
 
     const handleError = (error: Error) => {
       if (isUnavailableBootstrapFdError(error)) {
-        resume(Effect.succeedNone);
+        safeResume(Effect.succeedNone);
         return;
       }
-      resume(
+      safeResume(
         Effect.fail(
           new BootstrapError({
             message: "Failed to read bootstrap envelope.",
@@ -57,9 +65,9 @@ export const readBootstrapEnvelope = Effect.fn("readBootstrapEnvelope")(function
     const handleLine = (line: string) => {
       const parsed = decodeJsonResult(schema)(line);
       if (Result.isSuccess(parsed)) {
-        resume(Effect.succeedSome(parsed.success));
+        safeResume(Effect.succeedSome(parsed.success));
       } else {
-        resume(
+        safeResume(
           Effect.fail(
             new BootstrapError({
               message: "Failed to decode bootstrap envelope.",
@@ -71,10 +79,14 @@ export const readBootstrapEnvelope = Effect.fn("readBootstrapEnvelope")(function
     };
 
     const handleClose = () => {
-      resume(Effect.succeedNone);
+      safeResume(Effect.succeedNone);
     };
 
     stream.once("error", handleError);
+    // The readline Interface re-emits stream errors; without a listener the
+    // process crashes. This shows up under the wsl.exe PTY bridge where the
+    // inner pipe surfaces EAGAIN after the parent closes stdin.
+    input.once("error", handleError);
     input.once("line", handleLine);
     input.once("close", handleClose);