fix(oci): enforce destination validation deadlines

Author: Bill Leoutsakos

apps/sim/lib/internal/oci/client.server.test.ts

@@ -67,6 +67,7 @@ import {
   type OciAuthenticatedResponse,
   type OciClient,
   type OciRequest,
+  verifyOciApiKeyCredentialForSetup,
 } from '@/lib/internal/oci/client.server'
 import {
   createOciDiscoveredEndpointPolicy,
@@ -778,14 +779,7 @@ describe('credential-bound OCI client', () => {
 
   it('propagates caller abort without leaking a transport failure', async () => {
     const controller = new AbortController()
-    mocks.secureFetch.mockImplementationOnce(
-      (_url: string, options: { signal: AbortSignal }) =>
-        new Promise((_resolve, reject) => {
-          options.signal.addEventListener('abort', () => reject(options.signal.reason), {
-            once: true,
-          })
-        })
-    )
+    mocks.secureFetch.mockImplementationOnce(() => new Promise(() => {}))
     const { client, endpoint } = await createPreparedClient()
     const pending = client.request({
       endpoint,
@@ -801,14 +795,7 @@ describe('credential-bound OCI client', () => {
 
   it('applies one deadline to in-flight transport work', async () => {
     vi.useFakeTimers()
-    mocks.secureFetch.mockImplementationOnce(
-      (_url: string, options: { signal: AbortSignal }) =>
-        new Promise((_resolve, reject) => {
-          options.signal.addEventListener('abort', () => reject(options.signal.reason), {
-            once: true,
-          })
-        })
-    )
+    mocks.secureFetch.mockImplementationOnce(() => new Promise(() => {}))
     const { client, endpoint } = await createPreparedClient()
     const pending = client.request({
       endpoint,
@@ -822,6 +809,33 @@ describe('credential-bound OCI client', () => {
     await assertion
   })
 
+  it('propagates caller abort while setup destination validation is pending', async () => {
+    const controller = new AbortController()
+    mocks.secureFetch.mockImplementationOnce(() => new Promise(() => {}))
+    const pending = verifyOciApiKeyCredentialForSetup(SECRET, controller.signal)
+    await vi.waitFor(() => expect(mocks.secureFetch).toHaveBeenCalledOnce())
+    controller.abort()
+    await expect(pending).rejects.toMatchObject({ code: 'aborted' })
+  })
+
+  it('does not start setup destination validation after an earlier caller abort', async () => {
+    const controller = new AbortController()
+    controller.abort()
+    await expect(
+      verifyOciApiKeyCredentialForSetup(SECRET, controller.signal)
+    ).rejects.toMatchObject({ code: 'aborted' })
+    expect(mocks.secureFetch).not.toHaveBeenCalled()
+  })
+
+  it('applies the setup deadline while destination validation is pending', async () => {
+    vi.useFakeTimers()
+    mocks.secureFetch.mockImplementationOnce(() => new Promise(() => {}))
+    const pending = verifyOciApiKeyCredentialForSetup(SECRET)
+    const assertion = expect(pending).rejects.toMatchObject({ code: 'deadline_exceeded' })
+    await vi.advanceTimersByTimeAsync(10_001)
+    await assertion
+  })
+
   it('applies the same deadline while reading the response body', async () => {
     vi.useFakeTimers()
     const cancel = vi.fn()

apps/sim/lib/internal/oci/client.server.ts

@@ -654,19 +654,38 @@ function createDeadline(
   }
 }
 
-async function waitForRetry(delayMs: number, signal: AbortSignal): Promise<void> {
-  if (signal.aborted) throw toError(signal.reason)
-  let rejectAbort: ((reason?: unknown) => void) | undefined
-  const aborted = new Promise<never>((_, reject) => {
-    rejectAbort = reject
+function raceWithAbort<T>(operation: () => Promise<T>, signal: AbortSignal): Promise<T> {
+  if (signal.aborted) return Promise.reject(toError(signal.reason))
+  return new Promise<T>((resolve, reject) => {
+    const cleanup = () => signal.removeEventListener('abort', onAbort)
+    const onAbort = () => {
+      cleanup()
+      reject(toError(signal.reason))
+    }
+    signal.addEventListener('abort', onAbort, { once: true })
+    let pending: Promise<T>
+    try {
+      pending = operation()
+    } catch (error) {
+      cleanup()
+      reject(error)
+      return
+    }
+    pending.then(
+      (value) => {
+        cleanup()
+        resolve(value)
+      },
+      (error: unknown) => {
+        cleanup()
+        reject(error)
+      }
+    )
   })
-  const onAbort = () => rejectAbort?.(signal.reason)
-  signal.addEventListener('abort', onAbort, { once: true })
-  try {
-    await Promise.race([sleep(delayMs), aborted])
-  } finally {
-    signal.removeEventListener('abort', onAbort)
-  }
+}
+
+async function waitForRetry(delayMs: number, signal: AbortSignal): Promise<void> {
+  await raceWithAbort(() => sleep(delayMs), signal)
 }
 
 /** Creates a lazily loaded OCI client bound to trusted workspace and service context. */
@@ -769,20 +788,24 @@ export async function createOciClient(params: CreateOciClientParams): Promise<Oc
 
           let response: SecureFetchResponse
           try {
-            response = await secureFetchWithValidation(
-              signed.url,
-              {
-                method: request.method,
-                headers: { ...signed.headers },
-                ...(signed.body !== undefined ? { body: new Uint8Array(signed.body) } : {}),
-                timeout: Math.max(1, Math.floor(remainingMs)),
-                maxResponseBytes: request.maxResponseBytes,
-                maxRedirects: 0,
-                signal: deadline.signal,
-                profile: 'configuredEndpoint',
-                logUrlValidationDetails: false,
-              },
-              'OCI destination'
+            response = await raceWithAbort(
+              () =>
+                secureFetchWithValidation(
+                  signed.url,
+                  {
+                    method: request.method,
+                    headers: { ...signed.headers },
+                    ...(signed.body !== undefined ? { body: new Uint8Array(signed.body) } : {}),
+                    timeout: Math.max(1, Math.floor(remainingMs)),
+                    maxResponseBytes: request.maxResponseBytes,
+                    maxRedirects: 0,
+                    signal: deadline.signal,
+                    profile: 'configuredEndpoint',
+                    logUrlValidationDetails: false,
+                  },
+                  'OCI destination'
+                ),
+              deadline.signal
             )
           } catch (error) {
             if (deadline.signal.aborted) {
@@ -891,19 +914,23 @@ export async function verifyOciApiKeyCredentialForSetup(
       headers: { accept: 'application/json' },
       signingDate: new Date(),
     })
-    const response = await secureFetchWithValidation(
-      signed.url,
-      {
-        method: 'GET',
-        headers: { ...signed.headers },
-        timeout: SETUP_VERIFICATION_TIMEOUT_MS,
-        maxResponseBytes: SETUP_VERIFICATION_RESPONSE_BYTES,
-        maxRedirects: 0,
-        signal: deadline.signal,
-        profile: 'configuredEndpoint',
-        logUrlValidationDetails: false,
-      },
-      'OCI credential verification destination'
+    const response = await raceWithAbort(
+      () =>
+        secureFetchWithValidation(
+          signed.url,
+          {
+            method: 'GET',
+            headers: { ...signed.headers },
+            timeout: SETUP_VERIFICATION_TIMEOUT_MS,
+            maxResponseBytes: SETUP_VERIFICATION_RESPONSE_BYTES,
+            maxRedirects: 0,
+            signal: deadline.signal,
+            profile: 'configuredEndpoint',
+            logUrlValidationDetails: false,
+          },
+          'OCI credential verification destination'
+        ),
+      deadline.signal
     )
     if (!response.ok) {
       await readFailureCode(response, deadline.signal)