@jackwener/opencli 1.7.8 → 1.7.10

package/clis/zhihu/answer.test.js

@@ -2,80 +2,53 @@ import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
 import './answer.js';
 describe('zhihu answer', () => {
-    it('rejects create mode when the current user already answered the question', async () => {
+    it('registers as a cookie browser command', () => {
         const cmd = getRegistry().get('zhihu/answer');
-        expect(cmd?.func).toBeTypeOf('function');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn()
-                .mockResolvedValueOnce({ slug: 'alice' })
-                .mockResolvedValueOnce({ entryPathSafe: false, hasExistingAnswerByCurrentUser: true }),
-        };
-        await expect(cmd.func(page, { target: 'question:1', text: 'hello', execute: true })).rejects.toMatchObject({ code: 'ACTION_NOT_AVAILABLE' });
-    });
-    it('rejects anonymous mode instead of toggling it', async () => {
-        const cmd = getRegistry().get('zhihu/answer');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn()
-                .mockResolvedValueOnce({ slug: 'alice' })
-                .mockResolvedValueOnce({ entryPathSafe: true, hasExistingAnswerByCurrentUser: false })
-                .mockResolvedValueOnce({ editorState: 'fresh_empty', anonymousMode: 'on' }),
-        };
-        await expect(cmd.func(page, { target: 'question:1', text: 'hello', execute: true })).rejects.toMatchObject({ code: 'ACTION_NOT_AVAILABLE' });
+        expect(cmd).toBeDefined();
+        expect(cmd.strategy).toBe('cookie');
+        expect(cmd.browser).toBe(true);
     });
-    it('rejects when a unique safe answer composer cannot be proven', async () => {
+    it('creates an answer via API and returns result', async () => {
         const cmd = getRegistry().get('zhihu/answer');
         const page = {
             goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
             evaluate: vi.fn()
                 .mockResolvedValueOnce({ slug: 'alice' })
-                .mockResolvedValueOnce({ entryPathSafe: false, hasExistingAnswerByCurrentUser: false }),
+                .mockResolvedValueOnce({ ok: true, id: '42', url: 'https://www.zhihu.com/question/1/answer/42' }),
         };
-        await expect(cmd.func(page, { target: 'question:1', text: 'hello', execute: true })).rejects.toMatchObject({ code: 'ACTION_NOT_AVAILABLE' });
+        const rows = await cmd.func(page, { target: 'question:1', text: 'hello', execute: true });
+        expect(rows).toEqual([
+            expect.objectContaining({
+                outcome: 'created',
+                created_target: 'answer:1:42',
+                author_identity: 'alice',
+            }),
+        ]);
     });
-    it('rejects when anonymous mode cannot be proven off', async () => {
+    it('throws on API error', async () => {
         const cmd = getRegistry().get('zhihu/answer');
         const page = {
             goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
             evaluate: vi.fn()
                 .mockResolvedValueOnce({ slug: 'alice' })
-                .mockResolvedValueOnce({ entryPathSafe: true, hasExistingAnswerByCurrentUser: false })
-                .mockResolvedValueOnce({ editorState: 'fresh_empty', anonymousMode: 'unknown' }),
+                .mockResolvedValueOnce({ ok: false, status: 400, message: 'already answered' }),
         };
-        await expect(cmd.func(page, { target: 'question:1', text: 'hello', execute: true })).rejects.toMatchObject({ code: 'ACTION_NOT_AVAILABLE' });
+        await expect(cmd.func(page, { target: 'question:1', text: 'hello', execute: true }))
+            .rejects.toMatchObject({ code: 'COMMAND_EXEC' });
     });
-    it('requires a side-effect-free entry path and exact editor content before publish', async () => {
+    it('requires the answer API response to include the created id', async () => {
         const cmd = getRegistry().get('zhihu/answer');
         const page = {
             goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
             evaluate: vi.fn()
                 .mockResolvedValueOnce({ slug: 'alice' })
-                .mockResolvedValueOnce({ entryPathSafe: true })
-                .mockResolvedValueOnce({ editorState: 'fresh_empty', anonymousMode: 'off' })
-                .mockResolvedValueOnce({ editorContent: 'hello', bodyMatches: true })
-                .mockResolvedValueOnce({
-                createdTarget: 'answer:1:2',
-                createdUrl: 'https://www.zhihu.com/question/1/answer/2',
-                authorIdentity: 'alice',
-                bodyMatches: true,
-            }),
+                .mockResolvedValueOnce({ ok: false, status: 200, message: 'Answer API response did not include a created answer id' }),
         };
-        await expect(cmd.func(page, { target: 'question:1', text: 'hello', execute: true })).resolves.toEqual([
-            expect.objectContaining({
-                outcome: 'created',
-                created_target: 'answer:1:2',
-                created_url: 'https://www.zhihu.com/question/1/answer/2',
-                author_identity: 'alice',
-            }),
-        ]);
-        expect(page.evaluate.mock.calls[1][0]).toContain('composerCandidates.length === 1');
-        expect(page.evaluate.mock.calls[1][0]).not.toContain('writeAnswerButton');
-        expect(page.evaluate.mock.calls[1][0]).toContain('const readAnswerAuthorSlug = (node) =>');
-        expect(page.evaluate.mock.calls[1][0]).toContain('const answerAuthorScopeSelector = ".AuthorInfo, .AnswerItem-authorInfo, .ContentItem-meta, [itemprop=\\"author\\"]"');
-        expect(page.evaluate.mock.calls[1][0]).not.toContain("node.querySelector('a[href^=\"/people/\"]')");
-        expect(page.evaluate.mock.calls[3][0]).toContain('composerCandidates.length !== 1');
-        expect(page.evaluate.mock.calls[4][0]).toContain('const readAnswerAuthorSlug = (node) =>');
-        expect(page.evaluate.mock.calls[4][0]).not.toContain("answerContainer?.querySelector('a[href^=\"/people/\"]')");
+        await expect(cmd.func(page, { target: 'question:1', text: 'hello', execute: true }))
+            .rejects.toMatchObject({ code: 'COMMAND_EXEC' });
+        expect(page.evaluate.mock.calls[1][0]).toContain('Answer API response did not include a created answer id');
     });
 });

package/clis/zhihu/collection.js

@@ -0,0 +1,197 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { log } from '@jackwener/opencli/logger';
+
+function stripHtml(html) {
+  return html
+    .replace(/<[^>]+>/g, '')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&')
+    .replace(/&quot;/g, '"')
+    .replace(/<em>/g, '')
+    .replace(/<\/em>/g, '')
+    .trim();
+}
+
+function validatePositiveInt(value, name) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n <= 0) {
+    throw new ArgumentError(`zhihu collection --${name} must be a positive integer`, 'Example: opencli zhihu collection 83283292 --limit 20');
+  }
+  return n;
+}
+
+function validateNonNegativeInt(value, name) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 0) {
+    throw new ArgumentError(`zhihu collection --${name} must be a non-negative integer`, 'Example: opencli zhihu collection 83283292 --offset 0');
+  }
+  return n;
+}
+
+async function fetchCollectionPage(page, collectionId, offset, limit) {
+  const url = `https://www.zhihu.com/api/v4/collections/${collectionId}/items?offset=${offset}&limit=${limit}`;
+  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', 'Failed to fetch collection data from Zhihu. Please ensure you are logged in.');
+    }
+    throw new CommandExecutionError(
+      status ? `Zhihu collection request failed (HTTP ${status})` : 'Zhihu collection request failed',
+      'Try again later or rerun with -v for more detail',
+    );
+  }
+  return data;
+}
+
+function itemKey(item) {
+  const content = item?.content || {};
+  return `${content.type || 'unknown'}:${content.id || content.url || JSON.stringify(content).slice(0, 80)}`;
+}
+
+function mapCollectionItem(item, rank) {
+  const content = item.content || {};
+  const type = content.type || 'unknown';
+
+  let title = '';
+  let excerpt = '';
+  let url = '';
+  let author = '';
+  let votes = 0;
+
+  if (type === 'answer') {
+    const question = content.question || {};
+    title = question.title || '';
+    excerpt = stripHtml(content.content || '').substring(0, 150);
+    url = content.url || `https://www.zhihu.com/question/${question.id}/answer/${content.id}`;
+    author = content.author?.name || '匿名用户';
+    votes = content.voteup_count || 0;
+  } else if (type === 'article') {
+    title = content.title || '';
+    excerpt = stripHtml(content.content || '').substring(0, 150);
+    url = content.url || `https://zhuanlan.zhihu.com/p/${content.id}`;
+    author = content.author?.name || '匿名用户';
+    votes = content.voteup_count || 0;
+  } else if (type === 'pin') {
+    title = '想法';
+    excerpt = stripHtml((content.content || []).map((c) => c.content || '').join(' ')).substring(0, 150);
+    url = content.url || `https://www.zhihu.com/pin/${content.id}`;
+    author = content.author?.name || '匿名用户';
+    votes = content.reaction_count || 0;
+  }
+
+  return {
+    rank,
+    type,
+    title: title.substring(0, 100),
+    author,
+    votes,
+    excerpt,
+    url,
+  };
+}
+
+cli({
+  site: 'zhihu',
+  name: 'collection',
+  description: '知乎收藏夹内容列表（需要登录）',
+  domain: 'www.zhihu.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'id', positional: true, required: true, help: '收藏夹 ID (数字，可从收藏夹 URL 中获取)' },
+    { name: 'offset', type: 'int', default: 0, help: '起始偏移量（用于分页）' },
+    { name: 'limit', type: 'int', default: 20, help: '每页数量（最大 20）' },
+  ],
+  columns: ['rank', 'type', 'title', 'author', 'votes', 'excerpt', 'url'],
+  func: async (page, kwargs) => {
+    const { id, offset = 0, limit = 20 } = kwargs;
+
+    const collectionId = String(id);
+
+    // 验证收藏夹 ID 为数字
+    if (!/^\d+$/.test(collectionId)) {
+      throw new ArgumentError('Collection ID must be numeric', 'Example: opencli zhihu collection 83283292');
+    }
+
+    const pageOffset = validateNonNegativeInt(offset, 'offset');
+    const requestedLimit = validatePositiveInt(limit, 'limit');
+    const pageLimit = Math.min(requestedLimit, 20); // 知乎 API 限制每页最大 20
+
+    // 先访问知乎主页建立 session
+    await page.goto('https://www.zhihu.com');
+
+    const collected = [];
+    const seen = new Set();
+    let totals = 0;
+    let nextOffset = pageOffset;
+    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 data = await fetchCollectionPage(page, collectionId, nextOffset, currentFetchLimit);
+      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 = itemKey(item);
+        if (!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 > nextOffset) {
+            nextOffset = parsedOffset;
+            continue;
+          }
+        } catch {}
+      }
+      if (items.length < currentFetchLimit) break;
+      const fallbackOffset = nextOffset + items.length;
+      if (fallbackOffset <= nextOffset) break;
+      nextOffset = fallbackOffset;
+      if (totals && nextOffset >= totals) break;
+    }
+    
+    // 计算总页数
+    const totalPages = Math.ceil(totals / pageLimit);
+    const currentPage = Math.floor(pageOffset / pageLimit) + 1;
+    
+    // 输出统计信息
+    if (totals > 0) {
+      log.info(`收藏夹共有 ${totals} 条内容，共 ${totalPages} 页`);
+      log.info(`当前第 ${currentPage} 页，显示第 ${pageOffset + 1} - ${Math.min(pageOffset + collected.length, totals)} 条`);
+    }
+
+    if (collected.length === 0) {
+      throw new EmptyResultError('zhihu collection', `No items found for collection ${collectionId}. The collection may be empty, private, or the offset may be out of range.`);
+    }
+
+    return collected.slice(0, requestedLimit).map((item, i) => mapCollectionItem(item, pageOffset + i + 1));
+  },
+});
+
+export const __test__ = {
+  stripHtml,
+  validatePositiveInt,
+  validateNonNegativeInt,
+  itemKey,
+  mapCollectionItem,
+};

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);
+  });
+});