Address third WSL Bugbot review pass

- Drain in-flight startBackend before stopBackendAndWaitForExit so a WSL
  config update no longer races past a restart that is awaiting wslpath
  and throws a misleading error while the in-flight call spawns with
  stale config.
- Run wslpath inside the distro the user actually picked when they
  select a path under \wsl.localhost\<distro>\... rather than
  always using wslConfig.distro, so multi-distro setups convert
  correctly.
- Revert DEFAULT_TIMEOUT_MS in backendReadiness back to 30s; the only
  caller passes 60s explicitly, so the 5-minute default served no
  purpose and risked silently slowing future callers.
- Cover extractDistroFromUncPath in wsl.test.ts.

Author: Jgratton24

apps/desktop/src/backendReadiness.ts

@@ -8,7 +8,7 @@ export interface WaitForHttpReadyOptions {
   readonly isReady?: (response: Response) => boolean;
 }
 
-const DEFAULT_TIMEOUT_MS = 300_000;
+const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_INTERVAL_MS = 100;
 const DEFAULT_REQUEST_TIMEOUT_MS = 1_000;
 

apps/desktop/src/main.ts

@@ -58,6 +58,7 @@ import { showDesktopConfirmDialog } from "./confirmDialog.ts";
 import { resolveDesktopServerExposure } from "./serverExposure.ts";
 import {
   DISTRO_NAME_PATTERN,
+  extractDistroFromUncPath,
   isWslAvailable,
   listWslDistrosAsync,
   loadWslConfig,
@@ -215,7 +216,7 @@ type LinuxDesktopNamedApp = Electron.App & {
 
 let mainWindow: BrowserWindow | null = null;
 let backendProcess: ChildProcess.ChildProcess | null = null;
-let backendStartInFlight = false;
+let backendStartInFlight: Promise<void> | null = null;
 let backendPort = 0;
 let backendBindHost = DESKTOP_LOOPBACK_HOST;
 let backendBootstrapToken = "";
@@ -1416,12 +1417,16 @@ async function startBackend(): Promise<boolean> {
       scheduleBackendRestart(`missing server entry at ${windowsEntry}`);
       return false;
     }
-    backendStartInFlight = true;
+    let resolveStartInFlight!: () => void;
+    backendStartInFlight = new Promise<void>((resolve) => {
+      resolveStartInFlight = resolve;
+    });
     let linuxEntry: string | null;
     try {
       linuxEntry = await windowsToWslPathAsync(wslConfig.distro, windowsEntry);
     } finally {
-      backendStartInFlight = false;
+      backendStartInFlight = null;
+      resolveStartInFlight();
     }
     if (isQuitting || backendProcess) return false;
     if (linuxEntry === null) {
@@ -1576,6 +1581,15 @@ function stopBackend(): void {
 }
 
 async function stopBackendAndWaitForExit(timeoutMs = 5_000): Promise<void> {
+  // Drain any in-flight startBackend (e.g. an exponential-backoff restart still
+  // awaiting wslpath) so backendProcess reflects either a fully spawned child
+  // we should kill or a failed start. Otherwise a config update can race past
+  // the in-flight call and throw a misleading error while a backend still
+  // launches with stale config.
+  const inFlight = backendStartInFlight;
+  if (inFlight) {
+    await inFlight;
+  }
   cancelBackendReadinessWait();
   backendListeningDetector = null;
   if (restartTimer) {
@@ -1767,7 +1781,11 @@ function registerIpcHandlers(): void {
     const pickedPath = result.filePaths[0] ?? null;
     if (pickedPath === null) return null;
     if (!useWsl) return pickedPath;
-    const wslPath = await windowsToWslPathAsync(wslConfig.distro, pickedPath);
+    // If the user picked under \\wsl.localhost\<distro>\..., run wslpath inside
+    // that distro instead of the configured one — otherwise the conversion
+    // either fails or yields a path that points at the wrong filesystem.
+    const targetDistro = extractDistroFromUncPath(pickedPath) ?? wslConfig.distro;
+    const wslPath = await windowsToWslPathAsync(targetDistro, pickedPath);
     if (wslPath === null) {
       throw new Error("Could not convert the selected folder path for WSL.");
     }

apps/desktop/src/wsl.test.ts

@@ -6,6 +6,7 @@ import * as OS from "node:os";
 import { Readable } from "node:stream";
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import {
+  extractDistroFromUncPath,
   parseWslDistroList,
   loadWslConfig,
   resolveWslHomeUncPath,
@@ -114,6 +115,26 @@ describe("windowsToWslPathAsync", () => {
   });
 });
 
+describe("extractDistroFromUncPath", () => {
+  it("extracts the distro from \\\\wsl.localhost UNC paths", () => {
+    expect(extractDistroFromUncPath("\\\\wsl.localhost\\Ubuntu-22.04\\home\\josh")).toBe(
+      "Ubuntu-22.04",
+    );
+  });
+
+  it("extracts the distro from the legacy \\\\wsl$ UNC paths", () => {
+    expect(extractDistroFromUncPath("\\\\wsl$\\Debian\\home\\josh")).toBe("Debian");
+  });
+
+  it("returns null for non-UNC Windows paths", () => {
+    expect(extractDistroFromUncPath("C:\\Users\\Josh\\project")).toBeNull();
+  });
+
+  it("returns null when the segment is not a valid distro name", () => {
+    expect(extractDistroFromUncPath("\\\\wsl.localhost\\bad name!\\home")).toBeNull();
+  });
+});
+
 describe("resolveWslHomeUncPath", () => {
   const distros = [
     { name: "Debian", isDefault: true, version: 2 as const },

apps/desktop/src/wsl.ts

@@ -51,6 +51,16 @@ export function parseWslDistroList(stdout: Buffer): WslDistro[] {
   return distros;
 }
 
+// Recognizes \\wsl.localhost\<distro>\... and the legacy \\wsl$\<distro>\... so
+// `wslpath` can be invoked inside the distro that actually owns the path,
+// rather than whichever distro is configured for the desktop backend.
+export function extractDistroFromUncPath(windowsPath: string): string | null {
+  const match = /^\\\\(?:wsl\.localhost|wsl\$)\\([^\\]+)/i.exec(windowsPath);
+  if (!match) return null;
+  const candidate = match[1]!;
+  return DISTRO_NAME_PATTERN.test(candidate) ? candidate : null;
+}
+
 export function windowsToWslPathAsync(
   distro: string | null,
   windowsPath: string,