fix(server): run provider updates with instance env on Windows

Author: Haplois

apps/server/src/provider/ProviderInstanceEnvironment.test.ts

@@ -18,4 +18,25 @@ describe("mergeProviderInstanceEnvironment", () => {
       PATH: "/bin",
     });
   });
+
+  it("merges overrides with canonical Windows PATH casing", () => {
+    expect(
+      mergeProviderInstanceEnvironment(
+        [
+          { name: "PATH", value: "C:\\Provider\\Bin", sensitive: false },
+          { name: "FOO", value: "bar", sensitive: false },
+        ],
+        {
+          Path: "C:\\Base\\Bin",
+          PaTh: "C:\\Odd\\Bin",
+          ComSpec: "C:\\Windows\\System32\\cmd.exe",
+        },
+        "win32",
+      ),
+    ).toEqual({
+      ComSpec: "C:\\Windows\\System32\\cmd.exe",
+      FOO: "bar",
+      PATH: "C:\\Provider\\Bin",
+    });
+  });
 });

apps/server/src/provider/ProviderInstanceEnvironment.ts

@@ -3,14 +3,39 @@ import type { ProviderInstanceEnvironment } from "@t3tools/contracts";
 export function mergeProviderInstanceEnvironment(
   environment: ProviderInstanceEnvironment | undefined,
   baseEnv: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
 ): NodeJS.ProcessEnv {
-  if (!environment || environment.length === 0) {
-    return baseEnv;
-  }
-
   const next: NodeJS.ProcessEnv = { ...baseEnv };
-  for (const variable of environment) {
+  for (const variable of environment ?? []) {
     next[variable.name] = variable.value;
   }
+
+  if (platform !== "win32") {
+    return next;
+  }
+
+  let pathValue: string | undefined;
+  for (const [name, value] of Object.entries(baseEnv)) {
+    if (name.toUpperCase() === "PATH" && pathValue === undefined) {
+      pathValue = value;
+      break;
+    }
+  }
+
+  for (const variable of environment ?? []) {
+    if (variable.name.toUpperCase() === "PATH") {
+      pathValue = variable.value;
+    }
+  }
+
+  for (const name of Object.keys(next)) {
+    if (name.toUpperCase() === "PATH") {
+      delete next[name];
+    }
+  }
+  if (pathValue !== undefined) {
+    next.PATH = pathValue;
+  }
+
   return next;
 }

apps/server/src/provider/providerMaintenance.test.ts

@@ -132,6 +132,17 @@ describe("providerMaintenance", () => {
     });
   });
 
+  it.effect("attaches provider environments to update commands", () =>
+    Effect.gen(function* () {
+      const capabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(packageToolUpdate, {
+        env: { PATH: "C:\\Tools" },
+      });
+
+      expect(capabilities.update?.env).toEqual({ PATH: "C:\\Tools" });
+      expect(capabilities.update?.command).toBe("npm install -g @example/package-tool@latest");
+    }).pipe(Effect.provide(NodeServices.layer)),
+  );
+
   it.effect(
     "switches package-managed providers to vite-plus updates when the resolved binary lives in vite-plus global bin",
     () =>

apps/server/src/provider/providerMaintenance.ts

@@ -27,6 +27,7 @@ export interface ProviderMaintenanceCommandAction {
   readonly executable: string;
   readonly args: ReadonlyArray<string>;
   readonly lockKey: string;
+  readonly env?: NodeJS.ProcessEnv;
 }
 
 export interface ProviderMaintenanceCapabilityResolutionOptions {
@@ -330,28 +331,27 @@ export const resolveProviderMaintenanceCapabilitiesEffect = Effect.fn(
   resolver: ProviderMaintenanceCapabilitiesResolver,
   options?: Omit<ProviderMaintenanceCapabilityResolutionOptions, "realCommandPath">,
 ) {
+  let nextOptions: ProviderMaintenanceCapabilityResolutionOptions | undefined = options;
   const binaryPath = nonEmptyString(options?.binaryPath);
-  if (!binaryPath) {
-    return resolver.resolve(options);
-  }
+  const resolvedCommandPath = binaryPath
+    ? (resolveCommandPath(binaryPath, {
+        ...(options?.platform ? { platform: options.platform } : {}),
+        ...(options?.env ? { env: options.env } : {}),
+      }) ?? (hasPathSeparator(binaryPath) ? binaryPath : null))
+    : null;
 
-  const resolvedCommandPath =
-    resolveCommandPath(binaryPath, {
-      ...(options?.platform ? { platform: options.platform } : {}),
-      ...(options?.env ? { env: options.env } : {}),
-    }) ?? (hasPathSeparator(binaryPath) ? binaryPath : null);
-  if (!resolvedCommandPath) {
-    return resolver.resolve(options);
+  if (resolvedCommandPath) {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const realCommandPath = yield* fileSystem
+      .realPath(resolvedCommandPath)
+      .pipe(Effect.catch(() => Effect.succeed(resolvedCommandPath)));
+    nextOptions = { ...options, realCommandPath };
   }
 
-  const fileSystem = yield* FileSystem.FileSystem;
-  const realCommandPath = yield* fileSystem
-    .realPath(resolvedCommandPath)
-    .pipe(Effect.catch(() => Effect.succeed(resolvedCommandPath)));
-  return resolver.resolve({
-    ...options,
-    realCommandPath,
-  });
+  const capabilities = resolver.resolve(nextOptions);
+  return options?.env && capabilities.update
+    ? { ...capabilities, update: { ...capabilities.update, env: options.env } }
+    : capabilities;
 });
 
 function deriveVersionAdvisory(input: {

apps/server/src/provider/providerMaintenanceRunner.test.ts

@@ -125,6 +125,10 @@ function mockSpawnerLayer(
   handler: (
     command: string,
     args: ReadonlyArray<string>,
+    options: {
+      readonly env?: NodeJS.ProcessEnv;
+      readonly shell?: boolean;
+    },
   ) => {
     readonly stdout?: string;
     readonly stderr?: string;
@@ -138,8 +142,14 @@ function mockSpawnerLayer(
       const childProcess = command as unknown as {
         readonly command: string;
         readonly args: ReadonlyArray<string>;
+        readonly options?: {
+          readonly env?: NodeJS.ProcessEnv;
+          readonly shell?: boolean;
+        };
       };
-      return Effect.succeed(mockHandle(handler(childProcess.command, childProcess.args)));
+      return Effect.succeed(
+        mockHandle(handler(childProcess.command, childProcess.args, childProcess.options ?? {})),
+      );
     }),
   );
 }
@@ -240,7 +250,16 @@ describe("providerMaintenanceRunner", () => {
   });
 
   it.effect("uses the resolved provider capabilities when choosing the update executable", () => {
-    const calls: Array<{ command: string; args: ReadonlyArray<string> }> = [];
+    const updateEnv = {
+      PATH: "C:\\Provider\\Bin",
+      FOO: "bar",
+    };
+    const calls: Array<{
+      command: string;
+      args: ReadonlyArray<string>;
+      env?: NodeJS.ProcessEnv;
+      shell?: boolean;
+    }> = [];
     return Effect.gen(function* () {
       const { registry } = yield* makeRegistry({
         ...baseProvider,
@@ -257,30 +276,39 @@ describe("providerMaintenanceRunner", () => {
       const updater = yield* makeTestRunner({
         ...registry,
         getProviderMaintenanceCapabilitiesForInstance: () =>
-          Effect.succeed(
-            makeProviderMaintenanceCapabilities({
-              provider: CODEX_DRIVER,
-              packageName: "@openai/codex",
-              updateExecutable: "bun",
-              updateArgs: ["i", "-g", "@openai/codex@latest"],
-              updateLockKey: "bun-global",
-            }),
-          ),
+          Effect.succeed({
+            provider: CODEX_DRIVER,
+            packageName: "@openai/codex",
+            update: {
+              command: "bun i -g @openai/codex@latest",
+              executable: "bun",
+              args: ["i", "-g", "@openai/codex@latest"],
+              lockKey: "bun-global",
+              env: updateEnv,
+            },
+          }),
       });
 
       yield* updater.updateProvider(CODEX_DRIVER);
       assert.deepStrictEqual(calls, [
         {
           command: "bun",
           args: ["i", "-g", "@openai/codex@latest"],
+          env: updateEnv,
+          ...(process.platform === "win32" ? { shell: true } : {}),
         },
       ]);
     }).pipe(
       Effect.provide(
         Layer.mergeAll(
           latestVersionHttpClient("0.0.0"),
-          mockSpawnerLayer((command, args) => {
-            calls.push({ command, args });
+          mockSpawnerLayer((command, args, options) => {
+            calls.push({
+              command,
+              args,
+              ...(options.env ? { env: options.env } : {}),
+              ...(options.shell !== undefined ? { shell: options.shell } : {}),
+            });
             return { stdout: "updated" };
           }),
         ),

apps/server/src/provider/providerMaintenanceRunner.ts

@@ -72,11 +72,17 @@ const runProviderMaintenanceCommandWithSpawner = Effect.fn("ProviderMaintenanceR
     readonly spawner: ChildProcessSpawner.ChildProcessSpawner["Service"];
     readonly command: string;
     readonly args: ReadonlyArray<string>;
+    readonly env?: NodeJS.ProcessEnv;
   }) {
     const collectCommandResult = Effect.fn("ProviderMaintenanceRunner.collectCommandResult")(
       function* () {
         const child = yield* input.spawner
-          .spawn(ChildProcess.make(input.command, [...input.args]))
+          .spawn(
+            ChildProcess.make(input.command, [...input.args], {
+              ...(input.env ? { env: input.env } : {}),
+              ...(process.platform === "win32" ? { shell: true } : {}),
+            }),
+          )
           .pipe(
             Effect.mapError(
               (cause) =>
@@ -194,12 +200,6 @@ export const make = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
   const providerRegistry = yield* ProviderRegistry;
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
   const httpClient = yield* HttpClient.HttpClient;
-  const runMaintenanceCommand = (command: string, args: ReadonlyArray<string>) =>
-    runProviderMaintenanceCommandWithSpawner({
-      spawner,
-      command,
-      args,
-    });
   const commandCoordinator = yield* makeProviderMaintenanceCommandCoordinator({
     makeAlreadyRunningError: () =>
       new ServerProviderUpdateError({
@@ -330,7 +330,12 @@ export const make = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
               }),
             );
 
-            const result = yield* runMaintenanceCommand(update.executable, update.args);
+            const result = yield* runProviderMaintenanceCommandWithSpawner({
+              spawner,
+              command: update.executable,
+              args: update.args,
+              ...(update.env ? { env: update.env } : {}),
+            });
             const finishedAt = yield* nowIso;
             if (result.timedOut || result.exitCode !== 0) {
               return yield* finish(