fix(cli): cancel camera URL error bodies

vincentkoc · vincentkoc · commit 797865c9dc06 · 2026-06-19T11:57:43.000+02:00
diff --git a/src/cli/nodes-camera.test.ts b/src/cli/nodes-camera.test.ts
@@ -49,6 +49,25 @@ async function expectPathMissing(targetPath: string): Promise<void> {
   throw new Error(`expected missing path: ${targetPath}`);
 }
 
+function cancelTrackedResponse(init?: ResponseInit): {
+  response: Response;
+  wasCanceled: () => boolean;
+} {
+  let canceled = false;
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(new TextEncoder().encode("ignored"));
+    },
+    cancel() {
+      canceled = true;
+    },
+  });
+  return {
+    response: new Response(stream, init),
+    wasCanceled: () => canceled,
+  };
+}
+
 describe("nodes camera helpers", () => {
   beforeAll(async () => {
     ({
@@ -289,6 +308,52 @@ describe("nodes camera helpers", () => {
     },
   );
 
+  it.each([
+    {
+      name: "non-ok status",
+      response: () => cancelTrackedResponse({ status: 503, statusText: "Service Unavailable" }),
+      expectedMessage: /503/i,
+    },
+    {
+      name: "oversized content-length",
+      response: () =>
+        cancelTrackedResponse({
+          status: 200,
+          headers: { "content-length": String(999_999_999) },
+        }),
+      expectedMessage: /exceeds max/i,
+    },
+  ] as const)(
+    "cancels rejected url response bodies: $name",
+    async ({ response, expectedMessage }) => {
+      const tracked = response();
+      stubFetchResponse(tracked.response);
+
+      await expect(
+        writeUrlToFile("/tmp/ignored", "https://198.51.100.42/down.bin", {
+          expectedHost: "198.51.100.42",
+        }),
+      ).rejects.toThrow(expectedMessage);
+      expect(tracked.wasCanceled()).toBe(true);
+    },
+  );
+
+  it("cancels response bodies when a redirect changes host", async () => {
+    const tracked = cancelTrackedResponse({ status: 200 });
+    fetchGuardMocks.fetchWithSsrFGuard.mockResolvedValueOnce({
+      response: tracked.response,
+      finalUrl: "https://198.51.100.43/clip.mp4",
+      release: async () => {},
+    });
+
+    await expect(
+      writeUrlToFile("/tmp/ignored", "https://198.51.100.42/clip.mp4", {
+        expectedHost: "198.51.100.42",
+      }),
+    ).rejects.toThrow(/redirect host/i);
+    expect(tracked.wasCanceled()).toBe(true);
+  });
+
   it("removes partially written file when url stream fails", async () => {
     const stream = new ReadableStream<Uint8Array>({
       start(controller) {
diff --git a/src/cli/nodes-camera.ts b/src/cli/nodes-camera.ts
@@ -37,6 +37,12 @@ export type CameraClipPayload = {
   hasAudio: boolean;
 };
 
+async function cancelIgnoredResponseBody(response: Response | undefined): Promise<void> {
+  if (response?.bodyUsed !== true) {
+    await response?.body?.cancel().catch(() => undefined);
+  }
+}
+
 /** Validate and normalize an unknown camera still-image payload. */
 export function parseCameraSnapPayload(value: unknown): CameraSnapPayload {
   const obj = asRecord(value);
@@ -119,17 +125,20 @@ export async function writeUrlToFile(
       policy,
     });
     release = guarded.release;
+    const res = guarded.response;
     const finalUrl = new URL(guarded.finalUrl);
     if (finalUrl.protocol !== "https:") {
+      await cancelIgnoredResponseBody(res);
       throw new Error(`writeUrlToFile: redirect resolved to non-https URL ${guarded.finalUrl}`);
     }
     if (normalizeHostname(finalUrl.hostname) !== expectedHost) {
+      await cancelIgnoredResponseBody(res);
       throw new Error(
         `writeUrlToFile: redirect host ${finalUrl.hostname} must match node host ${opts.expectedHost}`,
       );
     }
-    const res = guarded.response;
     if (!res.ok) {
+      await cancelIgnoredResponseBody(res);
       throw new Error(`failed to download ${url}: ${res.status} ${res.statusText}`);
     }
 
@@ -140,20 +149,22 @@ export async function writeUrlToFile(
       Number.isFinite(contentLength) &&
       contentLength > MAX_CAMERA_URL_DOWNLOAD_BYTES
     ) {
+      await cancelIgnoredResponseBody(res);
       throw new Error(
         `writeUrlToFile: content-length ${contentLength} exceeds max ${MAX_CAMERA_URL_DOWNLOAD_BYTES}`,
       );
     }
 
     const body = res.body;
     if (!body) {
+      await cancelIgnoredResponseBody(res);
       throw new Error(`failed to download ${url}: empty response body`);
     }
 
     const fileHandle = await fs.open(filePath, "w");
     let thrown: unknown;
+    const reader = body.getReader();
     try {
-      const reader = body.getReader();
       while (true) {
         const { done, value } = await reader.read();
         if (done) {
@@ -164,6 +175,7 @@ export async function writeUrlToFile(
         }
         bytes += value.byteLength;
         if (bytes > MAX_CAMERA_URL_DOWNLOAD_BYTES) {
+          await reader.cancel().catch(() => undefined);
           throw new Error(
             `writeUrlToFile: downloaded ${bytes} bytes, exceeds max ${MAX_CAMERA_URL_DOWNLOAD_BYTES}`,
           );
@@ -172,7 +184,9 @@ export async function writeUrlToFile(
       }
     } catch (err) {
       thrown = err;
+      await reader.cancel().catch(() => undefined);
     } finally {
+      reader.releaseLock();
       await fileHandle.close();
     }
 
