refactor: simplify shimExecFile by removing type casts and promisify handling

Use Reflect.apply and a generic type parameter instead of `as unknown as`
chains. Replace promisify usage in tests with plain Promise callbacks,
which eliminates the need for the promisify custom symbol wrapping entirely.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jeremyruppel

test/utils/platform.test.ts

@@ -2,8 +2,7 @@ import * as cp from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { promisify } from "node:util";
-import { beforeAll, describe, expect, it } from "vitest";
+import {beforeAll, describe, expect, it} from "vitest";
 
 import {
 	expectPathsEqual,
@@ -95,8 +94,8 @@ describe("platform utils", () => {
 		const tmp = path.join(os.tmpdir(), "vscode-coder-tests-platform");
 
 		beforeAll(async () => {
-			await fs.rm(tmp, { recursive: true, force: true });
-			await fs.mkdir(tmp, { recursive: true });
+			await fs.rm(tmp, {recursive: true, force: true});
+			await fs.mkdir(tmp, {recursive: true});
 		});
 
 		it("writes a .js file and returns its path", async () => {
@@ -115,11 +114,10 @@ describe("platform utils", () => {
 	describe("shimExecFile", () => {
 		const tmp = path.join(os.tmpdir(), "vscode-coder-tests-shim");
 		const mod = shimExecFile(cp);
-		const shimmedExecFile = promisify(mod.execFile);
 
 		beforeAll(async () => {
-			await fs.rm(tmp, { recursive: true, force: true });
-			await fs.mkdir(tmp, { recursive: true });
+			await fs.rm(tmp, {recursive: true, force: true});
+			await fs.mkdir(tmp, {recursive: true});
 		});
 
 		it("runs .js files through node", async () => {
@@ -128,7 +126,11 @@ describe("platform utils", () => {
 				"echo",
 				'process.stdout.write("ok");',
 			);
-			const { stdout } = await shimmedExecFile(script);
+			const stdout = await new Promise<string>((resolve, reject) => {
+				mod.execFile(script, (err, out) =>
+					err ? reject(err) : resolve(out),
+				);
+			});
 			expect(stdout).toBe("ok");
 		});
 
@@ -138,24 +140,22 @@ describe("platform utils", () => {
 				"echo-args",
 				"process.stdout.write(process.argv.slice(2).join(','));",
 			);
-			const { stdout } = await shimmedExecFile(script, ["a", "b", "c"]);
+			const stdout = await new Promise<string>((resolve, reject) => {
+				mod.execFile(script, ["a", "b", "c"], (err, out) =>
+					err ? reject(err) : resolve(out),
+				);
+			});
 			expect(stdout).toBe("a,b,c");
 		});
 
 		it("does not rewrite non-.js files", async () => {
-			await expect(shimmedExecFile("/nonexistent/binary")).rejects.toThrow(
-				"ENOENT",
-			);
-		});
-
-		it("preserves the callback form", async () => {
-			const script = path.join(tmp, "echo.js");
-			const stdout = await new Promise<string>((resolve, reject) => {
-				mod.execFile(script, (err, out) =>
-					err ? reject(new Error(err.message)) : resolve(out),
-				);
-			});
-			expect(stdout).toBe("ok");
+			await expect(
+				new Promise((resolve, reject) => {
+					mod.execFile("/nonexistent/binary", (err, out) =>
+						err ? reject(err) : resolve(out),
+					);
+				}),
+			).rejects.toThrow("ENOENT");
 		});
 
 		it("does not touch spawn", () => {

test/utils/platform.ts

@@ -1,9 +1,8 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { expect } from "vitest";
-
-import type { ChildProcess } from "node:child_process";
+import * as cp from "node:child_process";
+import {expect} from "vitest";
 
 export function isWindows(): boolean {
 	return os.platform() === "win32";
@@ -62,10 +61,10 @@ export async function writeExecutable(
  */
 function prepend(file: string, rest: unknown[]): [string, ...unknown[]] {
 	if (!file.endsWith(".js")) return [file, ...rest];
-	const hasArgs = Array.isArray(rest[0]);
-	const cliArgs = hasArgs ? (rest[0] as string[]) : [];
-	const remaining = hasArgs ? rest.slice(1) : rest;
-	return [process.execPath, [file, ...cliArgs], ...remaining];
+	if (Array.isArray(rest[0])) {
+		return [process.execPath, [file, ...rest[0]], ...rest.slice(1)];
+	}
+	return [process.execPath, [file], ...rest];
 }
 
 /**
@@ -79,23 +78,14 @@ function prepend(file: string, rest: unknown[]): [string, ...unknown[]] {
  * });
  * ```
  */
-type ChildProcessModule = typeof import("node:child_process");
-type Callable = (...args: unknown[]) => unknown;
-
-export function shimExecFile(mod: ChildProcessModule): ChildProcessModule {
-	const { execFile: original, ...rest } = mod;
-
-	const execFile = (file: string, ...args: unknown[]): ChildProcess =>
-		(original as unknown as Callable)(...prepend(file, args)) as ChildProcess;
+export function shimExecFile<M extends {execFile: Function}>(mod: M): M {
+	const {execFile: original} = mod;
 
-	const sym = Symbol.for("nodejs.util.promisify.custom");
-	const originalCustom = (original as unknown as Record<symbol, Callable>)[sym];
-	(execFile as unknown as Record<symbol, unknown>)[sym] = (
-		file: string,
-		...args: unknown[]
-	): unknown => originalCustom(...prepend(file, args));
+	function execFile(file: string, ...rest: unknown[]): cp.ChildProcess {
+		return Reflect.apply(original, undefined, prepend(file, rest));
+	}
 
-	return { ...rest, execFile } as ChildProcessModule;
+	return Object.assign({}, mod, {execFile});
 }
 
 export function expectPathsEqual(actual: string, expected: string) {