@jackwener/opencli 1.7.7 → 1.7.9

package/clis/youtube/channel.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './channel.js';
+
+function tab(title, contents, selected = false) {
+    return {
+        tabRenderer: {
+            title,
+            selected,
+            content: {
+                richGridRenderer: {
+                    contents,
+                },
+            },
+        },
+    };
+}
+
+function browseData(tabs) {
+    return {
+        contents: {
+            twoColumnBrowseResultsRenderer: {
+                tabs,
+            },
+        },
+    };
+}
+
+describe('youtube channel helpers', () => {
+    it('uses the selected rich-grid tab instead of the first tab', () => {
+        const home = [{ richItemRenderer: { content: { videoRenderer: { videoId: 'home' } } } }];
+        const videos = [{ richItemRenderer: { content: { videoRenderer: { videoId: 'videos' } } } }];
+
+        expect(__test__.extractSelectedRichGridContents(browseData([
+            tab('Home', home),
+            tab('Videos', videos, true),
+        ]))).toBe(videos);
+    });
+
+    it('falls back to the first non-empty rich-grid tab when no tab is selected', () => {
+        const videos = [{ richItemRenderer: { content: { videoRenderer: { videoId: 'only' } } } }];
+
+        expect(__test__.extractSelectedRichGridContents(browseData([
+            tab('Home', []),
+            tab('Videos', videos),
+        ]))).toBe(videos);
+    });
+
+    it('is self-contained for browser evaluate injection', () => {
+        const extractSelectedRichGridContents = Function(
+            `return ${__test__.extractSelectedRichGridContents.toString()}`
+        )();
+        const videos = [{ richItemRenderer: { content: { videoRenderer: { videoId: 'serialized' } } } }];
+
+        expect(extractSelectedRichGridContents(browseData([
+            tab('Home', []),
+            tab('Videos', videos, true),
+        ]))).toEqual(videos);
+    });
+});

package/clis/zhihu/answer.js

@@ -2,13 +2,12 @@ import { CliError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { assertAllowedKinds, parseTarget } from './target.js';
 import { buildResultRow, requireExecute, resolveCurrentUserIdentity, resolvePayload } from './write-shared.js';
-const ANSWER_AUTHOR_SCOPE_SELECTOR = '.AuthorInfo, .AnswerItem-authorInfo, .ContentItem-meta, [itemprop="author"]';
 cli({
     site: 'zhihu',
     name: 'answer',
     description: 'Answer a Zhihu question',
     domain: 'www.zhihu.com',
-    strategy: Strategy.UI,
+    strategy: Strategy.COOKIE,
     browser: true,
     args: [
         { name: 'target', positional: true, required: true, help: 'Zhihu question URL or typed target' },
@@ -23,171 +22,31 @@ cli({
         requireExecute(kwargs);
         const rawTarget = String(kwargs.target);
         const target = assertAllowedKinds('answer', parseTarget(rawTarget));
-        const questionTarget = target;
         const payload = await resolvePayload(kwargs);
         await page.goto(target.url);
+        await page.wait(3);
         const authorIdentity = await resolveCurrentUserIdentity(page);
-        const entryPath = await page.evaluate(`(() => {
-      const currentUserSlug = ${JSON.stringify(authorIdentity)};
-      const answerAuthorScopeSelector = ${JSON.stringify(ANSWER_AUTHOR_SCOPE_SELECTOR)};
-      const readAnswerAuthorSlug = (node) => {
-        const authorScopes = Array.from(node.querySelectorAll(answerAuthorScopeSelector));
-        const slugs = Array.from(new Set(authorScopes
-          .flatMap((scope) => Array.from(scope.querySelectorAll('a[href^="/people/"]')))
-          .map((link) => (link.getAttribute('href') || '').match(/^\\/people\\/([A-Za-z0-9_-]+)/)?.[1] || null)
-          .filter(Boolean)));
-        return slugs.length === 1 ? slugs[0] : null;
-      };
-      const restoredDraft = !!document.querySelector('[contenteditable="true"][data-draft-restored], textarea[data-draft-restored]');
-      const composerCandidates = Array.from(document.querySelectorAll('[contenteditable="true"], textarea')).map((editor) => {
-        const container = editor.closest('form, .AnswerForm, .DraftEditor-root, [data-za-module*="Answer"]') || editor.parentElement;
-        const text = 'value' in editor ? editor.value || '' : (editor.textContent || '');
-        const submitButton = Array.from((container || document).querySelectorAll('button')).find((node) => /发布|提交/.test(node.textContent || ''));
-        const nestedComment = Boolean(container?.closest('[data-comment-id], .CommentItem'));
-        return { editor, container, text, submitButton, nestedComment };
-      }).filter((candidate) => candidate.container && candidate.submitButton && !candidate.nestedComment);
-      const hasExistingAnswerByCurrentUser = Array.from(document.querySelectorAll('[data-zop-question-answer], article')).some((node) => {
-        return readAnswerAuthorSlug(node) === currentUserSlug;
-      });
-      return {
-        entryPathSafe: composerCandidates.length === 1
-          && !String(composerCandidates[0].text || '').trim()
-          && !restoredDraft
-          && !hasExistingAnswerByCurrentUser,
-        hasExistingAnswerByCurrentUser,
-      };
-    })()`);
-        if (entryPath.hasExistingAnswerByCurrentUser) {
-            throw new CliError('ACTION_NOT_AVAILABLE', 'zhihu answer only supports creating a new answer when the current user has not already answered this question');
-        }
-        if (!entryPath.entryPathSafe) {
-            throw new CliError('ACTION_NOT_AVAILABLE', 'Answer editor entry path was not proven side-effect free');
-        }
-        const editorState = await page.evaluate(`(async () => {
-      const composerCandidates = Array.from(document.querySelectorAll('[contenteditable="true"], textarea')).map((editor) => {
-        const container = editor.closest('form, .AnswerForm, .DraftEditor-root, [data-za-module*="Answer"]') || editor.parentElement;
-        const text = 'value' in editor ? editor.value || '' : (editor.textContent || '');
-        const submitButton = Array.from((container || document).querySelectorAll('button')).find((node) => /发布|提交/.test(node.textContent || ''));
-        const nestedComment = Boolean(container?.closest('[data-comment-id], .CommentItem'));
-        return { editor, container, text, submitButton, nestedComment };
-      }).filter((candidate) => candidate.container && candidate.submitButton && !candidate.nestedComment);
-      if (composerCandidates.length !== 1) return { editorState: 'unsafe', anonymousMode: 'unknown' };
-      const { editor, text } = composerCandidates[0];
-      const anonymousLabeledControl =
-        (composerCandidates[0].container && composerCandidates[0].container.querySelector('[aria-label*="匿名"], [title*="匿名"]'))
-        || Array.from((composerCandidates[0].container || document).querySelectorAll('label, button, [role="switch"], [role="checkbox"]')).find((node) => /匿名/.test(node.textContent || ''))
-        || null;
-      const anonymousToggle =
-        anonymousLabeledControl?.matches?.('input[type="checkbox"], [role="switch"], [role="checkbox"], button')
-          ? anonymousLabeledControl
-          : anonymousLabeledControl?.querySelector?.('input[type="checkbox"], [role="switch"], [role="checkbox"], button')
-            || null;
-      let anonymousMode = 'unknown';
-      if (anonymousToggle) {
-        const ariaChecked = anonymousToggle.getAttribute && anonymousToggle.getAttribute('aria-checked');
-        const checked = 'checked' in anonymousToggle ? anonymousToggle.checked === true : false;
-        if (ariaChecked === 'true' || checked) anonymousMode = 'on';
-        else if (ariaChecked === 'false' || ('checked' in anonymousToggle && anonymousToggle.checked === false)) anonymousMode = 'off';
-      }
-      return {
-        editorState: editor && !text.trim() ? 'fresh_empty' : 'unsafe',
-        anonymousMode,
-      };
-    })()`);
-        if (editorState.editorState !== 'fresh_empty') {
-            throw new CliError('ACTION_NOT_AVAILABLE', 'Answer editor was not fresh and empty');
-        }
-        if (editorState.anonymousMode !== 'off') {
-            throw new CliError('ACTION_NOT_AVAILABLE', 'Anonymous answer mode could not be proven off for zhihu answer');
-        }
-        const editorCheck = await page.evaluate(`(async () => {
-      const textToInsert = ${JSON.stringify(payload)};
-      const composerCandidates = Array.from(document.querySelectorAll('[contenteditable="true"], textarea')).map((editor) => {
-        const container = editor.closest('form, .AnswerForm, .DraftEditor-root, [data-za-module*="Answer"]') || editor.parentElement;
-        const submitButton = Array.from((container || document).querySelectorAll('button')).find((node) => /发布|提交/.test(node.textContent || ''));
-        const nestedComment = Boolean(container?.closest('[data-comment-id], .CommentItem'));
-        return { editor, container, submitButton, nestedComment };
-      }).filter((candidate) => candidate.container && candidate.submitButton && !candidate.nestedComment);
-      if (composerCandidates.length !== 1) return { editorContent: '', bodyMatches: false };
-      const { editor } = composerCandidates[0];
-      editor.focus();
-      if ('value' in editor) {
-        editor.value = '';
-        editor.dispatchEvent(new Event('input', { bubbles: true }));
-        editor.value = textToInsert;
-        editor.dispatchEvent(new Event('input', { bubbles: true }));
-      } else {
-        editor.textContent = '';
-        document.execCommand('insertText', false, textToInsert);
-        editor.dispatchEvent(new InputEvent('input', { bubbles: true, data: textToInsert, inputType: 'insertText' }));
-      }
-      await new Promise((resolve) => setTimeout(resolve, 200));
-      const content = 'value' in editor ? editor.value : (editor.textContent || '');
-      return { editorContent: content, bodyMatches: content === textToInsert };
-    })()`);
-        if (editorCheck.editorContent !== payload || !editorCheck.bodyMatches) {
-            throw new CliError('OUTCOME_UNKNOWN', 'Answer editor content did not exactly match the requested payload before publish');
-        }
-        const proof = await page.evaluate(`(async () => {
-      const normalize = (value) => value.replace(/\\s+/g, ' ').trim();
-      const answerAuthorScopeSelector = ${JSON.stringify(ANSWER_AUTHOR_SCOPE_SELECTOR)};
-      const readAnswerAuthorSlug = (node) => {
-        const authorScopes = Array.from(node.querySelectorAll(answerAuthorScopeSelector));
-        const slugs = Array.from(new Set(authorScopes
-          .flatMap((scope) => Array.from(scope.querySelectorAll('a[href^="/people/"]')))
-          .map((link) => (link.getAttribute('href') || '').match(/^\\/people\\/([A-Za-z0-9_-]+)/)?.[1] || null)
-          .filter(Boolean)));
-        return slugs.length === 1 ? slugs[0] : null;
-      };
-      const composerCandidates = Array.from(document.querySelectorAll('[contenteditable="true"], textarea')).map((editor) => {
-        const container = editor.closest('form, [role="dialog"], .AnswerForm, .DraftEditor-root, [data-za-module*="Answer"]') || editor.parentElement;
-        const submitButton = Array.from((container || document).querySelectorAll('button')).find((node) => /发布|提交/.test(node.textContent || ''));
-        const nestedComment = Boolean(container?.closest('[data-comment-id], .CommentItem'));
-        return { editor, container, submitButton, nestedComment };
-      }).filter((candidate) => candidate.container && candidate.submitButton && !candidate.nestedComment);
-      if (composerCandidates.length !== 1) return { createdTarget: null, createdUrl: null, authorIdentity: null, bodyMatches: false };
-      const submitScope = composerCandidates[0].container || document;
-      const submit = Array.from(submitScope.querySelectorAll('button')).find((node) => /发布|提交/.test(node.textContent || ''));
-      submit && submit.click();
-      await new Promise((resolve) => setTimeout(resolve, 1500));
-      const href = location.href;
-      const match = href.match(/question\\/(\\d+)\\/answer\\/(\\d+)/);
-      const targetHref = match ? '/question/' + match[1] + '/answer/' + match[2] : null;
-      const answerContainer = targetHref
-        ? Array.from(document.querySelectorAll('[data-zop-question-answer], article')).find((node) => {
-            const dataAnswerId = node.getAttribute('data-answerid') || node.getAttribute('data-zop-question-answer') || '';
-            if (dataAnswerId && dataAnswerId.includes(match[2])) return true;
-            return Array.from(node.querySelectorAll('a[href*="/answer/"]')).some((link) => {
-              const hrefValue = link.getAttribute('href') || '';
-              return hrefValue.includes(targetHref);
+        const apiResult = await page.evaluate(`(async () => {
+            var questionId = ${JSON.stringify(target.id)};
+            var content = ${JSON.stringify(payload)};
+            var url = 'https://www.zhihu.com/api/v4/questions/' + questionId + '/answers';
+            var resp = await fetch(url, {
+                method: 'POST',
+                credentials: 'include',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ content: content, reshipment_settings: 'disallowed' }),
             });
-          })
-        : null;
-      const authorSlug = answerContainer ? readAnswerAuthorSlug(answerContainer) : null;
-      const bodyNode =
-        answerContainer?.querySelector('[itemprop="text"]')
-        || answerContainer?.querySelector('.RichContent-inner')
-        || answerContainer?.querySelector('.RichText')
-        || answerContainer;
-      const bodyText = normalize(bodyNode?.textContent || '');
-      return match
-        ? {
-            createdTarget: 'answer:' + match[1] + ':' + match[2],
-            createdUrl: href,
-            authorIdentity: authorSlug,
-            bodyMatches: bodyText === normalize(${JSON.stringify(payload)}),
-          }
-        : { createdTarget: null, createdUrl: null, authorIdentity: authorSlug, bodyMatches: false };
-    })()`);
-        if (proof.authorIdentity !== authorIdentity) {
-            throw new CliError('OUTCOME_UNKNOWN', 'Answer was created but authorship could not be proven for the frozen current user');
-        }
-        if (!proof.createdTarget || !proof.bodyMatches || proof.createdTarget.split(':')[1] !== questionTarget.id) {
-            throw new CliError('OUTCOME_UNKNOWN', 'Created answer proof did not match the requested question or payload');
+            var data = await resp.json();
+            if (!resp.ok) return { ok: false, status: resp.status, message: data.error ? data.error.message : 'unknown error' };
+            if (!data || !data.id) return { ok: false, status: resp.status, message: 'Answer API response did not include a created answer id' };
+            return { ok: true, id: String(data.id), url: data.url || ('https://www.zhihu.com/question/' + questionId + '/answer/' + data.id) };
+        })()`);
+        if (!apiResult?.ok) {
+            throw new CliError('COMMAND_EXEC', apiResult?.message || 'Failed to create answer');
         }
-        return buildResultRow(`Answered question ${questionTarget.id}`, target.kind, rawTarget, 'created', {
-            created_target: proof.createdTarget,
-            created_url: proof.createdUrl,
+        return buildResultRow(`Answered question ${target.id}`, target.kind, rawTarget, 'created', {
+            created_target: 'answer:' + target.id + ':' + apiResult.id,
+            created_url: apiResult.url,
             author_identity: authorIdentity,
         });
     },

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