@jackwener/opencli 1.7.11 → 1.7.13

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,51 +1,63 @@
 /**
- * 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',
+    access: 'read',
     description: 'Reuters 路透社新闻搜索',
     domain: 'www.reuters.com',
     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;
     },
 });

package/clis/reuters/utils.js

@@ -0,0 +1,159 @@
+/**
+ * Shared helpers for the reuters adapter.
+ */
+import { ArgumentError } from '@jackwener/opencli/errors';
+
+const MIN_LIMIT = 1;
+const MAX_LIMIT = 40;
+
+export function parseLimit(raw, fallback = 10) {
+    if (raw === undefined || raw === null || raw === '') return fallback;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        throw new ArgumentError(`--limit must be an integer between ${MIN_LIMIT} and ${MAX_LIMIT}, got ${JSON.stringify(raw)}`);
+    }
+    if (parsed < MIN_LIMIT || parsed > MAX_LIMIT) {
+        throw new ArgumentError(`--limit must be between ${MIN_LIMIT} and ${MAX_LIMIT}, got ${parsed}`);
+    }
+    return parsed;
+}
+
+/**
+ * Build the in-page IIFE that fetches the Reuters search API.
+ *
+ * Returns a raw envelope `{ ok, status, body, error? }` so that error-handling
+ * lives in node space (not silently swallowed by `catch(e) {}` inside the
+ * browser).
+ */
+export function buildSearchScript(query, count) {
+    return `
+    (async () => {
+      const apiQuery = JSON.stringify({
+        keyword: ${JSON.stringify(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' });
+        const status = resp.status;
+        const statusText = resp.statusText || '';
+        const text = await resp.text();
+        let body = null;
+        let parseError = null;
+        if ((text || '').trim()) {
+          try { body = JSON.parse(text); } catch (e) { parseError = String((e && e.message) || e); }
+        }
+        return { ok: resp.ok, status, statusText, body, parseError, textPreview: (text || '').slice(0, 500) };
+      } catch (e) {
+        return { ok: false, status: 0, body: null, error: String((e && e.message) || e) };
+      }
+    })()
+  `;
+}
+
+/**
+ * In-page IIFE that walks the Reuters article page DOM and surfaces
+ * canonical metadata + body text. Returns a raw `{ ok, body, error? }`
+ * envelope so node-side handling can throw typed errors.
+ */
+export function buildArticleDetailScript() {
+    return `
+    (() => {
+      try {
+        const pageText = document.body ? (document.body.innerText || '') : '';
+        const authRequired = ${looksAuthWallText.toString()}([
+          window.location.href || '',
+          document.title || '',
+          pageText.slice(0, 4000),
+        ].join('\\n')) || Boolean(document.querySelector('[data-testid*="paywall" i], [class*="paywall" i], [id*="paywall" i], [data-testid*="captcha" i], [class*="captcha" i]'));
+        const meta = document.getElementById('fusion-metadata');
+        let fusion = null;
+        if (meta) {
+          try { fusion = JSON.parse(meta.textContent || '{}'); } catch (e) { fusion = null; }
+        }
+        const article = fusion?.globalContent || null;
+        const paragraphs = Array.from(document.querySelectorAll('article [data-testid^="paragraph-"], article p'))
+          .map((p) => (p.textContent || '').trim())
+          .filter(Boolean);
+        const bodyText = paragraphs.length ? paragraphs.join('\\n\\n') : ((document.querySelector('article')?.innerText || '').trim() || null);
+        return { ok: true, authRequired, body: { article, bodyText } };
+      } catch (e) {
+        return { ok: false, error: String((e && e.message) || e) };
+      }
+    })()
+  `;
+}
+
+export function isAuthStatus(status) {
+    return Number(status) === 401 || Number(status) === 403;
+}
+
+export function looksAuthWallText(value) {
+    const text = String(value ?? '').toLowerCase();
+    return /datadome|captcha|verify you are human|human verification|access to this page has been denied|unusual traffic|subscribe to continue|subscription required|sign in to (continue|read|access)|log in to (continue|read|access)/.test(text);
+}
+
+function pickAuthors(a) {
+    if (!Array.isArray(a)) return null;
+    const names = a
+        .map((au) => (typeof au === 'string' ? au : au?.name || au?.byline || ''))
+        .map((s) => String(s).trim())
+        .filter(Boolean);
+    return names.length ? names.join(', ') : null;
+}
+
+function trimOrNull(v) {
+    const s = String(v ?? '').trim();
+    return s ? s : null;
+}
+
+function dateOnly(v) {
+    const s = String(v ?? '').trim();
+    if (!s) return null;
+    return s.split('T')[0];
+}
+
+function articleUrl(canonical) {
+    if (!canonical) return null;
+    const c = String(canonical);
+    if (/^https?:\/\//i.test(c)) return c;
+    return 'https://www.reuters.com' + c;
+}
+
+export function mapSearchArticles(body, limit) {
+    const articles = body?.result?.articles || body?.articles || [];
+    if (!Array.isArray(articles)) return [];
+    return articles
+        .filter((a) => a && typeof a === 'object')
+        .slice(0, limit)
+        .map((a, i) => ({
+            rank: i + 1,
+            title: trimOrNull(a.title || a.headlines?.basic),
+            date: dateOnly(a.display_date || a.published_time),
+            section: trimOrNull(a.taxonomy?.section?.name),
+            section_path: trimOrNull(a.taxonomy?.section?.path),
+            authors: pickAuthors(a.authors),
+            url: articleUrl(a.canonical_url),
+        }))
+        .filter((row) => row.title && row.url);
+}
+
+export function mapArticleDetail(article, bodyText, fallbackUrl = null) {
+    if (!article && !bodyText) return null;
+    return {
+        title: trimOrNull(article?.title || article?.headlines?.basic),
+        date: dateOnly(article?.display_date || article?.published_time),
+        section: trimOrNull(article?.taxonomy?.section?.name),
+        section_path: trimOrNull(article?.taxonomy?.section?.path),
+        authors: pickAuthors(article?.authors),
+        description: trimOrNull(article?.description?.basic || article?.subheadlines?.basic),
+        word_count: Number.isFinite(article?.word_count) ? article.word_count : null,
+        url: articleUrl(article?.canonical_url) || trimOrNull(fallbackUrl),
+        body: trimOrNull(bodyText),
+    };
+}
+
+export const __test__ = { MIN_LIMIT, MAX_LIMIT };

package/clis/rfc/rfc.js

@@ -0,0 +1,52 @@
+// rfc rfc — fetch a single IETF RFC's metadata.
+//
+// Hits `https://datatracker.ietf.org/doc/rfc<N>/doc.json` and projects the
+// agent-useful fields: title, abstract (full text — RFCs don't truncate well),
+// page count, working group, authors, std level, publish date, plus rendered URLs.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { RFC_BASE, requireRfcNumber, rfcFetch, trimDate } from './utils.js';
+
+cli({
+    site: 'rfc',
+    name: 'rfc',
+    access: 'read',
+    description: 'Single IETF RFC metadata (title, abstract, working group, authors, std level)',
+    domain: 'datatracker.ietf.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'number', positional: true, type: 'int', required: true, help: 'RFC number (e.g. 9000, 791, 2616)' },
+    ],
+    columns: [
+        'rfc', 'title', 'state', 'stdLevel', 'group', 'groupType',
+        'pages', 'published', 'authors', 'abstract', 'rfcEditorUrl', 'url',
+    ],
+    func: async (args) => {
+        const number = requireRfcNumber(args.number);
+        const name = `rfc${number}`;
+        const doc = await rfcFetch(`${RFC_BASE}/doc/${name}/doc.json`, `rfc ${number}`);
+        if (!doc || !doc.name) {
+            throw new EmptyResultError('rfc rfc', `IETF datatracker returned no metadata for RFC ${number}.`);
+        }
+        const authors = Array.isArray(doc.authors)
+            ? doc.authors.map((a) => String(a?.name ?? '').trim()).filter(Boolean).join(', ')
+            : '';
+        const groupName = String(doc.group?.name ?? '').trim();
+        const groupType = String(doc.group?.type ?? '').trim();
+        return [{
+            rfc: number,
+            title: String(doc.title ?? '').trim(),
+            state: String(doc.state ?? '').trim(),
+            stdLevel: String(doc.std_level ?? '').trim(),
+            group: groupName,
+            groupType,
+            pages: doc.pages == null ? null : Number(doc.pages),
+            published: trimDate(doc.time),
+            authors,
+            abstract: String(doc.abstract ?? '').trim(),
+            rfcEditorUrl: `https://www.rfc-editor.org/rfc/rfc${number}`,
+            url: `${RFC_BASE}/doc/${name}/`,
+        }];
+    },
+});