From f5edef3c963294245c5334abb9e57cdbea312295 Mon Sep 17 00:00:00 2001 From: morluto <76467478+morluto@users.noreply.github.com> Date: Tue, 27 Oct 2026 12:25:03 +0800 Subject: [PATCH] fix(hopper): share cancellable probe output waits --- src/hopper/LinuxPrivateDisplayProbe.ts | 22 ++++-------------- src/process/ProviderProcessOutput.test.ts | 16 +++++++++---- .../hopper/linuxPrivateDisplay.test.ts | 23 ++++++++++++++++--- 3 files changed, 37 insertions(+), 24 deletions(-) diff --git a/src/hopper/LinuxPrivateDisplayProbe.ts b/src/hopper/LinuxPrivateDisplayProbe.ts index cd1d7dd371..e40e08745b 100644 --- a/src/hopper/LinuxPrivateDisplayProbe.ts +++ b/src/hopper/LinuxPrivateDisplayProbe.ts @@ -344,21 +344,9 @@ const waitForProbeOutputClose = async ( signal: AbortSignal | undefined, ): Promise<"exit" | "timeout" | "cancelled"> => { if (signal?.aborted === true) return "cancelled"; - let releaseAbort: (() => void) | undefined; - const aborted = new Promise<"cancelled">((resolve) => { - if (signal === undefined) return; - const listener = (): void => resolve("cancelled"); - signal.addEventListener("abort", listener, { once: true }); - releaseAbort = () => signal.removeEventListener("abort", listener); - }); - try { - return await Promise.race([ - supervisor - .waitForOutputClose(Math.max(1, timeoutMs)) - .then((closed): "exit" | "timeout" => (closed ? "exit" : "timeout")), - aborted, - ]); - } finally { - releaseAbort?.(); - } + const closed = await supervisor.waitForOutputClose( + Math.max(1, timeoutMs), + signal, + ); + return closed ? "exit" : isAborted(signal) ? "cancelled" : "timeout"; }; diff --git a/src/process/ProviderProcessOutput.test.ts b/src/process/ProviderProcessOutput.test.ts index b8a8235c7d..f8a71a749a 100644 --- a/src/process/ProviderProcessOutput.test.ts +++ b/src/process/ProviderProcessOutput.test.ts @@ -752,9 +752,15 @@ it("unreferences process and stream handles when stop reports incomplete cleanup } }); -it.each(["close", "abort"] as const)( - "awaits output without a deadline until %s", - async (outcome) => { +it.each([ + { outcome: "close", timeoutMs: undefined }, + { outcome: "abort", timeoutMs: undefined }, + { outcome: "close", timeoutMs: 5000 }, + { outcome: "abort", timeoutMs: 5000 }, +] as const)( + "releases output wait resources after $outcome with timeout $timeoutMs", + async ({ outcome, timeoutMs }) => { + vi.useFakeTimers(); const producer = Object.assign(new EventEmitter(), { stdout: new PassThrough(), stderr: new PassThrough(), @@ -770,7 +776,7 @@ it.each(["close", "abort"] as const)( const removeListener = vi.spyOn(controller.signal, "removeEventListener"); let settled = false; const pending = owner - .waitForOutputClose(undefined, controller.signal) + .waitForOutputClose(timeoutMs, controller.signal) .then((result) => { settled = true; return result; @@ -781,11 +787,13 @@ it.each(["close", "abort"] as const)( if (outcome === "close") producer.emit("close", 0, null); else controller.abort(); expect(await pending).toBe(outcome === "close"); + expect(vi.getTimerCount()).toBe(0); expect(removeListener).toHaveBeenCalledWith( "abort", expect.any(Function), ); } finally { + vi.useRealTimers(); removeListener.mockRestore(); owner.dispose(); producer.stdout.destroy(); diff --git a/tests/boundary/providers/hopper/linuxPrivateDisplay.test.ts b/tests/boundary/providers/hopper/linuxPrivateDisplay.test.ts index b87aee72c5..0f18c5b271 100644 --- a/tests/boundary/providers/hopper/linuxPrivateDisplay.test.ts +++ b/tests/boundary/providers/hopper/linuxPrivateDisplay.test.ts @@ -407,12 +407,22 @@ it.skipIf(process.platform === "win32").each(["exited", "cancelled"] as const)( async (outcome) => { const { helper, ready } = await inertProbe(outcome === "cancelled"); const controller = new AbortController(); + const scheduled = vi.spyOn(globalThis, "setTimeout"); + const cleared = vi.spyOn(globalThis, "clearTimeout"); + onTestFinished(() => { + scheduled.mockRestore(); + cleared.mockRestore(); + }); const original = ownership.cleanupOwnedProcessGroup; const cleanup = vi .spyOn(ownership, "cleanupOwnedProcessGroup") - .mockResolvedValue({ - cleaned: false, - reason: "controlled display probe cleanup refusal", + .mockImplementation(async () => { + // Finalization cancellation must not replace a completed probe outcome. + if (outcome === "exited") controller.abort("cancelled during cleanup"); + return { + cleaned: false, + reason: "controlled display probe cleanup refusal", + }; }); let pending: | Extract< @@ -435,6 +445,13 @@ it.skipIf(process.platform === "win32").each(["exited", "cancelled"] as const)( } const result = await operation; expect(result.outcome).toBe(outcome); + // The probe has settled despite refused cleanup; no abandoned output wait + // should keep its original deadline alive until a later cleanup retry. + const deadlines = scheduled.mock.calls.flatMap((arguments_, index) => + arguments_[1] === 5000 ? [scheduled.mock.results[index]!.value] : [], + ); + expect(deadlines.length).toBeGreaterThan(0); + for (const timer of deadlines) expect(cleared).toHaveBeenCalledWith(timer); expect(result.stderr).toBe("authored probe diagnostic"); expect(result.cleanup.status).toBe("pending"); if (result.cleanup.status !== "pending")