Debugging

lib/resolve/wait-subprocess.js

@@ -1,6 +1,6 @@
-import {once} from 'node:events';
+import {once, on} from 'node:events';
 import {isStream as isNodeStream} from 'is-stream';
-import {errorSignal} from '../terminate/kill.js';
+import {errorSignal, isRepeatKillError} from '../terminate/kill.js';
 import {throwOnTimeout} from '../terminate/timeout.js';
 import {isStandardStream} from '../utils/standard-stream.js';
 import {TRANSFORM_TYPES} from '../stdio/type.js';
@@ -62,8 +62,8 @@ export const waitForSubprocessResult = async ({
 				...originalPromises,
 				...customStreamsEndPromises,
 			]),
-			throwOnSubprocessError(subprocess, controller),
 			throwOnInternalError(subprocess, controller),
+			throwOnSubprocessError(subprocess, controller),
 			...throwOnTimeout(subprocess, timeout, context, controller),
 		]);
 	} catch (error) {
@@ -97,8 +97,12 @@ const waitForCustomStreamsEnd = (fileDescriptors, streamInfo) => fileDescriptors
 
 // Fails when the subprocess emits an `error` event
 const throwOnSubprocessError = async (subprocess, {signal}) => {
-	const [error] = await once(subprocess, 'error', {signal});
-	throw error;
+	for await (const [error] of on(subprocess, 'error', {signal})) {
+		console.log('EVENT', {error});
+		if (!isRepeatKillError(error)) {
+			throw error;
+		}
+	}
 };
 
 // Fails right away when calling `subprocess.kill(error)`.

lib/terminate/kill.js

@@ -29,7 +29,7 @@ export const subprocessKill = (
 ) => {
 	const {signal, error} = parseKillArguments(signalOrError, errorArgument, killSignal);
 	emitKillError(subprocess, error);
-	const killResult = kill(signal);
+	const killResult = safeKill(kill, signal);
 	setKillTimeout({
 		kill,
 		signal,
@@ -41,6 +41,15 @@ export const subprocessKill = (
 	return killResult;
 };
 
+const safeKill = (kill, signal) => {
+	try {
+		return kill(signal);
+	} catch (error) {
+		console.log('THROWING', {error});
+		throw error;
+	}
+};
+
 const parseKillArguments = (signalOrError, errorArgument, killSignal) => {
 	const [signal = killSignal, error] = isErrorInstance(signalOrError)
 		? [undefined, signalOrError]
@@ -86,3 +95,10 @@ const shouldForceKill = (signal, forceKillAfterDelay, killSignal, killResult) =>
 const normalizeSignal = signal => typeof signal === 'string'
 	? os.constants.signals[signal.toUpperCase()]
 	: signal;
+
+// Calling `subprocess.kill()` on a process that has already exited emits an `error` event on Windows.
+// However, it does not do it on Unix. This ignores the error to make it cross-platform.
+// `subprocess.kill()` returns `false` in both cases.
+export const isRepeatKillError = error => error instanceof Error
+	&& error.syscall === 'kill'
+	&& error.code === 'EPERM';