@sovovs/bycli 1.8.0

package/clis/barchart/quote.js

@@ -0,0 +1,135 @@
+/**
+ * Barchart stock quote — price, volume, market cap, P/E, EPS, and key metrics.
+ * Auth: CSRF token from <meta name="csrf-token"> + session cookies.
+ */
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { CommandExecutionError } from '@sovovs/bycli/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,
+    args: [
+        { name: 'symbol', required: true, positional: true, help: 'Stock ticker (e.g. AAPL, MSFT, TSLA)' },
+    ],
+    columns: [
+        'symbol', 'name', 'price', 'change', 'changePct',
+        'open', 'high', 'low', 'prevClose', 'volume',
+        'avgVolume', 'marketCap', 'peRatio', 'eps',
+    ],
+    func: async (page, kwargs) => {
+        const symbol = kwargs.symbol.toUpperCase().trim();
+        await page.goto(`https://www.barchart.com/stocks/quotes/${encodeURIComponent(symbol)}/overview`);
+        await page.wait(4);
+        const data = await page.evaluate(`
+      (async () => {
+        const sym = ${JSON.stringify(symbol)};
+        const csrf = document.querySelector('meta[name="csrf-token"]')?.content || '';
+
+        // Strategy 1: internal proxy API with CSRF token
+        try {
+          const fields = [
+            'symbol','symbolName','lastPrice','priceChange','percentChange',
+            'highPrice','lowPrice','openPrice','previousPrice','volume','averageVolume',
+            'marketCap','peRatio','earningsPerShare','tradeTime',
+          ].join(',');
+          const url = '/proxies/core-api/v1/quotes/get?symbol=' + encodeURIComponent(sym) + '&fields=' + fields;
+          const resp = await fetch(url, {
+            credentials: 'include',
+            headers: { 'X-CSRF-TOKEN': csrf },
+          });
+          if (resp.ok) {
+            const d = await resp.json();
+            const row = d?.data?.[0] || null;
+            if (row) {
+              return { source: 'api', row };
+            }
+          }
+        } catch(e) {}
+
+        // Strategy 2: parse from DOM
+        try {
+          const priceEl = document.querySelector('span.last-change');
+          const price = priceEl ? priceEl.textContent.trim() : null;
+
+          // Change values are sibling spans inside .pricechangerow > .last-change
+          const changeParent = priceEl?.parentElement;
+          const changeSpans = changeParent ? changeParent.querySelectorAll('span') : [];
+          let change = null;
+          let changePct = null;
+          for (const s of changeSpans) {
+            const t = s.textContent.trim();
+            if (s === priceEl) continue;
+            if (t.includes('%')) changePct = t.replace(/[()]/g, '');
+            else if (t.match(/^[+-]?[\\d.]+$/)) change = t;
+          }
+
+          // Financial data rows
+          const rows = document.querySelectorAll('.financial-data-row');
+          const fdata = {};
+          for (const row of rows) {
+            const spans = row.querySelectorAll('span');
+            if (spans.length >= 2) {
+              const label = spans[0].textContent.trim();
+              const valSpan = row.querySelector('span.right span:not(.ng-hide)');
+              fdata[label] = valSpan ? valSpan.textContent.trim() : '';
+            }
+          }
+
+          // Day high/low from row chart
+          const dayLow = document.querySelector('.bc-quote-row-chart .small-6:first-child .inline:not(.ng-hide)');
+          const dayHigh = document.querySelector('.bc-quote-row-chart .text-right .inline:not(.ng-hide)');
+          const openEl = document.querySelector('.mark span');
+          const openText = openEl ? openEl.textContent.trim().replace('Open ', '') : null;
+
+          const name = document.querySelector('h1 span.symbol');
+
+          return {
+            source: 'dom',
+            row: {
+              symbol: sym,
+              symbolName: name ? name.textContent.trim() : sym,
+              lastPrice: price,
+              priceChange: change,
+              percentChange: changePct,
+              open: openText,
+              highPrice: dayHigh ? dayHigh.textContent.trim() : null,
+              lowPrice: dayLow ? dayLow.textContent.trim() : null,
+              previousClose: fdata['Previous Close'] || null,
+              volume: fdata['Volume'] || null,
+              averageVolume: fdata['Average Volume'] || null,
+              marketCap: null,
+              peRatio: null,
+              earningsPerShare: null,
+            }
+          };
+        } catch(e) {
+          return { error: 'Could not fetch quote for ' + sym + ': ' + e.message };
+        }
+      })()
+    `);
+        if (!data || data.error)
+            throw new CommandExecutionError(data?.error || `Failed to fetch quote for ${symbol}`);
+        const r = data.row || {};
+        // API returns formatted strings like "+1.41" and "+0.56%"; use raw if available
+        const raw = r.raw || {};
+        return [{
+                symbol: r.symbol || symbol,
+                name: r.symbolName || r.name || symbol,
+                price: r.lastPrice ?? null,
+                change: r.priceChange ?? null,
+                changePct: r.percentChange ?? null,
+                open: r.openPrice ?? r.open ?? null,
+                high: r.highPrice ?? null,
+                low: r.lowPrice ?? null,
+                prevClose: r.previousPrice ?? r.previousClose ?? null,
+                volume: r.volume ?? null,
+                avgVolume: r.averageVolume ?? null,
+                marketCap: r.marketCap ?? null,
+                peRatio: r.peRatio ?? null,
+                eps: r.earningsPerShare ?? null,
+            }];
+    },
+});

package/clis/bbc/news.js

@@ -0,0 +1,42 @@
+/**
+ * BBC News headlines — public RSS feed, no browser needed.
+ */
+import { cli, Strategy } from '@sovovs/bycli/registry';
+cli({
+    site: 'bbc',
+    name: 'news',
+    access: 'read',
+    description: 'BBC News headlines (RSS)',
+    domain: 'www.bbc.com',
+    strategy: Strategy.PUBLIC,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of headlines (max 50)' },
+    ],
+    columns: ['rank', 'title', 'description', 'url'],
+    func: async (kwargs) => {
+        const count = Math.min(kwargs.limit || 20, 50);
+        const resp = await fetch('https://feeds.bbci.co.uk/news/rss.xml');
+        if (!resp.ok)
+            return [];
+        const xml = await resp.text();
+        // Simple XML parsing without DOMParser (works in Node)
+        const items = [];
+        const itemRegex = /<item>([\s\S]*?)<\/item>/g;
+        let match;
+        while ((match = itemRegex.exec(xml)) && items.length < count) {
+            const block = match[1];
+            const title = block.match(/<title><!\[CDATA\[(.*?)\]\]>|<title>(.*?)<\/title>/)?.[1] || block.match(/<title>(.*?)<\/title>/)?.[1] || '';
+            const desc = block.match(/<description><!\[CDATA\[(.*?)\]\]>|<description>(.*?)<\/description>/)?.[1] || block.match(/<description>(.*?)<\/description>/)?.[1] || '';
+            const link = block.match(/<link>(.*?)<\/link>/)?.[1] || block.match(/<guid[^>]*>(.*?)<\/guid>/)?.[1] || '';
+            if (title) {
+                items.push({
+                    rank: items.length + 1,
+                    title: title.trim(),
+                    description: desc.trim().substring(0, 200),
+                    url: link.trim(),
+                });
+            }
+        }
+        return items;
+    },
+});

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 '@sovovs/bycli/registry';
+import { ArgumentError, EmptyResultError } from '@sovovs/bycli/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,
+        }));
+    },
+});

package/clis/bbc/utils.js

@@ -0,0 +1,79 @@
+// Shared helpers for the bbc adapters that hit BBC's public RSS feeds.
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+
+export const BBC_FEED_BASE = 'https://feeds.bbci.co.uk/news';
+const UA = 'bycli-bbc-adapter (+https://github.com/sovovs/byCLI)';
+
+const HTML_ENTITIES = {
+    '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'", '&#39;': "'", '&nbsp;': ' ',
+};
+
+export function decodeHtmlEntities(value) {
+    return String(value ?? '')
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+        .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
+        .replace(/&(amp|lt|gt|quot|apos|#39|nbsp);/g, (m) => HTML_ENTITIES[m] || m);
+}
+
+/** Extract `<tag>…</tag>` (CDATA-aware) from a block. */
+export function extractRssTag(block, tag) {
+    const cdata = block.match(new RegExp(`<${tag}[^>]*>\\s*<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>\\s*<\\/${tag}>`));
+    if (cdata) return cdata[1];
+    const plain = block.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`));
+    return plain ? plain[1] : '';
+}
+
+export function parseRssItems(xml) {
+    const out = [];
+    const re = /<item[^>]*>([\s\S]*?)<\/item>/g;
+    let m;
+    while ((m = re.exec(String(xml || ''))) !== null) {
+        const block = m[1];
+        out.push({
+            title: decodeHtmlEntities(extractRssTag(block, 'title')).trim(),
+            description: decodeHtmlEntities(extractRssTag(block, 'description')).trim(),
+            link: decodeHtmlEntities(extractRssTag(block, 'link')).trim(),
+            pubDate: decodeHtmlEntities(extractRssTag(block, 'pubDate')).trim(),
+            guid: decodeHtmlEntities(extractRssTag(block, 'guid')).trim(),
+        });
+    }
+    return out;
+}
+
+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(`bbc ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`bbc ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export async function bbcFetchRss(path, label) {
+    const url = `${BBC_FEED_BASE}/${path}`;
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/rss+xml, application/xml' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that feeds.bbci.co.uk is reachable from this network.',
+        );
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status} (${url})`);
+    }
+    return resp.text();
+}
+
+/** Convert RFC-822 pubDate to ISO `YYYY-MM-DD`; empty string on parse failure. */
+export function pubDateToIso(value) {
+    if (!value) return '';
+    const d = new Date(value);
+    if (Number.isNaN(d.getTime())) return '';
+    return d.toISOString().slice(0, 10);
+}

package/clis/bilibili/comment.js

@@ -0,0 +1,125 @@
+/**
+ * Bilibili comment — posts a top-level comment or a reply on a video via the official API.
+ * Uses /x/v2/reply/add, authenticated by the logged-in cookie + bili_jct CSRF token.
+ * @username mentions in the message are resolved to real mentions (at_name_to_mid).
+ */
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
+import { apiGet, apiPost, resolveBvid, resolveUid } from './utils.js';
+
+function isAuthLikeBilibiliError(code, message) {
+    return code === -101 || code === -111 || code === -403 || /csrf|登录|账号|权限|forbidden|permission|login/i.test(String(message ?? ''));
+}
+
+function requireOkPayload(payload, label) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload) || !Object.hasOwn(payload, 'code')) {
+        throw new CommandExecutionError(`Bilibili ${label} API returned a malformed payload`);
+    }
+    if (payload.code !== 0) {
+        const message = payload.message ?? 'unknown error';
+        if (isAuthLikeBilibiliError(payload.code, message)) {
+            throw new AuthRequiredError('bilibili.com', `Bilibili ${label} API requires login or permission: ${message} (${payload.code})`);
+        }
+        throw new CommandExecutionError(`Bilibili ${label} API failed: ${message} (${payload.code})`);
+    }
+    return payload.data;
+}
+
+function readPositiveInteger(value, label) {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`bilibili comment ${label} must be a positive integer`);
+    }
+    return n;
+}
+
+cli({
+    site: 'bilibili',
+    name: 'comment',
+    access: 'write',
+    description: '在 B站视频下发表评论或回复（官方 API，需登录；消息里的 @用户 会被解析为真实提及）',
+    domain: 'www.bilibili.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'bvid', required: true, positional: true, help: 'Video BV ID / URL / b23.tv short link' },
+        { name: 'message', required: true, positional: true, help: 'Comment text. Any @username in it is resolved to a real mention' },
+        { name: 'parent', type: 'int', help: 'top-level/root rpid to reply under (omit for a top-level comment)' },
+        { name: 'execute', type: 'boolean', help: 'Actually post the comment. Without it the command refuses to write.' },
+    ],
+    columns: ['rpid', 'bvid', 'oid', 'message', 'url'],
+    func: async (page, kwargs) => {
+        if (!page) {
+            throw new CommandExecutionError('Browser session required for bilibili comment');
+        }
+        const message = String(kwargs.message ?? '').trim();
+        if (!message)
+            throw new ArgumentError('bilibili comment message cannot be empty');
+        // Write guard: posting is public and irreversible-ish, so require an explicit opt-in.
+        if (!kwargs.execute)
+            throw new ArgumentError('Refusing to post: pass --execute to actually publish this comment');
+        const parent = kwargs.parent != null ? readPositiveInteger(kwargs.parent, 'parent') : null;
+        let bvid;
+        try {
+            bvid = await resolveBvid(kwargs.bvid);
+        }
+        catch (error) {
+            throw new ArgumentError(`Cannot resolve Bilibili BV ID from input: ${String(kwargs.bvid ?? '')}`, error instanceof Error ? error.message : String(error));
+        }
+        // Resolve bvid → aid (the reply API addresses videos by aid, as `oid`)
+        const view = await apiGet(page, '/x/web-interface/view', { params: { bvid } });
+        const viewData = requireOkPayload(view, 'view');
+        const oid = viewData?.aid;
+        if (!oid)
+            throw new CommandExecutionError(`Cannot resolve aid for bvid: ${bvid}`);
+        // Resolve @username mentions to uids. Bilibili only turns "@name" into a real
+        // mention — one that notifies the mentioned user — when the request carries
+        // at_name_to_mid; a plain-text "@name" is otherwise inert and notifies nobody.
+        /** @type {Record<string, number>} */
+        const atNameToMid = {};
+        for (const match of message.matchAll(/@([^\s@]+)/g)) {
+            const name = match[1];
+            if (name in atNameToMid)
+                continue;
+            try {
+                const mid = Number(await resolveUid(page, name));
+                if (!Number.isInteger(mid) || mid <= 0) {
+                    throw new CommandExecutionError(`Bilibili user search returned malformed mid for @${name}`);
+                }
+                atNameToMid[name] = mid;
+            }
+            catch (error) {
+                if (!(error instanceof EmptyResultError)) {
+                    throw error;
+                }
+                // Unresolvable @name (typo, or not a user) — leave it as plain text.
+            }
+        }
+        // For a reply, Bilibili needs both `root` (top-level comment) and `parent`.
+        // Replying to a top-level comment means root === parent.
+        const params = {
+            oid,
+            type: 1,
+            message,
+            plat: 1,
+            ...(parent != null
+                ? { root: parent, parent }
+                : {}),
+            ...(Object.keys(atNameToMid).length > 0
+                ? { at_name_to_mid: JSON.stringify(atNameToMid) }
+                : {}),
+        };
+        const payload = await apiPost(page, '/x/v2/reply/add', { params });
+        const postData = requireOkPayload(payload, 'reply add');
+        const rpid = postData?.rpid;
+        if (!rpid) {
+            throw new CommandExecutionError('Bilibili reply add API did not return rpid for the posted comment');
+        }
+        return [{
+            rpid: String(rpid),
+            bvid,
+            oid: String(oid),
+            message,
+            url: `https://www.bilibili.com/video/${bvid}#reply${rpid}`,
+        }];
+    },
+});

package/clis/bilibili/comment.test.js

@@ -0,0 +1,153 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
+
+const { mockApiGet, mockApiPost, mockResolveUid } = vi.hoisted(() => ({
+    mockApiGet: vi.fn(),
+    mockApiPost: vi.fn(),
+    mockResolveUid: vi.fn(),
+}));
+
+vi.mock('./utils.js', async (importOriginal) => ({
+    ...(await importOriginal()),
+    apiGet: mockApiGet,
+    apiPost: mockApiPost,
+    resolveUid: mockResolveUid,
+}));
+
+import { getRegistry } from '@sovovs/bycli/registry';
+import './comment.js';
+
+describe('bilibili comment', () => {
+    const command = getRegistry().get('bilibili/comment');
+
+    beforeEach(() => {
+        mockApiGet.mockReset();
+        mockApiPost.mockReset();
+        mockResolveUid.mockReset();
+    });
+
+    it('refuses to post without --execute', async () => {
+        await expect(
+            command.func({}, { bvid: 'BV1WtAGzYEBm', message: 'hi' }),
+        ).rejects.toThrow(/--execute/);
+        expect(mockApiPost).not.toHaveBeenCalled();
+    });
+
+    it('rejects an empty message before calling the API', async () => {
+        await expect(
+            command.func({}, { bvid: 'BV1xxx', message: '   ', execute: true }),
+        ).rejects.toThrow(/empty/i);
+        expect(mockApiGet).not.toHaveBeenCalled();
+    });
+
+    it('posts a top-level comment, resolving @mentions to at_name_to_mid', async () => {
+        mockApiGet.mockResolvedValueOnce({ code: 0, data: { aid: 12345 } });
+        mockResolveUid.mockResolvedValueOnce('1141159409'); // @AI视频小助理 → mid
+        mockApiPost.mockResolvedValueOnce({ code: 0, data: { rpid: 99887766 } });
+
+        const result = await command.func({}, {
+            bvid: 'BV1WtAGzYEBm', message: '@AI视频小助理 总结一下', execute: true,
+        });
+
+        expect(mockApiGet).toHaveBeenNthCalledWith(1, {}, '/x/web-interface/view', { params: { bvid: 'BV1WtAGzYEBm' } });
+        expect(mockResolveUid).toHaveBeenCalledWith({}, 'AI视频小助理');
+        expect(mockApiPost).toHaveBeenCalledWith({}, '/x/v2/reply/add', {
+            params: {
+                oid: 12345,
+                type: 1,
+                message: '@AI视频小助理 总结一下',
+                plat: 1,
+                at_name_to_mid: '{"AI视频小助理":1141159409}',
+            },
+        });
+        expect(result).toEqual([{
+            rpid: '99887766',
+            bvid: 'BV1WtAGzYEBm',
+            oid: '12345',
+            message: '@AI视频小助理 总结一下',
+            url: 'https://www.bilibili.com/video/BV1WtAGzYEBm#reply99887766',
+        }]);
+    });
+
+    it('still posts when an @mention cannot be resolved, leaving it as plain text', async () => {
+        mockApiGet.mockResolvedValueOnce({ code: 0, data: { aid: 7 } });
+        mockResolveUid.mockRejectedValueOnce(new EmptyResultError('bilibili user search'));
+        mockApiPost.mockResolvedValueOnce({ code: 0, data: { rpid: 5 } });
+
+        await command.func({}, { bvid: 'BV1xxx', message: '@幽灵用户zzz hi', execute: true });
+
+        expect(mockApiPost).toHaveBeenCalledWith({}, '/x/v2/reply/add', {
+            params: { oid: 7, type: 1, message: '@幽灵用户zzz hi', plat: 1 },
+        });
+    });
+
+    it('fails closed when mention resolution has parser or transport errors', async () => {
+        mockApiGet.mockResolvedValueOnce({ code: 0, data: { aid: 7 } });
+        mockResolveUid.mockRejectedValueOnce(new CommandExecutionError('search API drift'));
+
+        await expect(
+            command.func({}, { bvid: 'BV1xxx', message: '@用户 hi', execute: true }),
+        ).rejects.toBeInstanceOf(CommandExecutionError);
+        expect(mockApiPost).not.toHaveBeenCalled();
+    });
+
+    it('fails closed when mention resolution returns a malformed mid', async () => {
+        mockApiGet.mockResolvedValueOnce({ code: 0, data: { aid: 7 } });
+        mockResolveUid.mockResolvedValueOnce('not-a-mid');
+
+        await expect(
+            command.func({}, { bvid: 'BV1xxx', message: '@用户 hi', execute: true }),
+        ).rejects.toBeInstanceOf(CommandExecutionError);
+        expect(mockApiPost).not.toHaveBeenCalled();
+    });
+
+    it('posts a reply under an existing comment when --parent is given', async () => {
+        mockApiGet.mockResolvedValueOnce({ code: 0, data: { aid: 1 } });
+        mockApiPost.mockResolvedValueOnce({ code: 0, data: { rpid: 2 } });
+
+        await command.func({}, { bvid: 'BV1xxx', message: 'thanks', parent: 555, execute: true });
+
+        expect(mockApiPost).toHaveBeenCalledWith({}, '/x/v2/reply/add', {
+            params: { oid: 1, type: 1, message: 'thanks', plat: 1, root: 555, parent: 555 },
+        });
+    });
+
+    it('throws when the bvid cannot be resolved to an aid', async () => {
+        mockApiGet.mockResolvedValueOnce({ code: 0, data: {} });
+        await expect(
+            command.func({}, { bvid: 'BVbroken', message: 'hi', execute: true }),
+        ).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws with the API code and message when Bilibili rejects the comment', async () => {
+        mockApiGet.mockResolvedValueOnce({ code: 0, data: { aid: 9 } });
+        mockApiPost.mockResolvedValueOnce({ code: 12025, message: '评论字数过多' });
+        await expect(
+            command.func({}, { bvid: 'BV1xxx', message: 'x', execute: true }),
+        ).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('maps login/csrf failures from the write API to AuthRequiredError', async () => {
+        mockApiGet.mockResolvedValueOnce({ code: 0, data: { aid: 9 } });
+        mockApiPost.mockResolvedValueOnce({ code: -111, message: 'csrf 校验失败' });
+        await expect(
+            command.func({}, { bvid: 'BV1xxx', message: 'x', execute: true }),
+        ).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('rejects invalid parent ids before posting', async () => {
+        await expect(
+            command.func({}, { bvid: 'BV1xxx', message: 'x', parent: 0, execute: true }),
+        ).rejects.toBeInstanceOf(ArgumentError);
+        expect(mockApiGet).not.toHaveBeenCalled();
+        expect(mockApiPost).not.toHaveBeenCalled();
+    });
+
+    it('fails closed when the write API omits rpid', async () => {
+        mockApiGet.mockResolvedValueOnce({ code: 0, data: { aid: 9 } });
+        mockApiPost.mockResolvedValueOnce({ code: 0, data: {} });
+        await expect(
+            command.func({}, { bvid: 'BV1xxx', message: 'x', execute: true }),
+        ).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+});