@jackwener/opencli 1.5.5 → 1.5.7

package/dist/clis/youtube/search.js

@@ -11,32 +11,60 @@ cli({
     args: [
         { name: 'query', required: true, positional: true, help: 'Search query' },
         { name: 'limit', type: 'int', default: 20, help: 'Max results (max 50)' },
+        { name: 'type', default: '', help: 'Filter type: shorts, video, channel, playlist' },
+        { name: 'upload', default: '', help: 'Upload date: hour, today, week, month, year' },
+        { name: 'sort', default: '', help: 'Sort by: relevance, date, views, rating' },
     ],
-    columns: ['rank', 'title', 'channel', 'views', 'duration', 'url'],
+    columns: ['rank', 'title', 'channel', 'views', 'duration', 'published', 'url'],
     func: async (page, kwargs) => {
         const limit = Math.min(kwargs.limit || 20, 50);
-        await page.goto('https://www.youtube.com');
-        await page.wait(2);
+        const query = encodeURIComponent(kwargs.query);
+        // Build search URL with filter params
+        // YouTube uses sp= parameter for filters — we use the URL approach for reliability
+        const spMap = {
+            // type filters
+            'shorts': 'EgIQCQ%3D%3D', // Shorts (type=9)
+            'video': 'EgIQAQ%3D%3D',
+            'channel': 'EgIQAg%3D%3D',
+            'playlist': 'EgIQAw%3D%3D',
+            // upload date filters (can be combined with type via URL)
+            'hour': 'EgIIAQ%3D%3D',
+            'today': 'EgIIAg%3D%3D',
+            'week': 'EgIIAw%3D%3D',
+            'month': 'EgIIBA%3D%3D',
+            'year': 'EgIIBQ%3D%3D',
+        };
+        const sortMap = {
+            'date': 'CAI%3D',
+            'views': 'CAM%3D',
+            'rating': 'CAE%3D',
+        };
+        // YouTube only supports a single sp= parameter — pick the most specific filter.
+        // Priority: type > upload > sort (type is the most common use case)
+        let sp = '';
+        if (kwargs.type && spMap[kwargs.type])
+            sp = spMap[kwargs.type];
+        else if (kwargs.upload && spMap[kwargs.upload])
+            sp = spMap[kwargs.upload];
+        else if (kwargs.sort && sortMap[kwargs.sort])
+            sp = sortMap[kwargs.sort];
+        let url = `https://www.youtube.com/results?search_query=${query}`;
+        if (sp)
+            url += `&sp=${sp}`;
+        await page.goto(url);
+        await page.wait(3);
         const data = await page.evaluate(`
       (async () => {
-        const cfg = window.ytcfg?.data_ || {};
-        const apiKey = cfg.INNERTUBE_API_KEY;
-        const context = cfg.INNERTUBE_CONTEXT;
-        if (!apiKey || !context) return {error: 'YouTube config not found'};
+        const data = window.ytInitialData;
+        if (!data) return {error: 'YouTube data not found'};
 
-        const resp = await fetch('/youtubei/v1/search?key=' + apiKey + '&prettyPrint=false', {
-          method: 'POST', credentials: 'include',
-          headers: {'Content-Type': 'application/json'},
-          body: JSON.stringify({context, query: '${kwargs.query.replace(/'/g, "\\'")}'})
-        });
-        if (!resp.ok) return {error: 'HTTP ' + resp.status};
-
-        const data = await resp.json();
         const contents = data.contents?.twoColumnSearchResultsRenderer?.primaryContents?.sectionListRenderer?.contents || [];
         const videos = [];
         for (const section of contents) {
-          for (const item of (section.itemSectionRenderer?.contents || [])) {
-            if (item.videoRenderer && videos.length < ${limit}) {
+          const items = section.itemSectionRenderer?.contents || section.reelShelfRenderer?.items || [];
+          for (const item of items) {
+            if (videos.length >= ${limit}) break;
+            if (item.videoRenderer) {
               const v = item.videoRenderer;
               videos.push({
                 rank: videos.length + 1,
@@ -44,8 +72,20 @@ cli({
                 channel: v.ownerText?.runs?.[0]?.text || '',
                 views: v.viewCountText?.simpleText || v.shortViewCountText?.simpleText || '',
                 duration: v.lengthText?.simpleText || 'LIVE',
+                published: v.publishedTimeText?.simpleText || '',
                 url: 'https://www.youtube.com/watch?v=' + v.videoId
               });
+            } else if (item.reelItemRenderer) {
+              const r = item.reelItemRenderer;
+              videos.push({
+                rank: videos.length + 1,
+                title: r.headline?.simpleText || '',
+                channel: r.navigationEndpoint?.reelWatchEndpoint?.overlay?.reelPlayerOverlayRenderer?.reelPlayerHeaderSupportedRenderers?.reelPlayerHeaderRenderer?.channelTitleText?.runs?.[0]?.text || '',
+                views: r.viewCountText?.simpleText || '',
+                duration: 'SHORT',
+                published: r.publishedTimeText?.simpleText || '',
+                url: 'https://www.youtube.com/shorts/' + r.videoId
+              });
             }
           }
         }

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/zhihu/question.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { AuthRequiredError } from '../../errors.js';
+import { AuthRequiredError, CliError } from '../../errors.js';
 cli({
     site: 'zhihu',
     name: 'question',
@@ -13,23 +13,25 @@ cli({
     columns: ['rank', 'author', 'votes', 'content'],
     func: async (page, kwargs) => {
         const { id, limit = 5 } = kwargs;
+        const answerLimit = Number(limit);
         const stripHtml = (html) => (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').trim();
-        // Fetch question detail and answers in parallel via evaluate
-        const result = await page.evaluate(`
-      async () => {
-        const [qResp, aResp] = await Promise.all([
-          fetch('https://www.zhihu.com/api/v4/questions/${id}?include=data[*].detail,excerpt,answer_count,follower_count,visit_count', {credentials: 'include'}),
-          fetch('https://www.zhihu.com/api/v4/questions/${id}/answers?limit=${limit}&offset=0&sort_by=default&include=data[*].content,voteup_count,comment_count,author', {credentials: 'include'})
-        ]);
-        if (!qResp.ok || !aResp.ok) return { error: true };
-        const q = await qResp.json();
-        const a = await aResp.json();
-        return { question: q, answers: a.data || [] };
-      }
-    `);
-        if (!result || result.error)
-            throw new AuthRequiredError('www.zhihu.com', 'Failed to fetch question data from Zhihu');
-        const answers = (result.answers ?? []).slice(0, Number(limit)).map((a, i) => ({
+        // Only fetch answers here. The question detail endpoint is not used by the
+        // current CLI output and can fail independently, which would incorrectly
+        // turn a successful answers response into a login error.
+        const result = await page.evaluate(async ({ questionId, answerLimit }) => {
+            const aResp = await fetch(`https://www.zhihu.com/api/v4/questions/${questionId}/answers?limit=${answerLimit}&offset=0&sort_by=default&include=data[*].content,voteup_count,comment_count,author`, { credentials: 'include' });
+            if (!aResp.ok)
+                return { ok: false, status: aResp.status };
+            const a = await aResp.json();
+            return { ok: true, answers: Array.isArray(a?.data) ? a.data : [] };
+        }, { questionId: String(id), answerLimit });
+        if (!result?.ok) {
+            if (result?.status === 401 || result?.status === 403) {
+                throw new AuthRequiredError('www.zhihu.com', 'Failed to fetch question data from Zhihu');
+            }
+            throw new CliError('FETCH_ERROR', `Zhihu question answers request failed with HTTP ${result?.status ?? 'unknown'}`, 'Try again later or rerun with -v for more detail');
+        }
+        const answers = result.answers.slice(0, answerLimit).map((a, i) => ({
             rank: i + 1,
             author: a.author?.name ?? 'anonymous',
             votes: a.voteup_count ?? 0,

package/dist/clis/zhihu/question.test.d.ts

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

package/dist/clis/zhihu/question.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import { AuthRequiredError } from '../../errors.js';
+import './question.js';
+describe('zhihu question', () => {
+    it('returns answers even when the unused question detail request fails', async () => {
+        const cmd = getRegistry().get('zhihu/question');
+        expect(cmd?.func).toBeTypeOf('function');
+        const evaluate = vi.fn().mockImplementation(async (_fn, args) => {
+            expect(args).toEqual({ questionId: '2021881398772981878', answerLimit: 3 });
+            return {
+                ok: true,
+                answers: [
+                    {
+                        author: { name: 'alice' },
+                        voteup_count: 12,
+                        content: '<p>Hello <b>Zhihu</b></p>',
+                    },
+                ],
+            };
+        });
+        const page = {
+            evaluate,
+        };
+        await expect(cmd.func(page, { id: '2021881398772981878', limit: 3 })).resolves.toEqual([
+            {
+                rank: 1,
+                author: 'alice',
+                votes: 12,
+                content: 'Hello Zhihu',
+            },
+        ]);
+        expect(evaluate).toHaveBeenCalledTimes(1);
+    });
+    it('maps auth-like answer failures to AuthRequiredError', async () => {
+        const cmd = getRegistry().get('zhihu/question');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = {
+            evaluate: vi.fn().mockResolvedValue({ ok: false, status: 403 }),
+        };
+        await expect(cmd.func(page, { id: '2021881398772981878', limit: 3 })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+    it('preserves non-auth fetch failures as CliError instead of login errors', async () => {
+        const cmd = getRegistry().get('zhihu/question');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = {
+            evaluate: vi.fn().mockResolvedValue({ ok: false, status: 500 }),
+        };
+        await expect(cmd.func(page, { id: '2021881398772981878', limit: 3 })).rejects.toMatchObject({
+            code: 'FETCH_ERROR',
+            message: 'Zhihu question answers request failed with HTTP 500',
+        });
+    });
+});

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';