publishport-opencli 1.8.4-pp.1

package/clis/bilibili/feed.js

@@ -0,0 +1,220 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { apiGet, payloadData, resolveUid, stripHtml } from './utils.js';
+
+/** Map bilibili dynamic type to readable short name */
+const TYPE_MAP = {
+    DYNAMIC_TYPE_AV: 'video',
+    DYNAMIC_TYPE_DRAW: 'draw',
+    DYNAMIC_TYPE_ARTICLE: 'article',
+    DYNAMIC_TYPE_FORWARD: 'forward',
+    DYNAMIC_TYPE_WORD: 'text',
+    DYNAMIC_TYPE_LIVE_RCMD: 'live',
+    DYNAMIC_TYPE_PGC: 'bangumi',
+};
+
+function parseItem(item) {
+    const modules = item.modules ?? {};
+    const authorModule = modules.module_author ?? {};
+    const dynamicModule = modules.module_dynamic ?? {};
+    const major = dynamicModule.major ?? {};
+    const stat = modules.module_stat ?? {};
+
+    let title = '';
+    let url = item.id_str ? `https://t.bilibili.com/${item.id_str}` : '';
+    const itemType = TYPE_MAP[item.type] ?? item.type ?? '';
+
+    // video
+    if (major.archive) {
+        title = major.archive.title ?? '';
+        url = major.archive.jump_url ? `https:${major.archive.jump_url}` : url;
+    }
+    // article
+    if (!title && major.article) {
+        title = major.article.title ?? '';
+        url = major.article.jump_url ? `https:${major.article.jump_url}` : url;
+    }
+    // text content in desc
+    if (!title && dynamicModule.desc?.text) {
+        title = stripHtml(dynamicModule.desc.text).slice(0, 60);
+    }
+    // draw (图文) — use opus or draw items count as hint
+    if (!title && major.draw) {
+        const imgCount = major.draw.items?.length ?? 0;
+        title = imgCount > 0 ? `[图片x${imgCount}]` : '[图文动态]';
+    }
+    // VIP only content
+    if (!title && item.basic?.is_only_fans) {
+        title = '[充电专属]';
+    }
+    // forward
+    if (!title && item.type === 'DYNAMIC_TYPE_FORWARD') {
+        title = '[转发动态]';
+    }
+    // final fallback
+    if (!title) {
+        title = `[${itemType || '动态'}]`;
+    }
+
+    const time = authorModule.pub_time ?? '';
+    const likes = stat.like?.count ?? 0;
+    const comments = stat.comment?.count ?? 0;
+
+    return { title, url, itemType, author: authorModule.name ?? '', time, likes, comments };
+}
+
+cli({
+    site: 'bilibili',
+    name: 'feed',
+    access: 'read',
+    description: '动态时间线（不传 uid 查关注时间线，传 uid 查指定用户动态）',
+    domain: 'www.bilibili.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'uid', positional: true, required: false, help: '用户 UID 或用户名（不传则显示关注时间线）' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results to return' },
+        { name: 'type', default: 'all', help: 'Filter: all, video, article, draw, text' },
+        { name: 'pages', type: 'int', default: 1, help: 'Number of pages to fetch (each ~20 items)' },
+    ],
+    columns: ['rank', 'time', 'author', 'title', 'type', 'likes', 'url'],
+    func: async (page, kwargs) => {
+        const maxResults = Number(kwargs.limit) || 20;
+        const maxPages = Number(kwargs.pages) || 1;
+        const filterType = kwargs.type === 'all' ? '' : (kwargs.type ?? '');
+
+        const isUserFeed = !!kwargs.uid;
+        const uid = isUserFeed ? await resolveUid(page, String(kwargs.uid)) : null;
+
+        const rows = [];
+        let offset = '';
+
+        for (let p = 0; p < maxPages; p++) {
+            if (rows.length >= maxResults) break;
+
+            let payload;
+            if (isUserFeed) {
+                const params = { host_mid: uid, timezone_offset: -480 };
+                if (offset) params.offset = offset;
+                payload = await apiGet(page, '/x/polymer/web-dynamic/v1/feed/space', { params });
+            } else {
+                const params = {
+                    timezone_offset: -480,
+                    type: filterType || 'all',
+                    page: p + 1,
+                };
+                if (offset) params.offset = offset;
+                payload = await apiGet(page, '/x/polymer/web-dynamic/v1/feed/all', { params });
+            }
+
+            const data = payloadData(payload) ?? {};
+            const items = data.items ?? [];
+            if (items.length === 0) break;
+
+            for (const item of items) {
+                if (rows.length >= maxResults) break;
+                const parsed = parseItem(item);
+                if (filterType && parsed.itemType !== filterType) continue;
+                rows.push({
+                    rank: rows.length + 1,
+                    time: parsed.time,
+                    author: parsed.author,
+                    title: parsed.title,
+                    type: parsed.itemType,
+                    likes: parsed.likes,
+                    url: parsed.url,
+                });
+            }
+
+            offset = data.offset ?? items[items.length - 1]?.id_str ?? '';
+            if (!offset || !data.has_more) break;
+        }
+
+        return rows;
+    },
+});
+
+cli({
+    site: 'bilibili',
+    name: 'feed-detail',
+    access: 'read',
+    description: '查看 Bilibili 动态详情（支持充电专属内容）',
+    domain: 'www.bilibili.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'id', positional: true, required: true, help: '动态 ID（从 feed 命令的 url 中获取）' },
+    ],
+    columns: ['field', 'value'],
+    func: async (page, kwargs) => {
+        const id = String(kwargs.id);
+        const payload = await apiGet(page, '/x/polymer/web-dynamic/v1/detail', {
+            params: { id, timezone_offset: -480 },
+        });
+
+        const rows = [];
+        const data = payloadData(payload);
+        const item = data?.item;
+        if (!item) {
+            rows.push({ field: 'error', value: '动态不存在或无权查看'});
+            return rows;
+        }
+
+        const modules = item.modules ?? {};
+        const author = modules.module_author ?? {};
+        const dynamicModule = modules.module_dynamic ?? {};
+        const major = dynamicModule.major ?? {};
+        const stat = modules.module_stat ?? {};
+
+        rows.push({ field: 'id', value: item.id_str ?? id });
+        rows.push({ field: 'author', value: author.name ?? '' });
+        rows.push({ field: 'time', value: author.pub_time ?? '' });
+        rows.push({ field: 'type', value: TYPE_MAP[item.type] ?? item.type ?? '' });
+
+        // text content
+        if (dynamicModule.desc?.text) {
+            rows.push({ field: 'text', value: stripHtml(dynamicModule.desc.text) });
+        }
+
+        // video
+        if (major.archive) {
+            rows.push({ field: 'video_title', value: major.archive.title ?? '' });
+            rows.push({ field: 'video_desc', value: major.archive.desc ?? '' });
+            rows.push({ field: 'video_url', value: major.archive.jump_url ? `https:${major.archive.jump_url}` : '' });
+            rows.push({ field: 'play', value: String(major.archive.stat?.play ?? '') });
+            rows.push({ field: 'danmaku', value: String(major.archive.stat?.danmaku ?? '') });
+        }
+
+        // article
+        if (major.article) {
+            rows.push({ field: 'article_title', value: major.article.title ?? '' });
+            rows.push({ field: 'article_url', value: major.article.jump_url ? `https:${major.article.jump_url}` : '' });
+        }
+
+        // draw (images)
+        if (major.draw?.items?.length) {
+            rows.push({ field: 'images', value: major.draw.items.map((img) => img.src).join('\n') });
+        }
+
+        // opus (rich text, some dynamics use this)
+        if (major.opus?.summary?.text) {
+            rows.push({ field: 'opus_text', value: stripHtml(major.opus.summary.text) });
+        }
+        if (major.opus?.title) {
+            rows.push({ field: 'opus_title', value: major.opus.title });
+        }
+
+        // forward - show original dynamic info
+        if (item.orig) {
+            const origAuthor = item.orig.modules?.module_author?.name ?? '';
+            const origDesc = item.orig.modules?.module_dynamic?.desc?.text ?? '';
+            rows.push({ field: 'forward_from', value: origAuthor });
+            if (origDesc) rows.push({ field: 'forward_text', value: stripHtml(origDesc).slice(0, 200) });
+        }
+
+        // stats
+        rows.push({ field: 'likes', value: String(stat.like?.count ?? 0) });
+        rows.push({ field: 'comments', value: String(stat.comment?.count ?? 0) });
+        rows.push({ field: 'forwards', value: String(stat.forward?.count ?? 0) });
+        rows.push({ field: 'url', value: `https://t.bilibili.com/${item.id_str ?? id}` });
+
+        return rows;
+    },
+});

package/clis/bilibili/follow.js

@@ -0,0 +1,140 @@
+/**
+ * Bilibili follow — establishes a follow relation via the official write API.
+ * Authenticated by logged-in cookie + bili_jct CSRF token (handled by apiPost).
+ *
+ * Accepts target as: numeric uid, username, or a space.bilibili.com profile URL.
+ * Pre-checks the current relation so the result row reports `already-following`
+ * accurately instead of relying on the modify API's idempotent silent success.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { apiPost, fetchJson, getSelfUid, requireOkPayload, resolveUid } from './utils.js';
+
+const RELATION_VERIFY_TIMEOUT_MS = 5000;
+const RELATION_VERIFY_POLL_MS = 500;
+
+function parseSpaceMidUrl(raw) {
+    const trimmed = String(raw ?? '').trim();
+    if (!trimmed) return '';
+    const candidate = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+    let parsed;
+    try {
+        parsed = new URL(candidate);
+    } catch {
+        return '';
+    }
+    if (parsed.hostname.toLowerCase() !== 'space.bilibili.com') return '';
+    const match = parsed.pathname.match(/^\/(\d+)\/?$/);
+    return match ? match[1] : '';
+}
+
+/**
+ * Pull a uid out of a `space.bilibili.com/<uid>` URL before falling back to the
+ * generic resolver. `resolveUid` only handles bare digits or usernames; without
+ * this short-circuit a profile URL would get sent to the user-search endpoint
+ * and likely return nothing.
+ */
+async function resolveTargetMid(page, raw) {
+    const trimmed = String(raw ?? '').trim();
+    if (!trimmed) {
+        throw new ArgumentError('bilibili follow target cannot be empty');
+    }
+    if (/^(?:https?:\/\/)?space\.bilibili\.com\//i.test(trimmed)) {
+        const mid = parseSpaceMidUrl(trimmed);
+        if (!mid) {
+            throw new ArgumentError('bilibili follow target must be a valid space.bilibili.com/<uid> URL');
+        }
+        return mid;
+    }
+    try {
+        return await resolveUid(page, trimmed);
+    } catch (error) {
+        if (error instanceof EmptyResultError) throw error;
+        throw new ArgumentError(
+            `Cannot resolve Bilibili target from input: ${trimmed}`,
+            error instanceof Error ? error.message : String(error),
+        );
+    }
+}
+
+/**
+ * `attribute` from /x/relation encodes the viewer→target relation:
+ *   0 = no relation, 2 = following, 6 = mutual follow, 128 = blocked.
+ * `2` and `6` both count as "already following" from the follow command's POV.
+ */
+async function fetchRelationAttribute(page, mid) {
+    const payload = await fetchJson(page, `https://api.bilibili.com/x/relation?fid=${mid}`);
+    requireOkPayload(payload, 'relation query');
+    const attribute = payload?.data?.attribute;
+    if (typeof attribute !== 'number') {
+        throw new CommandExecutionError('Bilibili relation query returned a malformed attribute');
+    }
+    return attribute;
+}
+
+async function waitForRelation(page, mid, predicate, expectedLabel) {
+    const deadline = Date.now() + RELATION_VERIFY_TIMEOUT_MS;
+    let lastAttribute;
+    while (Date.now() <= deadline) {
+        lastAttribute = await fetchRelationAttribute(page, mid);
+        if (predicate(lastAttribute)) return lastAttribute;
+        if (typeof page.wait !== 'function') break;
+        await page.wait({ time: RELATION_VERIFY_POLL_MS / 1000 });
+    }
+    throw new CommandExecutionError(
+        `Bilibili relation modify did not verify ${expectedLabel}; last attribute=${lastAttribute}`,
+    );
+}
+
+cli({
+    site: 'bilibili',
+    name: 'follow',
+    access: 'write',
+    description: '关注 B站用户（官方 API，需登录）',
+    domain: 'www.bilibili.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        {
+            name: 'target',
+            required: true,
+            positional: true,
+            help: '目标 UID / 用户名 / space.bilibili.com 链接',
+        },
+    ],
+    columns: ['mid', 'name', 'status', 'url'],
+    func: async (page, kwargs) => {
+        if (!page) {
+            throw new CommandExecutionError('Browser session required for bilibili follow');
+        }
+        const mid = await resolveTargetMid(page, kwargs.target);
+        const self = await getSelfUid(page);
+        if (mid === self) {
+            throw new ArgumentError('Cannot follow yourself');
+        }
+        const attribute = await fetchRelationAttribute(page, mid);
+        const url = `https://space.bilibili.com/${mid}`;
+        if (attribute === 2 || attribute === 6) {
+            return [{ mid, name: '', status: 'already-following', url }];
+        }
+        if (attribute === 128) {
+            throw new CommandExecutionError(
+                `Bilibili user ${mid} is blocked; unblock first before following.`,
+            );
+        }
+        // act=1 follow, act=2 unfollow. re_src=11 is the community-standard
+        // "web" source value used by third-party libs (bilibili-api-python etc.);
+        // omitting it makes the modify API reject with a vague code.
+        const payload = await apiPost(page, '/x/relation/modify', {
+            params: { fid: mid, act: 1, re_src: 11 },
+        });
+        requireOkPayload(payload, 'relation modify');
+        await waitForRelation(page, mid, (nextAttribute) => nextAttribute === 2 || nextAttribute === 6, 'following');
+        return [{ mid, name: '', status: 'followed', url }];
+    },
+});
+
+export const __test__ = {
+    resolveTargetMid,
+    fetchRelationAttribute,
+    waitForRelation,
+};

package/clis/bilibili/follow.test.js

@@ -0,0 +1,203 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const { mockApiPost, mockFetchJson, mockGetSelfUid, mockResolveUid } = vi.hoisted(() => ({
+    mockApiPost: vi.fn(),
+    mockFetchJson: vi.fn(),
+    mockGetSelfUid: vi.fn(),
+    mockResolveUid: vi.fn(),
+}));
+
+vi.mock('./utils.js', async (importOriginal) => ({
+    ...(await importOriginal()),
+    apiPost: mockApiPost,
+    fetchJson: mockFetchJson,
+    getSelfUid: mockGetSelfUid,
+    resolveUid: mockResolveUid,
+}));
+
+import { getRegistry } from '@jackwener/opencli/registry';
+import './follow.js';
+import './unfollow.js';
+
+describe('bilibili follow', () => {
+    const command = getRegistry().get('bilibili/follow');
+
+    beforeEach(() => {
+        mockApiPost.mockReset();
+        mockFetchJson.mockReset();
+        mockGetSelfUid.mockReset();
+        mockResolveUid.mockReset();
+        mockResolveUid.mockImplementation(async (_page, input) => String(input));
+        mockGetSelfUid.mockResolvedValue('11111111');
+    });
+
+    it('follows a user by numeric uid', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 0 } });
+        mockApiPost.mockResolvedValueOnce({ code: 0, data: {} });
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 2 } });
+
+        const result = await command.func({}, { target: '9617619' });
+
+        expect(mockFetchJson).toHaveBeenCalledWith({}, 'https://api.bilibili.com/x/relation?fid=9617619');
+        expect(mockApiPost).toHaveBeenCalledWith({}, '/x/relation/modify', {
+            params: { fid: '9617619', act: 1, re_src: 11 },
+        });
+        expect(result).toEqual([{
+            mid: '9617619', name: '', status: 'followed',
+            url: 'https://space.bilibili.com/9617619',
+        }]);
+    });
+
+    it('extracts uid from a space.bilibili.com URL without calling resolveUid', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 0 } });
+        mockApiPost.mockResolvedValueOnce({ code: 0, data: {} });
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 2 } });
+
+        await command.func({}, { target: 'https://space.bilibili.com/9617619' });
+
+        expect(mockResolveUid).not.toHaveBeenCalled();
+        expect(mockApiPost).toHaveBeenCalledWith({}, '/x/relation/modify', {
+            params: { fid: '9617619', act: 1, re_src: 11 },
+        });
+    });
+
+    it('resolves a username via resolveUid', async () => {
+        mockResolveUid.mockResolvedValueOnce('555');
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 0 } });
+        mockApiPost.mockResolvedValueOnce({ code: 0, data: {} });
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 6 } });
+
+        const result = await command.func({}, { target: '某up主' });
+
+        expect(mockResolveUid).toHaveBeenCalledWith({}, '某up主');
+        expect(result[0].mid).toBe('555');
+    });
+
+    it('reports already-following without calling modify when attribute is 2', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 2 } });
+
+        const result = await command.func({}, { target: '9617619' });
+
+        expect(mockApiPost).not.toHaveBeenCalled();
+        expect(result[0].status).toBe('already-following');
+    });
+
+    it('reports already-following for mutual-follow (attribute=6)', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 6 } });
+
+        const result = await command.func({}, { target: '9617619' });
+
+        expect(mockApiPost).not.toHaveBeenCalled();
+        expect(result[0].status).toBe('already-following');
+    });
+
+    it('refuses to follow yourself', async () => {
+        mockGetSelfUid.mockResolvedValueOnce('9617619');
+
+        await expect(command.func({}, { target: '9617619' })).rejects.toBeInstanceOf(ArgumentError);
+        expect(mockFetchJson).not.toHaveBeenCalled();
+        expect(mockApiPost).not.toHaveBeenCalled();
+    });
+
+    it('rejects an empty target before touching the API', async () => {
+        await expect(command.func({}, { target: '   ' })).rejects.toBeInstanceOf(ArgumentError);
+        expect(mockGetSelfUid).not.toHaveBeenCalled();
+    });
+
+    it('rejects malformed Bilibili profile URLs instead of searching the whole URL', async () => {
+        await expect(command.func({}, { target: 'https://space.bilibili.com/not-a-uid' })).rejects.toBeInstanceOf(ArgumentError);
+        expect(mockResolveUid).not.toHaveBeenCalled();
+        expect(mockFetchJson).not.toHaveBeenCalled();
+    });
+
+    it('propagates EmptyResultError when resolveUid finds no user', async () => {
+        mockResolveUid.mockRejectedValueOnce(new EmptyResultError('bilibili user search'));
+
+        await expect(command.func({}, { target: '幽灵用户zzz' })).rejects.toBeInstanceOf(EmptyResultError);
+        expect(mockApiPost).not.toHaveBeenCalled();
+    });
+
+    it('refuses to follow when the target is blocked (attribute=128)', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 128 } });
+
+        await expect(command.func({}, { target: '9617619' })).rejects.toBeInstanceOf(CommandExecutionError);
+        expect(mockApiPost).not.toHaveBeenCalled();
+    });
+
+    it('maps login/csrf failures from modify to AuthRequiredError', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 0 } });
+        mockApiPost.mockResolvedValueOnce({ code: -101, message: '账号未登录' });
+
+        await expect(command.func({}, { target: '9617619' })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('requires the relation to verify as following after modify succeeds', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 0 } });
+        mockApiPost.mockResolvedValueOnce({ code: 0, data: {} });
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 0 } });
+
+        await expect(command.func({}, { target: '9617619' })).rejects.toThrow(/did not verify following/);
+    });
+
+    it('throws when relation query returns malformed attribute', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: {} });
+
+        await expect(command.func({}, { target: '9617619' })).rejects.toThrow(/malformed attribute/);
+        expect(mockApiPost).not.toHaveBeenCalled();
+    });
+
+    it('throws CommandExecutionError with the upstream code on non-auth modify failure', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 0 } });
+        mockApiPost.mockResolvedValueOnce({ code: 22002, message: 'follow too fast' });
+
+        await expect(command.func({}, { target: '9617619' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws when no browser session is provided', async () => {
+        await expect(command.func(null, { target: '9617619' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+});
+
+describe('bilibili unfollow', () => {
+    const command = getRegistry().get('bilibili/unfollow');
+
+    beforeEach(() => {
+        mockApiPost.mockReset();
+        mockFetchJson.mockReset();
+        mockGetSelfUid.mockReset();
+        mockResolveUid.mockReset();
+        mockResolveUid.mockImplementation(async (_page, input) => String(input));
+        mockGetSelfUid.mockResolvedValue('11111111');
+    });
+
+    it('unfollows a followed user and verifies the relation flipped', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 2 } });
+        mockApiPost.mockResolvedValueOnce({ code: 0, data: {} });
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 0 } });
+
+        const result = await command.func({}, { target: '9617619' });
+
+        expect(mockApiPost).toHaveBeenCalledWith({}, '/x/relation/modify', {
+            params: { fid: '9617619', act: 2, re_src: 11 },
+        });
+        expect(result[0].status).toBe('unfollowed');
+    });
+
+    it('returns not-following without calling modify when already not following', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 0 } });
+
+        const result = await command.func({}, { target: '9617619' });
+
+        expect(mockApiPost).not.toHaveBeenCalled();
+        expect(result[0].status).toBe('not-following');
+    });
+
+    it('requires the relation to verify as not-following after modify succeeds', async () => {
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 6 } });
+        mockApiPost.mockResolvedValueOnce({ code: 0, data: {} });
+        mockFetchJson.mockResolvedValueOnce({ code: 0, data: { attribute: 6 } });
+
+        await expect(command.func({}, { target: '9617619' })).rejects.toThrow(/did not verify not following/);
+    });
+});

package/clis/bilibili/following.js

@@ -0,0 +1,44 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { fetchJson, getSelfUid, resolveUid } from './utils.js';
+cli({
+    site: 'bilibili',
+    name: 'following',
+    access: 'read',
+    description: '获取 Bilibili 用户的关注列表',
+    domain: 'www.bilibili.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'uid', positional: true, required: false, help: '目标用户 ID（默认为当前登录用户）' },
+        { name: 'page', type: 'int', required: false, default: 1, help: '页码' },
+        { name: 'limit', type: 'int', required: false, default: 50, help: '每页数量 (最大 50)' },
+    ],
+    columns: ['mid', 'name', 'sign', 'following', 'fans'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for bilibili following');
+        // 1. Resolve UID (default to self)
+        const uid = kwargs.uid
+            ? await resolveUid(page, kwargs.uid)
+            : await getSelfUid(page);
+        const pn = kwargs.page ?? 1;
+        const ps = Math.min(kwargs.limit ?? 50, 50);
+        // 2. Fetch following list (standard Cookie API, no Wbi signing needed)
+        const payload = await fetchJson(page, `https://api.bilibili.com/x/relation/followings?vmid=${uid}&pn=${pn}&ps=${ps}&order=desc`);
+        if (payload.code !== 0) {
+            throw new CommandExecutionError(`获取关注列表失败: ${payload.message} (${payload.code})`);
+        }
+        const list = payload.data?.list || [];
+        if (list.length === 0) {
+            return [{ mid: '-', name: `共 ${payload.data?.total ?? 0} 人关注，当前页无数据`, sign: '', following: '', fans: '' }];
+        }
+        // 3. Map to output
+        return list.map((u) => ({
+            mid: u.mid,
+            name: u.uname,
+            sign: (u.sign || '').slice(0, 40),
+            following: u.attribute === 6 ? '互相关注' : '已关注',
+            fans: u.official_verify?.desc || '',
+        }));
+    },
+});

package/clis/bilibili/history.js

@@ -0,0 +1,45 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { apiGet, payloadData } from './utils.js';
+cli({
+    site: 'bilibili',
+    name: 'history',
+    access: 'read',
+    description: '我的观看历史',
+    domain: 'www.bilibili.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'author', 'progress', 'url'],
+    func: async (page, kwargs) => {
+        const { limit = 20 } = kwargs;
+        const payload = await apiGet(page, '/x/web-interface/history/cursor', {
+            params: { ps: Math.min(Number(limit), 30), type: 'archive' },
+        });
+        const list = payloadData(payload)?.list ?? [];
+        return list.slice(0, Number(limit)).map((item, i) => {
+            const progress = item.progress ?? 0;
+            const duration = item.duration ?? 0;
+            let progressStr;
+            if (progress < 0 || progress >= duration) {
+                progressStr = '已看完';
+            }
+            else {
+                const pct = duration > 0 ? Math.round(progress / duration * 100) : 0;
+                progressStr = `${formatDuration(progress)}/${formatDuration(duration)} (${pct}%)`;
+            }
+            return {
+                rank: i + 1,
+                title: item.title ?? '',
+                author: item.author_name ?? '',
+                progress: progressStr,
+                url: item.history?.bvid ? `https://www.bilibili.com/video/${item.history.bvid}` : '',
+            };
+        });
+    },
+});
+function formatDuration(seconds) {
+    const m = Math.floor(seconds / 60);
+    const s = seconds % 60;
+    return `${m}:${s.toString().padStart(2, '0')}`;
+}