@jackwener/opencli 1.7.21 → 1.8.0

package/clis/youtube/transcript.test.js

@@ -3,6 +3,7 @@ import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getRegistry } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 import './transcript.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -15,6 +16,7 @@ function createPageMock(captionUrl) {
         evaluate: vi.fn(),
     };
     page.evaluate
+        .mockResolvedValueOnce(null)
         .mockResolvedValueOnce({
         captionUrl,
         language: 'en',
@@ -33,7 +35,10 @@ afterEach(() => {
 });
 
 describe('youtube transcript source contract', () => {
-    it('gets caption tracks from watch page bootstrap data, not Android InnerTube', () => {
+    it('uses the watch player captions module before falling back to watch HTML, not Android InnerTube', () => {
+        expect(transcriptSource).toContain("player.loadModule?.('captions')");
+        expect(transcriptSource).toContain("player.setOption('captions', 'track', track)");
+        expect(transcriptSource).toContain("url.includes('pot=')");
         expect(transcriptSource).toContain("fetch('/watch?v='");
         expect(transcriptSource).toContain("extractJsonAssignmentFromHtml(html, 'ytInitialPlayerResponse')");
         expect(transcriptSource).toContain('playerCaptionsTracklistRenderer');
@@ -48,6 +53,23 @@ describe('youtube transcript source contract', () => {
     it('checks HTTP status before reading caption response body', () => {
         expect(transcriptSource).toContain('resp.ok');
     });
+
+    it('restores page fetch and XHR hooks even when caption probing exits early', () => {
+        expect(transcriptSource).toContain('} finally {');
+        expect(transcriptSource).toContain('globalThis.fetch = originalFetch');
+        expect(transcriptSource).toContain('globalThis.XMLHttpRequest = OriginalXHR');
+    });
+
+    it('scopes timedtext URL matching to the current videoId in both in-page paths', () => {
+        // YouTube is an SPA — daemon-shared tabs preserve prior videos'
+        // performance.getEntriesByType('resource') across watch→watch navigations.
+        // Both findTimedtextUrl (resource buffer) and isJson3TimedtextUrl (fetch/XHR
+        // hook) must require the URL contain v=<currentVideoId>, otherwise a
+        // previously-viewed same-language video's captions can be returned.
+        expect(transcriptSource).toContain('const targetVideoId = ');
+        expect(transcriptSource).toContain("parsed.searchParams.get('v') === targetVideoId");
+        expect(transcriptSource).toContain('timedtextUrlMatchesVideo(url)');
+    });
 });
 
 describe('youtube transcript caption fetch', () => {
@@ -58,18 +80,110 @@ describe('youtube transcript caption fetch', () => {
 
         const rows = await command.func(page, { url: 'abc', mode: 'raw' });
 
-        expect(page.evaluate.mock.calls[1][0]).toContain('const primaryUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=srv3"');
-        expect(page.evaluate.mock.calls[1][0]).toContain('const originalUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en"');
+        expect(page.evaluate.mock.calls[2][0]).toContain('const primaryUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=srv3"');
+        expect(page.evaluate.mock.calls[2][0]).toContain('const originalUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en"');
         expect(rows).toEqual([{ index: 1, start: '1.00s', end: '3.00s', text: 'hello & world' }]);
     });
 
+    it('uses Browser Bridge envelope-wrapped player caption segments without fallback', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValueOnce({
+                session: 'browser:default',
+                data: [{ start: 2, end: 4.5, text: 'from player captions' }],
+            }),
+        };
+
+        const rows = await command.func(page, { url: 'abc', mode: 'raw' });
+
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+        expect(rows).toEqual([{ index: 1, start: '2.00s', end: '4.50s', text: 'from player captions' }]);
+    });
+
+    it('uses captured timedtext json3 when player selection returns no segments', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            startNetworkCapture: vi.fn().mockResolvedValue(undefined),
+            readNetworkCapture: vi.fn().mockResolvedValue({
+                session: 'browser:default',
+                data: [{
+                    url: 'https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=json3&pot=token',
+                    responsePreview: JSON.stringify({
+                        events: [
+                            { tStartMs: 1000, dDurationMs: 1500, segs: [{ utf8: 'hello ' }, { utf8: 'capture' }] },
+                        ],
+                    }),
+                }],
+            }),
+            evaluate: vi.fn().mockResolvedValueOnce(null),
+        };
+
+        const rows = await command.func(page, { url: 'abc', mode: 'raw', lang: 'en' });
+
+        expect(page.startNetworkCapture).toHaveBeenCalledWith('/api/timedtext');
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+        expect(rows).toEqual([{ index: 1, start: '1.00s', end: '2.50s', text: 'hello capture' }]);
+    });
+
+    it('ignores captured timedtext entries from a prior video and uses only the current videoId', async () => {
+        // Regression: opencli daemon reuses one Chrome tab across sequential
+        // youtube transcript calls. YouTube's SPA navigation between watch URLs
+        // leaves prior videos' timedtext entries in performance.getEntriesByType
+        // and (rarely) in the CDP capture buffer. Without filtering by videoId,
+        // the same-language predecessor's captions can leak into the current row.
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            startNetworkCapture: vi.fn().mockResolvedValue(undefined),
+            readNetworkCapture: vi.fn().mockResolvedValue({
+                session: 'browser:default',
+                data: [
+                    {
+                        // Stale entry from a prior watch on the shared tab — must be ignored.
+                        url: 'https://www.youtube.com/api/timedtext?v=prev&lang=en&fmt=json3&pot=token',
+                        responsePreview: JSON.stringify({
+                            events: [
+                                { tStartMs: 0, dDurationMs: 1000, segs: [{ utf8: 'WRONG video captions' }] },
+                            ],
+                        }),
+                    },
+                    {
+                        // Prefix collision: substring matching for "v=abc" would accept this.
+                        url: 'https://www.youtube.com/api/timedtext?v=abcd&lang=en&fmt=json3&pot=token',
+                        responsePreview: JSON.stringify({
+                            events: [
+                                { tStartMs: 1000, dDurationMs: 1000, segs: [{ utf8: 'WRONG prefix captions' }] },
+                            ],
+                        }),
+                    },
+                    {
+                        // Current video's captions.
+                        url: 'https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=json3&pot=token',
+                        responsePreview: JSON.stringify({
+                            events: [
+                                { tStartMs: 2000, dDurationMs: 1000, segs: [{ utf8: 'right captions' }] },
+                            ],
+                        }),
+                    },
+                ],
+            }),
+            evaluate: vi.fn().mockResolvedValueOnce(null),
+        };
+
+        const rows = await command.func(page, { url: 'abc', mode: 'raw', lang: 'en' });
+
+        expect(rows).toEqual([{ index: 1, start: '2.00s', end: '3.00s', text: 'right captions' }]);
+    });
+
     it('does not override an existing caption format', async () => {
         const page = createPageMock('https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=vtt');
 
         await command.func(page, { url: 'abc', mode: 'raw' });
 
-        expect(page.evaluate.mock.calls[1][0]).toContain('const primaryUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=vtt"');
-        expect(page.evaluate.mock.calls[1][0]).toContain('const originalUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=vtt"');
+        expect(page.evaluate.mock.calls[2][0]).toContain('const primaryUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=vtt"');
+        expect(page.evaluate.mock.calls[2][0]).toContain('const originalUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=vtt"');
     });
 
     it('falls back to the original URL only after an empty successful srv3 response', async () => {
@@ -77,7 +191,7 @@ describe('youtube transcript caption fetch', () => {
 
         await command.func(page, { url: 'abc', mode: 'raw' });
 
-        const script = page.evaluate.mock.calls[1][0];
+        const script = page.evaluate.mock.calls[2][0];
         expect(script).toContain('if (!result.xml.length && originalUrl !== primaryUrl)');
         expect(script).toContain('result = await fetchCaptionXml(originalUrl)');
         expect(script).toContain('if (result.error) {');
@@ -87,6 +201,7 @@ describe('youtube transcript caption fetch', () => {
         const page = createPageMock('https://www.youtube.com/api/timedtext?v=abc&lang=en');
         page.evaluate.mockReset();
         page.evaluate
+            .mockResolvedValueOnce(null)
             .mockResolvedValueOnce({
             captionUrl: 'https://www.youtube.com/api/timedtext?v=abc&lang=en',
             language: 'en',
@@ -103,4 +218,79 @@ describe('youtube transcript caption fetch', () => {
             message: expect.stringContaining('HTTP 503'),
         });
     });
+
+    it('fails typed on malformed browser extraction payloads', async () => {
+        const page = createPageMock('https://www.youtube.com/api/timedtext?v=abc&lang=en');
+        page.evaluate.mockReset();
+        page.evaluate
+            .mockResolvedValueOnce(null)
+            .mockResolvedValueOnce({
+                captionUrl: 'https://www.youtube.com/api/timedtext?v=abc&lang=en',
+                language: 'en',
+                kind: 'manual',
+                available: ['en'],
+                requestedLang: null,
+                langMatched: false,
+                langPrefixMatched: false,
+            })
+            .mockResolvedValueOnce({ session: 'browser:default', data: { rows: [] } });
+
+        await expect(command.func(page, { url: 'abc', mode: 'raw' })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('Malformed caption XML extraction payload'),
+        });
+    });
+
+    it('fails typed on malformed caption info payloads before URL construction', async () => {
+        const page = createPageMock('https://www.youtube.com/api/timedtext?v=abc&lang=en');
+        page.evaluate.mockReset();
+        page.evaluate
+            .mockResolvedValueOnce(null)
+            .mockResolvedValueOnce({ session: 'browser:default', data: { rows: [] } });
+
+        await expect(command.func(page, { url: 'abc', mode: 'raw' })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('Malformed caption info payload'),
+        });
+    });
+
+    it('maps explicit no-captions watch metadata to EmptyResultError', async () => {
+        const page = createPageMock('https://www.youtube.com/api/timedtext?v=abc&lang=en');
+        page.evaluate.mockReset();
+        page.evaluate
+            .mockResolvedValueOnce(null)
+            .mockResolvedValueOnce({ error: 'No captions available for this video' });
+
+        await expect(command.func(page, { url: 'abc', mode: 'raw' })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('keeps malformed watch metadata as CommandExecutionError', async () => {
+        const page = createPageMock('https://www.youtube.com/api/timedtext?v=abc&lang=en');
+        page.evaluate.mockReset();
+        page.evaluate
+            .mockResolvedValueOnce(null)
+            .mockResolvedValueOnce({ error: 'ytInitialPlayerResponse not found in watch HTML' });
+
+        await expect(command.func(page, { url: 'abc', mode: 'raw' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('fails typed on malformed captured timedtext json3', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            startNetworkCapture: vi.fn().mockResolvedValue(undefined),
+            readNetworkCapture: vi.fn().mockResolvedValue([
+                {
+                    url: 'https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=json3&pot=token',
+                    responsePreview: '{"events":',
+                },
+            ]),
+            evaluate: vi.fn().mockResolvedValueOnce(null),
+        };
+
+        await expect(command.func(page, { url: 'abc', mode: 'raw', lang: 'en' })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('Malformed json3 timedtext response'),
+        });
+    });
 });

package/clis/zhihu/answer-comments.js

@@ -0,0 +1,299 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+function decodeEntity(codePoint) {
+    return Number.isInteger(codePoint) && codePoint >= 0 && codePoint <= 0x10FFFF
+        ? String.fromCodePoint(codePoint)
+        : null;
+}
+
+function stripHtml(html) {
+    if (!html) return '';
+    return html
+        .replace(/<br\s*\/?\s*>/gi, '\n')
+        .replace(/<\/(?:p|div|h[1-6]|li|blockquote)>/gi, '\n\n')
+        .replace(/<[^>]+>/g, '')
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&#(\d+);/g, (entity, value) => decodeEntity(Number(value)) ?? entity)
+        .replace(/&#x([0-9a-f]+);/gi, (entity, value) => decodeEntity(Number.parseInt(value, 16)) ?? entity)
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+
+const ANSWER_ID_RE = /^\d+$/;
+const ANSWER_TYPED_RE = /^answer:(\d+):(\d+)$/;
+const ANSWER_PATH_RE = /^\/question\/(\d+)\/answer\/(\d+)\/?$/;
+const BARE_ANSWER_PATH_RE = /^\/answer\/(\d+)\/?$/;
+
+function parseAnswerTarget(input) {
+    const value = String(input ?? '').trim();
+    if (!value) return null;
+    if (ANSWER_ID_RE.test(value)) return { answerId: value, questionId: '' };
+    const typed = value.match(ANSWER_TYPED_RE);
+    if (typed) return { questionId: typed[1], answerId: typed[2] };
+    try {
+        const url = new URL(value);
+        if (
+            url.protocol !== 'https:' ||
+            url.username ||
+            url.password ||
+            url.port ||
+            (url.hostname !== 'www.zhihu.com' && url.hostname !== 'zhihu.com')
+        ) {
+            return null;
+        }
+        let m = url.pathname.match(ANSWER_PATH_RE);
+        if (m) return { questionId: m[1], answerId: m[2] };
+        m = url.pathname.match(BARE_ANSWER_PATH_RE);
+        if (m) return { answerId: m[1], questionId: '' };
+    } catch {
+        return null;
+    }
+    return null;
+}
+
+function extractQuestionIdFromAnswerUrl(input) {
+    const value = String(input ?? '').trim();
+    if (!value) return '';
+    try {
+        const url = new URL(value);
+        if (url.protocol !== 'https:' || (url.hostname !== 'www.zhihu.com' && url.hostname !== 'zhihu.com')) return '';
+        return url.pathname.match(ANSWER_PATH_RE)?.[1] || '';
+    } catch {
+        return '';
+    }
+}
+
+function normalizeCount(value) {
+    return Number.isInteger(value) && value >= 0 ? value : 0;
+}
+
+function normalizeUnixSeconds(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0
+        ? new Date(value * 1000).toISOString()
+        : '';
+}
+
+function memberName(author) {
+    return author?.member?.name || author?.name || '';
+}
+
+function normalizeCommentId(value) {
+    if (typeof value === 'string') return value.trim();
+    if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) return String(value);
+    return '';
+}
+
+function normalizeCommentUrl(url, questionId, answerId, commentId) {
+    if (questionId && answerId && commentId) {
+        return `https://www.zhihu.com/question/${questionId}/answer/${answerId}#comment-${commentId}`;
+    }
+    return typeof url === 'string' ? url : '';
+}
+
+function normalizeCommentsApiUrl(url, answerId) {
+    if (typeof url !== 'string' || !url) return '';
+    try {
+        const parsed = new URL(url);
+        const expectedWwwPath = `/api/v4/answers/${answerId}/comments`;
+        const expectedApiPath = `/answers/${answerId}/comments`;
+        if (parsed.protocol !== 'https:' || parsed.username || parsed.password || parsed.port) return '';
+        if (parsed.hostname === 'www.zhihu.com' && parsed.pathname === expectedWwwPath) return parsed.toString();
+        if (parsed.hostname === 'api.zhihu.com' && parsed.pathname === expectedApiPath) {
+            return `https://www.zhihu.com${expectedWwwPath}${parsed.search}`;
+        }
+    } catch {
+        return '';
+    }
+    return '';
+}
+
+function buildRows(comments, { answerId, questionId, topLevelLimit, repliesLimit }) {
+    const rows = [];
+    let topLevelCount = 0;
+    let currentCommentRank = 0;
+    let currentReplyCount = 0;
+    let reachedTopLevelLimit = false;
+    let malformedComments = 0;
+
+    for (const comment of comments) {
+        if (!comment || typeof comment !== 'object' || Array.isArray(comment)) {
+            malformedComments += 1;
+            continue;
+        }
+        const id = normalizeCommentId(comment.id);
+        if (!id) {
+            malformedComments += 1;
+            continue;
+        }
+        const author = memberName(comment.author);
+        const replyToAuthor = memberName(comment.reply_to_author);
+        const isReply = Boolean(replyToAuthor);
+
+        if (!isReply) {
+            if (topLevelCount >= topLevelLimit) {
+                reachedTopLevelLimit = true;
+                break;
+            }
+            topLevelCount += 1;
+            currentCommentRank = topLevelCount;
+            currentReplyCount = 0;
+        } else if (!currentCommentRank || currentReplyCount >= repliesLimit) {
+            continue;
+        } else {
+            currentReplyCount += 1;
+        }
+
+        rows.push({
+            rank: rows.length + 1,
+            comment_rank: currentCommentRank,
+            reply_rank: isReply ? currentReplyCount : 0,
+            depth: 0,
+            id,
+            parent_id: '',
+            author: author || 'anonymous',
+            reply_to: replyToAuthor,
+            likes: normalizeCount(comment.vote_count),
+            created_at: normalizeUnixSeconds(comment.created_time),
+            url: normalizeCommentUrl(comment.url, questionId, answerId, id),
+            content: stripHtml(comment.content || ''),
+        });
+    }
+    return { rows, topLevelCount, reachedTopLevelLimit, malformedComments };
+}
+
+const MAX_LIMIT = 1000;
+const MAX_REPLIES_LIMIT = 100;
+const ZHIHU_PAGE_SIZE = 20;
+
+cli({
+    site: 'zhihu',
+    name: 'answer-comments',
+    access: 'read',
+    description: '知乎回答评论列表',
+    domain: 'www.zhihu.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'id', required: true, positional: true, help: 'Answer ID, full Zhihu answer URL, or typed target (answer:<qid>:<aid>)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of top-level comments (max 1000)' },
+        { name: 'replies-limit', type: 'int', default: 3, help: 'Number of replies to include per top-level comment (max 100)' },
+    ],
+    columns: ['rank', 'comment_rank', 'reply_rank', 'depth', 'id', 'parent_id', 'author', 'reply_to', 'likes', 'created_at', 'url', 'content'],
+    func: async (page, kwargs) => {
+        const target = parseAnswerTarget(kwargs.id);
+        if (!target) {
+            throw new ArgumentError(
+                'Answer ID must be a numeric id, a Zhihu answer URL, or answer:<qid>:<aid>',
+                'Example: opencli zhihu answer-comments 1937205528846655537',
+            );
+        }
+        const topLevelLimit = Number(kwargs.limit ?? 20);
+        if (!Number.isInteger(topLevelLimit) || topLevelLimit <= 0 || topLevelLimit > MAX_LIMIT) {
+            throw new ArgumentError(`--limit must be a positive integer no greater than ${MAX_LIMIT}`);
+        }
+        const repliesLimit = Number(kwargs['replies-limit'] ?? 3);
+        if (!Number.isInteger(repliesLimit) || repliesLimit < 0 || repliesLimit > MAX_REPLIES_LIMIT) {
+            throw new ArgumentError(`--replies-limit must be an integer between 0 and ${MAX_REPLIES_LIMIT}`);
+        }
+
+        const { answerId } = target;
+        try {
+            await page.goto(`https://www.zhihu.com/answer/${answerId}`);
+        } catch (err) {
+            throw new CommandExecutionError(
+                `Failed to open Zhihu answer ${answerId}: ${err instanceof Error ? err.message : String(err)}`,
+                'Open the answer URL in Chrome and retry after the page is reachable.',
+            );
+        }
+        const currentQuestionId = page.getCurrentUrl
+            ? extractQuestionIdFromAnswerUrl(await page.getCurrentUrl().catch(() => ''))
+            : '';
+        const questionId = target.questionId || currentQuestionId;
+
+        let url = `https://www.zhihu.com/api/v4/answers/${answerId}/comments?order=normal&limit=${ZHIHU_PAGE_SIZE}&offset=0&status=open`;
+        const fetched = [];
+        const visited = new Set();
+
+        while (url && !visited.has(url)) {
+            visited.add(url);
+            const data = await page.evaluate(`
+      (async () => {
+        const r = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
+        if (!r.ok) return { __httpError: r.status };
+        try {
+          return await r.json();
+        } catch (error) {
+          return { __malformedJson: error instanceof Error ? error.message : String(error) };
+        }
+      })()
+    `).catch((err) => {
+                throw new CommandExecutionError(
+                    `Zhihu answer comments request failed: ${err instanceof Error ? err.message : String(err)}`,
+                    'Try again later or rerun with -v for more detail.',
+                );
+            });
+            if (!data || data.__httpError) {
+                const status = data?.__httpError;
+                if (status === 401 || status === 403) {
+                    throw new AuthRequiredError('www.zhihu.com', 'Failed to fetch Zhihu answer comments');
+                }
+                if (status === 404) {
+                    throw new EmptyResultError('zhihu answer-comments', `No Zhihu answer comments resource was found for ${answerId}.`);
+                }
+                throw new CommandExecutionError(
+                    status
+                        ? `Zhihu answer comments request failed (HTTP ${status})`
+                        : 'Zhihu answer comments request failed',
+                    'Try again later or rerun with -v for more detail',
+                );
+            }
+            if (data.__malformedJson) {
+                throw new CommandExecutionError(
+                    `Zhihu answer comments returned malformed JSON: ${data.__malformedJson}`,
+                    'Try again later or rerun with -v for more detail',
+                );
+            }
+            if (!Array.isArray(data.data) || !data.paging || typeof data.paging !== 'object') {
+                throw new CommandExecutionError(
+                    'Zhihu answer comments returned a malformed payload',
+                    'Try again later or rerun with -v for more detail',
+                );
+            }
+            fetched.push(...data.data);
+            const built = buildRows(fetched, { answerId, questionId, topLevelLimit, repliesLimit });
+            if (built.malformedComments > 0) {
+                throw new CommandExecutionError('Zhihu answer comments contained rows without comment ids');
+            }
+            if (built.reachedTopLevelLimit || data.paging?.is_end) {
+                if (built.rows.length === 0) {
+                    throw new EmptyResultError('zhihu answer-comments', `No comments found for answer ${answerId}.`);
+                }
+                return built.rows;
+            }
+            const next = normalizeCommentsApiUrl(data.paging?.next, answerId);
+            if (!next) {
+                throw new CommandExecutionError('Zhihu answer comments pagination returned malformed next URL');
+            }
+            if (visited.has(next)) {
+                throw new CommandExecutionError('Zhihu answer comments pagination returned a repeated next URL');
+            }
+            url = next;
+        }
+
+        const built = buildRows(fetched, { answerId, questionId, topLevelLimit, repliesLimit });
+        if (built.malformedComments > 0) {
+            throw new CommandExecutionError('Zhihu answer comments contained rows without comment ids');
+        }
+        if (built.rows.length === 0) {
+            throw new EmptyResultError('zhihu answer-comments', `No comments found for answer ${answerId}.`);
+        }
+        return built.rows;
+    },
+});
+
+export const __test__ = { stripHtml, parseAnswerTarget, normalizeCommentsApiUrl, buildRows };