@jackwener/opencli 1.7.12 → 1.7.14

package/clis/rest-countries/utils.js

@@ -0,0 +1,126 @@
+// Shared helpers for the REST Countries adapter (https://restcountries.com).
+//
+// REST Countries is a free public country-metadata API, no API key required.
+// We hit v3.1 only. The `fields=` query param is mandatory in v3.1 to keep
+// payloads small; we always specify the agent-useful projection.
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const REST_COUNTRIES_BASE = 'https://restcountries.com/v3.1';
+const UA = 'opencli-rest-countries-adapter/1.0 (+https://github.com/jackwener/opencli; mailto:opencli@example.com)';
+
+// REST Countries valid region values; subregions are validated server-side.
+export const REST_COUNTRIES_REGIONS = new Set(['africa', 'americas', 'asia', 'europe', 'oceania', 'antarctic']);
+
+// Fields the adapter always requests; keep this list aligned with `columns` so
+// rows never have null-where-absent silent drops.
+export const COUNTRY_FIELDS = [
+    'name', 'cca2', 'cca3', 'ccn3', 'capital', 'region', 'subregion',
+    'population', 'area', 'languages', 'currencies', 'flag', 'latlng', 'timezones',
+    'independent', 'unMember', 'landlocked',
+].join(',');
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`rest-countries ${label} cannot be empty`);
+    return s;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`rest-countries ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`rest-countries ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export function requireRegion(value) {
+    const raw = String(value ?? '').trim().toLowerCase();
+    if (!raw) throw new ArgumentError('rest-countries region is required (e.g. "europe", "asia")');
+    if (!REST_COUNTRIES_REGIONS.has(raw)) {
+        throw new ArgumentError(
+            `rest-countries region "${value}" is not recognised`,
+            `Allowed regions: ${[...REST_COUNTRIES_REGIONS].join(', ')}.`,
+        );
+    }
+    return raw;
+}
+
+export async function restCountriesFetch(url, label) {
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that restcountries.com is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `REST Countries returned 404 for ${url}.`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(`${label} returned HTTP 429 (rate limited)`);
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status}`);
+    }
+    let body;
+    try {
+        body = await resp.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} returned malformed JSON: ${err?.message ?? err}`);
+    }
+    return body;
+}
+
+/** Convert REST Countries' `{cur: {name, symbol}}` map to a comma-joined list. */
+export function joinCurrencies(currencies) {
+    if (!currencies || typeof currencies !== 'object') return '';
+    return Object.entries(currencies)
+        .map(([code, info]) => {
+            const name = info && typeof info.name === 'string' ? info.name : '';
+            return name ? `${code} (${name})` : code;
+        })
+        .join(', ');
+}
+
+/** Convert `{eng: 'English', fra: 'French'}` map to a comma-joined list of language names. */
+export function joinLanguages(languages) {
+    if (!languages || typeof languages !== 'object') return '';
+    return Object.values(languages).filter((v) => typeof v === 'string' && v.trim()).join(', ');
+}
+
+/** Project a REST Countries v3.1 country object into a row matching the adapter columns. */
+export function projectCountry(c) {
+    const common = c?.name?.common ?? null;
+    const official = c?.name?.official ?? null;
+    const cca3 = typeof c?.cca3 === 'string' ? c.cca3 : null;
+    return {
+        commonName: typeof common === 'string' ? common : null,
+        officialName: typeof official === 'string' ? official : null,
+        cca2: typeof c?.cca2 === 'string' ? c.cca2 : null,
+        cca3,
+        ccn3: typeof c?.ccn3 === 'string' ? c.ccn3 : null,
+        capital: Array.isArray(c?.capital) ? c.capital.join(', ') : null,
+        region: typeof c?.region === 'string' ? c.region : null,
+        subregion: typeof c?.subregion === 'string' ? c.subregion : null,
+        population: typeof c?.population === 'number' ? c.population : null,
+        area: typeof c?.area === 'number' ? c.area : null,
+        languages: joinLanguages(c?.languages),
+        currencies: joinCurrencies(c?.currencies),
+        latitude: Array.isArray(c?.latlng) && typeof c.latlng[0] === 'number' ? c.latlng[0] : null,
+        longitude: Array.isArray(c?.latlng) && typeof c.latlng[1] === 'number' ? c.latlng[1] : null,
+        timezones: Array.isArray(c?.timezones) ? c.timezones.join(', ') : null,
+        independent: typeof c?.independent === 'boolean' ? c.independent : null,
+        unMember: typeof c?.unMember === 'boolean' ? c.unMember : null,
+        landlocked: typeof c?.landlocked === 'boolean' ? c.landlocked : null,
+        flag: typeof c?.flag === 'string' ? c.flag : null,
+        url: cca3 ? `https://restcountries.com/v3.1/alpha/${cca3.toLowerCase()}` : '',
+    };
+}

package/clis/reuters/article-detail.js

@@ -0,0 +1,53 @@
+/**
+ * Reuters article-detail — full article body + canonical metadata.
+ *
+ * Pairs with `reuters search` (use the `url` column to round-trip into
+ * detail). Reads the in-page Fusion globalContent payload + paragraph DOM.
+ */
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { buildArticleDetailScript, mapArticleDetail } from './utils.js';
+
+const REUTERS_HOST = /^https?:\/\/(?:www\.)?reuters\.com\//i;
+
+cli({
+    site: 'reuters',
+    name: 'article-detail',
+    access: 'read',
+    description: 'Reuters 路透社文章详情：标题/作者/正文文本',
+    domain: 'www.reuters.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'url', required: true, positional: true, help: 'Reuters article URL (must be on reuters.com)' },
+    ],
+    columns: ['title', 'date', 'section', 'section_path', 'authors', 'description', 'word_count', 'url', 'body'],
+    func: async (page, kwargs) => {
+        const url = String(kwargs.url || '').trim();
+        if (!url) {
+            throw new ArgumentError('Article URL cannot be empty');
+        }
+        if (!REUTERS_HOST.test(url)) {
+            throw new ArgumentError(`URL must be on reuters.com, got ${url}`);
+        }
+        await page.goto(url);
+        await page.wait(2);
+        const result = await page.evaluate(buildArticleDetailScript());
+        if (result?.error) {
+            throw new CommandExecutionError(`Reuters article-detail failed inside the page: ${result.error}`);
+        }
+        if (result?.authRequired) {
+            throw new AuthRequiredError('www.reuters.com', 'Reuters article-detail is gated by login, subscription, or human verification');
+        }
+        if (!result || result.ok !== true) {
+            throw new CommandExecutionError(
+                'Reuters article-detail returned no payload',
+                'Check that the URL points to a Reuters article and that the page loaded',
+            );
+        }
+        const detail = mapArticleDetail(result.body?.article, result.body?.bodyText, url);
+        if (!detail || (!detail.title && !detail.body)) {
+            throw new EmptyResultError('reuters article-detail', 'Page rendered no article body — likely paywalled or a non-article URL');
+        }
+        return [detail];
+    },
+});

package/clis/reuters/reuters.test.js

@@ -0,0 +1,299 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './search.js';
+import './article-detail.js';
+import { buildArticleDetailScript, buildSearchScript, isAuthStatus, looksAuthWallText, mapArticleDetail, mapSearchArticles, parseLimit } from './utils.js';
+
+function makePage(evaluateResult) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(evaluateResult),
+    };
+}
+
+describe('reuters parseLimit', () => {
+    it('returns fallback for undefined / empty', () => {
+        expect(parseLimit(undefined)).toBe(10);
+        expect(parseLimit('')).toBe(10);
+    });
+    it('accepts integers in [1, 40]', () => {
+        expect(parseLimit(1)).toBe(1);
+        expect(parseLimit(40)).toBe(40);
+        expect(parseLimit('25')).toBe(25);
+    });
+    it('rejects non-integer', () => {
+        expect(() => parseLimit('abc')).toThrow('--limit must be an integer');
+        expect(() => parseLimit(3.5)).toThrow('--limit must be an integer');
+    });
+    it('rejects out-of-range without silent clamp', () => {
+        expect(() => parseLimit(0)).toThrow('--limit must be between 1 and 40, got 0');
+        expect(() => parseLimit(41)).toThrow('--limit must be between 1 and 40, got 41');
+    });
+});
+
+describe('reuters buildSearchScript', () => {
+    it('embeds the user query as JSON-safe literal', () => {
+        const script = buildSearchScript('hello "world"', 5);
+        expect(script).toContain('"hello \\"world\\""');
+        expect(script).toContain('size: 5');
+    });
+});
+
+describe('reuters auth-wall helpers', () => {
+    it('detects auth statuses and Reuters challenge/paywall text', () => {
+        expect(isAuthStatus(401)).toBe(true);
+        expect(isAuthStatus(403)).toBe(true);
+        expect(isAuthStatus(500)).toBe(false);
+        expect(looksAuthWallText('DataDome verify you are human')).toBe(true);
+        expect(looksAuthWallText('Subscribe to continue reading')).toBe(true);
+        expect(looksAuthWallText('ordinary article body')).toBe(false);
+    });
+});
+
+describe('reuters mapSearchArticles', () => {
+    const sampleBody = {
+        result: {
+            articles: [
+                {
+                    title: 'Tariff war heats up',
+                    display_date: '2026-05-06T14:30:00.000Z',
+                    taxonomy: { section: { name: 'World', path: '/world' } },
+                    authors: [{ name: 'Jane Doe' }, { name: 'Bob Smith' }],
+                    canonical_url: '/world/tariff-war-2026-05-06/',
+                },
+                {
+                    headlines: { basic: 'Markets rally' },
+                    published_time: '2026-05-05T09:00:00.000Z',
+                    canonical_url: '/markets/rally-2026-05-05/',
+                },
+            ],
+        },
+    };
+
+    it('projects to declared shape', () => {
+        const rows = mapSearchArticles(sampleBody, 5);
+        expect(rows).toEqual([
+            {
+                rank: 1,
+                title: 'Tariff war heats up',
+                date: '2026-05-06',
+                section: 'World',
+                section_path: '/world',
+                authors: 'Jane Doe, Bob Smith',
+                url: 'https://www.reuters.com/world/tariff-war-2026-05-06/',
+            },
+            {
+                rank: 2,
+                title: 'Markets rally',
+                date: '2026-05-05',
+                section: null,
+                section_path: null,
+                authors: null,
+                url: 'https://www.reuters.com/markets/rally-2026-05-05/',
+            },
+        ]);
+    });
+
+    it('honors limit slice', () => {
+        const rows = mapSearchArticles(sampleBody, 1);
+        expect(rows).toHaveLength(1);
+    });
+
+    it('falls back to top-level articles array', () => {
+        const rows = mapSearchArticles({ articles: [{ title: 'X', canonical_url: '/x/' }] }, 5);
+        expect(rows).toHaveLength(1);
+        expect(rows[0].url).toBe('https://www.reuters.com/x/');
+    });
+
+    it('returns empty array when no articles', () => {
+        expect(mapSearchArticles({}, 5)).toEqual([]);
+    });
+
+    it('drops rows that have no title (no silent empty-title row)', () => {
+        const rows = mapSearchArticles({ articles: [{ canonical_url: '/x/' }] }, 5);
+        expect(rows).toEqual([]);
+    });
+
+    it('drops rows without url because search.url is the article-detail id', () => {
+        const rows = mapSearchArticles({ articles: [{ title: 'No URL' }, { title: 'Has URL', canonical_url: '/world/has-url/' }] }, 5);
+        expect(rows).toEqual([
+            {
+                rank: 2,
+                title: 'Has URL',
+                date: null,
+                section: null,
+                section_path: null,
+                authors: null,
+                url: 'https://www.reuters.com/world/has-url/',
+            },
+        ]);
+    });
+});
+
+describe('reuters mapArticleDetail', () => {
+    it('projects fusion globalContent + body text', () => {
+        const detail = mapArticleDetail(
+            {
+                title: 'Headline',
+                display_date: '2026-05-06T14:30:00.000Z',
+                taxonomy: { section: { name: 'Tech', path: '/tech' } },
+                authors: [{ name: 'Alice' }],
+                description: { basic: 'A summary.' },
+                word_count: 312,
+                canonical_url: '/tech/headline-2026-05-06/',
+            },
+            'Para 1\n\nPara 2',
+        );
+        expect(detail).toEqual({
+            title: 'Headline',
+            date: '2026-05-06',
+            section: 'Tech',
+            section_path: '/tech',
+            authors: 'Alice',
+            description: 'A summary.',
+            word_count: 312,
+            url: 'https://www.reuters.com/tech/headline-2026-05-06/',
+            body: 'Para 1\n\nPara 2',
+        });
+    });
+
+    it('returns null when neither article nor body text', () => {
+        expect(mapArticleDetail(null, '')).toBeNull();
+    });
+
+    it('uses input URL fallback when fusion metadata has no canonical URL', () => {
+        const detail = mapArticleDetail({ title: 'Body-only' }, 'Body text', 'https://www.reuters.com/world/body-only/');
+        expect(detail.url).toBe('https://www.reuters.com/world/body-only/');
+    });
+});
+
+describe('reuters search command (registry-level)', () => {
+    const cmd = getRegistry().get('reuters/search');
+
+    it('declares Strategy.COOKIE + access:read', () => {
+        expect(cmd.access).toBe('read');
+        expect(String(cmd.strategy)).toContain('cookie');
+    });
+
+    it('rejects --limit out-of-range before browser navigation', async () => {
+        const page = makePage(null);
+        await expect(cmd.func(page, { query: 'x', limit: 0 })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(cmd.func(page, { query: 'x', limit: 41 })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('rejects empty query as ArgumentError', async () => {
+        const page = makePage(null);
+        await expect(cmd.func(page, { query: '   ', limit: 5 })).rejects.toBeInstanceOf(ArgumentError);
+    });
+
+    it('throws CommandExecutionError when in-page fetch errored', async () => {
+        const page = makePage({ ok: false, status: 0, body: null, error: 'NetworkError' });
+        await expect(cmd.func(page, { query: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws AuthRequiredError on Reuters auth/challenge status', async () => {
+        const page = makePage({ ok: false, status: 403, body: { html: '<captcha/>' } });
+        await expect(cmd.func(page, { query: 'x', limit: 5 })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('throws CommandExecutionError on non-auth upstream failure', async () => {
+        const page = makePage({ ok: false, status: 500, statusText: 'Server Error', body: { error: 'upstream' } });
+        await expect(cmd.func(page, { query: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws AuthRequiredError when 200 body is Reuters challenge HTML', async () => {
+        const page = makePage({ ok: true, status: 200, body: null, textPreview: 'DataDome verify you are human', parseError: 'Unexpected token <' });
+        await expect(cmd.func(page, { query: 'x', limit: 5 })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('throws CommandExecutionError when 200 but body is null (captcha HTML)', async () => {
+        const page = makePage({ ok: true, status: 200, body: null });
+        await expect(cmd.func(page, { query: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError when API returned no articles', async () => {
+        const page = makePage({ ok: true, status: 200, body: { result: { articles: [] } } });
+        await expect(cmd.func(page, { query: 'x', limit: 5 })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('returns mapped rows on success', async () => {
+        const page = makePage({
+            ok: true,
+            status: 200,
+            body: {
+                result: {
+                    articles: [
+                        { title: 'A', display_date: '2026-05-06T00:00:00Z', canonical_url: '/a/' },
+                    ],
+                },
+            },
+        });
+        const rows = await cmd.func(page, { query: 'tariff', limit: 5 });
+        expect(rows).toHaveLength(1);
+        expect(rows[0].title).toBe('A');
+    });
+});
+
+describe('reuters article-detail command (registry-level)', () => {
+    const cmd = getRegistry().get('reuters/article-detail');
+
+    it('rejects empty url', async () => {
+        const page = makePage(null);
+        await expect(cmd.func(page, { url: '   ' })).rejects.toBeInstanceOf(ArgumentError);
+    });
+
+    it('rejects non-reuters URL', async () => {
+        const page = makePage(null);
+        await expect(cmd.func(page, { url: 'https://example.com/article' })).rejects.toThrow('must be on reuters.com');
+    });
+
+    it('throws CommandExecutionError when in-page returns nothing', async () => {
+        const page = makePage(null);
+        await expect(cmd.func(page, { url: 'https://www.reuters.com/world/x/' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws CommandExecutionError when in-page errored', async () => {
+        const page = makePage({ ok: false, error: 'boom' });
+        await expect(cmd.func(page, { url: 'https://www.reuters.com/world/x/' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws AuthRequiredError when page reports a paywall/challenge', async () => {
+        const page = makePage({ ok: true, authRequired: true, body: { article: null, bodyText: null } });
+        await expect(cmd.func(page, { url: 'https://www.reuters.com/world/x/' })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('throws EmptyResultError when page rendered no article body', async () => {
+        const page = makePage({ ok: true, body: { article: null, bodyText: null } });
+        await expect(cmd.func(page, { url: 'https://www.reuters.com/world/x/' })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('returns single-row detail on success', async () => {
+        const page = makePage({
+            ok: true,
+            body: {
+                article: {
+                    title: 'H',
+                    display_date: '2026-05-06T00:00:00Z',
+                    taxonomy: { section: { name: 'World', path: '/world' } },
+                    canonical_url: '/world/h/',
+                },
+                bodyText: 'Body here',
+            },
+        });
+        const rows = await cmd.func(page, { url: 'https://www.reuters.com/world/h/' });
+        expect(rows).toHaveLength(1);
+        expect(rows[0].body).toBe('Body here');
+        expect(rows[0].url).toBe('https://www.reuters.com/world/h/');
+    });
+});
+
+describe('reuters buildArticleDetailScript', () => {
+    it('returns a valid JS string referencing fusion-metadata + paragraph selectors', () => {
+        const s = buildArticleDetailScript();
+        expect(s).toContain('fusion-metadata');
+        expect(s).toContain("data-testid^=\"paragraph-\"");
+    });
+});

package/clis/reuters/search.js

@@ -1,7 +1,13 @@
 /**
- * Reuters news search — API with HTML fallback.
+ * Reuters news search — uses the in-page articles-by-search-v2 API.
+ *
+ * The endpoint sits behind a Datadome anti-bot challenge for direct fetches,
+ * so we run inside an authenticated reuters.com tab via Strategy.COOKIE.
  */
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { buildSearchScript, isAuthStatus, looksAuthWallText, mapSearchArticles, parseLimit } from './utils.js';
+
 cli({
     site: 'reuters',
     name: 'search',
@@ -11,42 +17,47 @@ cli({
     strategy: Strategy.COOKIE,
     args: [
         { name: 'query', required: true, positional: true, help: 'Search query' },
-        { name: 'limit', type: 'int', default: 10, help: 'Number of results (max 40)' },
+        { name: 'limit', type: 'int', default: 10, help: 'Number of results (1-40)' },
     ],
-    columns: ['rank', 'title', 'date', 'section', 'url'],
+    columns: ['rank', 'title', 'date', 'section', 'section_path', 'authors', 'url'],
     func: async (page, kwargs) => {
-        const count = Math.min(kwargs.limit || 10, 40);
+        const limit = parseLimit(kwargs.limit);
+        const query = String(kwargs.query || '').trim();
+        if (!query) {
+            throw new ArgumentError('Search query cannot be empty', 'Provide a non-empty keyword');
+        }
         await page.goto('https://www.reuters.com');
         await page.wait(2);
-        const data = await page.evaluate(`
-      (async () => {
-        const count = ${count};
-        const apiQuery = JSON.stringify({
-          keyword: ${JSON.stringify(kwargs.query)},
-          offset: 0, orderby: 'display_date:desc', size: count, website: 'reuters'
-        });
-        const apiUrl = 'https://www.reuters.com/pf/api/v3/content/fetch/articles-by-search-v2?query=' + encodeURIComponent(apiQuery);
-        try {
-          const resp = await fetch(apiUrl, {credentials: 'include'});
-          if (resp.ok) {
-            const data = await resp.json();
-            const articles = data.result?.articles || data.articles || [];
-            if (articles.length > 0) {
-              return articles.slice(0, count).map((a, i) => ({
-                rank: i + 1,
-                title: a.title || a.headlines?.basic || '',
-                date: (a.display_date || a.published_time || '').split('T')[0],
-                section: a.taxonomy?.section?.name || '',
-                url: a.canonical_url ? 'https://www.reuters.com' + a.canonical_url : '',
-              }));
-            }
-          }
-        } catch(e) {}
-        return {error: 'Reuters API unavailable'};
-      })()
-    `);
-        if (!Array.isArray(data))
-            return [];
-        return data;
+        const result = await page.evaluate(buildSearchScript(query, limit));
+        if (result?.error) {
+            throw new CommandExecutionError(`Reuters search failed inside the page: ${result.error}`);
+        }
+        if (!result || typeof result !== 'object') {
+            throw new CommandExecutionError('Reuters search API returned an unreadable response');
+        }
+        if (isAuthStatus(result.status) || looksAuthWallText(result.textPreview)) {
+            throw new AuthRequiredError(
+                'www.reuters.com',
+                `Reuters search requires an accessible Reuters browser session or completed human verification${result.status ? ` (HTTP ${result.status})` : ''}`,
+            );
+        }
+        if (result.ok !== true) {
+            const status = Number.isFinite(result.status) && result.status > 0
+                ? `HTTP ${result.status}${result.statusText ? ` ${result.statusText}` : ''}`
+                : 'no upstream response';
+            throw new CommandExecutionError(`Reuters search API failed (${status})`);
+        }
+        if (!result.body) {
+            const detail = result.parseError ? `: ${result.parseError}` : '';
+            throw new CommandExecutionError(
+                `Reuters search returned a non-JSON body${detail}`,
+                'Open www.reuters.com in your browser and clear any challenge before retrying.',
+            );
+        }
+        const rows = mapSearchArticles(result.body, limit);
+        if (!rows.length) {
+            throw new EmptyResultError('reuters search', `No articles matched "${query}". Try broadening the query.`);
+        }
+        return rows;
     },
 });