Improve suppressed recurse diagnostics and output/body error handling

Add debug logging for suppressed recursive lookup failures so best-effort
runs leave traceable diagnostics for both thrown lookup errors and not-found
results.

In traverse mode, isolate output writing failures from traversal/fetch
failures by handling separator/object write errors in an inner try/catch and
failing with an output-specific message.

For image downloads, cancel non-OK terminal response bodies before returning
null to avoid retaining response body resources in manual-fetch paths.

#608 (comment)
#608 (comment)
#608 (comment)
#608 (comment)

Co-Authored-By: Codex <codex@openai.com>

Author: dahlia

packages/cli/src/imagerenderer.test.ts

@@ -149,3 +149,24 @@ test("downloadImage - cancels redirect body when location is missing", async ()
     globalThis.fetch = originalFetch;
   }
 });
+
+test("downloadImage - cancels body for non-ok terminal response", async () => {
+  let cancelled = 0;
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = ((_input: URL | RequestInfo) => {
+    const body = new ReadableStream<Uint8Array>({
+      cancel() {
+        cancelled++;
+      },
+    });
+    return Promise.resolve(new Response(body, { status: 500 }));
+  }) as typeof fetch;
+
+  try {
+    const result = await downloadImage("https://example.com/image.png");
+    assert.equal(result, null);
+    assert.equal(cancelled, 1);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});

packages/cli/src/imagerenderer.ts

@@ -125,7 +125,11 @@ export async function downloadImage(url: string): Promise<string | null> {
       }
       break;
     }
-    if (response == null || !response.ok) return null;
+    if (response == null) return null;
+    if (!response.ok) {
+      await response.body?.cancel();
+      return null;
+    }
     const imageData = new Uint8Array(await response.arrayBuffer());
     const extension = new URL(targetUrl).pathname.split(".").pop() || "jpg";
     const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "fedify"));

packages/cli/src/lookup.ts

@@ -534,11 +534,25 @@ export async function collectRecursiveObjects(
     try {
       next = await lookup(target);
     } catch (error) {
-      if (options.suppressErrors) break;
+      if (options.suppressErrors) {
+        logger.debug(
+          "Failed to recursively fetch object {target}, " +
+            "but suppressing error: {error}",
+          { target, error },
+        );
+        break;
+      }
       throw error;
     }
     if (next == null) {
-      if (options.suppressErrors) break;
+      if (options.suppressErrors) {
+        logger.debug(
+          "Failed to recursively fetch object {target} " +
+            "(not found), but suppressing error.",
+          { target },
+        );
+        break;
+      }
       throw new RecursiveLookupError(target);
     }
     results.push(next);
@@ -950,16 +964,26 @@ export async function runLookup(
             suppressError: command.suppressErrors,
           })
         ) {
-          if (totalItems > 0 || collectionItems > 0) {
-            await writeSeparator(command.separator, getOutputStream());
+          try {
+            if (totalItems > 0 || collectionItems > 0) {
+              await writeSeparator(command.separator, getOutputStream());
+            }
+            await writeObjectToStream(
+              item,
+              command.output,
+              command.format,
+              contextLoader,
+              getOutputStream(),
+            );
+          } catch (error) {
+            logger.error("Failed to write output for {url}: {error}", {
+              url,
+              error,
+            });
+            spinner.fail(`Failed to write output for: ${colors.red(url)}.`);
+            await finalizeAndExit(1);
+            return;
           }
-          await writeObjectToStream(
-            item,
-            command.output,
-            command.format,
-            contextLoader,
-            getOutputStream(),
-          );
           collectionItems++;
           totalItems++;
         }