@jackwener/opencli 1.7.7 → 1.7.9

package/clis/zhihu/collection.test.js

@@ -0,0 +1,290 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+// Mock logger
+vi.mock('@jackwener/opencli/logger', () => ({
+  log: {
+    info: vi.fn(),
+    status: vi.fn(),
+    success: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    step: vi.fn(),
+    stepResult: vi.fn(),
+  },
+}));
+
+import './collection.js';
+
+describe('zhihu collection', () => {
+  it('returns collection items from the Zhihu API', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    const goto = vi.fn().mockResolvedValue(undefined);
+    const evaluate = vi.fn().mockImplementation(async (js) => {
+      expect(js).toContain('collections/83283292/items');
+      expect(js).toContain("credentials: 'include'");
+      return {
+        data: [
+          {
+            content: {
+              type: 'answer',
+              id: 123456,
+              question: { id: 789012, title: 'Test Question' },
+              author: { name: 'test_author' },
+              voteup_count: 42,
+              content: '<p>Test answer content</p>',
+              url: 'https://www.zhihu.com/question/789012/answer/123456',
+            },
+          },
+        ],
+        paging: { totals: 100 },
+      };
+    });
+
+    const page = { goto, evaluate };
+
+    const result = await cmd.func(page, { id: '83283292', offset: 0, limit: 20 });
+    
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      rank: 1,
+      type: 'answer',
+      title: 'Test Question',
+      author: 'test_author',
+      votes: 42,
+      url: 'https://www.zhihu.com/question/789012/answer/123456',
+    });
+
+    expect(goto).toHaveBeenCalledWith('https://www.zhihu.com');
+    expect(evaluate).toHaveBeenCalledTimes(1);
+  });
+
+  it('handles article type items', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    const evaluate = vi.fn().mockResolvedValue({
+      data: [
+        {
+          content: {
+            type: 'article',
+            id: 987654,
+            title: 'Test Article',
+            author: { name: 'article_author' },
+            voteup_count: 100,
+            content: '<p>Article content</p>',
+            url: 'https://zhuanlan.zhihu.com/p/987654',
+          },
+        },
+      ],
+      paging: { totals: 50 },
+    });
+
+    const page = { goto: vi.fn().mockResolvedValue(undefined), evaluate };
+
+    const result = await cmd.func(page, { id: '83283292', offset: 0, limit: 20 });
+    
+    expect(result[0]).toMatchObject({
+      type: 'article',
+      title: 'Test Article',
+      author: 'article_author',
+      votes: 100,
+    });
+  });
+
+  it('handles pin type items', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    const evaluate = vi.fn().mockResolvedValue({
+      data: [
+        {
+          content: {
+            type: 'pin',
+            id: 111222,
+            author: { name: 'pin_author' },
+            reaction_count: 25,
+            content: [{ content: 'Pin content here' }],
+            url: 'https://www.zhihu.com/pin/111222',
+          },
+        },
+      ],
+      paging: { totals: 30 },
+    });
+
+    const page = { goto: vi.fn().mockResolvedValue(undefined), evaluate };
+
+    const result = await cmd.func(page, { id: '83283292', offset: 0, limit: 20 });
+    
+    expect(result[0]).toMatchObject({
+      type: 'pin',
+      title: '想法',
+      author: 'pin_author',
+      votes: 25,
+    });
+  });
+
+  it('maps auth failures to AuthRequiredError', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue({ __httpError: 401 }),
+    };
+
+    await expect(
+      cmd.func(page, { id: '83283292', offset: 0, limit: 20 }),
+    ).rejects.toBeInstanceOf(AuthRequiredError);
+  });
+
+  it('maps 403 errors to AuthRequiredError', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue({ __httpError: 403 }),
+    };
+
+    await expect(
+      cmd.func(page, { id: '83283292', offset: 0, limit: 20 }),
+    ).rejects.toBeInstanceOf(AuthRequiredError);
+  });
+
+  it('preserves non-auth fetch failures as CommandExecutionError', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue({ __httpError: 500 }),
+    };
+
+    await expect(
+      cmd.func(page, { id: '83283292', offset: 0, limit: 20 }),
+    ).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('handles null evaluate response as fetch error', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue(null),
+    };
+
+    await expect(
+      cmd.func(page, { id: '83283292', offset: 0, limit: 20 }),
+    ).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('rejects non-numeric collection IDs', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    const page = { goto: vi.fn(), evaluate: vi.fn() };
+
+    await expect(
+      cmd.func(page, { id: "abc'; alert(1); //", offset: 0, limit: 20 }),
+    ).rejects.toBeInstanceOf(ArgumentError);
+
+    expect(page.goto).not.toHaveBeenCalled();
+    expect(page.evaluate).not.toHaveBeenCalled();
+  });
+
+  it('respects pagination offset', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    const evaluate = vi.fn().mockResolvedValue({
+      data: [
+        {
+          content: {
+            type: 'answer',
+            id: 1,
+            question: { id: 1, title: 'Test' },
+            author: { name: 'author' },
+            voteup_count: 10,
+            content: 'Content',
+          },
+        },
+      ],
+      paging: { totals: 100 },
+    });
+
+    const page = { goto: vi.fn().mockResolvedValue(undefined), evaluate };
+
+    const result = await cmd.func(page, { id: '83283292', offset: 40, limit: 20 });
+    
+    expect(result[0].rank).toBe(41); // offset 40 + index 0 + 1
+    expect(evaluate).toHaveBeenCalledWith(
+      expect.stringContaining('offset=40'),
+    );
+  });
+
+  it('rejects invalid offset and limit before navigation', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    const page = { goto: vi.fn(), evaluate: vi.fn() };
+
+    await expect(cmd.func(page, { id: '83283292', offset: -1, limit: 20 }))
+      .rejects.toBeInstanceOf(ArgumentError);
+    await expect(cmd.func(page, { id: '83283292', offset: 0, limit: 0 }))
+      .rejects.toBeInstanceOf(ArgumentError);
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('paginates until requested limit and deduplicates items', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    const evaluate = vi.fn()
+      .mockResolvedValueOnce({
+        data: [
+          {
+            content: {
+              type: 'answer',
+              id: 1,
+              question: { id: 1, title: 'A' },
+              author: { name: 'alice' },
+              content: 'A',
+            },
+          },
+        ],
+        paging: { totals: 3, is_end: false, next: 'https://www.zhihu.com/api/v4/collections/83283292/items?offset=1&limit=1' },
+      })
+      .mockResolvedValueOnce({
+        data: [
+          {
+            content: {
+              type: 'answer',
+              id: 1,
+              question: { id: 1, title: 'A duplicate' },
+              author: { name: 'alice' },
+              content: 'A',
+            },
+          },
+          {
+            content: {
+              type: 'answer',
+              id: 2,
+              question: { id: 2, title: 'B' },
+              author: { name: 'bob' },
+              content: 'B',
+            },
+          },
+        ],
+        paging: { totals: 3, is_end: true },
+      });
+
+    const page = { goto: vi.fn().mockResolvedValue(undefined), evaluate };
+
+    const result = await cmd.func(page, { id: '83283292', offset: 0, limit: 2 });
+
+    expect(result.map((row) => row.title)).toEqual(['A', 'B']);
+    expect(evaluate).toHaveBeenCalledTimes(2);
+    expect(evaluate.mock.calls[1][0]).toContain('offset=1');
+  });
+
+  it('throws EmptyResultError for empty collection', async () => {
+    const cmd = getRegistry().get('zhihu/collection');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue({
+        data: [],
+        paging: { totals: 0 },
+      }),
+    };
+
+    await expect(cmd.func(page, { id: '83283292', offset: 0, limit: 20 }))
+      .rejects.toBeInstanceOf(EmptyResultError);
+  });
+});

package/clis/zhihu/collections.js

@@ -0,0 +1,127 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { log } from '@jackwener/opencli/logger';
+
+function validatePositiveInt(value, name) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n <= 0) {
+    throw new ArgumentError(`zhihu collections --${name} must be a positive integer`, 'Example: opencli zhihu collections --limit 20');
+  }
+  return n;
+}
+
+async function fetchJson(page, url, errorLabel) {
+  const data = await page.evaluate(`
+    (async () => {
+      const r = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
+      if (!r.ok) return { __httpError: r.status };
+      return await r.json();
+    })()
+  `);
+
+  if (!data || data.__httpError) {
+    const status = data?.__httpError;
+    if (status === 401 || status === 403) {
+      throw new AuthRequiredError('www.zhihu.com', `${errorLabel} from Zhihu failed. Please ensure you are logged in.`);
+    }
+    throw new CommandExecutionError(
+      status ? `${errorLabel} from Zhihu failed (HTTP ${status})` : `${errorLabel} from Zhihu failed`,
+      'Try again later or rerun with -v for more detail',
+    );
+  }
+  return data;
+}
+
+function collectionKey(item) {
+  return String(item?.id || item?.url || item?.title || '');
+}
+
+cli({
+  site: 'zhihu',
+  name: 'collections',
+  description: '知乎收藏夹列表（需要登录）',
+  domain: 'www.zhihu.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: '每页数量（最大 20）' },
+  ],
+  columns: ['rank', 'title', 'item_count', 'description', 'collection_id'],
+  func: async (page, kwargs) => {
+    const { limit = 20 } = kwargs;
+    const requestedLimit = validatePositiveInt(limit, 'limit');
+
+    // 先访问知乎主页建立 session
+    await page.goto('https://www.zhihu.com');
+    // 获取当前用户的 url_token
+    const meData = await fetchJson(page, 'https://www.zhihu.com/api/v4/me?include=url_token', 'Zhihu user info request');
+
+    const urlToken = meData.url_token;
+    if (!urlToken) {
+      throw new CommandExecutionError('Failed to get user url_token from Zhihu', 'Please ensure you are logged in.');
+    }
+
+    const collected = [];
+    const seen = new Set();
+    let totals = 0;
+    let offset = 0;
+    const pageLimit = Math.min(requestedLimit, 20);
+    const maxPages = Math.ceil(requestedLimit / pageLimit) + 2;
+
+    for (let pageIndex = 0; pageIndex < maxPages && collected.length < requestedLimit; pageIndex += 1) {
+      const currentFetchLimit = Math.min(pageLimit, requestedLimit - collected.length);
+      const url = `https://www.zhihu.com/api/v4/people/${urlToken}/collections?include=data%5B*%5D.updated_time&offset=${offset}&limit=${currentFetchLimit}`;
+      const data = await fetchJson(page, url, 'Zhihu favorite collections request');
+      const items = Array.isArray(data.data) ? data.data : [];
+      const paging = data.paging || {};
+      totals = Number(paging.totals || totals || 0);
+
+      for (const item of items) {
+        const key = collectionKey(item);
+        if (key && !seen.has(key)) {
+          seen.add(key);
+          collected.push(item);
+        }
+        if (collected.length >= requestedLimit) break;
+      }
+
+      if (items.length === 0 || paging.is_end || collected.length >= requestedLimit) break;
+      if (typeof paging.next === 'string') {
+        try {
+          const nextUrl = new URL(paging.next);
+          const parsedOffset = Number(nextUrl.searchParams.get('offset'));
+          if (Number.isInteger(parsedOffset) && parsedOffset > offset) {
+            offset = parsedOffset;
+            continue;
+          }
+        } catch {}
+      }
+      if (items.length < currentFetchLimit) break;
+      const fallbackOffset = offset + items.length;
+      if (fallbackOffset <= offset) break;
+      offset = fallbackOffset;
+      if (totals && offset >= totals) break;
+    }
+
+    if (totals > 0) {
+      log.info(`共有 ${totals} 个收藏夹`);
+    }
+
+    if (collected.length === 0) {
+      throw new EmptyResultError('zhihu collections', 'No favorite collections were returned for the logged-in user.');
+    }
+
+    return collected.slice(0, requestedLimit).map((item, i) => ({
+      rank: i + 1,
+      title: item.title || '未命名',
+      item_count: item.item_count ?? item.answer_count ?? 0,
+      description: item.description || '',
+      collection_id: String(item.id || ''),
+    }));
+  },
+});
+
+export const __test__ = {
+  validatePositiveInt,
+  collectionKey,
+};

package/clis/zhihu/collections.test.js

@@ -0,0 +1,182 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+// Mock logger
+vi.mock('@jackwener/opencli/logger', () => ({
+  log: {
+    info: vi.fn(),
+    status: vi.fn(),
+    success: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    step: vi.fn(),
+    stepResult: vi.fn(),
+  },
+}));
+
+import './collections.js';
+
+describe('zhihu collections', () => {
+  it('returns list of collections', async () => {
+    const cmd = getRegistry().get('zhihu/collections');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    const goto = vi.fn().mockResolvedValue(undefined);
+    let callCount = 0;
+    const evaluate = vi.fn().mockImplementation(async (js) => {
+      callCount++;
+      if (callCount === 1) {
+        expect(js).toContain('api/v4/me');
+        return { url_token: 'testuser', id: 'abc123' };
+      }
+      expect(js).toContain('people/testuser/collections');
+      return {
+        data: [
+          { id: 123456, title: '我的收藏夹', item_count: 42, description: '待读' },
+          { id: 789012, title: '技术文章', item_count: 100, description: '' },
+        ],
+        paging: { totals: 2 },
+      };
+    });
+
+    const page = { goto, evaluate };
+    const result = await cmd.func(page, { limit: 20 });
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({
+      rank: 1,
+      title: '我的收藏夹',
+      item_count: 42,
+      description: '待读',
+      collection_id: '123456',
+    });
+    expect(result[1]).toMatchObject({
+      rank: 2,
+      title: '技术文章',
+      item_count: 100,
+      description: '',
+      collection_id: '789012',
+    });
+    expect(evaluate).toHaveBeenCalledTimes(2);
+  });
+
+  it('returns list of collections with answer_count fallback', async () => {
+    const cmd = getRegistry().get('zhihu/collections');
+    let callCount = 0;
+    const evaluate = vi.fn().mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) {
+        return { url_token: 'testuser', id: 'abc123' };
+      }
+      return {
+        data: [{ id: 111, title: '默认收藏夹', answer_count: 15, description: 'test desc' }],
+        paging: { totals: 1 },
+      };
+    });
+
+    const page = { goto: vi.fn().mockResolvedValue(undefined), evaluate };
+    const result = await cmd.func(page, { limit: 20 });
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      title: '默认收藏夹',
+      item_count: 15,
+      description: 'test desc',
+      collection_id: '111',
+    });
+  });
+
+  it('maps auth failures to AuthRequiredError', async () => {
+    const cmd = getRegistry().get('zhihu/collections');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue({ __httpError: 401 }),
+    };
+
+    await expect(cmd.func(page, { limit: 20 }))
+      .rejects.toBeInstanceOf(AuthRequiredError);
+  });
+
+  it('handles missing url_token', async () => {
+    const cmd = getRegistry().get('zhihu/collections');
+    let callCount = 0;
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockImplementation(async () => {
+        callCount++;
+        if (callCount === 1) return { id: 'abc123' };
+        return {};
+      }),
+    };
+
+    await expect(cmd.func(page, { limit: 20 }))
+      .rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('respects limit parameter', async () => {
+    const cmd = getRegistry().get('zhihu/collections');
+    let callCount = 0;
+    const evaluate = vi.fn().mockImplementation(async (js) => {
+      callCount++;
+      if (callCount === 1) {
+        return { url_token: 'testuser', id: 'abc123' };
+      }
+      expect(js).toContain('limit=10');
+      return {
+        data: [{ id: 1, title: 'Test', answer_count: 0, description: '' }],
+        paging: { totals: 1 },
+      };
+    });
+
+    const page = { goto: vi.fn().mockResolvedValue(undefined), evaluate };
+    const result = await cmd.func(page, { limit: 10 });
+
+    expect(result).toHaveLength(1);
+    expect(evaluate).toHaveBeenCalledTimes(2);
+  });
+
+  it('rejects invalid limits before navigation', async () => {
+    const cmd = getRegistry().get('zhihu/collections');
+    const page = { goto: vi.fn(), evaluate: vi.fn() };
+
+    await expect(cmd.func(page, { limit: 0 })).rejects.toBeInstanceOf(ArgumentError);
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('paginates collection list and deduplicates by collection id', async () => {
+    const cmd = getRegistry().get('zhihu/collections');
+    const evaluate = vi.fn()
+      .mockResolvedValueOnce({ url_token: 'testuser', id: 'abc123' })
+      .mockResolvedValueOnce({
+        data: [{ id: 1, title: 'A', item_count: 1, description: '' }],
+        paging: { totals: 3, is_end: false, next: 'https://www.zhihu.com/api/v4/people/testuser/collections?offset=1&limit=1' },
+      })
+      .mockResolvedValueOnce({
+        data: [
+          { id: 1, title: 'A duplicate', item_count: 1, description: '' },
+          { id: 2, title: 'B', item_count: 2, description: '' },
+        ],
+        paging: { totals: 3, is_end: true },
+      });
+    const page = { goto: vi.fn().mockResolvedValue(undefined), evaluate };
+
+    const result = await cmd.func(page, { limit: 2 });
+
+    expect(result.map((row) => row.title)).toEqual(['A', 'B']);
+    expect(evaluate).toHaveBeenCalledTimes(3);
+    expect(evaluate.mock.calls[2][0]).toContain('offset=1');
+  });
+
+  it('throws EmptyResultError when no collections are returned', async () => {
+    const cmd = getRegistry().get('zhihu/collections');
+    const evaluate = vi.fn()
+      .mockResolvedValueOnce({ url_token: 'testuser', id: 'abc123' })
+      .mockResolvedValueOnce({ data: [], paging: { totals: 0, is_end: true } });
+    const page = { goto: vi.fn().mockResolvedValue(undefined), evaluate };
+
+    await expect(cmd.func(page, { limit: 20 })).rejects.toBeInstanceOf(EmptyResultError);
+  });
+});