fix: destroy piped streams on child exit to prevent grandchild deadlock

When a child process spawns a grandchild that inherits the piped
stdout/stderr file descriptors, the grandchild holds them open after the
child exits. Node's close event waits for all fds to be released, so
it never fires. readStream and combineStreams hang indefinitely because
the streams never end.

Listen for the exit event (fires when the process exits, regardless of
pipe state) and destroy the piped streams. This forces the PassThrough
and readline consumers to complete.

Refs: lint-staged/lint-staged#1800

Author: Mearman

src/main.ts

@@ -334,6 +334,7 @@ export class ExecProcess implements Result {
 
     this._process = handle;
     handle.once('error', this._onError);
+    handle.once('exit', this._onExit);
     handle.once('close', this._onClose);
 
     if (handle.stdin) {
@@ -366,6 +367,15 @@ export class ExecProcess implements Result {
     this._thrownError = err;
   };
 
+  protected _onExit = (): void => {
+    // Destroy piped streams when the child process exits, even if grandchild
+    // processes still hold the underlying file descriptors open. Without this,
+    // the 'close' event never fires (it waits for all fds to be released),
+    // causing readStream and combineStreams to hang indefinitely.
+    this._streamOut?.destroy();
+    this._streamErr?.destroy();
+  };
+
   protected _onClose = (): void => {
     if (this._resolveClose) {
       this._resolveClose();

src/test/grandchild_test.ts

@@ -1,4 +1,3 @@
-import {x} from '../main.js';
 import {describe, test, expect} from 'vitest';
 import os from 'node:os';
 import fs from 'node:fs';
@@ -7,124 +6,127 @@ import {spawnSync} from 'node:child_process';
 
 const isWindows = os.platform() === 'win32';
 
+function runInSubprocess(
+  childScript: string,
+  runnerBody: string
+): {status: number | null; signal: string | null; stdout: string} {
+  const dir = path.dirname(childScript);
+  const runnerScript = path.join(dir, 'runner.mjs');
+  const distPath = JSON.stringify(
+    path.join(process.cwd(), 'dist', 'main.mjs')
+  );
+  const childPath = JSON.stringify(childScript);
+
+  fs.writeFileSync(
+    runnerScript,
+    `import { x } from ${distPath}\n${runnerBody.replace(/CHILD_SCRIPT/g, childPath)}`
+  );
+
+  try {
+    const proc = spawnSync('node', [runnerScript], {
+      timeout: 10000,
+      encoding: 'utf8',
+      killSignal: 'SIGKILL'
+    });
+
+    return {
+      status: proc.status,
+      signal: proc.signal,
+      stdout: proc.stdout ?? ''
+    };
+  } finally {
+    try {
+      spawnSync('pkill', ['-f', dir]);
+    } catch {}
+    fs.rmSync(dir, {recursive: true, force: true});
+  }
+}
+
 describe.skipIf(isWindows)('exec (grandchild pipe inheritance)', () => {
   test('await completes when grandchild holds piped stdout open', async () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tinyexec-grandchild-'));
+    const dir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'tinyexec-grandchild-')
+    );
     const childScript = path.join(dir, 'child.mjs');
 
     fs.writeFileSync(
       childScript,
       `import { spawn } from 'node:child_process'
+console.log('output')
 spawn('node', ['-e', 'setTimeout(() => void 0, 30000)'], {
   stdio: ['ignore', 1, 'ignore'],
 })
-process.stdout.write('output\\n')
 process.exit(0)
 `
     );
 
-    // Run in a subprocess so the orphaned grandchild doesn't block vitest.
-    // The runner uses the built dist/main.mjs directly.
-    const runnerScript = path.join(dir, 'runner.mjs');
-    const distPath = path.join(process.cwd(), 'dist', 'main.mjs');
-    fs.writeFileSync(
-      runnerScript,
-      `import { x } from '${distPath}'
-
+    const result = runInSubprocess(
+      childScript,
+      `
 const result = await Promise.race([
-  x('node', ['${childScript}']).then(() => 'completed'),
+  x('node', [CHILD_SCRIPT]).then(() => 'completed'),
   new Promise((resolve) => setTimeout(() => resolve('hung'), 5000)),
 ])
-
-try { process.kill(-process.pid) } catch {}
 process.stdout.write(result)
 process.exit(result === 'completed' ? 0 : 1)
 `
     );
 
-    try {
-      const proc = spawnSync('node', [runnerScript], {
-        timeout: 10000,
-        encoding: 'utf8',
-        killSignal: 'SIGKILL',
-      });
-
-      if (proc.signal === 'SIGKILL') {
-        expect.unreachable(
-          'exec hung for 10s (grandchild held pipe open)'
-        );
-      }
-
-      expect(proc.status).toBe(0);
-      expect(proc.stdout.trim()).toBe('completed');
-    } finally {
-      try {
-        spawnSync('pkill', ['-f', dir]);
-      } catch {}
-      fs.rmSync(dir, {recursive: true, force: true});
+    if (result.signal === 'SIGKILL') {
+      expect.unreachable(
+        'exec hung for 10s (grandchild held pipe open)'
+      );
     }
+
+    expect(result.status).toBe(0);
+    expect(result.stdout.trim()).toBe('completed');
   });
 
   test('async iterator completes when grandchild holds piped stdout open', async () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tinyexec-grandchild-'));
+    const dir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'tinyexec-grandchild-')
+    );
     const childScript = path.join(dir, 'child.mjs');
 
     fs.writeFileSync(
       childScript,
       `import { spawn } from 'node:child_process'
+console.log('line1')
+console.log('line2')
 spawn('node', ['-e', 'setTimeout(() => void 0, 30000)'], {
   stdio: ['ignore', 1, 'ignore'],
 })
-process.stdout.write('line1\\nline2\\n')
 process.exit(0)
 `
     );
 
-    const runnerScript = path.join(dir, 'runner.mjs');
-    const distPath = path.join(process.cwd(), 'dist', 'main.mjs');
-    fs.writeFileSync(
-      runnerScript,
-      `import { x } from '${distPath}'
-
+    const result = runInSubprocess(
+      childScript,
+      `
 const lines = []
 const result = await Promise.race([
   (async () => {
-    for await (const line of x('node', ['${childScript}'])) {
+    for await (const line of x('node', [CHILD_SCRIPT])) {
       lines.push(line)
     }
     return 'completed'
   })(),
   new Promise((resolve) => setTimeout(() => resolve('hung'), 5000)),
 ])
-
-try { process.kill(-process.pid) } catch {}
 process.stdout.write(JSON.stringify({ result, lines }))
 process.exit(result === 'completed' ? 0 : 1)
 `
     );
 
-    try {
-      const proc = spawnSync('node', [runnerScript], {
-        timeout: 10000,
-        encoding: 'utf8',
-        killSignal: 'SIGKILL',
-      });
-
-      if (proc.signal === 'SIGKILL') {
-        expect.unreachable(
-          'async iterator hung for 10s (grandchild held pipe open)'
-        );
-      }
-
-      expect(proc.status).toBe(0);
-      const parsed = JSON.parse(proc.stdout.trim());
-      expect(parsed.result).toBe('completed');
-      expect(parsed.lines).toEqual(['line1', 'line2']);
-    } finally {
-      try {
-        spawnSync('pkill', ['-f', dir]);
-      } catch {}
-      fs.rmSync(dir, {recursive: true, force: true});
+    if (result.signal === 'SIGKILL') {
+      expect.unreachable(
+        'async iterator hung for 10s (grandchild held pipe open)'
+      );
     }
+
+    expect(result.status).toBe(0);
+    const parsed = JSON.parse(result.stdout.trim());
+    expect(parsed.result).toBe('completed');
+    expect(parsed.lines).toEqual(['line1', 'line2']);
   });
 });