OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security
TypeScript ai-securityapplication-securityclicode-scanningcodexcodex-securitycybersecuritydevsecopsnodejsnpmopenaisdksecuritytypescriptvulnerability-scanning
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.tsindex 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.tsnew file mode 100644index 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);+ }+ });+}