@jackwener/opencli 1.7.11 → 1.7.13

package/clis/antigravity/new.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 export const newCommand = cli({
     site: 'antigravity',
     name: 'new',
+    access: 'read',
     description: 'Start a new conversation / clear context in Antigravity',
     domain: 'localhost',
     strategy: Strategy.UI,

package/clis/antigravity/read.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 export const readCommand = cli({
     site: 'antigravity',
     name: 'read',
+    access: 'read',
     description: 'Read the latest chat messages from Antigravity AI',
     domain: 'localhost',
     strategy: Strategy.UI,

package/clis/antigravity/send.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 export const sendCommand = cli({
     site: 'antigravity',
     name: 'send',
+    access: 'write',
     description: 'Send a message to Antigravity AI via the internal Lexical editor',
     domain: 'localhost',
     strategy: Strategy.UI,

package/clis/antigravity/status.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 export const statusCommand = cli({
     site: 'antigravity',
     name: 'status',
+    access: 'read',
     description: 'Check Antigravity CDP connection and get current page state',
     domain: 'localhost',
     strategy: Strategy.UI,

package/clis/antigravity/watch.js

@@ -2,12 +2,14 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 export const watchCommand = cli({
     site: 'antigravity',
     name: 'watch',
+    access: 'read',
     description: 'Stream new chat messages from Antigravity in real-time',
     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/apple-podcasts/episodes.js

@@ -4,6 +4,7 @@ import { itunesFetch, formatDuration, formatDate } from './utils.js';
 cli({
     site: 'apple-podcasts',
     name: 'episodes',
+    access: 'read',
     description: 'List recent episodes of an Apple Podcast (use ID from search)',
     strategy: Strategy.PUBLIC,
     browser: false,

package/clis/apple-podcasts/search.js

@@ -4,6 +4,7 @@ import { itunesFetch } from './utils.js';
 cli({
     site: 'apple-podcasts',
     name: 'search',
+    access: 'read',
     description: 'Search Apple Podcasts',
     strategy: Strategy.PUBLIC,
     browser: false,

package/clis/apple-podcasts/top.js

@@ -6,6 +6,7 @@ const CHARTS_TIMEOUT_MS = 15_000;
 cli({
     site: 'apple-podcasts',
     name: 'top',
+    access: 'read',
     description: 'Top podcasts chart on Apple Podcasts',
     strategy: Strategy.PUBLIC,
     browser: false,

package/clis/arxiv/arxiv.test.js

@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { normalizeArxivCategory, normalizeArxivLimit, parseEntries } from './utils.js';
+import './paper.js';
+import './search.js';
+import './recent.js';
+
+const SAMPLE_ENTRY_XML = `<?xml version='1.0' encoding='UTF-8'?>
+<feed xmlns:opensearch="http://a9.com/-/spec/opensearch/1.1/"
+      xmlns:arxiv="http://arxiv.org/schemas/atom"
+      xmlns="http://www.w3.org/2005/Atom">
+  <entry>
+    <id>http://arxiv.org/abs/1706.03762v7</id>
+    <title>Attention Is All You Need &amp; Friends</title>
+    <updated>2023-08-02T00:41:18Z</updated>
+    <link href="https://arxiv.org/abs/1706.03762v7" rel="alternate" type="text/html"/>
+    <link href="https://arxiv.org/pdf/1706.03762v7" rel="related" type="application/pdf" title="pdf"/>
+    <summary>The dominant sequence transduction models are based on complex recurrent or convolutional neural networks. We propose a new simple network architecture, the Transformer, based solely on attention.</summary>
+    <category term="cs.CL" scheme="http://arxiv.org/schemas/atom"/>
+    <category term="cs.LG" scheme="http://arxiv.org/schemas/atom"/>
+    <published>2017-06-12T17:57:34Z</published>
+    <arxiv:comment>15 pages, 5 figures</arxiv:comment>
+    <arxiv:primary_category term="cs.CL"/>
+    <author><name>Ashish Vaswani</name></author>
+    <author><name>Noam Shazeer</name></author>
+    <author><name>Niki Parmar</name></author>
+    <author><name>Jakob Uszkoreit</name></author>
+    <author><name>Llion Jones</name></author>
+    <author><name>Aidan N. Gomez</name></author>
+    <author><name>Lukasz Kaiser</name></author>
+    <author><name>Illia Polosukhin</name></author>
+  </entry>
+</feed>`;
+
+describe('arxiv adapter', () => {
+  it('registers paper, search and recent commands with the expected columns', () => {
+    const paper = getRegistry().get('arxiv/paper');
+    const search = getRegistry().get('arxiv/search');
+    const recent = getRegistry().get('arxiv/recent');
+
+    expect(paper).toBeDefined();
+    expect(search).toBeDefined();
+    expect(recent).toBeDefined();
+
+    expect(paper.columns).toEqual([
+      'id', 'title', 'authors', 'published', 'updated',
+      'primary_category', 'categories', 'abstract', 'comment', 'pdf', 'url',
+    ]);
+    expect(search.columns).toEqual([
+      'id', 'title', 'authors', 'published', 'primary_category', 'url',
+    ]);
+    expect(recent.columns).toEqual([
+      'id', 'title', 'authors', 'published', 'primary_category', 'url',
+    ]);
+  });
+
+  it('parseEntries returns full abstract, all authors, pdf, primary category and comment', () => {
+    const [entry] = parseEntries(SAMPLE_ENTRY_XML);
+
+    expect(entry.id).toBe('1706.03762');
+    expect(entry.title).toBe('Attention Is All You Need & Friends');
+    // All 8 authors must be present — earlier impl truncated to 3.
+    expect(entry.authors.split(', ')).toHaveLength(8);
+    expect(entry.authors).toContain('Ashish Vaswani');
+    expect(entry.authors).toContain('Illia Polosukhin');
+    // Full abstract — earlier impl truncated at 200 chars.
+    expect(entry.abstract.length).toBeGreaterThan(140);
+    expect(entry.abstract.endsWith('...')).toBe(false);
+    expect(entry.abstract).toContain('attention');
+    expect(entry.published).toBe('2017-06-12');
+    expect(entry.updated).toBe('2023-08-02');
+    expect(entry.primary_category).toBe('cs.CL');
+    expect(entry.categories).toBe('cs.CL, cs.LG');
+    expect(entry.comment).toBe('15 pages, 5 figures');
+    expect(entry.pdf).toBe('https://arxiv.org/pdf/1706.03762v7');
+    expect(entry.url).toBe('https://arxiv.org/abs/1706.03762');
+  });
+
+  it('parseEntries returns an empty list for feeds with no entries', () => {
+    expect(parseEntries('<feed></feed>')).toEqual([]);
+  });
+
+  it('recent rejects malformed category strings', async () => {
+    const recent = getRegistry().get('arxiv/recent');
+    await expect(recent.func({ category: 'not a category', limit: 5 })).rejects.toMatchObject({
+      code: 'ARGUMENT',
+    });
+    await expect(recent.func({ category: '', limit: 5 })).rejects.toMatchObject({
+      code: 'ARGUMENT',
+    });
+  });
+
+  it('category validation accepts real arXiv archive and subcategory forms', () => {
+    expect(normalizeArxivCategory('cs.CL')).toBe('cs.CL');
+    expect(normalizeArxivCategory('math')).toBe('math');
+    expect(normalizeArxivCategory('physics.comp-ph')).toBe('physics.comp-ph');
+    expect(normalizeArxivCategory('physics.data-an')).toBe('physics.data-an');
+    expect(normalizeArxivCategory('cond-mat.soft')).toBe('cond-mat.soft');
+    expect(normalizeArxivCategory('q-bio.NC')).toBe('q-bio.NC');
+    expect(() => normalizeArxivCategory('not a category')).toThrow('Invalid arXiv category');
+    expect(() => normalizeArxivCategory('cs/CL')).toThrow('Invalid arXiv category');
+    expect(() => normalizeArxivCategory('')).toThrow('Invalid arXiv category');
+  });
+
+  it('limit validation rejects non-positive, non-integer and over-cap values', () => {
+    expect(normalizeArxivLimit(10, 5, 25)).toBe(10);
+    expect(normalizeArxivLimit(undefined, 5, 25)).toBe(5);
+    expect(() => normalizeArxivLimit(0, 5, 25)).toThrow('positive integer');
+    expect(() => normalizeArxivLimit(1.5, 5, 25)).toThrow('positive integer');
+    expect(() => normalizeArxivLimit(26, 5, 25)).toThrow('<= 25');
+  });
+});

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/arxiv/paper.js

@@ -1,21 +1,22 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { CliError } from '@jackwener/opencli/errors';
+import { EmptyResultError } from '@jackwener/opencli/errors';
 import { arxivFetch, parseEntries } from './utils.js';
 cli({
     site: 'arxiv',
     name: 'paper',
+    access: 'read',
     description: 'Get arXiv paper details by ID',
     strategy: Strategy.PUBLIC,
     browser: false,
     args: [
         { name: 'id', positional: true, required: true, help: 'arXiv paper ID (e.g. 1706.03762)' },
     ],
-    columns: ['id', 'title', 'authors', 'published', 'abstract', 'url'],
+    columns: ['id', 'title', 'authors', 'published', 'updated', 'primary_category', 'categories', 'abstract', 'comment', 'pdf', 'url'],
     func: async (args) => {
         const xml = await arxivFetch(`id_list=${encodeURIComponent(args.id)}`);
         const entries = parseEntries(xml);
         if (!entries.length)
-            throw new CliError('NOT_FOUND', `Paper ${args.id} not found`, 'Check the arXiv ID format, e.g. 1706.03762');
+            throw new EmptyResultError('arxiv paper', `Paper ${args.id} was not found. Check the arXiv ID format, e.g. 1706.03762`);
         return entries;
     },
 });

package/clis/arxiv/recent.js

@@ -0,0 +1,33 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { arxivFetch, normalizeArxivCategory, normalizeArxivLimit, parseEntries } from './utils.js';
+cli({
+    site: 'arxiv',
+    name: 'recent',
+    access: 'read',
+    description: 'List recent arXiv submissions in a category',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'category', positional: true, required: true, help: 'arXiv category (e.g. cs.CL, cs.LG, math.PR, q-bio.NC)' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max results (max 50)' },
+    ],
+    columns: ['id', 'title', 'authors', 'published', 'primary_category', 'url'],
+    func: async (args) => {
+        const category = normalizeArxivCategory(args.category);
+        const limit = normalizeArxivLimit(args.limit, 10, 50);
+        const query = encodeURIComponent(`cat:${category}`);
+        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', `No recent papers in ${category}. Check the category name.`);
+        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/arxiv/search.js

@@ -1,9 +1,10 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { CliError } from '@jackwener/opencli/errors';
-import { arxivFetch, parseEntries } from './utils.js';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import { arxivFetch, normalizeArxivLimit, parseEntries } from './utils.js';
 cli({
     site: 'arxiv',
     name: 'search',
+    access: 'read',
     description: 'Search arXiv papers',
     strategy: Strategy.PUBLIC,
     browser: false,
@@ -11,14 +12,25 @@ cli({
         { name: 'query', positional: true, required: true, help: 'Search keyword (e.g. "attention is all you need")' },
         { name: 'limit', type: 'int', default: 10, help: 'Max results (max 25)' },
     ],
-    columns: ['id', 'title', 'authors', 'published', 'url'],
+    columns: ['id', 'title', 'authors', 'published', 'primary_category', 'url'],
     func: async (args) => {
-        const limit = Math.max(1, Math.min(Number(args.limit), 25));
-        const query = encodeURIComponent(`all:${args.query}`);
+        const queryText = String(args.query || '').trim();
+        if (!queryText) {
+            throw new ArgumentError('arxiv search query cannot be empty');
+        }
+        const limit = normalizeArxivLimit(args.limit, 10, 25);
+        const query = encodeURIComponent(`all:${queryText}`);
         const xml = await arxivFetch(`search_query=${query}&max_results=${limit}&sortBy=relevance`);
         const entries = parseEntries(xml);
         if (!entries.length)
-            throw new CliError('NOT_FOUND', 'No papers found', 'Try a different keyword');
-        return entries.map(e => ({ id: e.id, title: e.title, authors: e.authors, published: e.published, url: e.url }));
+            throw new EmptyResultError('arxiv', 'No papers found. Try a different keyword.');
+        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/arxiv/utils.js

@@ -4,15 +4,44 @@
  * arXiv exposes a public Atom/XML API — no key required.
  * https://info.arxiv.org/help/api/index.html
  */
-import { CliError } from '@jackwener/opencli/errors';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
 export const ARXIV_BASE = 'https://export.arxiv.org/api/query';
+const ARXIV_CATEGORY_PATTERN = /^[a-z]+(?:-[a-z]+)*(?:\.[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*)?$/;
 export async function arxivFetch(params) {
     const resp = await fetch(`${ARXIV_BASE}?${params}`);
     if (!resp.ok) {
-        throw new CliError('FETCH_ERROR', `arXiv API HTTP ${resp.status}`, 'Check your search term or paper ID');
+        throw new CommandExecutionError(`arXiv API HTTP ${resp.status}`, 'Check your search term or paper ID');
     }
     return resp.text();
 }
+export function normalizeArxivLimit(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const limit = Number(raw);
+    if (!Number.isInteger(limit) || limit <= 0) {
+        throw new ArgumentError(`arxiv ${label} must be a positive integer`);
+    }
+    if (limit > maxValue) {
+        throw new ArgumentError(`arxiv ${label} must be <= ${maxValue}`);
+    }
+    return limit;
+}
+export function normalizeArxivCategory(value) {
+    const category = String(value || '').trim();
+    if (!ARXIV_CATEGORY_PATTERN.test(category)) {
+        throw new ArgumentError(`Invalid arXiv category "${value}". Examples: cs.CL, cs.LG, math.PR, q-bio.NC, physics.comp-ph`);
+    }
+    return category;
+}
+/** Decode the small set of XML entities arXiv emits in text fields. */
+function decodeEntities(s) {
+    return s
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&#39;/g, "'");
+}
 /** Extract the text content of the first matching XML tag. */
 function extract(xml, tag) {
     const m = xml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`));
@@ -27,6 +56,34 @@ function extractAll(xml, tag) {
         results.push(m[1].trim());
     return results;
 }
+/** Extract the value of a named attribute from the first matching tag (open or self-closing). */
+function extractAttr(xml, tag, attr) {
+    const m = xml.match(new RegExp(`<${tag}\\b[^>]*?\\b${attr}="([^"]*)"`));
+    return m ? m[1] : '';
+}
+/** Extract all values of a named attribute across repeated tags. */
+function extractAllAttr(xml, tag, attr) {
+    const re = new RegExp(`<${tag}\\b[^>]*?\\b${attr}="([^"]*)"`, 'g');
+    const out = [];
+    let m;
+    while ((m = re.exec(xml)) !== null)
+        out.push(m[1]);
+    return out;
+}
+/** Find the href of the first <link> tag matching a given rel. */
+function findLinkHref(xml, rel) {
+    const re = /<link\b([^>]*)\/?>/g;
+    let m;
+    while ((m = re.exec(xml)) !== null) {
+        const attrs = m[1];
+        if (new RegExp(`\\brel="${rel}"`).test(attrs)) {
+            const h = attrs.match(/\bhref="([^"]*)"/);
+            if (h)
+                return h[1];
+        }
+    }
+    return '';
+}
 /** Parse Atom XML feed into structured entries. */
 export function parseEntries(xml) {
     const entryRe = /<entry>([\s\S]*?)<\/entry>/g;
@@ -36,12 +93,18 @@ export function parseEntries(xml) {
         const e = m[1];
         const rawId = extract(e, 'id');
         const arxivId = rawId.replace(/^https?:\/\/arxiv\.org\/abs\//, '').replace(/v\d+$/, '');
+        const pdf = findLinkHref(e, 'related') || `https://arxiv.org/pdf/${arxivId}`;
         entries.push({
             id: arxivId,
-            title: extract(e, 'title').replace(/\s+/g, ' '),
-            authors: extractAll(e, 'name').slice(0, 3).join(', '),
-            abstract: (() => { const s = extract(e, 'summary').replace(/\s+/g, ' '); return s.length > 200 ? s.slice(0, 200) + '...' : s; })(),
+            title: decodeEntities(extract(e, 'title').replace(/\s+/g, ' ')),
+            authors: decodeEntities(extractAll(e, 'name').join(', ')),
+            abstract: decodeEntities(extract(e, 'summary').replace(/\s+/g, ' ')),
             published: extract(e, 'published').slice(0, 10),
+            updated: extract(e, 'updated').slice(0, 10),
+            primary_category: extractAttr(e, 'arxiv:primary_category', 'term'),
+            categories: extractAllAttr(e, 'category', 'term').join(', '),
+            comment: decodeEntities(extract(e, 'arxiv:comment').replace(/\s+/g, ' ')),
+            pdf,
             url: `https://arxiv.org/abs/${arxivId}`,
         });
     }

package/clis/baidu-scholar/search.js

@@ -4,6 +4,7 @@ import { clampInt, requireNonEmptyQuery } from '../_shared/common.js';
 cli({
     site: 'baidu-scholar',
     name: 'search',
+    access: 'read',
     description: '百度学术搜索',
     domain: 'xueshu.baidu.com',
     strategy: Strategy.PUBLIC,
@@ -13,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/band/bands.js

@@ -13,6 +13,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'band',
     name: 'bands',
+    access: 'read',
     description: 'List all Bands you belong to',
     domain: 'www.band.us',
     strategy: Strategy.COOKIE,

package/clis/band/mentions.js

@@ -12,6 +12,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'band',
     name: 'mentions',
+    access: 'read',
     description: 'Show Band notifications where you are @mentioned',
     domain: 'www.band.us',
     strategy: Strategy.INTERCEPT,

package/clis/band/post.js

@@ -18,6 +18,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'band',
     name: 'post',
+    access: 'read',
     description: 'Export full content of a post including comments',
     domain: 'www.band.us',
     strategy: Strategy.COOKIE,

package/clis/band/posts.js

@@ -10,6 +10,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'band',
     name: 'posts',
+    access: 'read',
     description: 'List posts from a Band',
     domain: 'www.band.us',
     strategy: Strategy.COOKIE,

package/clis/barchart/flow.js

@@ -7,6 +7,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'barchart',
     name: 'flow',
+    access: 'read',
     description: 'Barchart unusual options activity / options flow',
     domain: 'www.barchart.com',
     strategy: Strategy.COOKIE,

package/clis/barchart/greeks.js

@@ -7,6 +7,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'barchart',
     name: 'greeks',
+    access: 'read',
     description: 'Barchart options greeks overview (IV, delta, gamma, theta, vega)',
     domain: 'www.barchart.com',
     strategy: Strategy.COOKIE,

package/clis/barchart/options.js

@@ -6,6 +6,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'barchart',
     name: 'options',
+    access: 'read',
     description: 'Barchart options chain with greeks, IV, volume, and open interest',
     domain: 'www.barchart.com',
     strategy: Strategy.COOKIE,

package/clis/barchart/quote.js

@@ -7,6 +7,7 @@ import { CommandExecutionError } from '@jackwener/opencli/errors';
 cli({
     site: 'barchart',
     name: 'quote',
+    access: 'read',
     description: 'Barchart stock quote with price, volume, and key metrics',
     domain: 'www.barchart.com',
     strategy: Strategy.COOKIE,

package/clis/bbc/news.js

@@ -5,6 +5,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'bbc',
     name: 'news',
+    access: 'read',
     description: 'BBC News headlines (RSS)',
     domain: 'www.bbc.com',
     strategy: Strategy.PUBLIC,

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,
+        }));
+    },
+});