@sovovs/bycli 1.8.0 → 2.0.0

package/clis/bilibili/comment.test.js

@@ -1,153 +0,0 @@
-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);
-    });
-});

package/clis/bilibili/comments.test.js

@@ -1,142 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-const { mockApiGet } = vi.hoisted(() => ({
-    mockApiGet: vi.fn(),
-}));
-vi.mock('./utils.js', async (importOriginal) => ({
-    ...(await importOriginal()),
-    apiGet: mockApiGet,
-}));
-import { getRegistry } from '@sovovs/bycli/registry';
-import './comments.js';
-describe('bilibili comments', () => {
-    const command = getRegistry().get('bilibili/comments');
-    beforeEach(() => {
-        mockApiGet.mockReset();
-    });
-    it('resolves bvid to aid and fetches replies', async () => {
-        mockApiGet
-            .mockResolvedValueOnce({ code: 0, data: { aid: 12345 } }) // view endpoint
-            .mockResolvedValueOnce({
-            code: 0,
-            data: {
-                replies: [
-                    {
-                        rpid: 777,
-                        member: { uname: 'Alice' },
-                        content: { message: 'Great video!' },
-                        like: 42,
-                        rcount: 3,
-                        ctime: 1700000000,
-                    },
-                ],
-            },
-        });
-        const result = await command.func({}, { bvid: 'BV1WtAGzYEBm', limit: 5 });
-        expect(mockApiGet).toHaveBeenNthCalledWith(1, {}, '/x/web-interface/view', { params: { bvid: 'BV1WtAGzYEBm' } });
-        expect(mockApiGet).toHaveBeenNthCalledWith(2, {}, '/x/v2/reply/main', {
-            params: { oid: 12345, type: 1, mode: 3, ps: 5 },
-            signed: true,
-        });
-        expect(result).toEqual([
-            {
-                rank: 1,
-                rpid: '777',
-                author: 'Alice',
-                text: 'Great video!',
-                likes: 42,
-                replies: 3,
-                time: new Date(1700000000 * 1000).toISOString().slice(0, 16).replace('T', ' '),
-            },
-        ]);
-    });
-    it('fetches replies under a comment via /x/v2/reply/reply when --parent is given', async () => {
-        mockApiGet
-            .mockResolvedValueOnce({ code: 0, data: { aid: 12345 } }) // view endpoint
-            .mockResolvedValueOnce({
-            code: 0,
-            data: {
-                replies: [
-                    {
-                        rpid: 888,
-                        member: { uname: 'AI视频小助理' },
-                        content: { message: '视频总结：作者开了一家咖啡馆' },
-                        like: 8,
-                        rcount: 0,
-                        ctime: 1700000000,
-                    },
-                ],
-            },
-        });
-        const result = await command.func({}, { bvid: 'BV1WtAGzYEBm', parent: 777, limit: 5 });
-        expect(mockApiGet).toHaveBeenNthCalledWith(1, {}, '/x/web-interface/view', { params: { bvid: 'BV1WtAGzYEBm' } });
-        expect(mockApiGet).toHaveBeenNthCalledWith(2, {}, '/x/v2/reply/reply', {
-            params: { oid: 12345, type: 1, root: 777, pn: 1, ps: 5 },
-        });
-        expect(result[0].author).toBe('AI视频小助理');
-        expect(result[0].rpid).toBe('888');
-        expect(result[0].text).toBe('视频总结：作者开了一家咖啡馆');
-    });
-    it('throws when aid cannot be resolved', async () => {
-        mockApiGet.mockResolvedValueOnce({ code: 0, data: {} }); // no aid
-        await expect(command.func({}, { bvid: 'BVinvalid123', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-    it('throws CommandExecutionError when replies is missing', async () => {
-        mockApiGet
-            .mockResolvedValueOnce({ code: 0, data: { aid: 99 } })
-            .mockResolvedValueOnce({ code: 0, data: {} }); // no replies key
-        await expect(command.func({}, { bvid: 'BV1xxx', limit: 5 }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-    it('rejects out-of-range limits instead of silently clamping', async () => {
-        await expect(command.func({}, { bvid: 'BV1xxx', limit: 999 }))
-            .rejects.toBeInstanceOf(ArgumentError);
-        expect(mockApiGet).not.toHaveBeenCalled();
-    });
-    it('rejects invalid parent ids before fetching comments', async () => {
-        await expect(command.func({}, { bvid: 'BV1xxx', parent: 0, limit: 5 }))
-            .rejects.toBeInstanceOf(ArgumentError);
-        expect(mockApiGet).not.toHaveBeenCalled();
-    });
-    it('maps auth-like API errors to AuthRequiredError', async () => {
-        mockApiGet
-            .mockResolvedValueOnce({ code: -101, message: '账号未登录', data: null });
-        await expect(command.func({}, { bvid: 'BV1xxx', limit: 5 }))
-            .rejects.toBeInstanceOf(AuthRequiredError);
-    });
-    it('throws EmptyResultError for explicit empty comments', async () => {
-        mockApiGet
-            .mockResolvedValueOnce({ code: 0, data: { aid: 1 } })
-            .mockResolvedValueOnce({ code: 0, data: { replies: [] } });
-        await expect(command.func({}, { bvid: 'BV1xxx', limit: 5 }))
-            .rejects.toBeInstanceOf(EmptyResultError);
-    });
-    it('collapses newlines in comment text', async () => {
-        mockApiGet
-            .mockResolvedValueOnce({ code: 0, data: { aid: 1 } })
-            .mockResolvedValueOnce({
-            code: 0,
-            data: {
-                replies: [
-                    { rpid: 123, member: { uname: 'Bob' }, content: { message: 'line1\nline2\nline3' }, like: 0, rcount: 0, ctime: 0 },
-                ],
-            },
-        });
-        const result = (await command.func({}, { bvid: 'BV1xxx', limit: 5 }));
-        expect(result[0].text).toBe('line1 line2 line3');
-    });
-    it('throws CommandExecutionError when a comment row lacks rpid', async () => {
-        mockApiGet
-            .mockResolvedValueOnce({ code: 0, data: { aid: 1 } })
-            .mockResolvedValueOnce({
-            code: 0,
-            data: {
-                replies: [
-                    { member: { uname: 'Bob' }, content: { message: 'hi' }, like: 0, rcount: 0, ctime: 0 },
-                ],
-            },
-        });
-        await expect(command.func({}, { bvid: 'BV1xxx', limit: 5 }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-});

package/clis/bilibili/dynamic.test.js

@@ -1,68 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { mockApiGet } = vi.hoisted(() => ({
-    mockApiGet: vi.fn(),
-}));
-vi.mock('./utils.js', () => ({
-    apiGet: mockApiGet,
-}));
-import { getRegistry } from '@sovovs/bycli/registry';
-import './dynamic.js';
-describe('bilibili dynamic adapter', () => {
-    const command = getRegistry().get('bilibili/dynamic');
-    beforeEach(() => {
-        mockApiGet.mockReset();
-    });
-    it('maps desc text rows from the dynamic feed payload', async () => {
-        mockApiGet.mockResolvedValue({
-            data: {
-                items: [
-                    {
-                        id_str: '123',
-                        modules: {
-                            module_author: { name: 'Alice' },
-                            module_dynamic: { desc: { text: 'hello world' } },
-                            module_stat: { like: { count: 9 } },
-                        },
-                    },
-                ],
-            },
-        });
-        const result = await command.func({}, { limit: 5 });
-        expect(mockApiGet).toHaveBeenCalledWith({}, '/x/polymer/web-dynamic/v1/feed/all', { params: {}, signed: false });
-        expect(result).toEqual([
-            {
-                id: '123',
-                author: 'Alice',
-                text: 'hello world',
-                likes: 9,
-                url: 'https://t.bilibili.com/123',
-            },
-        ]);
-    });
-    it('falls back to archive title when desc text is absent', async () => {
-        mockApiGet.mockResolvedValue({
-            data: {
-                items: [
-                    {
-                        id_str: '456',
-                        modules: {
-                            module_author: { name: 'Bob' },
-                            module_dynamic: { major: { archive: { title: 'Video title' } } },
-                            module_stat: { like: { count: 3 } },
-                        },
-                    },
-                ],
-            },
-        });
-        const result = await command.func({}, { limit: 5 });
-        expect(result).toEqual([
-            {
-                id: '456',
-                author: 'Bob',
-                text: 'Video title',
-                likes: 3,
-                url: 'https://t.bilibili.com/456',
-            },
-        ]);
-    });
-});

package/clis/bilibili/hot.test.js

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './hot.js';
-
-describe('bilibili hot adapter', () => {
-  const command = getRegistry().get('bilibili/hot');
-
-  it('registers bvid and url columns in the public hot-list shape', () => {
-    expect(command?.columns).toEqual(['rank', 'title', 'author', 'play', 'danmaku', 'bvid', 'url']);
-    expect(command?.pipeline?.[1]?.evaluate).toContain('bvid: item.bvid');
-    expect(command?.pipeline?.[1]?.evaluate).toContain("'https://www.bilibili.com/video/' + item.bvid");
-    expect(command?.pipeline?.[2]?.map).toMatchObject({
-      bvid: '${{ item.bvid }}',
-      url: '${{ item.url }}',
-    });
-  });
-});

package/clis/bilibili/subtitle.test.js

@@ -1,196 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-const { mockApiGet } = vi.hoisted(() => ({
-    mockApiGet: vi.fn(),
-}));
-vi.mock('./utils.js', async (importOriginal) => ({
-    ...(await importOriginal()),
-    apiGet: mockApiGet,
-}));
-import { getRegistry } from '@sovovs/bycli/registry';
-import './subtitle.js';
-describe('bilibili subtitle', () => {
-    const command = getRegistry().get('bilibili/subtitle');
-    const page = {
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn(),
-    };
-    beforeEach(() => {
-        mockApiGet.mockReset();
-        page.goto.mockClear();
-        page.evaluate.mockReset();
-    });
-
-    // 帮助函数：第一发 apiGet（view）固定返 cid=123456 的 OK 响应
-    const mockViewOk = (cid = 123456) =>
-        mockApiGet.mockResolvedValueOnce({ code: 0, data: { bvid: 'BV1GbXPBeEZm', cid } });
-
-    it('throws AuthRequiredError when bilibili hides subtitles behind login', async () => {
-        mockViewOk();
-        mockApiGet.mockResolvedValueOnce({
-            code: 0,
-            data: {
-                need_login_subtitle: true,
-                subtitle: { subtitles: [] },
-            },
-        });
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toSatisfy(
-            (err) => err instanceof AuthRequiredError && /login|登录/i.test(err.message),
-        );
-    });
-
-    it('throws EmptyResultError when a video truly has no subtitles', async () => {
-        mockViewOk();
-        mockApiGet.mockResolvedValueOnce({
-            code: 0,
-            data: {
-                need_login_subtitle: false,
-                subtitle: { subtitles: [] },
-            },
-        });
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(EmptyResultError);
-    });
-
-    it('throws CommandExecutionError when view API returns non-zero code', async () => {
-        // 番剧/地区限制等场景下 view API 也会返非零；之前路径走 SELECTOR 错，现在统一走 view 错
-        mockApiGet.mockResolvedValueOnce({ code: -404, message: '啥都木有' });
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('wraps view API fetch/json exceptions as CommandExecutionError', async () => {
-        mockApiGet.mockRejectedValueOnce(new SyntaxError('Unexpected token <'));
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError when view API succeeds but lacks cid', async () => {
-        mockApiGet.mockResolvedValueOnce({ code: 0, data: { bvid: 'BV1GbXPBeEZm' /* no cid */ } });
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(/cid/);
-    });
-
-    it('throws CommandExecutionError when player subtitle payload is malformed', async () => {
-        mockViewOk();
-        mockApiGet.mockResolvedValueOnce({
-            code: 0,
-            data: {
-                need_login_subtitle: false,
-                subtitle: { subtitles: { lan: 'zh-CN' } },
-            },
-        });
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError when player API returns a non-object payload', async () => {
-        mockViewOk();
-        mockApiGet.mockResolvedValueOnce(null);
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(CommandExecutionError);
-
-        mockApiGet.mockReset();
-        mockViewOk();
-        mockApiGet.mockResolvedValueOnce([]);
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('throws AuthRequiredError only for explicit empty subtitle_url entries', async () => {
-        mockViewOk();
-        mockApiGet.mockResolvedValueOnce({
-            code: 0,
-            data: {
-                need_login_subtitle: false,
-                subtitle: { subtitles: [{ lan: 'zh-CN', subtitle_url: '' }] },
-            },
-        });
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(AuthRequiredError);
-    });
-
-    it('throws CommandExecutionError when subtitle entry lacks subtitle_url field', async () => {
-        mockViewOk();
-        mockApiGet.mockResolvedValueOnce({
-            code: 0,
-            data: {
-                need_login_subtitle: false,
-                subtitle: { subtitles: [{ lan: 'zh-CN' }] },
-            },
-        });
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('wraps subtitle file fetch exceptions as CommandExecutionError', async () => {
-        mockViewOk();
-        mockApiGet.mockResolvedValueOnce({
-            code: 0,
-            data: {
-                need_login_subtitle: false,
-                subtitle: { subtitles: [{ lan: 'zh-CN', subtitle_url: '//example.com/sub.json' }] },
-            },
-        });
-        page.evaluate.mockRejectedValueOnce(new Error('Failed to fetch'));
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('throws EmptyResultError when subtitle file has no cue rows', async () => {
-        mockViewOk();
-        mockApiGet.mockResolvedValueOnce({
-            code: 0,
-            data: {
-                need_login_subtitle: false,
-                subtitle: { subtitles: [{ lan: 'zh-CN', subtitle_url: '//example.com/sub.json' }] },
-            },
-        });
-        page.evaluate.mockResolvedValueOnce({ success: true, data: [] });
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(EmptyResultError);
-    });
-
-    it('throws CommandExecutionError when subtitle cue rows have malformed time ranges', async () => {
-        mockViewOk();
-        mockApiGet.mockResolvedValueOnce({
-            code: 0,
-            data: {
-                need_login_subtitle: false,
-                subtitle: { subtitles: [{ lan: 'zh-CN', subtitle_url: '//example.com/sub.json' }] },
-            },
-        });
-        page.evaluate.mockResolvedValueOnce({ success: true, data: [{ from: 'bad', to: 1.5, content: 'hello' }] });
-        await expect(command.func(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('works for bangumi-bound bvid (PGC content) — same code path, view API returns cid + redirect_url', async () => {
-        // 回归保护：以前 page.goto(/video/<bvid>) 对 bangumi 走重定向，
-        // window.__INITIAL_STATE__.videoData 不存在 → SELECTOR 错。view API 不依赖页面结构，bangumi 同样能拿 cid。
-        mockApiGet.mockResolvedValueOnce({
-            code: 0,
-            data: {
-                bvid: 'BV1Py4y1D781',
-                cid: 267270412,
-                redirect_url: 'https://www.bilibili.com/bangumi/play/ep371508',
-                title: '【纪录片】灭绝的真相',
-            },
-        });
-        mockApiGet.mockResolvedValueOnce({
-            code: 0,
-            data: {
-                need_login_subtitle: false,
-                subtitle: {
-                    subtitles: [{ lan: 'zh-CN', subtitle_url: '//example.com/sub.json' }],
-                },
-            },
-        });
-        page.evaluate.mockResolvedValueOnce({
-            success: true,
-            data: [
-                { from: 0, to: 1.5, content: 'hello' },
-                { from: 1.5, to: 3.2, content: 'world' },
-            ],
-        });
-        const out = await command.func(page, { bvid: 'BV1Py4y1D781' });
-        expect(out).toEqual([
-            { index: 1, from: '0.00s', to: '1.50s', content: 'hello' },
-            { index: 2, from: '1.50s', to: '3.20s', content: 'world' },
-        ]);
-        // 关键：不再依赖 page.goto，所有 cid 解析走 apiGet
-        expect(page.goto).not.toHaveBeenCalled();
-        // 第一发 apiGet 一定是 view 端点
-        const firstCall = mockApiGet.mock.calls[0];
-        expect(firstCall[1]).toBe('/x/web-interface/view');
-        expect(firstCall[2]?.params?.bvid).toBe('BV1Py4y1D781');
-    });
-});