@jackwener/opencli 1.5.4 → 1.5.6

package/dist/clis/youtube/transcript.js

@@ -10,7 +10,7 @@
  *   --mode raw: every caption segment as-is with precise timestamps
  */
 import { cli, Strategy } from '../../registry.js';
-import { parseVideoId } from './utils.js';
+import { parseVideoId, prepareYoutubeApiPage } from './utils.js';
 import { groupTranscriptSegments, formatGroupedTranscript, } from './transcript-group.js';
 import { CommandExecutionError, EmptyResultError } from '../../errors.js';
 cli({
@@ -28,9 +28,7 @@ cli({
     // so we let the renderer auto-detect columns from the data keys.
     func: async (page, kwargs) => {
         const videoId = parseVideoId(kwargs.url);
-        const videoUrl = `https://www.youtube.com/watch?v=${videoId}`;
-        await page.goto(videoUrl);
-        await page.wait(3);
+        await prepareYoutubeApiPage(page);
         const lang = kwargs.lang || '';
         const mode = kwargs.mode || 'grouped';
         // Step 1: Get caption track URL via Android InnerTube API

package/dist/clis/youtube/utils.d.ts

@@ -1,8 +1,17 @@
 /**
  * Shared YouTube utilities — URL parsing, video ID extraction, etc.
  */
+import type { IPage } from '../../types.js';
 /**
  * Extract a YouTube video ID from a URL or bare video ID string.
  * Supports: watch?v=, youtu.be/, /shorts/, /embed/, /live/, /v/
  */
 export declare function parseVideoId(input: string): string;
+/**
+ * Extract a JSON object assigned to a known bootstrap variable inside YouTube HTML.
+ */
+export declare function extractJsonAssignmentFromHtml(html: string, keys: string | string[]): Record<string, unknown> | null;
+/**
+ * Prepare a quiet YouTube API-capable page without opening the watch UI.
+ */
+export declare function prepareYoutubeApiPage(page: IPage): Promise<void>;

package/dist/clis/youtube/utils.js

@@ -1,6 +1,3 @@
-/**
- * Shared YouTube utilities — URL parsing, video ID extraction, etc.
- */
 /**
  * Extract a YouTube video ID from a URL or bare video ID string.
  * Supports: watch?v=, youtu.be/, /shorts/, /embed/, /live/, /v/
@@ -26,3 +23,70 @@ export function parseVideoId(input) {
     }
     return input;
 }
+/**
+ * Extract a JSON object assigned to a known bootstrap variable inside YouTube HTML.
+ */
+export function extractJsonAssignmentFromHtml(html, keys) {
+    const candidates = Array.isArray(keys) ? keys : [keys];
+    for (const key of candidates) {
+        const markers = [
+            `var ${key} = `,
+            `window["${key}"] = `,
+            `window.${key} = `,
+            `${key} = `,
+        ];
+        for (const marker of markers) {
+            const markerIndex = html.indexOf(marker);
+            if (markerIndex === -1)
+                continue;
+            const jsonStart = html.indexOf('{', markerIndex + marker.length);
+            if (jsonStart === -1)
+                continue;
+            let depth = 0;
+            let inString = false;
+            let escaping = false;
+            for (let i = jsonStart; i < html.length; i += 1) {
+                const ch = html[i];
+                if (inString) {
+                    if (escaping) {
+                        escaping = false;
+                    }
+                    else if (ch === '\\') {
+                        escaping = true;
+                    }
+                    else if (ch === '"') {
+                        inString = false;
+                    }
+                    continue;
+                }
+                if (ch === '"') {
+                    inString = true;
+                    continue;
+                }
+                if (ch === '{') {
+                    depth += 1;
+                    continue;
+                }
+                if (ch === '}') {
+                    depth -= 1;
+                    if (depth === 0) {
+                        try {
+                            return JSON.parse(html.slice(jsonStart, i + 1));
+                        }
+                        catch {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Prepare a quiet YouTube API-capable page without opening the watch UI.
+ */
+export async function prepareYoutubeApiPage(page) {
+    await page.goto('https://www.youtube.com', { waitUntil: 'none' });
+    await page.wait(2);
+}

package/dist/clis/youtube/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/youtube/utils.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from 'vitest';
+import { extractJsonAssignmentFromHtml, prepareYoutubeApiPage } from './utils.js';
+describe('youtube utils', () => {
+    it('extractJsonAssignmentFromHtml parses bootstrap objects with nested braces in strings', () => {
+        const html = `
+      <script>
+        var ytInitialPlayerResponse = {
+          "title": "brace { inside } string",
+          "nested": { "count": 2, "text": "quote \\"value\\"" }
+        };
+      </script>
+    `;
+        expect(extractJsonAssignmentFromHtml(html, 'ytInitialPlayerResponse')).toEqual({
+            title: 'brace { inside } string',
+            nested: { count: 2, text: 'quote "value"' },
+        });
+    });
+    it('extractJsonAssignmentFromHtml supports window assignments', () => {
+        const html = `
+      <script>
+        window["ytInitialData"] = {"contents":{"items":[1,2,3]}};
+      </script>
+    `;
+        expect(extractJsonAssignmentFromHtml(html, 'ytInitialData')).toEqual({
+            contents: { items: [1, 2, 3] },
+        });
+    });
+    it('prepareYoutubeApiPage loads the quiet API bootstrap page', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+        };
+        await expect(prepareYoutubeApiPage(page)).resolves.toBeUndefined();
+        expect(page.goto).toHaveBeenCalledWith('https://www.youtube.com', { waitUntil: 'none' });
+        expect(page.wait).toHaveBeenCalledWith(2);
+    });
+});

package/dist/clis/youtube/video.js

@@ -1,8 +1,8 @@
 /**
- * YouTube video metadata — read ytInitialPlayerResponse + ytInitialData from video page.
+ * YouTube video metadata — fetch watch HTML and parse bootstrap data without opening the watch UI.
  */
 import { cli, Strategy } from '../../registry.js';
-import { parseVideoId } from './utils.js';
+import { extractJsonAssignmentFromHtml, parseVideoId, prepareYoutubeApiPage } from './utils.js';
 import { CommandExecutionError } from '../../errors.js';
 cli({
     site: 'youtube',
@@ -16,23 +16,28 @@ cli({
     columns: ['field', 'value'],
     func: async (page, kwargs) => {
         const videoId = parseVideoId(kwargs.url);
-        const videoUrl = `https://www.youtube.com/watch?v=${videoId}`;
-        await page.goto(videoUrl);
-        await page.wait(3);
+        await prepareYoutubeApiPage(page);
         const data = await page.evaluate(`
       (async () => {
-        const player = window.ytInitialPlayerResponse;
-        const yt = window.ytInitialData;
-        if (!player) return { error: 'ytInitialPlayerResponse not found' };
+        const extractJsonAssignmentFromHtml = ${extractJsonAssignmentFromHtml.toString()};
+
+        const watchResp = await fetch('/watch?v=' + encodeURIComponent(${JSON.stringify(videoId)}), {
+          credentials: 'include',
+        });
+        if (!watchResp.ok) return { error: 'Watch HTML returned HTTP ' + watchResp.status };
+
+        const html = await watchResp.text();
+        const player = extractJsonAssignmentFromHtml(html, 'ytInitialPlayerResponse');
+        const yt = extractJsonAssignmentFromHtml(html, 'ytInitialData');
+        if (!player) return { error: 'ytInitialPlayerResponse not found in watch HTML' };
 
         const details = player.videoDetails || {};
         const microformat = player.microformat?.playerMicroformatRenderer || {};
+        const contents = yt?.contents?.twoColumnWatchNextResults?.results?.results?.contents || [];
 
-        // Try to get full description from ytInitialData
+        // Try to get full description from watch bootstrap data
         let fullDescription = details.shortDescription || '';
         try {
-          const contents = yt?.contents?.twoColumnWatchNextResults
-            ?.results?.results?.contents;
           if (contents) {
             for (const c of contents) {
               const desc = c.videoSecondaryInfoRenderer?.attributedDescription?.content;
@@ -44,8 +49,6 @@ cli({
         // Get like count if available
         let likes = '';
         try {
-          const contents = yt?.contents?.twoColumnWatchNextResults
-            ?.results?.results?.contents;
           if (contents) {
             for (const c of contents) {
               const buttons = c.videoPrimaryInfoRenderer?.videoActions
@@ -73,8 +76,6 @@ cli({
         // Get channel subscriber count if available
         let subscribers = '';
         try {
-          const contents = yt?.contents?.twoColumnWatchNextResults
-            ?.results?.results?.contents;
           if (contents) {
             for (const c of contents) {
               const owner = c.videoSecondaryInfoRenderer?.owner

package/dist/clis/zsxq/dynamics.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/zsxq/dynamics.js

@@ -0,0 +1,47 @@
+import { cli, Strategy } from '../../registry.js';
+import { ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getTopicText, getTopicAuthor, getTopicUrl, } from './utils.js';
+cli({
+    site: 'zsxq',
+    name: 'dynamics',
+    description: '获取所有星球的最新动态',
+    domain: 'wx.zsxq.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of dynamics to return' },
+    ],
+    columns: ['time', 'group', 'author', 'title', 'comments', 'likes', 'url'],
+    func: async (page, kwargs) => {
+        await ensureZsxqPage(page);
+        await ensureZsxqAuth(page);
+        const limit = Math.max(1, Number(kwargs.limit) || 20);
+        const { data } = await fetchFirstJson(page, [
+            `https://api.zsxq.com/v2/dynamics?scope=general&count=${limit}`,
+        ]);
+        const respData = data?.resp_data || data;
+        const dynamics = respData?.dynamics || [];
+        return dynamics.slice(0, limit).map((d) => {
+            const topic = d.topic;
+            if (!topic) {
+                return {
+                    time: d.create_time || '',
+                    group: '',
+                    author: '',
+                    title: `[${d.action || 'unknown'}]`,
+                    comments: 0,
+                    likes: 0,
+                    url: '',
+                };
+            }
+            return {
+                time: d.create_time || topic.create_time || '',
+                group: topic.group?.name || '',
+                author: getTopicAuthor(topic),
+                title: getTopicText(topic).slice(0, 120),
+                comments: topic.comments_count ?? 0,
+                likes: topic.likes_count ?? 0,
+                url: getTopicUrl(topic.topic_id),
+            };
+        });
+    },
+});

package/dist/clis/zsxq/groups.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/zsxq/groups.js

@@ -0,0 +1,32 @@
+import { cli, Strategy } from '../../registry.js';
+import { ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getGroupsFromResponse, } from './utils.js';
+cli({
+    site: 'zsxq',
+    name: 'groups',
+    description: '列出当前账号加入的星球',
+    domain: 'wx.zsxq.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 50, help: 'Number of groups to return' },
+    ],
+    columns: ['group_id', 'name', 'category', 'members', 'topics', 'joined_at', 'url'],
+    func: async (page, kwargs) => {
+        await ensureZsxqPage(page);
+        await ensureZsxqAuth(page);
+        const limit = Math.max(1, Number(kwargs.limit) || 50);
+        const { data } = await fetchFirstJson(page, [
+            `https://api.zsxq.com/v2/groups`,
+        ]);
+        return getGroupsFromResponse(data).slice(0, limit).map((group) => ({
+            group_id: group.group_id ?? '',
+            name: group.name || '',
+            category: group.category?.title || '',
+            members: group.statistics?.subscriptions_count ?? 0,
+            topics: group.statistics?.topics_count ?? 0,
+            joined_at: group.user_specific?.join_time || '',
+            valid_until: group.user_specific?.validity?.end_time || '',
+            url: group.group_id ? `https://wx.zsxq.com/group/${group.group_id}` : 'https://wx.zsxq.com',
+        }));
+    },
+});

package/dist/clis/zsxq/search.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/zsxq/search.js

@@ -0,0 +1,43 @@
+import { cli, Strategy } from '../../registry.js';
+import { getActiveGroupId, ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getGroupsFromResponse, getTopicsFromResponse, toTopicRow, } from './utils.js';
+cli({
+    site: 'zsxq',
+    name: 'search',
+    description: '搜索星球内容',
+    domain: 'wx.zsxq.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'keyword', required: true, positional: true, help: 'Search keyword' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results to return' },
+        { name: 'group_id', help: 'Optional group id; defaults to the active group in Chrome' },
+    ],
+    columns: ['topic_id', 'group', 'author', 'title', 'comments', 'likes', 'time', 'url'],
+    func: async (page, kwargs) => {
+        await ensureZsxqPage(page);
+        await ensureZsxqAuth(page);
+        const keyword = String(kwargs.keyword || '').trim();
+        const limit = Math.max(1, Number(kwargs.limit) || 20);
+        const groupId = String(kwargs.group_id || await getActiveGroupId(page));
+        const query = encodeURIComponent(keyword);
+        // Resolve group name from groups API
+        let groupName = groupId;
+        try {
+            const { data: groupsData } = await fetchFirstJson(page, [
+                `https://api.zsxq.com/v2/groups`,
+            ]);
+            const groups = getGroupsFromResponse(groupsData);
+            const found = groups.find(g => String(g.group_id) === groupId);
+            if (found?.name)
+                groupName = found.name;
+        }
+        catch { /* ignore */ }
+        const { data } = await fetchFirstJson(page, [
+            `https://api.zsxq.com/v2/search/groups/${groupId}/topics?keyword=${query}&count=${limit}`,
+        ]);
+        return getTopicsFromResponse(data).slice(0, limit).map((topic) => ({
+            ...toTopicRow(topic),
+            group: groupName,
+        }));
+    },
+});

package/dist/clis/zsxq/search.test.d.ts

@@ -0,0 +1 @@
+import './search.js';

package/dist/clis/zsxq/search.test.js

@@ -0,0 +1,24 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './search.js';
+describe('zsxq search command', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('requires an explicit group_id when there is no active group context', async () => {
+        const command = getRegistry().get('zsxq/search');
+        expect(command?.func).toBeTypeOf('function');
+        const mockPage = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce(true)
+                .mockResolvedValueOnce(null),
+        };
+        await expect(command.func(mockPage, { keyword: 'opencli', limit: 20 })).rejects.toMatchObject({
+            code: 'ARGUMENT',
+            message: 'Cannot determine active group_id',
+        });
+        expect(mockPage.goto).toHaveBeenCalledWith('https://wx.zsxq.com');
+        expect(mockPage.evaluate).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/clis/zsxq/topic.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/zsxq/topic.js

@@ -0,0 +1,47 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { browserJsonRequest, ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getCommentsFromResponse, getTopicFromResponse, getTopicUrl, summarizeComments, toTopicRow, } from './utils.js';
+cli({
+    site: 'zsxq',
+    name: 'topic',
+    description: '获取单个话题详情和评论',
+    domain: 'wx.zsxq.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'id', required: true, positional: true, help: 'Topic ID' },
+        { name: 'comment_limit', type: 'int', default: 20, help: 'Number of comments to fetch' },
+    ],
+    columns: ['topic_id', 'type', 'author', 'title', 'comments', 'likes', 'comment_preview', 'url'],
+    func: async (page, kwargs) => {
+        await ensureZsxqPage(page);
+        await ensureZsxqAuth(page);
+        const topicId = String(kwargs.id);
+        const commentLimit = Math.max(1, Number(kwargs.comment_limit) || 20);
+        const detailUrl = `https://api.zsxq.com/v2/topics/${topicId}`;
+        const detailResp = await browserJsonRequest(page, detailUrl);
+        if (detailResp.status === 404) {
+            throw new CliError('NOT_FOUND', `Topic ${topicId} not found`);
+        }
+        if (!detailResp.ok) {
+            throw new CliError('FETCH_ERROR', detailResp.error || `Failed to fetch topic ${topicId}`, `Checked endpoint: ${detailUrl}`);
+        }
+        const commentsResp = await fetchFirstJson(page, [
+            `https://api.zsxq.com/v2/topics/${topicId}/comments?sort=asc&count=${commentLimit}`,
+        ]);
+        const topic = getTopicFromResponse(detailResp.data);
+        if (!topic)
+            throw new CliError('NOT_FOUND', `Topic ${topicId} not found`);
+        const comments = getCommentsFromResponse(commentsResp.data);
+        const row = toTopicRow({
+            ...topic,
+            comments,
+            comments_count: topic.comments_count ?? comments.length,
+        });
+        return [{
+                ...row,
+                comment_preview: summarizeComments(comments, 5),
+                url: getTopicUrl(topic.topic_id ?? topicId),
+            }];
+    },
+});

package/dist/clis/zsxq/topic.test.d.ts

@@ -0,0 +1 @@
+import './topic.js';

package/dist/clis/zsxq/topic.test.js

@@ -0,0 +1,29 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './topic.js';
+describe('zsxq topic command', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('maps topic detail 404 responses to NOT_FOUND before fetching comments', async () => {
+        const command = getRegistry().get('zsxq/topic');
+        expect(command?.func).toBeTypeOf('function');
+        const mockPage = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce(true)
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 404,
+                url: 'https://api.zsxq.com/v2/topics/404',
+                data: null,
+            }),
+        };
+        await expect(command.func(mockPage, { id: '404', comment_limit: 20 })).rejects.toMatchObject({
+            code: 'NOT_FOUND',
+            message: 'Topic 404 not found',
+        });
+        expect(mockPage.goto).toHaveBeenCalledWith('https://wx.zsxq.com');
+        expect(mockPage.evaluate).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/clis/zsxq/topics.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/zsxq/topics.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.js';
+import { getActiveGroupId, ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getTopicsFromResponse, toTopicRow, } from './utils.js';
+cli({
+    site: 'zsxq',
+    name: 'topics',
+    description: '获取当前星球的话题列表',
+    domain: 'wx.zsxq.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of topics to return' },
+        { name: 'group_id', help: 'Optional group id; defaults to the active group in Chrome' },
+    ],
+    columns: ['topic_id', 'type', 'author', 'title', 'comments', 'likes', 'time', 'url'],
+    func: async (page, kwargs) => {
+        await ensureZsxqPage(page);
+        await ensureZsxqAuth(page);
+        const limit = Math.max(1, Number(kwargs.limit) || 20);
+        const groupId = String(kwargs.group_id || await getActiveGroupId(page));
+        const { data } = await fetchFirstJson(page, [
+            `https://api.zsxq.com/v2/groups/${groupId}/topics?scope=all&count=${limit}`,
+        ]);
+        return getTopicsFromResponse(data).slice(0, limit).map(toTopicRow);
+    },
+});

package/dist/clis/zsxq/topics.test.d.ts

@@ -0,0 +1 @@
+import './topics.js';

package/dist/clis/zsxq/topics.test.js

@@ -0,0 +1,24 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './topics.js';
+describe('zsxq topics command', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('requires an explicit group_id when there is no active group context', async () => {
+        const command = getRegistry().get('zsxq/topics');
+        expect(command?.func).toBeTypeOf('function');
+        const mockPage = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce(true)
+                .mockResolvedValueOnce(null),
+        };
+        await expect(command.func(mockPage, { limit: 20 })).rejects.toMatchObject({
+            code: 'ARGUMENT',
+            message: 'Cannot determine active group_id',
+        });
+        expect(mockPage.goto).toHaveBeenCalledWith('https://wx.zsxq.com');
+        expect(mockPage.evaluate).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/clis/zsxq/utils.d.ts

@@ -0,0 +1,97 @@
+import type { IPage } from '../../types.js';
+export interface ZsxqUser {
+    user_id?: number;
+    name?: string;
+    avatar_url?: string;
+}
+export interface ZsxqGroup {
+    group_id?: number;
+    name?: string;
+    description?: string;
+    background_url?: string;
+    owner?: ZsxqUser;
+    statistics?: {
+        topics_count?: number;
+        answers_count?: number;
+        comments_count?: number;
+        likes_count?: number;
+        subscriptions_count?: number;
+    };
+    category?: {
+        title?: string;
+    };
+    user_specific?: {
+        join_time?: string;
+        validity?: {
+            end_time?: string;
+        };
+    };
+}
+export interface ZsxqComment {
+    comment_id?: number;
+    create_time?: string;
+    text?: string;
+    owner?: ZsxqUser;
+    likes_count?: number;
+    rewards_count?: number;
+    repliee?: ZsxqUser;
+}
+export interface ZsxqTopic {
+    topic_id?: number;
+    create_time?: string;
+    comments_count?: number;
+    likes_count?: number;
+    readers_count?: number;
+    reading_count?: number;
+    rewards_count?: number;
+    title?: string;
+    type?: string;
+    group?: ZsxqGroup;
+    owner?: ZsxqUser;
+    user_specific?: Record<string, unknown>;
+    talk?: {
+        owner?: ZsxqUser;
+        text?: string;
+    };
+    question?: {
+        owner?: ZsxqUser;
+        text?: string;
+    };
+    answer?: {
+        owner?: ZsxqUser;
+        text?: string;
+    };
+    task?: {
+        owner?: ZsxqUser;
+        text?: string;
+    };
+    solution?: {
+        owner?: ZsxqUser;
+        text?: string;
+    };
+    show_comments?: ZsxqComment[];
+    comments?: ZsxqComment[];
+}
+export interface BrowserFetchResult {
+    ok: boolean;
+    url?: string;
+    status?: number;
+    error?: string;
+    data?: unknown;
+}
+export declare function ensureZsxqPage(page: IPage): Promise<void>;
+export declare function ensureZsxqAuth(page: IPage): Promise<void>;
+export declare function getCookieValue(page: IPage, name: string): Promise<string | undefined>;
+export declare function getActiveGroupId(page: IPage): Promise<string>;
+export declare function browserJsonRequest(page: IPage, path: string): Promise<BrowserFetchResult>;
+export declare function fetchFirstJson(page: IPage, paths: string[]): Promise<BrowserFetchResult>;
+export declare function unwrapRespData<T>(payload: unknown): T;
+export declare function getTopicsFromResponse(payload: unknown): ZsxqTopic[];
+export declare function getCommentsFromResponse(payload: unknown): ZsxqComment[];
+export declare function getGroupsFromResponse(payload: unknown): ZsxqGroup[];
+export declare function getTopicFromResponse(payload: unknown): ZsxqTopic | null;
+export declare function getTopicAuthor(topic: ZsxqTopic): string;
+export declare function getTopicText(topic: ZsxqTopic): string;
+export declare function getTopicUrl(topicId: number | string | undefined): string;
+export declare function summarizeComments(comments: ZsxqComment[], limit?: number): string;
+export declare function toTopicRow(topic: ZsxqTopic): Record<string, unknown>;