fix(cli): canonicalize Windows PATH env key so local builds find bun

On Windows the PATH variable is typically keyed as `Path` (its registry
casing). The compute SDK spreads process.env into a plain, case-sensitive
object when it prepends node_modules/.bin directories for a local build,
so `baseEnv.PATH` reads undefined: the rebuilt PATH drops every inherited
entry and is written as a second, truncated `PATH` key next to `Path`. In
the spawned shell's case-insensitive environment block the truncated key
wins, and `bun run build` fails with "'bun' is not recognized as an
internal or external command" even though Bun is installed and on Path.

Collapse case-variants of PATH into the canonical `PATH` key at CLI
startup, before any command delegates to the SDK. Windows resolves
environment variables case-insensitively, so the rename is invisible to
this process and its children.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ankur-arch

packages/cli/src/cli.ts

@@ -23,6 +23,7 @@ import {
   writeJsonError,
   writeJsonSuccess,
 } from "./shell/output";
+import { canonicalizeWindowsPathKey } from "./shell/path-env";
 import { disposePromptState } from "./shell/prompt";
 import {
   type CliRuntime,
@@ -37,6 +38,11 @@ export interface RunCliOptions extends Partial<CliRuntime> {
 }
 
 export async function runCli(options: RunCliOptions = {}): Promise<number> {
+  // The compute SDK spreads process.env into plain objects when building the
+  // environment for local build subprocesses; a Windows `Path` key breaks
+  // that (see canonicalizeWindowsPathKey), so normalize before any command.
+  canonicalizeWindowsPathKey(process.env);
+
   const runtime = resolveRuntime(options);
   const program = createProgram(runtime);
   process.exitCode = 0;

packages/cli/src/shell/path-env.ts

@@ -0,0 +1,44 @@
+/**
+ * Collapses case-variant spellings of the `PATH` environment variable into
+ * the canonical `PATH` key, in place. No-op outside Windows.
+ *
+ * Windows typically keys the variable as `Path` (its registry casing), and
+ * `process.env` papers over that with case-insensitive lookups. Anything that
+ * spreads `process.env` into a plain object — the compute SDK does this when
+ * it prepends `node_modules/.bin` directories for a local build — loses that
+ * case-insensitivity: reading `env.PATH` returns undefined, so the rewritten
+ * PATH drops every inherited entry, and writing `env.PATH` forks a second key
+ * alongside `Path`. The child's environment block is case-insensitive again,
+ * so the truncated `PATH` clobbers the real `Path` and the spawned build
+ * cannot resolve commands like `bun` ("'bun' is not recognized ...").
+ *
+ * Windows itself resolves environment variables case-insensitively, so
+ * renaming the key to `PATH` is invisible to this process and its children.
+ */
+export function canonicalizeWindowsPathKey(
+  env: NodeJS.ProcessEnv,
+  platform: NodeJS.Platform = process.platform,
+): void {
+  if (platform !== "win32") {
+    return;
+  }
+
+  const variants = Object.keys(env).filter(
+    (key) => key.toUpperCase() === "PATH" && key !== "PATH",
+  );
+  if (variants.length === 0) {
+    return;
+  }
+
+  // On the real Windows process.env, `env.PATH` already resolves the `Path`
+  // entry case-insensitively; a plain-object copy needs the variant lookup.
+  const value = env.PATH ?? env[variants[0]];
+  for (const variant of variants) {
+    delete env[variant];
+  }
+  // On process.env the deletes above also remove the case-insensitive `PATH`
+  // entry itself, so always write the canonical key back.
+  if (value !== undefined) {
+    env.PATH = value;
+  }
+}

packages/cli/tests/path-env.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+
+import { canonicalizeWindowsPathKey } from "../src/shell/path-env";
+
+describe("canonicalizeWindowsPathKey", () => {
+  it("renames the Windows registry-cased Path key to PATH", () => {
+    const env: NodeJS.ProcessEnv = {
+      Path: "C:\\Windows\\System32;C:\\Users\\flo\\.bun\\bin",
+      ComSpec: "C:\\Windows\\System32\\cmd.exe",
+    };
+
+    canonicalizeWindowsPathKey(env, "win32");
+
+    expect(Object.keys(env).sort()).toEqual(["ComSpec", "PATH"]);
+    expect(env.PATH).toBe("C:\\Windows\\System32;C:\\Users\\flo\\.bun\\bin");
+  });
+
+  it("keeps a spread of the env readable and rewritable via env.PATH", () => {
+    // The failure mode from the field: the compute SDK spreads process.env
+    // into a plain object and rebuilds PATH from `baseEnv.PATH`. With the
+    // Windows `Path` casing that read is undefined, so the rebuilt PATH loses
+    // every inherited entry and the spawned `bun run build` cannot find bun.
+    const env: NodeJS.ProcessEnv = { Path: "C:\\Users\\flo\\.bun\\bin" };
+
+    canonicalizeWindowsPathKey(env, "win32");
+    const spread = { ...env };
+
+    expect(spread.PATH).toBe("C:\\Users\\flo\\.bun\\bin");
+    expect(
+      Object.keys(spread).filter((key) => key.toUpperCase() === "PATH"),
+    ).toEqual(["PATH"]);
+  });
+
+  it("collapses multiple case variants without dropping the value", () => {
+    const env: NodeJS.ProcessEnv = {
+      path: "ignored",
+      PATH: "C:\\kept",
+    };
+
+    canonicalizeWindowsPathKey(env, "win32");
+
+    expect(env).toEqual({ PATH: "C:\\kept" });
+  });
+
+  it("leaves a canonical PATH untouched", () => {
+    const env: NodeJS.ProcessEnv = { PATH: "C:\\Windows\\System32" };
+
+    canonicalizeWindowsPathKey(env, "win32");
+
+    expect(env).toEqual({ PATH: "C:\\Windows\\System32" });
+  });
+
+  it("does nothing when no path variable exists", () => {
+    const env: NodeJS.ProcessEnv = { HOME: "C:\\Users\\flo" };
+
+    canonicalizeWindowsPathKey(env, "win32");
+
+    expect(env).toEqual({ HOME: "C:\\Users\\flo" });
+  });
+
+  it("is a no-op outside Windows, where casing is significant", () => {
+    const env: NodeJS.ProcessEnv = {
+      Path: "/opt/custom",
+      PATH: "/usr/bin:/bin",
+    };
+
+    canonicalizeWindowsPathKey(env, "linux");
+
+    expect(env).toEqual({ Path: "/opt/custom", PATH: "/usr/bin:/bin" });
+  });
+});