Add desktop WSL backend mode

apps/desktop/src/backendReadiness.test.ts

@@ -10,6 +10,7 @@ describe("waitForHttpReady", () => {
   it("returns once the backend serves the requested readiness path", async () => {
     const fetchImpl = vi
       .fn<typeof fetch>()
+      .mockResolvedValueOnce(new Response(null, { status: 404 }))
       .mockResolvedValueOnce(new Response(null, { status: 503 }))
       .mockResolvedValueOnce(new Response(null, { status: 200 }));
 
@@ -19,7 +20,7 @@ describe("waitForHttpReady", () => {
       intervalMs: 0,
     });
 
-    expect(fetchImpl).toHaveBeenCalledTimes(2);
+    expect(fetchImpl).toHaveBeenCalledTimes(3);
     expect(fetchImpl).toHaveBeenNthCalledWith(
       1,
       "http://127.0.0.1:3773/",

apps/desktop/src/nodeEngineRange.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from "vitest";
+
+import { satisfiesNodeEngineRange } from "./nodeEngineRange.js";
+
+const SERVER_RANGE = "^22.16 || ^23.11 || >=24.10";
+
+describe("satisfiesNodeEngineRange", () => {
+  it("accepts versions inside ^22.16 caret range", () => {
+    expect(satisfiesNodeEngineRange("22.16.0", SERVER_RANGE)).toBe(true);
+    expect(satisfiesNodeEngineRange("22.20.5", SERVER_RANGE)).toBe(true);
+  });
+
+  it("rejects versions below the lowest accepted minor in a caret range", () => {
+    expect(satisfiesNodeEngineRange("22.15.99", SERVER_RANGE)).toBe(false);
+    expect(satisfiesNodeEngineRange("22.0.0", SERVER_RANGE)).toBe(false);
+  });
+
+  it("does not let a caret cross major versions", () => {
+    expect(satisfiesNodeEngineRange("23.0.0", "^22.16")).toBe(false);
+    expect(satisfiesNodeEngineRange("21.5.0", "^22.16")).toBe(false);
+  });
+
+  it("accepts versions above >=24.10 including future majors", () => {
+    expect(satisfiesNodeEngineRange("24.10.0", SERVER_RANGE)).toBe(true);
+    expect(satisfiesNodeEngineRange("24.14.0", SERVER_RANGE)).toBe(true);
+    expect(satisfiesNodeEngineRange("25.0.0", SERVER_RANGE)).toBe(true);
+  });
+
+  it("rejects versions below all alternatives", () => {
+    expect(satisfiesNodeEngineRange("18.20.0", SERVER_RANGE)).toBe(false);
+    expect(satisfiesNodeEngineRange("20.11.1", SERVER_RANGE)).toBe(false);
+    expect(satisfiesNodeEngineRange("21.7.3", SERVER_RANGE)).toBe(false);
+  });
+
+  it("strips a leading v from the version string", () => {
+    expect(satisfiesNodeEngineRange("v24.14.0", SERVER_RANGE)).toBe(true);
+  });
+
+  it("returns false on an unparseable version", () => {
+    expect(satisfiesNodeEngineRange("", SERVER_RANGE)).toBe(false);
+    expect(satisfiesNodeEngineRange("not-a-version", SERVER_RANGE)).toBe(false);
+  });
+
+  it("treats missing minor and patch as zero", () => {
+    expect(satisfiesNodeEngineRange("24", ">=24.10")).toBe(false);
+    expect(satisfiesNodeEngineRange("25", ">=24.10")).toBe(true);
+  });
+});

apps/desktop/src/nodeEngineRange.ts

@@ -0,0 +1,67 @@
+// Minimal semver-range checker for the engines.node ranges in our package
+// manifests (e.g. "^22.16 || ^23.11 || >=24.10"). Ported from the same logic
+// in PR #2504's REMOTE_NODE_ENGINE_CHECK_SCRIPT so the two paths stay aligned;
+// when whichever PR merges second extracts this into packages/shared, the
+// other side can drop its copy.
+
+interface ParsedVersion {
+  readonly major: number;
+  readonly minor: number;
+  readonly patch: number;
+}
+
+function parseVersion(value: string): ParsedVersion | null {
+  const match = value
+    .trim()
+    .replace(/^v/, "")
+    .match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2] ?? "0"),
+    patch: Number(match[3] ?? "0"),
+  };
+}
+
+function compare(left: ParsedVersion, right: ParsedVersion): number {
+  if (left.major !== right.major) return left.major > right.major ? 1 : -1;
+  if (left.minor !== right.minor) return left.minor > right.minor ? 1 : -1;
+  if (left.patch !== right.patch) return left.patch > right.patch ? 1 : -1;
+  return 0;
+}
+
+function satisfiesComparator(version: ParsedVersion, comparator: string): boolean {
+  const trimmed = comparator.trim();
+  if (!trimmed) return true;
+  const match = trimmed.match(/^(\^|>=|>|<=|<|=)?\s*v?(\d+(?:\.\d+){0,2})$/);
+  if (!match) return false;
+  const operator = match[1] ?? "=";
+  const target = parseVersion(match[2]!);
+  if (!target) return false;
+  const compared = compare(version, target);
+  switch (operator) {
+    case "^":
+      return version.major === target.major && compared >= 0;
+    case ">=":
+      return compared >= 0;
+    case ">":
+      return compared > 0;
+    case "<=":
+      return compared <= 0;
+    case "<":
+      return compared < 0;
+    case "=":
+      return compared === 0;
+    default:
+      return false;
+  }
+}
+
+export function satisfiesNodeEngineRange(version: string, range: string): boolean {
+  const parsed = parseVersion(version);
+  if (!parsed) return false;
+  return range.split("||").some((group) => {
+    const comparators = group.trim().split(/\s+/).filter(Boolean);
+    return comparators.length > 0 && comparators.every((c) => satisfiesComparator(parsed, c));
+  });
+}

apps/desktop/src/preload.ts

@@ -13,6 +13,9 @@ const UPDATE_SET_CHANNEL_CHANNEL = "desktop:update-set-channel";
 const UPDATE_CHECK_CHANNEL = "desktop:update-check";
 const UPDATE_DOWNLOAD_CHANNEL = "desktop:update-download";
 const UPDATE_INSTALL_CHANNEL = "desktop:update-install";
+const WSL_LIST_DISTROS_CHANNEL = "desktop:wsl-list-distros";
+const WSL_GET_CONFIG_CHANNEL = "desktop:wsl-get-config";
+const WSL_SET_CONFIG_CHANNEL = "desktop:wsl-set-config";
 const GET_APP_BRANDING_CHANNEL = "desktop:get-app-branding";
 const GET_LOCAL_ENVIRONMENT_BOOTSTRAP_CHANNEL = "desktop:get-local-environment-bootstrap";
 const GET_CLIENT_SETTINGS_CHANNEL = "desktop:get-client-settings";
@@ -133,6 +136,9 @@ contextBridge.exposeInMainWorld("desktopBridge", {
   checkForUpdate: () => ipcRenderer.invoke(UPDATE_CHECK_CHANNEL),
   downloadUpdate: () => ipcRenderer.invoke(UPDATE_DOWNLOAD_CHANNEL),
   installUpdate: () => ipcRenderer.invoke(UPDATE_INSTALL_CHANNEL),
+  wslListDistros: () => ipcRenderer.invoke(WSL_LIST_DISTROS_CHANNEL),
+  wslGetConfig: () => ipcRenderer.invoke(WSL_GET_CONFIG_CHANNEL),
+  wslSetConfig: (config) => ipcRenderer.invoke(WSL_SET_CONFIG_CHANNEL, config),
   onUpdateState: (listener) => {
     const wrappedListener = (_event: Electron.IpcRendererEvent, state: unknown) => {
       if (typeof state !== "object" || state === null) return;

apps/desktop/src/prepareWslNodePty.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import * as Path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import serverPackageJson from "../../server/package.json" with { type: "json" };
+import { ensureWslNodePty } from "./wsl.ts";
+
+const repoRoot = Path.resolve(Path.dirname(fileURLToPath(import.meta.url)), "../../..");
+
+if (process.platform !== "win32") {
+  console.error("prepare:wsl must be run from Windows so it can invoke wsl.exe.");
+  process.exit(1);
+}
+
+const result = await ensureWslNodePty(null, repoRoot, {
+  allowBuild: true,
+  nodeEngineRange: serverPackageJson.engines.node,
+});
+if (!result.ok) {
+  console.error(result.reason);
+  process.exit(1);
+}
+
+console.log("WSL node-pty is prepared for the default distro.");