fix(test): stop forwarding a cleaned-up PTY session into stdout (#11002)

integration-tests/test-helper.test.ts

@@ -17,6 +17,9 @@ function isProcessAlive(pid: number): boolean {
   }
 }
 
+/** Emitted by the stand-in CLI below; nothing else in the run writes it. */
+const FORWARD_CANARY = 'PTY_FORWARD_CANARY_11002';
+
 describe('TestRig', () => {
   const originalKeepOutput = process.env['KEEP_OUTPUT'];
 
@@ -89,6 +92,103 @@ describe('TestRig', () => {
       .toBe(false);
   });
 
+  // Skipped on Windows: node-pty's kill() terminates the child unconditionally
+  // there, so it cannot outlive cleanup() and the premise below does not hold.
+  it.skipIf(process.platform === 'win32')(
+    "detaches a session's output forwarding during cleanup",
+    async () => {
+      // KEEP_OUTPUT is what the OpenTUI leg sets, and it is what makes the rig
+      // forward every PTY byte into this worker's stdout.
+      process.env['KEEP_OUTPUT'] = 'true';
+      const rig = new TestRig();
+      await rig.setup('cleanup detaches interactive output');
+      // Stands in for the CLI bundle, which traps the SIGHUP that node-pty's
+      // signal-less kill() sends and keeps rendering while its exit cleanup
+      // drains. The child therefore outlives cleanup() on purpose and keeps
+      // producing bytes: what is under test is whether the harness still
+      // forwards them into a stdout pipe vitest is about to destroy (#11002).
+      rig.bundlePath = rig.createFile(
+        'slow-exit-cli.js',
+        [
+          "process.on('SIGHUP', () => {});",
+          `setInterval(() => process.stdout.write('${FORWARD_CANARY}\\n'), 20);`,
+          'setTimeout(() => process.exit(0), 30000);',
+          '',
+        ].join('\n'),
+      );
+
+      const { ptyProcess } = rig.runInteractive();
+      // node-pty hands every onData registration its own disposable, so this
+      // witness keeps receiving after cleanup() detaches the harness's one.
+      const delivered: string[] = [];
+      const deliveryWitness = ptyProcess.onData((data) =>
+        delivered.push(String(data)),
+      );
+      try {
+        await expect
+          .poll(() => rig._interactiveOutput.includes(FORWARD_CANARY), {
+            message: 'the stand-in CLI never produced output',
+            timeout: 20_000,
+          })
+          .toBe(true);
+
+        const forwarded: string[] = [];
+        vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+          forwarded.push(String(chunk));
+          return true;
+        });
+
+        // Positive control, through the same KEEP_OUTPUT gate the harness uses:
+        // a forwarding path that never ran satisfies the empty assertion below
+        // exactly as well as one cleanup() has detached.
+        await expect
+          .poll(
+            () => forwarded.some((chunk) => chunk.includes(FORWARD_CANARY)),
+            {
+              message: 'stdout forwarding never went live before cleanup',
+              timeout: 20_000,
+            },
+          )
+          .toBe(true);
+
+        await rig.cleanup();
+        // Still alive: it swallowed SIGHUP. That is the window the real CLI's
+        // graceful shutdown opens between cleanup() and the child's own exit.
+        expect(isProcessAlive(ptyProcess.pid)).toBe(true);
+
+        forwarded.length = 0;
+        delivered.length = 0;
+        // Wait for a byte the surviving child provably delivered instead of
+        // sleeping a fixed window: a stalled worker runs the expired timer
+        // before the loop polls the pty fd, and an empty window then passes
+        // with the forwarding still attached.
+        await expect
+          .poll(
+            () => delivered.some((chunk) => chunk.includes(FORWARD_CANARY)),
+            {
+              message:
+                'the child that outlived cleanup() delivered no further bytes',
+              timeout: 10_000,
+            },
+          )
+          .toBe(true);
+
+        expect(
+          forwarded.filter((chunk) => chunk.includes(FORWARD_CANARY)),
+          'cleanup() left the session forwarding PTY bytes into stdout',
+        ).toEqual([]);
+      } finally {
+        deliveryWitness.dispose();
+        vi.restoreAllMocks();
+        try {
+          process.kill(ptyProcess.pid, 'SIGKILL');
+        } catch {
+          // Already gone
+        }
+      }
+    },
+  );
+
   it.each([
     [
       'telemetry events',

integration-tests/test-helper.ts

@@ -200,7 +200,12 @@ export class TestRig {
   testName?: string;
   _lastRunStdout?: string;
   _interactiveOutput = '';
-  private readonly interactiveProcesses: pty.IPty[] = [];
+  // Each interactive PTY paired with the listener forwarding its bytes to
+  // this worker's stdout, so cleanup() can detach that forwarding.
+  private readonly interactiveSessions: Array<{
+    ptyProcess: pty.IPty;
+    forwardOutput: pty.IDisposable;
+  }> = [];
 
   constructor() {
     this.bundlePath = join(__dirname, '..', 'dist/cli.js');
@@ -497,9 +502,16 @@ export class TestRig {
     // A session a test never closed keeps its CLI child forwarding PTY bytes
     // into this worker's stdout; after vitest tears the worker down those
     // writes EPIPE and fail an otherwise all-green run (#10969).
-    for (const ptyProcess of this.interactiveProcesses.splice(0)) {
+    //
+    // Killing is not enough: node-pty's signal-less kill() sends SIGHUP, which
+    // the CLI traps into an asynchronous graceful shutdown, so the child still
+    // renders after cleanup() returns and one more forwarded byte can reach a
+    // stdout pipe vitest has since destroyed. Detaching the listener closes
+    // that window however long the child takes to die (#11002).
+    for (const session of this.interactiveSessions.splice(0)) {
+      session.forwardOutput.dispose();
       try {
-        ptyProcess.kill();
+        session.ptyProcess.kill();
       } catch {
         // Process may have already exited
       }
@@ -944,14 +956,13 @@ export class TestRig {
         ...e2eRendererEnv(renderer),
       } as { [key: string]: string },
     });
-    this.interactiveProcesses.push(ptyProcess);
-
-    ptyProcess.onData((data) => {
+    const forwardOutput = ptyProcess.onData((data) => {
       this._interactiveOutput += data;
       if (env.KEEP_OUTPUT === 'true' || env.VERBOSE === 'true') {
         process.stdout.write(data);
       }
     });
+    this.interactiveSessions.push({ ptyProcess, forwardOutput });
 
     const promise = new Promise<{
       exitCode: number;