@jackwener/opencli 1.7.12 → 1.7.14

package/clis/1point3acres/utils.js

@@ -0,0 +1,247 @@
+/**
+ * Shared helpers for 一亩三分地 (1point3acres.com) adapters.
+ *
+ * Site is a Discuz!X PHP BBS that serves GBK-encoded HTML.
+ * - Thread listings:  /bbs/forum.php?mod=guide&view={hot|new|digest|newthread}
+ * - Forum:            /bbs/forum-<fid>-<page>.html
+ * - Thread detail:    /bbs/thread-<tid>-<page>-1.html
+ * - User profile:     /bbs/space-uid-<uid>.html  or  /bbs/space-username-<name>.html
+ * - Search:           /bbs/search.php?mod=forum  (COOKIE — guests get an alert page)
+ */
+import { AuthRequiredError, ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+export const BASE = 'https://www.1point3acres.com/bbs';
+
+/**
+ * Validate `limit` per typed-fail-fast convention (no silent clamp).
+ * Throws ArgumentError on non-positive / non-integer / out-of-range input.
+ */
+export function normalizeLimit(value, defaultValue, maxValue, label = 'limit') {
+    const limit = normalizePositiveInteger(value, defaultValue, label);
+    if (limit > maxValue) {
+        throw new ArgumentError(`${label} must be <= ${maxValue}`);
+    }
+    return limit;
+}
+
+/** Validate a positive integer argument without silently flooring/clamping. */
+export function normalizePositiveInteger(value, defaultValue, label = 'value', { min = 1 } = {}) {
+    const raw = value ?? defaultValue;
+    const limit = Number(raw);
+    if (!Number.isInteger(limit) || limit <= 0) {
+        throw new ArgumentError(`${label} must be a positive integer`);
+    }
+    if (limit < min) {
+        throw new ArgumentError(`${label} must be >= ${min}`);
+    }
+    return limit;
+}
+
+const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0 Safari/537.36';
+
+/** Fetch a GBK-encoded Discuz page and return decoded UTF-8 HTML. */
+export async function fetchHtml(url, { headers = {}, cookie = '' } = {}) {
+    let res;
+    try {
+        res = await fetch(url, {
+            headers: {
+                'User-Agent': UA,
+                'Accept': 'text/html,application/xhtml+xml',
+                'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
+                ...(cookie ? { Cookie: cookie } : {}),
+                ...headers,
+            },
+            redirect: 'follow',
+        });
+    } catch (error) {
+        throw new CommandExecutionError(`1point3acres request failed: ${error?.message || error}`);
+    }
+    if (!res.ok) {
+        throw new CommandExecutionError(`1point3acres request failed: HTTP ${res.status} ${res.statusText} from ${url}`);
+    }
+    const buf = await res.arrayBuffer();
+    return new TextDecoder('gbk').decode(buf);
+}
+
+/** Pull cookie string from the live browser session for this domain.
+ *  Discuz auth cookies (4Oaf_61d6_*, session) are HttpOnly and set on the
+ *  root domain `.1point3acres.com`, so we need `getCookies` (not document.cookie)
+ *  AND we need to query both host + root domain and merge.
+ */
+export async function getCookie(page) {
+    if (!page) return '';
+    const seen = new Map();
+    if (typeof page.getCookies === 'function') {
+        for (const opts of [{ domain: 'www.1point3acres.com' }, { domain: '.1point3acres.com' }]) {
+            try {
+                const cookies = await page.getCookies(opts);
+                for (const c of cookies || []) {
+                    if (!seen.has(c.name)) seen.set(c.name, c.value);
+                }
+            } catch { /* try next */ }
+        }
+    }
+    if (seen.size > 0) {
+        return [...seen].map(([k, v]) => `${k}=${v}`).join('; ');
+    }
+    try {
+        const result = await page.evaluate('document.cookie');
+        return typeof result === 'string' ? result : '';
+    } catch {
+        return '';
+    }
+}
+
+/** Detect the "you are a guest" alert page that Discuz returns for protected actions. */
+export function assertNotGuestAlert(html, domain = 'www.1point3acres.com') {
+    if (/<title>提示信息 \| 一亩三分地<\/title>/.test(html) && /无法进行此操作/.test(html)) {
+        throw new AuthRequiredError(domain, '需要登录一亩三分地后再使用该命令');
+    }
+}
+
+const ENTITY_MAP = {
+    '&nbsp;': ' ', '&amp;': '&', '&lt;': '<', '&gt;': '>',
+    '&quot;': '"', '&#39;': "'", '&apos;': "'",
+};
+
+/** Decode HTML entities (numeric + common named). */
+export function decodeEntities(s) {
+    if (!s) return '';
+    return s
+        .replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n)))
+        .replace(/&#[xX]([0-9a-fA-F]+);/g, (_, n) => String.fromCodePoint(parseInt(n, 16)))
+        .replace(/&(nbsp|amp|lt|gt|quot|#39|apos);/g, m => ENTITY_MAP[m] || m);
+}
+
+/** Strip HTML tags and collapse whitespace, returning plain text. */
+export function stripHtml(html) {
+    if (!html) return '';
+    return decodeEntities(
+        String(html)
+            .replace(/<br\s*\/?>/gi, '\n')
+            .replace(/<\/(p|div|li|tr)>/gi, '\n')
+            .replace(/<[^>]+>/g, '')
+    ).replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+
+/** Truncate text to n characters with ellipsis. */
+export function truncate(s, n = 300) {
+    if (!s) return '';
+    return s.length > n ? s.slice(0, n) + '…' : s;
+}
+
+/** Extract all <tbody id="normalthread_*"> blocks from a forum/guide page. */
+export function parseThreadRows(html) {
+    const rows = [];
+    const re = /<tbody id="(normalthread|stickthread)_(\d+)"[^>]*>([\s\S]*?)<\/tbody>/g;
+    let m;
+    while ((m = re.exec(html))) {
+        const [, kind, tid, inner] = m;
+        rows.push({ kind, tid, inner });
+    }
+    return rows;
+}
+
+/** Parse a single Discuz thread row (inner HTML of the tbody). */
+export function parseThreadRow({ kind, tid, inner }) {
+    const titleMatches = [...inner.matchAll(/<a [^>]*class="[^"]*\bxst\b[^"]*"[^>]*>([^<]+)<\/a>/g)];
+    const title = titleMatches.length
+        ? decodeEntities(titleMatches[titleMatches.length - 1][1].trim())
+        : '';
+
+    const forumMatch = inner.match(/<a href="forum-(\d+)-1\.html"[^>]*target="_blank"[^>]*>([^<]+)<\/a>/);
+    const fid = forumMatch ? forumMatch[1] : '';
+    const forumName = forumMatch ? decodeEntities(forumMatch[2].trim()) : '';
+
+    // <td class="by"> blocks; first with <cite> = author, last with <cite> = last reply
+    const byBlocks = [...inner.matchAll(/<td class="by"[^>]*>([\s\S]*?)<\/td>/g)].map(m => m[1]);
+    const readCite = (block) => {
+        const m = block.match(/<cite[^>]*>([\s\S]*?)<\/cite>/);
+        if (!m) return '';
+        return decodeEntities(m[1].replace(/<[^>]+>/g, '').trim());
+    };
+    const readTime = (block) => {
+        const titleM = block.match(/<span [^>]*title="([^"]+)"[^>]*>/);
+        if (titleM) return titleM[1].trim();
+        const plainA = block.match(/<em>[\s\S]*?<a [^>]*>\s*([^<]+?)\s*<\/a>/);
+        if (plainA) return decodeEntities(plainA[1].trim());
+        const plainSpan = block.match(/<em>[\s\S]*?<span[^>]*>\s*([^<]+?)\s*<\/span>/);
+        if (plainSpan) return decodeEntities(plainSpan[1].trim());
+        const bare = block.match(/<em>\s*([^<]+?)\s*<\/em>/);
+        return bare ? decodeEntities(bare[1].trim()) : '';
+    };
+    let authorBlock = '';
+    let lastBlock = '';
+    for (const b of byBlocks) {
+        if (/<cite/.test(b)) {
+            if (!authorBlock) authorBlock = b;
+            lastBlock = b;
+        }
+    }
+    const author = authorBlock ? readCite(authorBlock) : '';
+    const postTime = authorBlock ? readTime(authorBlock) : '';
+    const lastReplyUser = lastBlock && lastBlock !== authorBlock ? readCite(lastBlock) : '';
+    const lastReplyTime = lastBlock && lastBlock !== authorBlock ? readTime(lastBlock) : '';
+
+    const numMatch = inner.match(/<td class="num"[^>]*>\s*<a[^>]*class="xi2"[^>]*>(\d+)<\/a>(?:\s*<em>(\d+)<\/em>)?/);
+    const replies = numMatch ? Number(numMatch[1]) : 0;
+    const views = numMatch && numMatch[2] ? Number(numMatch[2]) : 0;
+    return {
+        tid,
+        kind,
+        title,
+        author,
+        forum: forumName,
+        fid,
+        replies,
+        views,
+        postTime,
+        lastReplyUser,
+        lastReplyTime,
+        url: `${BASE}/thread-${tid}-1-1.html`,
+    };
+}
+
+/** Quick one-shot listing parser used by hot/latest/digest/forum. */
+export function parseThreadList(html) {
+    return parseThreadRows(html).map(parseThreadRow).filter(t => t.title);
+}
+
+/**
+ * Parse Discuz search results page (different HTML shape than forum listings).
+ * Each hit is <li class="pbw" id="TID"> containing h3 > a[href*="tid=TID"],
+ * <p class="xg1">N 个回复 - M 次查看</p>, and a time/author/forum <p>.
+ */
+export function parseSearchList(html) {
+    const items = [];
+    const re = /<li class="pbw" id="(\d+)">([\s\S]*?)<\/li>/g;
+    let m;
+    while ((m = re.exec(html))) {
+        const [, tid, inner] = m;
+        const titleMatch = inner.match(/<h3[^>]*>\s*<a [^>]*>([\s\S]*?)<\/a>/);
+        const titleRaw = titleMatch ? titleMatch[1] : '';
+        const title = decodeEntities(titleRaw.replace(/<[^>]+>/g, '')).trim();
+        if (!title) continue;
+
+        const statsMatch = inner.match(/<p class="xg1">\s*([\d,]+)\s*个回复\s*-\s*([\d,]+)\s*次查看\s*<\/p>/);
+        const replies = statsMatch ? Number(statsMatch[1].replace(/,/g, '')) : 0;
+        const views = statsMatch ? Number(statsMatch[2].replace(/,/g, '')) : 0;
+
+        const metaMatch = inner.match(/<p>\s*<span>([^<]+)<\/span>[\s\S]*?<a [^>]*space-uid-\d+[^>]*>([^<]+?)<\/a>[\s\S]*?<a [^>]*href="forum-(\d+)-[^"]*"[^>]*>([^<]+?)<\/a>/);
+        const postTime = metaMatch ? decodeEntities(metaMatch[1].trim()) : '';
+        const author = metaMatch ? decodeEntities(metaMatch[2].trim()) : '';
+        const fid = metaMatch ? metaMatch[3] : '';
+        const forumName = metaMatch ? decodeEntities(metaMatch[4].trim()) : '';
+
+        items.push({
+            tid, title, author, forum: forumName, fid,
+            replies, views, postTime,
+            // Search pages don't show lastReplyTime separately — surface postTime instead.
+            lastReplyUser: '', lastReplyTime: postTime,
+            url: `${BASE}/thread-${tid}-1-1.html`,
+        });
+    }
+    return items;
+}
+
+export { UA };

package/clis/_shared/desktop-commands.js

@@ -14,6 +14,7 @@ export function makeScreenshotCommand(site, displayName, extra = {}) {
         ...extra,
         site,
         name: 'screenshot',
+        access: 'read',
         description: `Capture a snapshot of the current ${label} window (DOM + Accessibility tree)`,
         domain: 'localhost',
         strategy: Strategy.UI,
@@ -46,6 +47,7 @@ export function makeStatusCommand(site, displayName, extra = {}) {
         ...extra,
         site,
         name: 'status',
+        access: 'read',
         description: `Check active CDP connection to ${label}`,
         domain: 'localhost',
         strategy: Strategy.UI,
@@ -67,6 +69,7 @@ export function makeNewCommand(site, displayName, extra = {}) {
         ...extra,
         site,
         name: 'new',
+        access: 'write',
         description: `Start a new ${label} session`,
         domain: 'localhost',
         strategy: Strategy.UI,
@@ -87,6 +90,7 @@ export function makeDumpCommand(site) {
     return cli({
         site,
         name: 'dump',
+        access: 'read',
         description: `Dump the DOM and Accessibility tree of ${site} for reverse-engineering`,
         domain: 'localhost',
         strategy: Strategy.UI,

package/clis/aibase/news.js

@@ -0,0 +1,110 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError, getErrorMessage } from '@jackwener/opencli/errors';
+
+const AIBASE_DAILY_URL = 'https://www.aibase.com/zh/daily';
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 50;
+
+function normalizeLimit(value) {
+    const raw = value ?? DEFAULT_LIMIT;
+    const limit = Number(raw);
+    if (!Number.isInteger(limit) || limit <= 0) {
+        throw new ArgumentError('limit must be a positive integer', `Example: opencli aibase news --limit ${DEFAULT_LIMIT}`);
+    }
+    if (limit > MAX_LIMIT) {
+        throw new ArgumentError(`limit must be <= ${MAX_LIMIT}`, `Example: opencli aibase news --limit ${MAX_LIMIT}`);
+    }
+    return limit;
+}
+
+function normalizeText(value) {
+    return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+
+function buildExtractAibaseNewsJs() {
+    return `
+      (() => {
+        const anchors = Array.from(document.querySelectorAll('.bg-white .grid a[href], a[href*="/zh/daily/"]'))
+          .filter((anchor) => {
+            const href = anchor.getAttribute('href') || '';
+            const text = (anchor.innerText || anchor.textContent || '').trim();
+            return text && href && !href.endsWith('/zh/daily') && !href.endsWith('/zh/daily/');
+          });
+        if (anchors.length === 0) {
+          return {
+            ok: false,
+            reason: 'selector-missing',
+            title: document.title || '',
+            bodyText: (document.body?.innerText || document.body?.textContent || '').slice(0, 500),
+          };
+        }
+        const seen = new Set();
+        const rows = [];
+        for (const anchor of anchors) {
+          const url = new URL(anchor.getAttribute('href'), location.href).href;
+          if (seen.has(url)) continue;
+          seen.add(url);
+          rows.push({
+            rank: rows.length + 1,
+            title: anchor.innerText || anchor.textContent || '',
+            url,
+          });
+        }
+        return { ok: true, rows };
+      })()
+    `;
+}
+
+function toRows(payload, limit) {
+    if (!payload || typeof payload !== 'object') {
+        throw new CommandExecutionError('AIbase daily page returned an unreadable payload');
+    }
+    if (!payload.ok) {
+        const reason = typeof payload.reason === 'string' && payload.reason.trim() ? payload.reason.trim() : 'selector-drift';
+        throw new CommandExecutionError(
+            `AIbase daily selector drift: ${reason}`,
+            payload.title ? `Page title: ${payload.title}` : undefined,
+        );
+    }
+    const rows = (Array.isArray(payload.rows) ? payload.rows : [])
+        .map((row, index) => ({
+            rank: index + 1,
+            title: normalizeText(row.title),
+            url: normalizeText(row.url),
+        }))
+        .filter((row) => row.title && row.url);
+    if (rows.length === 0) {
+        throw new EmptyResultError('aibase news', 'AIbase daily page loaded, but no article rows with title and URL were extracted.');
+    }
+    return rows.slice(0, limit).map((row, index) => ({ ...row, rank: index + 1 }));
+}
+
+async function loadAibaseNews(page, args) {
+    const limit = normalizeLimit(args.limit);
+    await page.goto(AIBASE_DAILY_URL, { waitUntil: 'load', settleMs: 3000 });
+    const payload = await page.evaluate(buildExtractAibaseNewsJs()).catch((error) => {
+        throw new CommandExecutionError(`Failed to extract AIbase daily news: ${getErrorMessage(error)}`);
+    });
+    return toRows(payload, limit);
+}
+
+export const aibaseNewsCommand = cli({
+    site: 'aibase',
+    name: 'news',
+    access: 'read',
+    description: 'AIbase 日报 - 每天三分钟关注AI行业趋势',
+    domain: 'www.aibase.com',
+    strategy: Strategy.PUBLIC,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: DEFAULT_LIMIT, help: `Number of news items to return (max ${MAX_LIMIT})` },
+    ],
+    columns: ['rank', 'title', 'url'],
+    func: loadAibaseNews,
+});
+
+export const __test__ = {
+    buildExtractAibaseNewsJs,
+    normalizeLimit,
+    toRows,
+};

package/clis/aibase/news.test.js

@@ -0,0 +1,59 @@
+import { JSDOM } from 'jsdom';
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { aibaseNewsCommand, __test__ } from './news.js';
+
+function runBrowserScript(html, script, url = 'https://www.aibase.com/zh/daily') {
+    const dom = new JSDOM(html, { url, runScripts: 'outside-only' });
+    return dom.window.eval(script);
+}
+
+function makePage(evaluateResult) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(evaluateResult),
+    };
+}
+
+describe('aibase/news', () => {
+    it('registers stable URL in columns', () => {
+        expect(aibaseNewsCommand.access).toBe('read');
+        expect(aibaseNewsCommand.columns).toEqual(['rank', 'title', 'url']);
+    });
+
+    it('validates limit before browser navigation', async () => {
+        const page = makePage({ ok: true, rows: [] });
+        await expect(aibaseNewsCommand.func(page, { limit: 0 })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(aibaseNewsCommand.func(page, { limit: 51 })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('extracts and deduplicates AIbase daily rows', async () => {
+        const html = `
+          <div class="bg-white">
+            <div class="grid">
+              <a href="/zh/daily/123"> First AI daily item </a>
+              <a href="/zh/daily/123"> First AI daily item duplicate </a>
+              <a href="/zh/daily/456"> Second AI daily item </a>
+            </div>
+          </div>
+        `;
+        const payload = runBrowserScript(html, __test__.buildExtractAibaseNewsJs());
+        const page = makePage(payload);
+
+        const rows = await aibaseNewsCommand.func(page, { limit: 2 });
+
+        expect(page.goto).toHaveBeenCalledWith('https://www.aibase.com/zh/daily', { waitUntil: 'load', settleMs: 3000 });
+        expect(rows).toEqual([
+            { rank: 1, title: 'First AI daily item', url: 'https://www.aibase.com/zh/daily/123' },
+            { rank: 2, title: 'Second AI daily item', url: 'https://www.aibase.com/zh/daily/456' },
+        ]);
+    });
+
+    it('maps selector drift and empty rows to typed errors', async () => {
+        await expect(aibaseNewsCommand.func(makePage({ ok: false, reason: 'selector-missing' }), { limit: 1 }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(aibaseNewsCommand.func(makePage({ ok: true, rows: [{ title: '', url: '' }] }), { limit: 1 }))
+            .rejects.toBeInstanceOf(EmptyResultError);
+    });
+});

package/clis/amazon/discussion.test.js

@@ -3,35 +3,8 @@ import { AuthRequiredError } from '@jackwener/opencli/errors';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { __test__ } from './discussion.js';
 import './discussion.js';
+import { createPageMock } from '../test-utils.js';
 
-function createPageMock(evaluateResults) {
-  const evaluate = vi.fn();
-  for (const result of evaluateResults) {
-    evaluate.mockResolvedValueOnce(result);
-  }
-  return {
-    goto: vi.fn().mockResolvedValue(undefined),
-    wait: vi.fn().mockResolvedValue(undefined),
-    evaluate,
-    snapshot: vi.fn().mockResolvedValue(undefined),
-    click: vi.fn().mockResolvedValue(undefined),
-    typeText: vi.fn().mockResolvedValue(undefined),
-    pressKey: vi.fn().mockResolvedValue(undefined),
-    scrollTo: vi.fn().mockResolvedValue(undefined),
-    getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
-    tabs: vi.fn().mockResolvedValue([]),
-    selectTab: vi.fn().mockResolvedValue(undefined),
-    networkRequests: vi.fn().mockResolvedValue([]),
-    consoleMessages: vi.fn().mockResolvedValue([]),
-    scroll: vi.fn().mockResolvedValue(undefined),
-    autoScroll: vi.fn().mockResolvedValue(undefined),
-    installInterceptor: vi.fn().mockResolvedValue(undefined),
-    getInterceptedRequests: vi.fn().mockResolvedValue([]),
-    getCookies: vi.fn().mockResolvedValue([]),
-    screenshot: vi.fn().mockResolvedValue(''),
-    waitForCapture: vi.fn().mockResolvedValue(undefined),
-  };
-}
 
 describe('amazon discussion normalization', () => {
   it('normalizes review summary and sample reviews', () => {

package/clis/antigravity/watch.js

@@ -7,8 +7,9 @@ export const watchCommand = cli({
     domain: 'localhost',
     strategy: Strategy.UI,
     browser: true,
-    args: [],
-    timeoutSeconds: 86400, // Run for up to 24 hours
+    args: [
+        { name: 'timeout', type: 'int', required: false, default: 86400, help: 'Max seconds to keep watching (default: 86400 — 24h)' },
+    ],
     columns: [], // We use direct stdout streaming
     func: async (page) => {
         console.log('Watching Antigravity chat... (Press Ctrl+C to stop)');

package/clis/arxiv/author.js

@@ -0,0 +1,44 @@
+// arxiv author — list papers authored by a person, newest first.
+//
+// arXiv's public API supports `au:` prefix queries. Author names on arXiv are
+// not stable IDs, so this is a best-effort fuzzy match — the same person can
+// appear under multiple spellings ("Y. Bengio" vs "Yoshua Bengio").
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import { arxivFetch, normalizeArxivLimit, parseEntries } from './utils.js';
+
+cli({
+    site: 'arxiv',
+    name: 'author',
+    access: 'read',
+    description: 'List arXiv papers by a given author (newest first)',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'author', positional: true, required: true, help: 'Author name (e.g. "Yoshua Bengio" or "Y Bengio")' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max papers to return (max 50)' },
+    ],
+    columns: ['id', 'title', 'authors', 'published', 'primary_category', 'url'],
+    func: async (args) => {
+        const authorText = String(args.author || '').trim();
+        if (!authorText) {
+            throw new ArgumentError('arxiv author cannot be empty', 'Example: opencli arxiv author "Yoshua Bengio"');
+        }
+        const limit = normalizeArxivLimit(args.limit, 20, 50);
+        // Quote the value so multi-word author names match as a phrase.
+        const query = encodeURIComponent(`au:"${authorText}"`);
+        const xml = await arxivFetch(`search_query=${query}&max_results=${limit}&sortBy=submittedDate&sortOrder=descending`);
+        const entries = parseEntries(xml);
+        if (!entries.length) {
+            throw new EmptyResultError('arxiv author', `No papers found for author "${authorText}". Try alternate spellings (e.g. initials).`);
+        }
+        return entries.map(e => ({
+            id: e.id,
+            title: e.title,
+            authors: e.authors,
+            published: e.published,
+            primary_category: e.primary_category,
+            url: e.url,
+        }));
+    },
+});

package/clis/baidu-scholar/search.js

@@ -14,7 +14,6 @@ cli({
         { name: 'limit', type: 'int', default: 10, help: '返回结果数量 (max 20)' },
     ],
     columns: ['rank', 'title', 'authors', 'journal', 'year', 'cited', 'url'],
-    navigateBefore: false,
     func: async (page, kwargs) => {
         const limit = clampInt(kwargs.limit, 10, 1, 20);
         const query = requireNonEmptyQuery(kwargs.query);

package/clis/bbc/topic.js

@@ -0,0 +1,57 @@
+// bbc topic — BBC News headlines for a specific category, via public RSS.
+//
+// BBC publishes per-section RSS feeds at
+// `https://feeds.bbci.co.uk/news/<topic>/rss.xml`. We expose the eight
+// canonical sections and reject anything else with a typed argument error
+// so the user knows the supported set.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import { bbcFetchRss, parseRssItems, pubDateToIso, requireBoundedInt } from './utils.js';
+
+const TOPICS = [
+    'world',
+    'business',
+    'politics',
+    'health',
+    'education',
+    'science_and_environment',
+    'technology',
+    'entertainment_and_arts',
+];
+
+cli({
+    site: 'bbc',
+    name: 'topic',
+    access: 'read',
+    description: 'BBC News headlines for a specific section (RSS feed)',
+    domain: 'www.bbc.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'topic', positional: true, required: true, help: `Section name (${TOPICS.join(' / ')})` },
+        { name: 'limit', type: 'int', default: 20, help: 'Max headlines (1-50)' },
+    ],
+    columns: ['rank', 'title', 'description', 'pubDate', 'url'],
+    func: async (args) => {
+        const raw = String(args.topic ?? '').trim().toLowerCase().replace(/[\s-]+/g, '_');
+        if (!TOPICS.includes(raw)) {
+            throw new ArgumentError(
+                `bbc topic "${args.topic}" is not supported`,
+                `Supported topics: ${TOPICS.join(', ')}`,
+            );
+        }
+        const limit = requireBoundedInt(args.limit, 20, 50);
+        const xml = await bbcFetchRss(`${raw}/rss.xml`, `bbc topic ${raw}`);
+        const items = parseRssItems(xml);
+        if (!items.length) {
+            throw new EmptyResultError('bbc topic', `BBC ${raw} feed returned no items.`);
+        }
+        return items.slice(0, limit).map((it, i) => ({
+            rank: i + 1,
+            title: it.title,
+            description: it.description,
+            pubDate: pubDateToIso(it.pubDate),
+            url: it.link,
+        }));
+    },
+});