fix: make speedtest and sshProcess tests pass on Windows

- speedtest tests: use process.execPath instead of .cmd wrapper since
  execFile cannot spawn .cmd files on Windows (EINVAL)
- sshProcess tests: use path.join for expected log paths so separators
  match the OS (backslashes on Windows, forward slashes on Unix)
- Build integration tests on project build.

Author: EhabY

package.json

@@ -18,9 +18,10 @@
 	"type": "commonjs",
 	"main": "./dist/extension.js",
 	"scripts": {
-		"build": "concurrently -g -n webviews,extension \"pnpm build:webviews\" \"node esbuild.mjs\"",
+		"build": "concurrently -g -n webviews,extension,compile-tests:integration \"pnpm build:webviews\" \"node esbuild.mjs\" \"pnpm compile-tests:integration\"",
 		"build:production": "cross-env NODE_ENV=production pnpm build",
 		"build:webviews": "pnpm -r --filter \"./packages/*\" --parallel build",
+		"compile-tests:integration": "tsc -p test/integration --outDir out --noCheck",
 		"format": "prettier --write --cache --cache-strategy content .",
 		"format:check": "prettier --check --cache --cache-strategy content .",
 		"lint": "eslint --cache --cache-strategy content .",
@@ -29,7 +30,7 @@
 		"package:prerelease": "pnpm build:production && vsce package --pre-release --no-dependencies",
 		"test": "cross-env CI=true ELECTRON_RUN_AS_NODE=1 electron node_modules/vitest/vitest.mjs",
 		"test:extension": "cross-env ELECTRON_RUN_AS_NODE=1 electron node_modules/vitest/vitest.mjs --project extension",
-		"test:integration": "tsc -p test/integration --outDir out --noCheck && node esbuild.mjs && vscode-test",
+		"test:integration": "pnpm compile-tests:integration && node esbuild.mjs && vscode-test",
 		"test:webview": "cross-env ELECTRON_RUN_AS_NODE=1 electron node_modules/vitest/vitest.mjs --project webview",
 		"typecheck": "concurrently -g -n extension,tests,packages \"tsc --noEmit\" \"tsc --noEmit -p test\" \"pnpm typecheck:packages\"",
 		"typecheck:packages": "pnpm -r --filter \"./packages/*\" --parallel typecheck",

test/unit/core/cliExec.test.ts

@@ -1,15 +1,22 @@
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
-import { beforeAll, describe, expect, it } from "vitest";
-
-import * as cliExec from "@/core/cliExec";
+import { beforeAll, describe, expect, it, vi } from "vitest";
 
 import { MockConfigurationProvider } from "../../mocks/testHelpers";
 import { isWindows, writeExecutable } from "../../utils/platform";
 
 import type { CliEnv } from "@/core/cliExec";
 
+// Shim execFile so .js test scripts are run through node cross-platform.
+vi.mock("node:child_process", async (importOriginal) => {
+	const { shimExecFile } = await import("../../utils/platform");
+	return shimExecFile(await importOriginal());
+});
+
+// Import after mock so the module picks up the shimmed execFile.
+const cliExec = await import("@/core/cliExec");
+
 describe("cliExec", () => {
 	const tmp = path.join(os.tmpdir(), "vscode-coder-tests-cliExec");
 	let echoArgsBin: string;

test/unit/remote/sshProcess.test.ts

@@ -1,6 +1,7 @@
 import find from "find-process";
 import { vol } from "memfs";
 import * as fsPromises from "node:fs/promises";
+import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import {
@@ -313,8 +314,10 @@ describe("SshProcessMonitor", () => {
 			});
 			const logPath = await waitForEvent(monitor.onLogFilePathChange);
 
-			expect(logPath).toBe("/proxy-logs/999.log");
-			expect(monitor.getLogFilePath()).toBe("/proxy-logs/999.log");
+			expect(logPath).toBe(path.join("/proxy-logs", "999.log"));
+			expect(monitor.getLogFilePath()).toBe(
+				path.join("/proxy-logs", "999.log"),
+			);
 		});
 
 		it("finds log file with prefix pattern", async () => {
@@ -330,7 +333,7 @@ describe("SshProcessMonitor", () => {
 			});
 			const logPath = await waitForEvent(monitor.onLogFilePathChange);
 
-			expect(logPath).toBe("/proxy-logs/coder-ssh-999.log");
+			expect(logPath).toBe(path.join("/proxy-logs", "coder-ssh-999.log"));
 		});
 
 		it("returns undefined when no proxyLogDir set", async () => {
@@ -373,7 +376,7 @@ describe("SshProcessMonitor", () => {
 			});
 			const logPath = await waitForEvent(monitor.onLogFilePathChange);
 
-			expect(logPath).toBe("/proxy-logs/2024-01-03-999.log");
+			expect(logPath).toBe(path.join("/proxy-logs", "2024-01-03-999.log"));
 		});
 
 		it("sorts log files using localeCompare for consistent cross-platform ordering", async () => {
@@ -395,7 +398,7 @@ describe("SshProcessMonitor", () => {
 
 			// With localeCompare: ["a", "Z"] -> reversed -> "Z" first
 			// With plain sort(): ["Z", "a"] -> reversed -> "a" first (WRONG)
-			expect(logPath).toBe("/proxy-logs/Z-999.log");
+			expect(logPath).toBe(path.join("/proxy-logs", "Z-999.log"));
 		});
 	});
 

test/utils/platform.test.ts

@@ -1,11 +1,18 @@
-import { describe, expect, it } from "vitest";
+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 {
 	expectPathsEqual,
 	exitCommand,
+	isWindows,
 	printCommand,
 	printEnvCommand,
-	isWindows,
+	shimExecFile,
+	writeExecutable,
 } from "./platform";
 
 describe("platform utils", () => {
@@ -83,4 +90,76 @@ describe("platform utils", () => {
 			},
 		);
 	});
+
+	describe("writeExecutable", () => {
+		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 });
+		});
+
+		it("writes a .js file and returns its path", async () => {
+			const result = await writeExecutable(tmp, "test-script", "// hello");
+			expect(result).toBe(path.join(tmp, "test-script.js"));
+			expect(await fs.readFile(result, "utf-8")).toBe("// hello");
+		});
+
+		it("overwrites existing files", async () => {
+			await writeExecutable(tmp, "overwrite", "first");
+			const result = await writeExecutable(tmp, "overwrite", "second");
+			expect(await fs.readFile(result, "utf-8")).toBe("second");
+		});
+	});
+
+	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 });
+		});
+
+		it("runs .js files through node", async () => {
+			const script = await writeExecutable(
+				tmp,
+				"echo",
+				'process.stdout.write("ok");',
+			);
+			const { stdout } = await shimmedExecFile(script);
+			expect(stdout).toBe("ok");
+		});
+
+		it("passes args through to the script", async () => {
+			const script = await writeExecutable(
+				tmp,
+				"echo-args",
+				"process.stdout.write(process.argv.slice(2).join(','));",
+			);
+			const { stdout } = await shimmedExecFile(script, ["a", "b", "c"]);
+			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");
+		});
+
+		it("does not touch spawn", () => {
+			expect(mod.spawn).toBe(cp.spawn);
+		});
+	});
 });

test/utils/platform.ts

@@ -3,6 +3,8 @@ import os from "node:os";
 import path from "node:path";
 import { expect } from "vitest";
 
+import type { ChildProcess } from "node:child_process";
+
 export function isWindows(): boolean {
 	return os.platform() === "win32";
 }
@@ -39,27 +41,61 @@ export function printEnvCommand(key: string, varName: string): string {
 }
 
 /**
- * Write a cross-platform executable that runs the given JS code.
- * On Unix creates a shebang script; on Windows creates a .cmd wrapper.
- * Returns the path to the executable.
+ * Write a JS file that can be executed cross-platform.
+ * Tests that use `execFile` on the returned path should apply
+ * {@link shimExecFile} so `.js` files are run through `process.execPath`.
  */
 export async function writeExecutable(
 	dir: string,
 	name: string,
 	code: string,
 ): Promise<string> {
-	if (isWindows()) {
-		const jsPath = path.join(dir, `${name}.js`);
-		const cmdPath = path.join(dir, `${name}.cmd`);
-		await fs.writeFile(jsPath, code);
-		await fs.writeFile(cmdPath, `@node "${jsPath}" %*\r\n`);
-		return cmdPath;
-	}
+	const jsPath = path.join(dir, `${name}.js`);
+	await fs.writeFile(jsPath, code);
+	return jsPath;
+}
+
+/**
+ * If `file` is a `.js` path, prepend it into the args array and swap the
+ * binary to `process.execPath` so `execFile` works on every platform
+ * (Windows cannot `execFile` script wrappers).
+ */
+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];
+}
+
+/**
+ * Shim `child_process.execFile` so `.js` files are launched through node.
+ * Use with `vi.mock`:
+ *
+ * ```ts
+ * vi.mock("node:child_process", async (importOriginal) => {
+ *   const { shimExecFile } = await import("../../utils/platform");
+ *   return shimExecFile(await importOriginal());
+ * });
+ * ```
+ */
+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;
+
+	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));
 
-	const binPath = path.join(dir, name);
-	await fs.writeFile(binPath, `#!/usr/bin/env node\n${code}`);
-	await fs.chmod(binPath, "755");
-	return binPath;
+	return { ...rest, execFile } as ChildProcessModule;
 }
 
 export function expectPathsEqual(actual: string, expected: string) {