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(sdk): share close completion before abort callbacks (#1732)

Michael D'Angelo3a8c30da2df5
diff --git a/sdk/typescript/src/api.ts b/sdk/typescript/src/api.ts
index 8646467fd..584881145 100644
--- a/sdk/typescript/src/api.ts
+++ b/sdk/typescript/src/api.ts
@@ -3111,7 +3111,10 @@ export class CodexSecurity {
public async close(): Promise<void> {
if (this.#closePromise !== null) return await this.#closePromise;
this.#closed = true;
- this.#closePromise = this.#finishClose();
+ const completion = Promise.withResolvers<void>();
+ // Abort listeners can reenter close before finishClose reaches its first await.
+ this.#closePromise = completion.promise;
+ void this.#finishClose().then(completion.resolve, completion.reject);
await this.#closePromise;
}
diff --git a/sdk/typescript/tests-ts/api.test.ts b/sdk/typescript/tests-ts/api.test.ts
index 9dba00660..78ac1eb19 100644
--- a/sdk/typescript/tests-ts/api.test.ts
+++ b/sdk/typescript/tests-ts/api.test.ts
@@ -5280,6 +5280,144 @@ describe("CodexSecurity orchestration", () => {
},
);
+ test.each(
+ [false, true].flatMap((reenter) =>
+ [false, true].map((failCleanup) => ({ reenter, failCleanup })),
+ ),
+ )(
+ "close shares cleanup during abort reentry=$reenter and failure=$failCleanup",
+ async ({ reenter, failCleanup }) => {
+ const { root, repository, codexHome, scanDir } = await scanDirectories();
+ const prepared: ReturnType<typeof preparedRuntime> = {
+ ...preparedRuntime(codexHome),
+ };
+ const requestStarted = Promise.withResolvers<void>();
+ const operationRelease = Promise.withResolvers<void>();
+ const cleanupStarted = Promise.withResolvers<void>();
+ const cleanupRelease = Promise.withResolvers<void>();
+ const controller = new AbortController();
+ const deadline = AbortSignal.timeout(5_000);
+ const rejectReadiness = () => requestStarted.reject(deadline.reason);
+ deadline.addEventListener("abort", rejectReadiness, { once: true });
+ const failure = new Error("synthetic runtime cleanup failure");
+ const closes: Array<{ settled: boolean; result: Promise<unknown> }> = [];
+ const observeClose = (pending: Promise<void>) => {
+ const observed = {
+ settled: false,
+ result: pending.catch((error: unknown) => error),
+ };
+ observed.result = observed.result.finally(() => {
+ observed.settled = true;
+ });
+ closes.push(observed);
+ };
+ let cleanupCalls = 0;
+ let scanSignal: AbortSignal | undefined;
+ let budgetSignal: AbortSignal | undefined;
+ const client = new TestClient(
+ { codexOverrides: { model: "gpt-5.6-sol" } },
+ {
+ ...scanRuntimeDependencies(codexHome, scanDir),
+ prepareRuntime: async () => prepared,
+ createCodex: codexFactory(
+ async (_input: string, { signal }: { signal: AbortSignal }) => {
+ scanSignal = signal;
+ prepared.providerProfile = {
+ name: "synthetic-cleanup-observer",
+ path: join(root, "unused-profile.toml"),
+ async cleanup() {
+ cleanupCalls++;
+ cleanupStarted.resolve();
+ await cleanupRelease.promise;
+ if (failCleanup) throw failure;
+ },
+ };
+ async function* events(): AsyncGenerator<ThreadEvent> {
+ yield { type: "thread.started", thread_id: "scan-thread" };
+ await writeUsageSession(codexHome, "scan-thread", {
+ input_tokens: 900,
+ output_tokens: 0,
+ });
+ await (signal.aborted ? undefined : once(signal, "abort"));
+ await operationRelease.promise;
+ signal.throwIfAborted();
+ }
+ return { events: events() };
+ },
+ ),
+ },
+ );
+ const keepAlive = setTimeout(() => {}, 10_000);
+ const scan = client
+ .run(repository, {
+ mode: "standard",
+ maxCostUsd: 0.004,
+ signal: AbortSignal.any([controller.signal, deadline]),
+ onBudgetApproaching: ({ signal }) => {
+ budgetSignal = signal;
+ if (reenter) {
+ signal.addEventListener(
+ "abort",
+ () => observeClose(client.close()),
+ {
+ once: true,
+ },
+ );
+ signal.addEventListener(
+ "abort",
+ () => observeClose(client[Symbol.asyncDispose]()),
+ { once: true },
+ );
+ }
+ requestStarted.resolve();
+ return undefined;
+ },
+ })
+ .catch((error: unknown) => error);
+ try {
+ await Promise.race([
+ requestStarted.promise,
+ scan.then((result) => {
+ throw new Error("Scan ended before its budget callback", {
+ cause: result,
+ });
+ }),
+ ]);
+ observeClose(client.close());
+ expect(scanSignal?.aborted).toBe(true);
+ expect(budgetSignal?.aborted).toBe(true);
+ observeClose(client.close());
+ await new Promise((resolve) => setImmediate(resolve));
+ expect(cleanupCalls).toBe(0);
+ expect(closes.every(({ settled }) => !settled)).toBe(true);
+ operationRelease.resolve();
+ await cleanupStarted.promise;
+ await new Promise((resolve) => setImmediate(resolve));
+ expect(closes).toHaveLength(reenter ? 4 : 2);
+ expect(closes.every(({ settled }) => !settled)).toBe(true);
+ cleanupRelease.resolve();
+ for (const close of closes) {
+ expect(await close.result).toBe(failCleanup ? failure : undefined);
+ }
+ const late = client.close().catch((error: unknown) => error);
+ expect(await late).toBe(failCleanup ? failure : undefined);
+ expect(cleanupCalls).toBe(1);
+ expect(await scan).toMatchObject({
+ message: "CodexSecurity is closed.",
+ });
+ } finally {
+ clearTimeout(keepAlive);
+ deadline.removeEventListener("abort", rejectReadiness);
+ controller.abort();
+ operationRelease.resolve();
+ cleanupRelease.resolve();
+ await client.close().catch(() => {});
+ await scan;
+ await Promise.all(closes.map(({ result }) => result));
+ }
+ },
+ );
+
test("raises a live budget twice without restarting or resetting accumulated usage", async () => {
const { root, repository, codexHome } = await runtimeDirectories();
const scanDir = join(root, "scan");