@jackwener/opencli 1.5.5 → 1.5.7

package/src/clis/youtube/video.ts

@@ -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({
@@ -17,24 +17,29 @@ 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;
@@ -46,8 +51,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
@@ -75,8 +78,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/src/clis/zhihu/question.test.ts

@@ -0,0 +1,71 @@
+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: unknown, args: { questionId: string; answerLimit: number }) => {
+      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,
+    } as any;
+
+    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 }),
+    } as any;
+
+    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 }),
+    } as any;
+
+    await expect(
+      cmd!.func!(page, { id: '2021881398772981878', limit: 3 }),
+    ).rejects.toMatchObject({
+      code: 'FETCH_ERROR',
+      message: 'Zhihu question answers request failed with HTTP 500',
+    });
+  });
+});

package/src/clis/zhihu/question.ts

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { AuthRequiredError } from '../../errors.js';
+import { AuthRequiredError, CliError } from '../../errors.js';
 
 cli({
   site: 'zhihu',
@@ -14,27 +14,39 @@ cli({
   columns: ['rank', 'author', 'votes', 'content'],
   func: async (page, kwargs) => {
     const { id, limit = 5 } = kwargs;
+    const answerLimit = Number(limit);
 
     const stripHtml = (html: string) =>
       (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();
+    // 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 as any).evaluate(
+      async ({ questionId, answerLimit }: { questionId: string; answerLimit: number }) => {
+        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 as const, status: aResp.status };
         const a = await aResp.json();
-        return { question: q, answers: a.data || [] };
-      }
-    `);
+        return { ok: true as const, answers: Array.isArray(a?.data) ? a.data : [] };
+      },
+      { questionId: String(id), answerLimit },
+    );
 
-    if (!result || result.error) throw new AuthRequiredError('www.zhihu.com', 'Failed to fetch question data from Zhihu');
+    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, Number(limit)).map((a: any, i: number) => ({
+    const answers = result.answers.slice(0, answerLimit).map((a: any, i: number) => ({
       rank: i + 1,
       author: a.author?.name ?? 'anonymous',
       votes: a.voteup_count ?? 0,

package/src/clis/zsxq/dynamics.ts

@@ -0,0 +1,60 @@
+import { cli, Strategy } from '../../registry.js';
+import type { ZsxqTopic } from './utils.js';
+import {
+  ensureZsxqAuth,
+  ensureZsxqPage,
+  fetchFirstJson,
+  toTopicRow,
+  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 as any)?.resp_data || data;
+    const dynamics = respData?.dynamics || [];
+    return dynamics.slice(0, limit).map((d: any) => {
+      const topic = d.topic as ZsxqTopic | undefined;
+      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/src/clis/zsxq/groups.ts

@@ -0,0 +1,41 @@
+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/src/clis/zsxq/search.test.ts

@@ -0,0 +1,29 @@
+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),
+    } as any;
+
+    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/src/clis/zsxq/search.ts

@@ -0,0 +1,54 @@
+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/src/clis/zsxq/topic.test.ts

@@ -0,0 +1,34 @@
+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,
+        }),
+    } as any;
+
+    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/src/clis/zsxq/topic.ts

@@ -0,0 +1,68 @@
+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/src/clis/zsxq/topics.test.ts

@@ -0,0 +1,29 @@
+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),
+    } as any;
+
+    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/src/clis/zsxq/topics.ts

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