fix(integration): retry transient EBADF subprocess failures

Author: terion-labs

tests/integration/lib/process.test.ts

@@ -1,10 +1,17 @@
 import { describe, expect, test } from "bun:test";
-import { run } from "./process";
+import { DEFAULT_LOCAL_PROCESS_ATTEMPTS, isRetryableLocalProcessFailure, run } from "./process";
 
 describe("integration process helpers", () => {
   test("renders stdout and stderr for failed commands", async () => {
     await expect(run(["bash", "-lc", "echo useful-stdout; echo useful-stderr >&2; exit 7"])).rejects.toThrow(
       /command failed \(7\): bash -lc.*stdout:\nuseful-stdout.*stderr:\nuseful-stderr/s
     );
   });
+
+  test("retries only local EBADF subprocess failures", () => {
+    expect(DEFAULT_LOCAL_PROCESS_ATTEMPTS).toBeGreaterThan(1);
+    expect(isRetryableLocalProcessFailure({ exitCode: 127, stdout: "", stderr: "EBADF: bad file descriptor, epoll_ctl" })).toBeTrue();
+    expect(isRetryableLocalProcessFailure({ exitCode: 127, stdout: "", stderr: "bash: missing-command: command not found" })).toBeFalse();
+    expect(isRetryableLocalProcessFailure({ exitCode: 124, stdout: "", stderr: "EBADF: bad file descriptor, epoll_ctl" })).toBeFalse();
+  });
 });

tests/integration/lib/process.ts

@@ -13,6 +13,8 @@ export type CommandResult = {
   stderr: string;
 };
 
+export const DEFAULT_LOCAL_PROCESS_ATTEMPTS = 3;
+
 function renderCommandFailure(cmd: string[], result: CommandResult): string {
   const parts = [`command failed (${result.exitCode}): ${cmd.join(" ")}`];
   const stdout = result.stdout.trim();
@@ -26,13 +28,30 @@ function renderCommandFailure(cmd: string[], result: CommandResult): string {
   return parts.join("\n\n");
 }
 
+export function isRetryableLocalProcessFailure(result: CommandResult): boolean {
+  const output = `${result.stderr}\n${result.stdout}`;
+  return result.exitCode === 127 && /\bEBADF\b/.test(output) && /epoll_ctl/.test(output);
+}
+
 /**
  * Runs a command as argv, captures stdout/stderr, and never throws on non-zero exit.
  *
  * The harness uses this as the lowest-level primitive so every provider,
  * remote helper, and assertion can decide whether a failure is expected or fatal.
  */
 export async function runAllowFailure(cmd: string[], options: CommandOptions = {}): Promise<CommandResult> {
+  let result: CommandResult = { exitCode: 127, stdout: "", stderr: "command was not attempted" };
+  for (let attempt = 1; attempt <= DEFAULT_LOCAL_PROCESS_ATTEMPTS; attempt += 1) {
+    result = await runOnceAllowFailure(cmd, options);
+    if (!isRetryableLocalProcessFailure(result) || attempt >= DEFAULT_LOCAL_PROCESS_ATTEMPTS) {
+      return result;
+    }
+    await Bun.sleep(attempt * 500);
+  }
+  return result;
+}
+
+async function runOnceAllowFailure(cmd: string[], options: CommandOptions = {}): Promise<CommandResult> {
   return await new Promise<CommandResult>((resolve) => {
     const stdout: Buffer[] = [];
     const stderr: Buffer[] = [];