feat(tests): add case-insensitive env Proxy for Windows compatibility

Implement createEnvProxy() helper that provides:

1. **Live environment in tests**: In VITEST mode, constants.processEnv
   is a Proxy that always reads from process.env (not a snapshot)

2. **Case-insensitive access**: Handles PATH, TEMP, HOME, etc. with
   any casing (PATH vs Path vs path) to match Windows behavior

3. **Smart priority**:
   - Overrides (spawnEnv) take precedence
   - Exact key matches in base env
   - Case-insensitive fallback for known Windows vars

4. **Proper Proxy handlers**:
   - get: Handles lookups with case fallback
   - ownKeys: Merges all keys from base + overrides
   - getOwnPropertyDescriptor: Returns proper descriptors
   - has: Case-insensitive membership checks
   - set: Allows setting overrides

Benefits:
- No more snapshot vs live env issues
- Windows case-sensitivity handled properly
- Works seamlessly with socket-lib@1.3.5 fix
- Tests stay consistent across platforms

Author: jdalton

packages/cli/test/utils.mts

@@ -24,10 +24,152 @@ if (!process.env['VITEST']) {
   process.env['VITEST'] = '1'
 }
 
+/**
+ * Create a case-insensitive environment variable Proxy for Windows compatibility.
+ * On Windows, environment variables are case-insensitive (PATH vs Path vs path).
+ * This Proxy provides consistent access regardless of case, with priority given
+ * to exact matches, then case-insensitive matches for known vars.
+ *
+ * @param base - Base environment object (usually process.env)
+ * @param overrides - Optional overrides to merge
+ * @returns Proxy that handles case-insensitive env var access
+ */
+function createEnvProxy(
+  base: NodeJS.ProcessEnv,
+  overrides?: Record<string, string | undefined>,
+): NodeJS.ProcessEnv {
+  // Common environment variables that have case sensitivity issues on Windows.
+  const caseInsensitiveKeys = new Set([
+    'PATH',
+    'TEMP',
+    'TMP',
+    'HOME',
+    'USERPROFILE',
+    'APPDATA',
+    'LOCALAPPDATA',
+    'PROGRAMFILES',
+    'SYSTEMROOT',
+    'WINDIR',
+  ])
+
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop !== 'string') {
+          return undefined
+        }
+
+        // Priority 1: Check overrides for exact match.
+        if (overrides && prop in overrides) {
+          return overrides[prop]
+        }
+
+        // Priority 2: Check base for exact match.
+        if (prop in base) {
+          return base[prop]
+        }
+
+        // Priority 3: Case-insensitive lookup for known keys.
+        const upperProp = prop.toUpperCase()
+        if (caseInsensitiveKeys.has(upperProp)) {
+          // Check overrides with case variations.
+          if (overrides) {
+            for (const key of Object.keys(overrides)) {
+              if (key.toUpperCase() === upperProp) {
+                return overrides[key]
+              }
+            }
+          }
+          // Check base with case variations.
+          for (const key of Object.keys(base)) {
+            if (key.toUpperCase() === upperProp) {
+              return base[key]
+            }
+          }
+        }
+
+        return undefined
+      },
+
+      ownKeys(_target) {
+        const keys = new Set<string>([
+          ...Object.keys(base),
+          ...(overrides ? Object.keys(overrides) : []),
+        ])
+        return [...keys]
+      },
+
+      getOwnPropertyDescriptor(_target, prop) {
+        if (typeof prop !== 'string') {
+          return undefined
+        }
+
+        // Use the same lookup logic as get().
+        const value = this.get?.(_target, prop, _target)
+        return value !== undefined
+          ? {
+              enumerable: true,
+              configurable: true,
+              writable: true,
+              value,
+            }
+          : undefined
+      },
+
+      has(_target, prop) {
+        if (typeof prop !== 'string') {
+          return false
+        }
+
+        // Check overrides.
+        if (overrides && prop in overrides) {
+          return true
+        }
+
+        // Check base.
+        if (prop in base) {
+          return true
+        }
+
+        // Case-insensitive check.
+        const upperProp = prop.toUpperCase()
+        if (caseInsensitiveKeys.has(upperProp)) {
+          if (overrides) {
+            for (const key of Object.keys(overrides)) {
+              if (key.toUpperCase() === upperProp) {
+                return true
+              }
+            }
+          }
+          for (const key of Object.keys(base)) {
+            if (key.toUpperCase() === upperProp) {
+              return true
+            }
+          }
+        }
+
+        return false
+      },
+
+      set(_target, prop, value) {
+        if (typeof prop === 'string' && overrides) {
+          overrides[prop] = value
+          return true
+        }
+        return false
+      },
+    },
+  ) as NodeJS.ProcessEnv
+}
+
 // Backward compatibility object for tests.
+// In VITEST mode, use a Proxy to keep env vars live and handle case-sensitivity.
 const constants = {
   execPath,
-  processEnv: process.env,
+  processEnv: process.env['VITEST']
+    ? createEnvProxy(process.env)
+    : process.env,
 }
 
 // The asciiUnsafeRegexp match characters that are:
@@ -266,13 +408,17 @@ export async function spawnSocketCli(
   const commandArgs = isJsFile ? [entryPath, ...args] : args
 
   try {
+    // Create a Proxy env that handles Windows case-insensitivity issues.
+    // This ensures PATH, TEMP, and other Windows env vars work regardless
+    // of case (PATH vs Path vs path).
+    const env = createEnvProxy(
+      constants.processEnv,
+      spawnEnv as Record<string, string | undefined>,
+    )
+
     const output = await spawn(command, commandArgs, {
       cwd,
-      env: {
-        ...process.env,
-        ...constants.processEnv,
-        ...spawnEnv,
-      },
+      env,
       ...restOptions,
       // Close stdin to prevent tests from hanging
       // when commands wait for input. Must be after restOptions