Skip to content

OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security

fix(retry): honor waits longer than the Node timer limit (#1813)

Michael D'Angelo22657551e158
diff --git a/sdk/typescript/src/deduplication/retry.ts b/sdk/typescript/src/deduplication/retry.ts
index 384a21619..65f2d9468 100644
--- a/sdk/typescript/src/deduplication/retry.ts
+++ b/sdk/typescript/src/deduplication/retry.ts
@@ -1,5 +1,7 @@
import { setTimeout } from "node:timers/promises";
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+
export function retryDelay(attempt: number, random = Math.random): number {
return 1_000 * 2 ** (attempt - 1) * (1 + random());
}
@@ -10,6 +12,10 @@ export async function waitForRetry(
): Promise<void> {
signal?.throwIfAborted();
try {
+ while (delayMs > MAX_TIMER_DELAY_MS) {
+ await setTimeout(MAX_TIMER_DELAY_MS, undefined, { signal });
+ delayMs -= MAX_TIMER_DELAY_MS;
+ }
await setTimeout(delayMs, undefined, { signal });
} catch (error) {
signal?.throwIfAborted();
diff --git a/sdk/typescript/tests-ts/deduplication-retry.test.ts b/sdk/typescript/tests-ts/deduplication-retry.test.ts
new file mode 100644
index 000000000..fa2e8b56e
--- /dev/null
+++ b/sdk/typescript/tests-ts/deduplication-retry.test.ts
@@ -0,0 +1,152 @@
+import { setImmediate } from "node:timers";
+import { afterEach, expect, mock, spyOn, test } from "bun:test";
+import { runTestInSubprocess } from "./support/test-subprocess.js";
+
+const maximumDelay = 2_147_483_647;
+const flush = () => new Promise<void>((resolve) => setImmediate(resolve));
+afterEach(() => mock.restore());
+
+function controlledTimers() {
+ const timers: Array<{
+ delay: number;
+ signal?: AbortSignal;
+ resolve: () => void;
+ }> = [];
+ mock.module("node:timers/promises", () => ({
+ setTimeout: (
+ delay: number,
+ _value: undefined,
+ { signal }: { signal?: AbortSignal },
+ ) => {
+ signal?.throwIfAborted();
+ const pending = Promise.withResolvers<void>();
+ const abort = () =>
+ pending.reject(new DOMException("Timer aborted", "AbortError"));
+ signal?.addEventListener("abort", abort, { once: true });
+ timers.push({ delay, signal, resolve: pending.resolve });
+ return pending.promise.finally(() =>
+ signal?.removeEventListener("abort", abort),
+ );
+ },
+ }));
+ return timers;
+}
+
+for (const [delay, intervals] of [
+ [0, [0]],
+ [100, [100]],
+ [maximumDelay, [maximumDelay]],
+ [maximumDelay + 1, [maximumDelay, 1]],
+ [2 * maximumDelay, [maximumDelay, maximumDelay]],
+ [2 * maximumDelay + 123, [maximumDelay, maximumDelay, 123]],
+] as const) {
+ const name = `waits for the full ${delay}ms using supported timers`;
+ test(name, async () => {
+ if (runTestInSubprocess(import.meta.path, name)) return;
+ const timers = controlledTimers();
+ const { waitForRetry } = await import("../src/deduplication/retry.js");
+ let completed = false;
+ const waiting = waitForRetry(delay).then(() => {
+ completed = true;
+ });
+ for (const [index, interval] of intervals.entries()) {
+ await flush();
+ expect(completed).toBe(false);
+ expect(timers).toHaveLength(index + 1);
+ expect(timers[index]!.delay).toBe(interval);
+ timers[index]!.resolve();
+ }
+ await waiting;
+ expect(completed).toBe(true);
+ expect(timers).toHaveLength(intervals.length);
+ });
+}
+
+for (const stage of ["before waiting", "first interval", "later interval"]) {
+ const name = `preserves cancellation during ${stage}`;
+ test(name, async () => {
+ if (runTestInSubprocess(import.meta.path, name)) return;
+ const timers = controlledTimers();
+ const { waitForRetry } = await import("../src/deduplication/retry.js");
+ const controller = new AbortController();
+ const reason = new Error("Synthetic retry cancellation");
+ if (stage === "before waiting") controller.abort(reason);
+ const waiting = waitForRetry(
+ 2 * maximumDelay + 123,
+ controller.signal,
+ ).catch((error: unknown) => error);
+ if (stage === "later interval") {
+ timers[0]!.resolve();
+ await flush();
+ }
+ const count =
+ stage === "before waiting" ? 0 : stage === "first interval" ? 1 : 2;
+ expect(timers).toHaveLength(count);
+ expect(timers.every((timer) => timer.signal === controller.signal)).toBe(
+ true,
+ );
+ controller.abort(reason);
+ expect(await waiting).toBe(reason);
+ expect(timers).toHaveLength(count);
+ });
+}
+
+for (const kind of ["seconds", "HTTP date", "cancelled seconds"]) {
+ const name = `honors a long Retry-After in ${kind} before another request`;
+ test(name, async () => {
+ if (runTestInSubprocess(import.meta.path, name)) return;
+ const timers = controlledTimers();
+ const { FindingsClient } = await import("../src/findings-client.js");
+ const now = Date.UTC(2030, 0, 1);
+ spyOn(Date, "now").mockReturnValue(now);
+ const retryAfter =
+ kind === "HTTP date"
+ ? new Date(now + 2_147_484_000).toUTCString()
+ : "2147484";
+ const controller = new AbortController();
+ let requests = 0;
+ const request = mock(async () =>
+ ++requests === 1
+ ? new Response("busy", {
+ status: 429,
+ headers: { "Retry-After": retryAfter },
+ })
+ : Response.json({
+ finding: { findingId: "synthetic" },
+ potentialDuplicates: [],
+ }),
+ );
+ const client = new FindingsClient(
+ "http://synthetic.test",
+ controller.signal,
+ request,
+ { random: () => 0 },
+ );
+ const result = client
+ .potentialDuplicates("synthetic", {
+ repositoryId: "synthetic-repository",
+ })
+ .catch((error: unknown) => error);
+ await flush();
+ expect(request).toHaveBeenCalledTimes(1);
+ expect(timers).toHaveLength(1);
+ expect(timers[0]!.delay).toBe(maximumDelay);
+ timers[0]!.resolve();
+ await flush();
+ expect(request).toHaveBeenCalledTimes(1);
+ expect(timers).toHaveLength(2);
+ expect(timers[1]!.delay).toBe(353);
+ if (kind === "cancelled seconds") {
+ const reason = new Error("Synthetic request cancellation");
+ controller.abort(reason);
+ expect(await result).toBe(reason);
+ expect(request).toHaveBeenCalledTimes(1);
+ } else {
+ timers[1]!.resolve();
+ expect(await result).toMatchObject({
+ finding: { findingId: "synthetic" },
+ });
+ expect(request).toHaveBeenCalledTimes(2);
+ }
+ });
+}