fix(network): replay Request bodies across redirects

Author: waleedlatif1

apps/sim/lib/core/security/guarded-request-fetch.server.test.ts

@@ -134,6 +134,93 @@ describe('createSsrfGuardedFetchWithDispatcher (undici.request backed)', () => {
     expect(await response.text()).toBe('final-body')
   })
 
+  it.each([
+    [307, 'POST'],
+    [308, 'POST'],
+    [301, 'PUT'],
+    [302, 'PUT'],
+  ] as const)('replays a Request body through same-origin %s redirects', async (status, method) => {
+    const payloads: string[] = []
+    mockUndiciRequest.mockImplementation(async (_url, options: { body: Buffer | Readable }) => {
+      const chunks: Buffer[] = []
+      for await (const chunk of options.body instanceof Readable ? options.body : [options.body]) {
+        chunks.push(Buffer.from(chunk))
+      }
+      payloads.push(Buffer.concat(chunks).toString())
+      return payloads.length < 3
+        ? undiciReply(status, { location: `/hop-${payloads.length}` }, byteStream(''))
+        : undiciReply(200, {}, byteStream('done'))
+    })
+    const transport = createSsrfGuardedFetchWithDispatcher({ profile: 'configuredEndpoint' })
+    try {
+      const response = await transport.fetch(
+        new Request('https://api.example.com/start', {
+          method,
+          headers: { 'content-type': 'application/json' },
+          body: '{"payload":"replay"}',
+        })
+      )
+      expect(await response.text()).toBe('done')
+      expect(payloads).toEqual(Array(3).fill('{"payload":"replay"}'))
+      expect(response.redirected).toBe(true)
+      expect(mockUndiciRequest.mock.calls.map(([, options]) => options.method)).toEqual(
+        Array(3).fill(method)
+      )
+    } finally {
+      await transport.dispatcher.destroy()
+    }
+  })
+
+  it.each(['manual', 'error'] as const)(
+    'keeps Request bodies streaming in %s mode',
+    async (redirect) => {
+      const request = new Request('https://api.example.com/upload', {
+        method: 'POST',
+        redirect,
+        body: 'payload',
+      })
+      const transport = createSsrfGuardedFetchWithDispatcher({ profile: 'configuredEndpoint' })
+      mockUndiciRequest.mockImplementationOnce(async (_url, options: { body: Readable }) => {
+        expect(options.body).toBeInstanceOf(Readable)
+        const chunks: Buffer[] = []
+        for await (const chunk of options.body) chunks.push(Buffer.from(chunk))
+        expect(Buffer.concat(chunks).toString()).toBe('payload')
+        return undiciReply(200, {}, byteStream('done'))
+      })
+      try {
+        expect(await (await transport.fetch(request)).text()).toBe('done')
+      } finally {
+        await transport.dispatcher.destroy()
+      }
+    }
+  )
+
+  it('does not read the Request body when init supplies a replacement', async () => {
+    const request = new Request('https://api.example.com/upload', {
+      method: 'POST',
+      body: 'original',
+    })
+    const clone = vi.spyOn(request, 'clone')
+    const bodyOverride = vi.fn().mockReturnValueOnce('replacement').mockReturnValue(undefined)
+    mockUndiciRequest.mockResolvedValueOnce(undiciReply(200, {}, byteStream('done')))
+    const transport = createSsrfGuardedFetchWithDispatcher({ profile: 'configuredEndpoint' })
+    try {
+      const response = await transport.fetch(request, {
+        get body() {
+          return bodyOverride()
+        },
+      })
+      expect(await response.text()).toBe('done')
+      expect(mockUndiciRequest.mock.calls[0][1].body).toBe('replacement')
+      expect(request.bodyUsed).toBe(false)
+      expect(clone).not.toHaveBeenCalled()
+      expect(bodyOverride).toHaveBeenCalledTimes(1)
+    } finally {
+      await request.body?.cancel()
+      await transport.dispatcher.destroy()
+    }
+  })
+
   it('supports buffered reads (.json()) through the constructed body', async () => {
     mockUndiciRequest.mockResolvedValueOnce(
       undiciReply(

apps/sim/lib/core/security/input-validation.server.ts

@@ -893,26 +893,32 @@ async function undiciRequestAsResponse(
  * fetch semantics) so a manual redirect follower can't silently downgrade a POST Request to a
  * bare GET or lose its headers.
  */
-function liftFetchArgs(
+async function liftFetchArgs(
   input: RequestInfo | URL,
   init?: RequestInit
-): { target: string; effectiveInit: RequestInit } {
+): Promise<{ target: string; effectiveInit: RequestInit }> {
   const target = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url
   if (typeof Request !== 'undefined' && input instanceof Request) {
     const bodyAllowed = input.method !== 'GET' && input.method !== 'HEAD'
-    return {
-      target,
-      effectiveInit: {
-        method: input.method,
-        headers: input.headers,
-        body: bodyAllowed ? input.body : undefined,
-        signal: input.signal,
-        // Carry the Request's redirect mode so the pinned fetch honors `manual`/`error`
-        // instead of defaulting a `Request({ redirect: 'manual' })` to `follow`.
-        redirect: input.redirect,
-        ...init,
-      },
+    const effectiveInit: RequestInit = {
+      method: input.method,
+      headers: input.headers,
+      body: bodyAllowed ? input.body : undefined,
+      signal: input.signal,
+      // Carry the Request's redirect mode so the pinned fetch honors `manual`/`error`
+      // instead of defaulting a `Request({ redirect: 'manual' })` to `follow`.
+      redirect: input.redirect,
+      ...init,
+    }
+    /** Request hides its original body source, so following redirects requires replayable bytes. */
+    if (
+      !Object.hasOwn(init ?? {}, 'body') &&
+      effectiveInit.body &&
+      (effectiveInit.redirect ?? 'follow') === 'follow'
+    ) {
+      effectiveInit.body = await input.clone().arrayBuffer()
     }
+    return { target, effectiveInit }
   }
   return { target, effectiveInit: init ?? {} }
 }
@@ -941,7 +947,7 @@ function createValidatedFetch(
   return {
     dispatcher,
     fetch: async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-      const { target, effectiveInit } = liftFetchArgs(input, init)
+      const { target, effectiveInit } = await liftFetchArgs(input, init)
       const mode = effectiveInit.redirect ?? 'follow'
       // double-cast-allowed: DOM and Undici RequestInit represent the same wire request in this bridge
       const undiciInit = effectiveInit as unknown as UndiciRequestInit