@jackwener/opencli 1.3.3 → 1.4.1

package/dist/interceptor.js

@@ -8,6 +8,42 @@
  *   - stepIntercept              (pipeline/steps/intercept.ts)
  *   - stepTap                    (pipeline/steps/tap.ts)
  */
+/**
+ * Helper: define a non-enumerable property on window.
+ * Avoids detection via Object.keys(window) or for..in loops.
+ */
+const DEFINE_HIDDEN = `
+      function __defHidden(obj, key, val) {
+        try {
+          Object.defineProperty(obj, key, { value: val, writable: true, enumerable: false, configurable: true });
+        } catch { obj[key] = val; }
+      }`;
+/**
+ * Helper: disguise a patched function so toString() returns native code signature.
+ */
+const DISGUISE_FN = `
+      function __disguise(fn, name) {
+        const nativeStr = 'function ' + name + '() { [native code] }';
+        // Override toString on the instance AND patch Function.prototype.toString
+        // to handle Function.prototype.toString.call(fn) bypasses.
+        const _origToString = Function.prototype.toString;
+        const _patchedFns = window.__dFns || (function() {
+          const m = new Map();
+          Object.defineProperty(window, '__dFns', { value: m, enumerable: false, configurable: true });
+          // Patch Function.prototype.toString once to consult the map
+          Object.defineProperty(Function.prototype, 'toString', {
+            value: function() {
+              const override = m.get(this);
+              return override !== undefined ? override : _origToString.call(this);
+            },
+            writable: true, configurable: true
+          });
+          return m;
+        })();
+        _patchedFns.set(fn, nativeStr);
+        try { Object.defineProperty(fn, 'name', { value: name, configurable: true }); } catch {}
+        return fn;
+      }`;
 /**
  * Generate JavaScript source that installs a fetch/XHR interceptor.
  * Captured responses are pushed to `window.__opencli_intercepted`.
@@ -19,18 +55,23 @@
 export function generateInterceptorJs(patternExpr, opts = {}) {
     const arr = opts.arrayName ?? '__opencli_intercepted';
     const guard = opts.patchGuard ?? '__opencli_interceptor_patched';
+    // Store the current pattern in a separate global so it can be updated
+    // without re-patching fetch/XHR (the patchGuard only prevents double-patching).
+    const patternVar = `${guard}_pattern`;
     return `
     () => {
-      window.${arr} = window.${arr} || [];
-      window.${arr}_errors = window.${arr}_errors || [];
-      const __pattern = ${patternExpr};
+      ${DEFINE_HIDDEN}
+      ${DISGUISE_FN}
 
-      if (!window.${guard}) {
-        const __checkMatch = (url) => __pattern && url.includes(__pattern);
+      if (!window.${arr}) __defHidden(window, '${arr}', []);
+      if (!window.${arr}_errors) __defHidden(window, '${arr}_errors', []);
+      __defHidden(window, '${patternVar}', ${patternExpr});
+      const __checkMatch = (url) => window.${patternVar} && url.includes(window.${patternVar});
 
+      if (!window.${guard}) {
         // ── Patch fetch ──
         const __origFetch = window.fetch;
-        window.fetch = async function(...args) {
+        window.fetch = __disguise(async function(...args) {
           const reqUrl = typeof args[0] === 'string' ? args[0]
             : (args[0] && args[0].url) || '';
           const response = await __origFetch.apply(this, args);
@@ -42,28 +83,28 @@ export function generateInterceptorJs(patternExpr, opts = {}) {
             } catch(e) { window.${arr}_errors.push({ url: reqUrl, error: String(e) }); }
           }
           return response;
-        };
+        }, 'fetch');
 
         // ── Patch XMLHttpRequest ──
         const __XHR = XMLHttpRequest.prototype;
         const __origOpen = __XHR.open;
         const __origSend = __XHR.send;
-        __XHR.open = function(method, url) {
-          this.__opencli_url = String(url);
+        __XHR.open = __disguise(function(method, url) {
+          Object.defineProperty(this, '__iurl', { value: String(url), writable: true, enumerable: false, configurable: true });
           return __origOpen.apply(this, arguments);
-        };
-        __XHR.send = function() {
-          if (__checkMatch(this.__opencli_url)) {
+        }, 'open');
+        __XHR.send = __disguise(function() {
+          if (__checkMatch(this.__iurl)) {
             this.addEventListener('load', function() {
               try {
                 window.${arr}.push(JSON.parse(this.responseText));
-              } catch(e) { window.${arr}_errors.push({ url: this.__opencli_url, error: String(e) }); }
+              } catch(e) { window.${arr}_errors.push({ url: this.__iurl, error: String(e) }); }
             });
           }
           return __origSend.apply(this, arguments);
-        };
+        }, 'send');
 
-        window.${guard} = true;
+        __defHidden(window, '${guard}', true);
       }
     }
   `;
@@ -94,13 +135,19 @@ export function generateTapInterceptorJs(patternExpr) {
       let captureResolve;
       const capturePromise = new Promise(r => { captureResolve = r; });
       const capturePattern = ${patternExpr};
+      function __disguise(fn, name) {
+        const s = 'function ' + name + '() { [native code] }';
+        Object.defineProperty(fn, 'toString', { value: function() { return s; }, writable: true, configurable: true, enumerable: false });
+        try { Object.defineProperty(fn, 'name', { value: name, configurable: true }); } catch {}
+        return fn;
+      }
     `,
         capturedVar: 'captured',
         promiseVar: 'capturePromise',
         resolveVar: 'captureResolve',
         fetchPatch: `
       const origFetch = window.fetch;
-      window.fetch = async function(...fetchArgs) {
+      window.fetch = __disguise(async function(...fetchArgs) {
         const resp = await origFetch.apply(this, fetchArgs);
         try {
           const url = typeof fetchArgs[0] === 'string' ? fetchArgs[0]
@@ -110,17 +157,17 @@ export function generateTapInterceptorJs(patternExpr) {
           }
         } catch {}
         return resp;
-      };
+      }, 'fetch');
     `,
         xhrPatch: `
       const origXhrOpen = XMLHttpRequest.prototype.open;
       const origXhrSend = XMLHttpRequest.prototype.send;
-      XMLHttpRequest.prototype.open = function(method, url) {
-        this.__tapUrl = String(url);
+      XMLHttpRequest.prototype.open = __disguise(function(method, url) {
+        Object.defineProperty(this, '__iurl', { value: String(url), writable: true, enumerable: false, configurable: true });
         return origXhrOpen.apply(this, arguments);
-      };
-      XMLHttpRequest.prototype.send = function(body) {
-        if (capturePattern && this.__tapUrl?.includes(capturePattern)) {
+      }, 'open');
+      XMLHttpRequest.prototype.send = __disguise(function(body) {
+        if (capturePattern && this.__iurl?.includes(capturePattern)) {
           this.addEventListener('load', function() {
             if (!captured) {
               try { captured = JSON.parse(this.responseText); captureResolve(); } catch {}
@@ -128,7 +175,7 @@ export function generateTapInterceptorJs(patternExpr) {
           });
         }
         return origXhrSend.apply(this, arguments);
-      };
+      }, 'send');
     `,
         restorePatch: `
       window.fetch = origFetch;

package/dist/main.js

@@ -18,6 +18,7 @@ import { fileURLToPath } from 'node:url';
 import { discoverClis, discoverPlugins } from './discovery.js';
 import { getCompletions } from './completion.js';
 import { runCli } from './cli.js';
+import { emitHook } from './hooks.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const BUILTIN_CLIS = path.resolve(__dirname, 'clis');
@@ -46,4 +47,5 @@ if (getCompIdx !== -1) {
     process.stdout.write(candidates.join('\n') + '\n');
     process.exit(0);
 }
+await emitHook('onStartup', { command: '__startup__', args: {} });
 runCli(BUILTIN_CLIS, USER_CLIS);

package/dist/output.js

@@ -4,6 +4,12 @@
 import chalk from 'chalk';
 import Table from 'cli-table3';
 import yaml from 'js-yaml';
+function normalizeRows(data) {
+    return Array.isArray(data) ? data : [data];
+}
+function resolveColumns(rows, opts) {
+    return opts.columns ?? Object.keys(rows[0] ?? {});
+}
 export function render(data, opts = {}) {
     const fmt = opts.fmt ?? 'table';
     if (data === null || data === undefined) {
@@ -31,12 +37,12 @@ export function render(data, opts = {}) {
     }
 }
 function renderTable(data, opts) {
-    const rows = Array.isArray(data) ? data : [data];
+    const rows = normalizeRows(data);
     if (!rows.length) {
         console.log(chalk.dim('(no data)'));
         return;
     }
-    const columns = opts.columns ?? Object.keys(rows[0]);
+    const columns = resolveColumns(rows, opts);
     const header = columns.map(c => capitalize(c));
     const table = new Table({
         head: header.map(h => chalk.bold(h)),
@@ -68,10 +74,10 @@ function renderJson(data) {
     console.log(JSON.stringify(data, null, 2));
 }
 function renderMarkdown(data, opts) {
-    const rows = Array.isArray(data) ? data : [data];
+    const rows = normalizeRows(data);
     if (!rows.length)
         return;
-    const columns = opts.columns ?? Object.keys(rows[0]);
+    const columns = resolveColumns(rows, opts);
     console.log('| ' + columns.join(' | ') + ' |');
     console.log('| ' + columns.map(() => '---').join(' | ') + ' |');
     for (const row of rows) {
@@ -79,10 +85,10 @@ function renderMarkdown(data, opts) {
     }
 }
 function renderCsv(data, opts) {
-    const rows = Array.isArray(data) ? data : [data];
+    const rows = normalizeRows(data);
     if (!rows.length)
         return;
-    const columns = opts.columns ?? Object.keys(rows[0]);
+    const columns = resolveColumns(rows, opts);
     console.log(columns.join(','));
     for (const row of rows) {
         console.log(columns.map(c => {

package/dist/pipeline/executor.js

@@ -5,7 +5,7 @@ import { getStep } from './registry.js';
 import { log } from '../logger.js';
 import { ConfigError } from '../errors.js';
 /** Steps that interact with the browser and may fail transiently */
-const BROWSER_STEPS = new Set(['navigate', 'evaluate', 'click', 'type', 'press', 'wait', 'snapshot', 'scroll']);
+const BROWSER_STEPS = new Set(['navigate', 'evaluate', 'click', 'type', 'press', 'wait', 'snapshot']);
 export async function executePipeline(page, pipeline, ctx = {}) {
     const args = ctx.args ?? {};
     const debug = ctx.debug ?? false;

package/dist/pipeline/steps/browser.js

@@ -3,9 +3,7 @@
  * Browser interaction primitives.
  */
 import { render } from '../template.js';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
+import { isRecord } from '../../utils.js';
 export async function stepNavigate(page, params, data, args) {
     if (isRecord(params) && 'url' in params) {
         const url = String(render(params.url, { args, data }));

package/dist/pipeline/steps/download.js

@@ -10,30 +10,16 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { render } from '../template.js';
+import { getErrorMessage } from '../../errors.js';
 import { httpDownload, ytdlpDownload, saveDocument, detectContentType, requiresYtdlp, sanitizeFilename, generateFilename, exportCookiesToNetscape, getTempDir, formatCookieHeader, } from '../../download/index.js';
 import { DownloadProgressTracker, formatBytes } from '../../download/progress.js';
-/**
- * Simple async concurrency limiter for downloads.
- */
-async function mapConcurrent(items, limit, fn) {
-    const results = new Array(items.length);
-    let index = 0;
-    async function worker() {
-        while (index < items.length) {
-            const i = index++;
-            results[i] = await fn(items[i], i);
-        }
-    }
-    const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
-    await Promise.all(workers);
-    return results;
-}
+import { mapConcurrent } from '../../utils.js';
 /**
  * Extract cookies from browser page.
  */
 async function extractBrowserCookies(page, domain) {
     try {
-        const cookies = await page.getCookies(domain ? { domain } : {});
+        const cookies = await page.getCookies({ domain });
         return formatCookieHeader(cookies);
     }
     catch {
@@ -61,6 +47,13 @@ async function extractCookiesArray(page, domain) {
         return [];
     }
 }
+function dedupeCookies(cookies) {
+    const deduped = new Map();
+    for (const cookie of cookies) {
+        deduped.set(`${cookie.domain}\t${cookie.path}\t${cookie.name}`, cookie);
+    }
+    return [...deduped.values()];
+}
 /**
  * Download step handler for YAML pipelines.
  *
@@ -101,21 +94,28 @@ export async function stepDownload(page, params, data, args) {
     }
     // Create progress tracker
     const tracker = new DownloadProgressTracker(items.length, showProgress);
-    // Extract cookies if browser is available
-    let cookies = '';
+    // Cache cookie lookups per domain so mixed-domain batches stay isolated without repeated browser calls.
+    const cookieHeaderCache = new Map();
     let cookiesFile;
     if (page) {
-        cookies = await extractBrowserCookies(page);
         // For yt-dlp, we need to export cookies to Netscape format
         if (useYtdlp || items.some((item, index) => {
             const url = String(render(urlTemplate, { args, data, item, index }));
             return requiresYtdlp(url);
         })) {
             try {
-                // Try to get domain from first URL
-                const firstUrl = String(render(urlTemplate, { args, data, item: items[0], index: 0 }));
-                const domain = new URL(firstUrl).hostname;
-                const cookiesArray = await extractCookiesArray(page, domain);
+                const ytdlpDomains = [...new Set(items.flatMap((item, index) => {
+                        const url = String(render(urlTemplate, { args, data, item, index }));
+                        if (!useYtdlp && !requiresYtdlp(url))
+                            return [];
+                        try {
+                            return [new URL(url).hostname];
+                        }
+                        catch {
+                            return [];
+                        }
+                    }))];
+                const cookiesArray = dedupeCookies((await Promise.all(ytdlpDomains.map((domain) => extractCookiesArray(page, domain)))).flat());
                 if (cookiesArray.length > 0) {
                     const tempDir = getTempDir();
                     fs.mkdirSync(tempDir, { recursive: true });
@@ -199,6 +199,21 @@ export async function stepDownload(page, params, data, args) {
             }
             else {
                 // Direct HTTP download
+                let cookies = '';
+                if (page) {
+                    try {
+                        const targetDomain = new URL(url).hostname;
+                        let cookiePromise = cookieHeaderCache.get(targetDomain);
+                        if (!cookiePromise) {
+                            cookiePromise = extractBrowserCookies(page, targetDomain);
+                            cookieHeaderCache.set(targetDomain, cookiePromise);
+                        }
+                        cookies = await cookiePromise;
+                    }
+                    catch {
+                        cookies = '';
+                    }
+                }
                 result = await httpDownload(url, destPath, {
                     cookies,
                     timeout,
@@ -214,9 +229,10 @@ export async function stepDownload(page, params, data, args) {
             }
         }
         catch (err) {
-            result = { success: false, size: 0, error: err.message };
+            const msg = getErrorMessage(err);
+            result = { success: false, size: 0, error: msg };
             if (progressBar) {
-                progressBar.fail(err.message);
+                progressBar.fail(msg);
             }
         }
         tracker.onFileComplete(result.success);

package/dist/pipeline/steps/download.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pipeline/steps/download.test.js

@@ -0,0 +1,101 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import * as os from 'node:os';
+import * as path from 'node:path';
+const { mockHttpDownload, mockYtdlpDownload, mockExportCookiesToNetscape } = vi.hoisted(() => ({
+    mockHttpDownload: vi.fn(),
+    mockYtdlpDownload: vi.fn(),
+    mockExportCookiesToNetscape: vi.fn(),
+}));
+vi.mock('../../download/index.js', async () => {
+    const actual = await vi.importActual('../../download/index.js');
+    return {
+        ...actual,
+        httpDownload: mockHttpDownload,
+        ytdlpDownload: mockYtdlpDownload,
+        exportCookiesToNetscape: mockExportCookiesToNetscape,
+    };
+});
+import { stepDownload } from './download.js';
+function createMockPage(getCookies) {
+    return {
+        goto: vi.fn(),
+        evaluate: vi.fn().mockResolvedValue(null),
+        getCookies,
+        snapshot: vi.fn().mockResolvedValue(''),
+        click: vi.fn(),
+        typeText: vi.fn(),
+        pressKey: vi.fn(),
+        scrollTo: vi.fn(),
+        getFormState: vi.fn().mockResolvedValue({}),
+        wait: vi.fn(),
+        tabs: vi.fn().mockResolvedValue([]),
+        closeTab: vi.fn(),
+        newTab: vi.fn(),
+        selectTab: vi.fn(),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn(),
+        autoScroll: vi.fn(),
+        installInterceptor: vi.fn(),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        screenshot: vi.fn().mockResolvedValue(''),
+    };
+}
+describe('stepDownload', () => {
+    beforeEach(() => {
+        mockHttpDownload.mockReset();
+        mockHttpDownload.mockResolvedValue({ success: true, size: 2 });
+        mockYtdlpDownload.mockReset();
+        mockYtdlpDownload.mockResolvedValue({ success: true, size: 2 });
+        mockExportCookiesToNetscape.mockReset();
+    });
+    it('scopes browser cookies to each direct-download target domain', async () => {
+        const page = createMockPage(vi.fn().mockImplementation(async (opts) => {
+            const domain = opts?.domain ?? 'unknown';
+            return [{ name: 'sid', value: domain, domain }];
+        }));
+        await stepDownload(page, {
+            url: '${{ item.url }}',
+            dir: path.join(os.tmpdir(), 'opencli-download-test'),
+            filename: '${{ index }}.txt',
+            progress: false,
+            concurrency: 1,
+        }, [
+            { url: 'https://a.example/file-1.txt' },
+            { url: 'https://b.example/file-2.txt' },
+        ], {});
+        expect(mockHttpDownload).toHaveBeenNthCalledWith(1, 'https://a.example/file-1.txt', path.join(os.tmpdir(), 'opencli-download-test', '0.txt'), expect.objectContaining({ cookies: 'sid=a.example' }));
+        expect(mockHttpDownload).toHaveBeenNthCalledWith(2, 'https://b.example/file-2.txt', path.join(os.tmpdir(), 'opencli-download-test', '1.txt'), expect.objectContaining({ cookies: 'sid=b.example' }));
+    });
+    it('builds yt-dlp cookies from all target domains instead of only the first item', async () => {
+        const getCookies = vi.fn().mockImplementation(async (opts) => {
+            const domain = opts?.domain ?? 'unknown';
+            return [{
+                    name: `sid-${domain}`,
+                    value: domain,
+                    domain,
+                    path: '/',
+                    secure: false,
+                    httpOnly: false,
+                }];
+        });
+        const page = createMockPage(getCookies);
+        await stepDownload(page, {
+            url: '${{ item.url }}',
+            dir: '/tmp/opencli-download-test',
+            filename: '${{ index }}.mp4',
+            progress: false,
+            concurrency: 1,
+        }, [
+            { url: 'https://www.youtube.com/watch?v=one' },
+            { url: 'https://www.bilibili.com/video/BV1xx411c7mD' },
+        ], {});
+        expect(getCookies).toHaveBeenCalledWith({ domain: 'www.youtube.com' });
+        expect(getCookies).toHaveBeenCalledWith({ domain: 'www.bilibili.com' });
+        expect(mockExportCookiesToNetscape).toHaveBeenCalledWith(expect.arrayContaining([
+            expect.objectContaining({ name: 'sid-www.youtube.com', domain: 'www.youtube.com' }),
+            expect.objectContaining({ name: 'sid-www.bilibili.com', domain: 'www.bilibili.com' }),
+        ]), expect.any(String));
+        expect(mockYtdlpDownload).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/pipeline/steps/fetch.js

@@ -1,24 +1,10 @@
 /**
  * Pipeline step: fetch — HTTP API requests.
  */
+import { CliError, getErrorMessage } from '../../errors.js';
+import { log } from '../../logger.js';
 import { render } from '../template.js';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-/** Simple async concurrency limiter */
-async function mapConcurrent(items, limit, fn) {
-    const results = new Array(items.length);
-    let index = 0;
-    async function worker() {
-        while (index < items.length) {
-            const i = index++;
-            results[i] = await fn(items[i], i);
-        }
-    }
-    const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
-    await Promise.all(workers);
-    return results;
-}
+import { isRecord, mapConcurrent } from '../../utils.js';
 /** Single URL fetch helper */
 async function fetchSingle(page, url, method, queryParams, headers, args, data) {
     const renderedParams = {};
@@ -34,19 +20,32 @@ async function fetchSingle(page, url, method, queryParams, headers, args, data)
     }
     if (page === null) {
         const resp = await fetch(finalUrl, { method: method.toUpperCase(), headers: renderedHeaders });
+        if (!resp.ok) {
+            throw new CliError('FETCH_ERROR', `HTTP ${resp.status} ${resp.statusText} from ${finalUrl}`);
+        }
         return resp.json();
     }
     const headersJs = JSON.stringify(renderedHeaders);
     const urlJs = JSON.stringify(finalUrl);
     const methodJs = JSON.stringify(method.toUpperCase());
-    return page.evaluate(`
+    // Return error status instead of throwing inside evaluate to avoid CDP wrapper
+    // rewriting the message (CDP prepends "Evaluate error: " to thrown errors).
+    const result = await page.evaluate(`
     async () => {
       const resp = await fetch(${urlJs}, {
         method: ${methodJs}, headers: ${headersJs}, credentials: "include"
       });
+      if (!resp.ok) {
+        return { __httpError: resp.status, statusText: resp.statusText };
+      }
       return await resp.json();
     }
   `);
+    if (result && typeof result === 'object' && '__httpError' in result) {
+        const { __httpError: status, statusText } = result;
+        throw new CliError('FETCH_ERROR', `HTTP ${status} ${statusText} from ${finalUrl}`);
+    }
+    return result;
 }
 /**
  * Batch fetch: send all URLs into the browser as a single evaluate() call.
@@ -56,10 +55,11 @@ async function fetchSingle(page, url, method, queryParams, headers, args, data)
 async function fetchBatchInBrowser(page, urls, method, headers, concurrency) {
     const headersJs = JSON.stringify(headers);
     const urlsJs = JSON.stringify(urls);
+    const methodJs = JSON.stringify(method);
     return (await page.evaluate(`
     async () => {
       const urls = ${urlsJs};
-      const method = "${method}";
+      const method = ${methodJs};
       const headers = ${headersJs};
       const concurrency = ${concurrency};
 
@@ -71,9 +71,13 @@ async function fetchBatchInBrowser(page, urls, method, headers, concurrency) {
           const i = idx++;
           try {
             const resp = await fetch(urls[i], { method, headers, credentials: "include" });
+            if (!resp.ok) {
+              throw new Error('HTTP ' + resp.status + ' ' + resp.statusText + ' from ' + urls[i]);
+            }
             results[i] = await resp.json();
           } catch (e) {
-            results[i] = { error: e.message };
+            results[i] = { error: e instanceof Error ? e.message : String(e) };
+            // Note: getErrorMessage() is a Node.js utility — can't use it inside evaluate()
           }
         }
       }
@@ -111,12 +115,26 @@ export async function stepFetch(page, params, data, args) {
         });
         // BATCH IPC: if browser is available, batch all fetches into a single evaluate() call
         if (page !== null) {
-            return fetchBatchInBrowser(page, urls, method.toUpperCase(), renderedHeaders, concurrency);
+            const results = await fetchBatchInBrowser(page, urls, method.toUpperCase(), renderedHeaders, concurrency);
+            for (let i = 0; i < results.length; i++) {
+                const r = results[i];
+                if (r && typeof r === 'object' && 'error' in r) {
+                    log.warn(`Batch fetch failed for ${urls[i]}: ${r.error}`);
+                }
+            }
+            return results;
         }
         // Non-browser: use concurrent pool (already optimized)
         return mapConcurrent(data, concurrency, async (item, index) => {
             const itemUrl = String(render(urlTemplate, { args, data, item, index }));
-            return fetchSingle(null, itemUrl, method, queryParams, headers, args, data);
+            try {
+                return await fetchSingle(null, itemUrl, method, queryParams, headers, args, data);
+            }
+            catch (error) {
+                const message = getErrorMessage(error);
+                log.warn(`Batch fetch failed for ${itemUrl}: ${message}`);
+                return { error: message };
+            }
         });
     }
     const url = render(urlOrObj, { args, data });

package/dist/pipeline/steps/fetch.test.d.ts

@@ -0,0 +1 @@
+export {};