fix(desktop): preserve existing WSLENV entries

Author: Jgratton24

apps/desktop/src/backend/DesktopBackendConfiguration.test.ts

@@ -3,6 +3,7 @@ import { assert, describe, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 
 import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
@@ -43,12 +44,13 @@ function makeEnvironmentLayer(
   options?: {
     readonly isPackaged?: boolean;
     readonly devServerUrl?: string;
+    readonly platform?: NodeJS.Platform;
   },
 ) {
   return DesktopEnvironment.layer({
     dirname: "/repo/apps/desktop/src",
     homeDirectory: baseDir,
-    platform: "darwin",
+    platform: options?.platform ?? "darwin",
     processArch: "x64",
     appVersion: "1.2.3",
     appPath: "/repo",
@@ -71,6 +73,14 @@ function makeEnvironmentLayer(
   );
 }
 
+const restoreEnv = (name: string, value: string | undefined) => {
+  if (value === undefined) {
+    delete process.env[name];
+  } else {
+    process.env[name] = value;
+  }
+};
+
 const withHarness = <A, E, R>(
   effect: Effect.Effect<
     A,
@@ -198,4 +208,58 @@ describe("DesktopBackendConfiguration", () => {
       );
     }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
   );
+
+  it.effect("preserves existing WSLENV entries when forwarding WSL backend secrets", () =>
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const baseDir = yield* fileSystem.makeTempDirectoryScoped({
+        prefix: "t3-desktop-backend-config-test-",
+      });
+
+      const previousWslEnv = process.env.WSLENV;
+      const previousOpenAiKey = process.env.OPENAI_API_KEY;
+      const previousAnthropicKey = process.env.ANTHROPIC_API_KEY;
+      try {
+        process.env.WSLENV = "GOPATH/p:OPENAI_API_KEY/u:EMPTY::AZURE_DEVOPS_EXT_PAT/u";
+        process.env.OPENAI_API_KEY = "openai-key";
+        process.env.ANTHROPIC_API_KEY = "anthropic-key";
+
+        yield* Effect.gen(function* () {
+          const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
+          const config = yield* configuration.resolve;
+
+          assert.equal(config.executablePath, "wsl.exe");
+          assert.equal(config.env.OPENAI_API_KEY, "openai-key");
+          assert.equal(config.env.ANTHROPIC_API_KEY, "anthropic-key");
+          assert.equal(
+            config.env.WSLENV,
+            "GOPATH/p:OPENAI_API_KEY/u:EMPTY:AZURE_DEVOPS_EXT_PAT/u:ANTHROPIC_API_KEY",
+          );
+        }).pipe(
+          Effect.provide(
+            DesktopBackendConfiguration.layer.pipe(
+              Layer.provideMerge(serverExposureLayer),
+              Layer.provideMerge(
+                DesktopAppSettings.layerTest({
+                  ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
+                  wslMode: "wsl",
+                }),
+              ),
+              Layer.provideMerge(
+                DesktopWslEnvironment.layerTest({
+                  isAvailable: true,
+                  windowsToWslPath: () => Option.some("/mnt/c/repo/apps/server/src/index.ts"),
+                }),
+              ),
+              Layer.provideMerge(makeEnvironmentLayer(baseDir, { platform: "win32" })),
+            ),
+          ),
+        );
+      } finally {
+        restoreEnv("WSLENV", previousWslEnv);
+        restoreEnv("OPENAI_API_KEY", previousOpenAiKey);
+        restoreEnv("ANTHROPIC_API_KEY", previousAnthropicKey);
+      }
+    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
+  );
 });

apps/desktop/src/backend/DesktopBackendConfiguration.ts

@@ -57,6 +57,39 @@ const WSL_FORWARDED_ENV_NAMES = ["OPENAI_API_KEY", "ANTHROPIC_API_KEY"] as const
 const backendChildEnvPatch = (): Record<string, string | undefined> =>
   Object.fromEntries(DESKTOP_BACKEND_ENV_NAMES.map((name) => [name, undefined]));
 
+const getWslEnvEntryName = (entry: string): string => {
+  const slashIndex = entry.indexOf("/");
+  return slashIndex === -1 ? entry : entry.slice(0, slashIndex);
+};
+
+const mergeWslEnv = (
+  existingWslEnv: string | undefined,
+  forwardedEnvNames: ReadonlyArray<string>,
+): string | undefined => {
+  const entries: string[] = [];
+  const seenNames = new Set<string>();
+
+  for (const rawEntry of existingWslEnv?.split(":") ?? []) {
+    const entry = rawEntry.trim();
+    if (entry.length === 0) continue;
+
+    const name = getWslEnvEntryName(entry);
+    if (name.length === 0 || seenNames.has(name)) continue;
+
+    seenNames.add(name);
+    entries.push(entry);
+  }
+
+  for (const name of forwardedEnvNames) {
+    if (seenNames.has(name)) continue;
+
+    seenNames.add(name);
+    entries.push(name);
+  }
+
+  return entries.length > 0 ? entries.join(":") : undefined;
+};
+
 const { logWarning: logBackendConfigurationWarning } = DesktopObservability.makeComponentLogger(
   "desktop-backend-configuration",
 );
@@ -249,7 +282,6 @@ const resolveBackendStartConfig = Effect.fn("desktop.backendConfiguration.resolv
         forwardedEnvNames.push(name);
       }
     }
-    const wslEnvNames = [...new Set(forwardedEnvNames)];
 
     // Build an explicit copy of process.env minus T3CODE_HOME (dev-runner
     // exports the Windows-side base dir for the local backend; if it leaks
@@ -261,6 +293,7 @@ const resolveBackendStartConfig = Effect.fn("desktop.backendConfiguration.resolv
       if (key === "T3CODE_HOME") continue;
       parentEnvWithoutT3Home[key] = value;
     }
+    const wslEnv = mergeWslEnv(parentEnvWithoutT3Home.WSLENV, forwardedEnvNames);
 
     const baseConfig = {
       executablePath: "wsl.exe",
@@ -270,7 +303,7 @@ const resolveBackendStartConfig = Effect.fn("desktop.backendConfiguration.resolv
         ...parentEnvWithoutT3Home,
         ...backendChildEnvPatch(),
         ...forwardedEnv,
-        ...(wslEnvNames.length > 0 ? { WSLENV: wslEnvNames.join(":") } : {}),
+        ...(wslEnv !== undefined ? { WSLENV: wslEnv } : {}),
       },
       // env is already a complete process.env minus T3CODE_HOME; pass it
       // verbatim instead of letting the spawner re-merge process.env on top.