youpele52
diff --git a/‎apps/desktop/src/backend/backendManager.ts‎
Lines changed: 39 additions & 8 deletions b/‎apps/desktop/src/backend/backendManager.ts‎
Lines changed: 39 additions & 8 deletions
diff --git a/‎apps/desktop/src/env/pathResolver.platform.test.ts‎
Lines changed: 80 additions & 0 deletions b/‎apps/desktop/src/env/pathResolver.platform.test.ts‎
Lines changed: 80 additions & 0 deletions
diff --git a/‎apps/desktop/src/env/pathResolver.platform.ts‎
Lines changed: 109 additions & 0 deletions b/‎apps/desktop/src/env/pathResolver.platform.ts‎
Lines changed: 109 additions & 0 deletions
@@ -7,13 +7,44 @@ import {
   writeBackendSessionBoundary,
 } from "../logging/logging";
 import {
-  ensureBackendModulesSymlink,
+  ensureBackendModulesPath,
   resolveBackendCwd,
   resolveBackendEntry,
 } from "../env/pathResolver";
 import type { RotatingFileSink } from "@bigcode/shared/logging";
 import { readPersistedBackendObservabilitySettings } from "../logging/logging";
 
+// ---------------------------------------------------------------------------
+// Windows-safe process termination
+// ---------------------------------------------------------------------------
+
+/**
+ * Kills a child process in a platform-safe way.
+ *
+ * On Windows, `child.kill()` only terminates the top-level process — it does
+ * NOT kill the process tree.  If the child was spawned with `shell: true` it
+ * also leaves the real process running behind a `cmd.exe` wrapper.
+ * `taskkill /T /F` terminates the entire tree reliably on all Windows versions.
+ *
+ * On POSIX we fall back to standard signal delivery.
+ */
+function killBackendProcess(
+  child: ChildProcess.ChildProcess,
+  signal: NodeJS.Signals = "SIGTERM",
+): void {
+  if (process.platform === "win32" && child.pid !== undefined) {
+    try {
+      ChildProcess.spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+        stdio: "ignore",
+      });
+      return;
+    } catch {
+      // taskkill unavailable — fall through to direct kill.
+    }
+  }
+  child.kill(signal);
+}
+
 // ---------------------------------------------------------------------------
 // Module-level state
 // ---------------------------------------------------------------------------
@@ -107,9 +138,9 @@ export function startBackend(): void {
   const backendLogSink = _deps.getBackendLogSink();
   const captureBackendLogs = backendLogSink !== null;
 
-  // Ensure _modules → node_modules symlink exists for ESM resolution of
+  // Ensure _modules → node_modules link exists for ESM resolution of
   // external native packages (e.g. @github/copilot-sdk, node-pty).
-  ensureBackendModulesSymlink();
+  ensureBackendModulesPath();
 
   // Always pipe stderr so we can capture crash output for diagnostics,
   // regardless of whether a log sink is configured.
@@ -161,7 +192,7 @@ export function startBackend(): void {
     );
     bootstrapStream.end();
   } else {
-    child.kill("SIGTERM");
+    killBackendProcess(child);
     scheduleBackendRestart("missing desktop bootstrap pipe");
     return;
   }
@@ -221,10 +252,10 @@ export function stopBackend(): void {
 
   if (child.exitCode === null && child.signalCode === null) {
     expectedBackendExitChildren.add(child);
-    child.kill("SIGTERM");
+    killBackendProcess(child);
     setTimeout(() => {
       if (child.exitCode === null && child.signalCode === null) {
-        child.kill("SIGKILL");
+        killBackendProcess(child, "SIGKILL");
       }
     }, 2_000).unref();
   }
@@ -266,11 +297,11 @@ export async function stopBackendAndWaitForExit(timeoutMs = 5_000): Promise<void
     }
 
     backendChild.once("exit", onExit);
-    backendChild.kill("SIGTERM");
+    killBackendProcess(backendChild);
 
     forceKillTimer = setTimeout(() => {
       if (backendChild.exitCode === null && backendChild.signalCode === null) {
-        backendChild.kill("SIGKILL");
+        killBackendProcess(backendChild, "SIGKILL");
       }
     }, 2_000);
     forceKillTimer.unref();
 
@@ -0,0 +1,80 @@
+import * as Path from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import { resolveBackendModulesLinkPlan } from "./pathResolver.platform";
+
+describe("resolveBackendModulesLinkPlan", () => {
+  const resourcesPath = "/Applications/bigCode.app/Contents/Resources";
+
+  describe("Windows (win32)", () => {
+    it("returns junction link type", () => {
+      const plan = resolveBackendModulesLinkPlan("win32", resourcesPath);
+      expect(plan.linkType).toBe("junction");
+    });
+
+    it("uses absolute modulesDir as linkTarget", () => {
+      const plan = resolveBackendModulesLinkPlan("win32", resourcesPath);
+      expect(Path.isAbsolute(plan.linkTarget)).toBe(true);
+      expect(plan.linkTarget).toBe(plan.modulesDir);
+    });
+
+    it("computes correct paths from resourcesPath", () => {
+      const plan = resolveBackendModulesLinkPlan("win32", resourcesPath);
+      expect(plan.serverDir).toBe(Path.join(resourcesPath, "server"));
+      expect(plan.modulesDir).toBe(Path.join(resourcesPath, "server", "_modules"));
+      expect(plan.nodeModulesPath).toBe(Path.join(resourcesPath, "server", "node_modules"));
+    });
+  });
+
+  describe("macOS (darwin)", () => {
+    it("returns dir link type", () => {
+      const plan = resolveBackendModulesLinkPlan("darwin", resourcesPath);
+      expect(plan.linkType).toBe("dir");
+    });
+
+    it("uses relative _modules as linkTarget", () => {
+      const plan = resolveBackendModulesLinkPlan("darwin", resourcesPath);
+      expect(plan.linkTarget).toBe("_modules");
+      expect(Path.isAbsolute(plan.linkTarget)).toBe(false);
+    });
+
+    it("computes correct paths from resourcesPath", () => {
+      const plan = resolveBackendModulesLinkPlan("darwin", resourcesPath);
+      expect(plan.serverDir).toBe(Path.join(resourcesPath, "server"));
+      expect(plan.modulesDir).toBe(Path.join(resourcesPath, "server", "_modules"));
+      expect(plan.nodeModulesPath).toBe(Path.join(resourcesPath, "server", "node_modules"));
+    });
+  });
+
+  describe("Linux (linux)", () => {
+    it("returns dir link type", () => {
+      const plan = resolveBackendModulesLinkPlan("linux", resourcesPath);
+      expect(plan.linkType).toBe("dir");
+    });
+
+    it("uses relative _modules as linkTarget", () => {
+      const plan = resolveBackendModulesLinkPlan("linux", resourcesPath);
+      expect(plan.linkTarget).toBe("_modules");
+      expect(Path.isAbsolute(plan.linkTarget)).toBe(false);
+    });
+
+    it("computes correct paths from resourcesPath", () => {
+      const plan = resolveBackendModulesLinkPlan("linux", resourcesPath);
+      expect(plan.serverDir).toBe(Path.join(resourcesPath, "server"));
+      expect(plan.modulesDir).toBe(Path.join(resourcesPath, "server", "_modules"));
+      expect(plan.nodeModulesPath).toBe(Path.join(resourcesPath, "server", "node_modules"));
+    });
+  });
+
+  describe("Windows with Windows-style paths", () => {
+    const winResourcesPath = "C:\\Program Files\\bigCode\\resources";
+
+    it("produces absolute Windows junction target", () => {
+      const plan = resolveBackendModulesLinkPlan("win32", winResourcesPath);
+      expect(plan.linkType).toBe("junction");
+      expect(plan.linkTarget).toBe(plan.modulesDir);
+      expect(plan.modulesDir).toBe(Path.join(winResourcesPath, "server", "_modules"));
+    });
+  });
+});
@@ -0,0 +1,109 @@
+/**
+ * Pure, platform-aware backend module path resolver.
+ *
+ * This module is the single place that decides HOW `_modules` is made visible
+ * to the packaged backend's Node.js ESM resolver as `node_modules`.
+ *
+ * ## Background
+ *
+ * electron-builder silently strips directories named `node_modules` from
+ * `extraResources` copies.  The build script works around this by renaming
+ * the server's `node_modules` to `_modules` before electron-builder runs.
+ * At runtime the desktop main process must recreate a path that Node.js ESM
+ * resolution can find (it walks up the directory tree looking for
+ * `node_modules/`).  `NODE_PATH` is NOT used because Node.js ESM ignores it —
+ * only CJS honours `NODE_PATH`.
+ *
+ * ## Strategy by platform
+ *
+ * | Platform      | Link type  | Target format |
+ * |---------------|------------|---------------|
+ * | macOS / Linux | `dir`      | relative       |
+ * | Windows       | `junction` | absolute       |
+ *
+ * Windows directory symlinks require Developer Mode or admin privileges, so
+ * we use NTFS **junctions** instead.  Junctions:
+ * - Do NOT require elevated privileges or Developer Mode on any modern Windows.
+ * - Must point to an **absolute** path on the same NTFS volume.
+ * - Are NOT traversed across volumes (fine here — both sides are inside the
+ *   app's `Resources/` directory).
+ *
+ * If junction creation also fails (unlikely, but defensive), the plan includes
+ * a `fallback` strategy:  copy `_modules` to `node_modules` so the packaged
+ * backend can always start.  This is heavier but ensures correctness on
+ * locked-down machines.
+ */
+
+import * as Path from "node:path";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/**
+ * The link type passed to `fs.symlinkSync` / `fs.symlink`.
+ * `"junction"` is a Windows-only NTFS junction (no privilege needed).
+ * `"dir"` is a standard directory symlink (POSIX standard).
+ */
+export type ModuleLinkType = "junction" | "dir";
+
+/**
+ * The complete plan for making `_modules` resolvable as `node_modules`.
+ * The plan is pure data; execution is handled by `ensureBackendModulesPath`.
+ */
+export interface BackendModulesLinkPlan {
+  /** Absolute path to the server directory inside `Resources/`. */
+  readonly serverDir: string;
+  /** Absolute path to the `_modules` directory that was staged by the build. */
+  readonly modulesDir: string;
+  /** Absolute path where `node_modules` should appear. */
+  readonly nodeModulesPath: string;
+  /**
+   * The value passed as the `target` argument to `fs.symlinkSync`.
+   * - POSIX: relative string `"_modules"` (keeps bundle relocatable).
+   * - Windows: absolute path to `_modules` (junctions require absolute targets).
+   */
+  readonly linkTarget: string;
+  /** The `type` argument for `fs.symlinkSync`. */
+  readonly linkType: ModuleLinkType;
+}
+
+// ---------------------------------------------------------------------------
+// Pure resolver (no I/O, fully testable)
+// ---------------------------------------------------------------------------
+
+/**
+ * Computes a `BackendModulesLinkPlan` for the given platform.
+ *
+ * @param platform   `process.platform` value (`"win32"`, `"darwin"`, `"linux"`, …)
+ * @param resourcesPath  The Electron `process.resourcesPath` value for packaged
+ *                       builds, or any directory in dev contexts.
+ */
+export function resolveBackendModulesLinkPlan(
+  platform: string,
+  resourcesPath: string,
+): BackendModulesLinkPlan {
+  const serverDir = Path.join(resourcesPath, "server");
+  const modulesDir = Path.join(serverDir, "_modules");
+  const nodeModulesPath = Path.join(serverDir, "node_modules");
+
+  if (platform === "win32") {
+    // Windows junctions must point to an absolute target.
+    return {
+      serverDir,
+      modulesDir,
+      nodeModulesPath,
+      linkTarget: modulesDir,
+      linkType: "junction",
+    };
+  }
+
+  // macOS / Linux: use a relative symlink so the .app bundle stays relocatable.
+  return {
+    serverDir,
+    modulesDir,
+    nodeModulesPath,
+    linkTarget: "_modules",
+    linkType: "dir",
+  };
+}