@jackwener/opencli 1.6.8 → 1.6.10

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

@@ -0,0 +1,196 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './favorite.js';
+describe('zhihu favorite', () => {
+    it('rejects missing collection selectors before opening the chooser', async () => {
+        const cmd = getRegistry().get('zhihu/favorite');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = { goto: vi.fn(), evaluate: vi.fn() };
+        await expect(cmd.func(page, { target: 'article:1', execute: true })).rejects.toMatchObject({
+            code: 'INVALID_INPUT',
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+    it('requires persisted read-back and preserves previously selected collections', async () => {
+        const cmd = getRegistry().get('zhihu/favorite');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({
+                chooserRows: [
+                    { id: 'fav-a', name: '已存在', selected: true },
+                    { id: 'fav-b', name: '默认收藏夹', selected: false },
+                ],
+                targetRowId: 'fav-b',
+                targetRowName: '默认收藏夹',
+            })
+                .mockResolvedValueOnce({
+                persisted: true,
+                readbackSource: 'reopened_chooser',
+                selectedBefore: ['fav-a'],
+                selectedAfter: ['fav-a', 'fav-b'],
+                targetSelected: true,
+            }),
+        };
+        await expect(cmd.func(page, { target: 'article:1', collection: '默认收藏夹', execute: true })).resolves.toEqual([
+            expect.objectContaining({ outcome: 'applied', collection_name: '默认收藏夹', target: 'article:1' }),
+        ]);
+        expect(page.evaluate.mock.calls[1][0]).toContain('waitForChooserRows(false)');
+        expect(page.evaluate.mock.calls[1][0]).toContain("readbackSource");
+    });
+    it('requires persisted read-back before returning already_applied', async () => {
+        const cmd = getRegistry().get('zhihu/favorite');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({
+                chooserRows: [{ id: 'fav-a', name: '默认收藏夹', selected: true }],
+                targetRowId: 'fav-a',
+                targetRowName: '默认收藏夹',
+            })
+                .mockResolvedValueOnce({
+                persisted: true,
+                readbackSource: 'reopened_chooser',
+                selectedAfter: ['fav-a'],
+                targetSelected: true,
+            }),
+        };
+        await expect(cmd.func(page, { target: 'article:1', collection: '默认收藏夹', execute: true })).resolves.toEqual([
+            expect.objectContaining({ outcome: 'already_applied', collection_name: '默认收藏夹' }),
+        ]);
+    });
+    it('accepts --collection-id as the stable selector path', async () => {
+        const cmd = getRegistry().get('zhihu/favorite');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({
+                chooserRows: [
+                    { id: 'fav-a', name: '默认收藏夹', selected: false },
+                    { id: 'fav-b', name: '同名收藏夹', selected: false },
+                ],
+                targetRowId: 'fav-b',
+                targetRowName: null,
+            })
+                .mockResolvedValueOnce({
+                persisted: true,
+                readbackSource: 'reopened_chooser',
+                selectedAfter: ['fav-b'],
+                targetSelected: true,
+            }),
+        };
+        await expect(cmd.func(page, { target: 'article:1', 'collection-id': 'fav-b', execute: true })).resolves.toEqual([
+            expect.objectContaining({ outcome: 'applied', collection_id: 'fav-b' }),
+        ]);
+    });
+    it('rejects duplicate collection names before selecting any row', async () => {
+        const cmd = getRegistry().get('zhihu/favorite');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({
+                chooserRows: [
+                    { id: 'fav-a', name: '默认收藏夹', selected: false },
+                    { id: 'fav-b', name: '默认收藏夹', selected: false },
+                ],
+            }),
+        };
+        await expect(cmd.func(page, { target: 'article:1', collection: '默认收藏夹', execute: true })).rejects.toMatchObject({ code: 'ACTION_NOT_AVAILABLE' });
+    });
+    it('rejects optimistic chooser state that was not re-read from a reopened chooser', async () => {
+        const cmd = getRegistry().get('zhihu/favorite');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({
+                chooserRows: [
+                    { id: 'fav-a', name: '已存在', selected: true },
+                    { id: 'fav-b', name: '默认收藏夹', selected: false },
+                ],
+                targetRowId: 'fav-b',
+                targetRowName: '默认收藏夹',
+            })
+                .mockResolvedValueOnce({
+                persisted: true,
+                readbackSource: 'same_modal',
+                selectedAfter: ['fav-a', 'fav-b'],
+                targetSelected: true,
+            }),
+        };
+        await expect(cmd.func(page, { target: 'article:1', collection: '默认收藏夹', execute: true })).rejects.toMatchObject({ code: 'OUTCOME_UNKNOWN' });
+    });
+    it('matches unique collection names even when chooser rows include extra UI text', async () => {
+        const cmd = getRegistry().get('zhihu/favorite');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({
+                chooserRows: [
+                    { id: 'fav-b', name: '默认收藏夹 12 条内容', selected: false },
+                ],
+                targetRowId: null,
+                targetRowName: '默认收藏夹',
+            })
+                .mockResolvedValueOnce({
+                persisted: true,
+                readbackSource: 'reopened_chooser',
+                selectedAfter: ['fav-b'],
+                targetSelected: true,
+            }),
+        };
+        await expect(cmd.func(page, { target: 'article:1', collection: '默认收藏夹', execute: true })).resolves.toEqual([
+            expect.objectContaining({ outcome: 'applied', collection_name: '默认收藏夹' }),
+        ]);
+        expect(page.evaluate.mock.calls[1][0]).toContain('normalizeCollectionName');
+    });
+    it('normalizes id-less row keys during reopened chooser verification', async () => {
+        const cmd = getRegistry().get('zhihu/favorite');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({
+                chooserRows: [
+                    { id: '', name: '默认收藏夹 12 条内容', selected: false },
+                ],
+                targetRowId: null,
+                targetRowName: '默认收藏夹',
+            })
+                .mockResolvedValueOnce({
+                persisted: true,
+                readbackSource: 'reopened_chooser',
+                selectedAfter: ['name:默认收藏夹'],
+                targetSelected: true,
+            }),
+        };
+        await expect(cmd.func(page, { target: 'article:1', collection: '默认收藏夹', execute: true })).resolves.toEqual([
+            expect.objectContaining({ outcome: 'applied', collection_name: '默认收藏夹' }),
+        ]);
+        expect(page.evaluate.mock.calls[1][0]).toContain("const rowKey = (row) => row.id || 'name:' + normalizeCollectionName(row.name);");
+        expect(page.evaluate.mock.calls[1][0]).toContain('selectedAfter: chooserRows.filter((row) => row.selected).map(rowKey)');
+    });
+    it('reuses data-attribute answer anchoring during reopened chooser verification', async () => {
+        const cmd = getRegistry().get('zhihu/favorite');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({
+                chooserRows: [
+                    { id: 'fav-b', name: '默认收藏夹', selected: false },
+                ],
+                targetRowId: 'fav-b',
+                targetRowName: null,
+            })
+                .mockResolvedValueOnce({
+                persisted: true,
+                readbackSource: 'reopened_chooser',
+                selectedAfter: ['fav-b'],
+                targetSelected: true,
+            }),
+        };
+        await expect(cmd.func(page, { target: 'answer:1:2', 'collection-id': 'fav-b', execute: true })).resolves.toEqual([
+            expect.objectContaining({ outcome: 'applied', collection_id: 'fav-b', target: 'answer:1:2' }),
+        ]);
+        expect(page.evaluate.mock.calls[1][0]).toContain("node.getAttribute('data-answerid')");
+        expect(page.evaluate.mock.calls[1][0]).toContain("node.getAttribute('data-zop-question-answer')");
+    });
+});

package/dist/clis/zhihu/follow.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/zhihu/follow.js

@@ -0,0 +1,80 @@
+import { CliError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { assertAllowedKinds, parseTarget } from './target.js';
+import { buildResultRow, requireExecute } from './write-shared.js';
+cli({
+    site: 'zhihu',
+    name: 'follow',
+    description: 'Follow a Zhihu user or question',
+    domain: 'www.zhihu.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'target', positional: true, required: true, help: 'Zhihu target URL or typed target' },
+        { name: 'execute', type: 'boolean', help: 'Actually perform the write action' },
+    ],
+    columns: ['status', 'outcome', 'message', 'target_type', 'target'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for zhihu follow');
+        requireExecute(kwargs);
+        const rawTarget = String(kwargs.target);
+        const target = assertAllowedKinds('follow', parseTarget(rawTarget));
+        await page.goto(target.url);
+        const result = await page.evaluate(`(async () => {
+      const targetKind = ${JSON.stringify(target.kind)};
+      const mainRoot = document.querySelector('main') || document;
+      let followBtn = null;
+
+      if (targetKind === 'question') {
+        const questionRoots = Array.from(mainRoot.querySelectorAll('.QuestionHeader, .Question-main, [data-zop-question-id], [class*="QuestionHeader"]'));
+        const scopedRoots = questionRoots.length ? questionRoots : [mainRoot];
+        const candidates = Array.from(new Set(scopedRoots.flatMap((root) => Array.from(root.querySelectorAll('button, a'))))).filter((node) => {
+          const text = (node.textContent || '').trim();
+          const inAside = Boolean(node.closest('aside, [data-testid*="recommend"], .Recommendations'));
+          const inAnswerBlock = Boolean(node.closest('article, .AnswerItem, [data-zop-question-answer]'));
+          return /关注问题|已关注/.test(text) && !inAside && !inAnswerBlock;
+        });
+        if (candidates.length !== 1) return { state: 'ambiguous_question_follow' };
+        followBtn = candidates[0];
+      } else {
+        const candidates = Array.from(mainRoot.querySelectorAll('button, a')).filter((node) => {
+          const text = (node.textContent || '').trim();
+          const inAside = Boolean(node.closest('aside, [data-testid*="recommend"], .Recommendations'));
+          return /关注|已关注/.test(text) && !/邀请|收藏|评论/.test(text) && !inAside;
+        });
+
+        if (candidates.length !== 1) return { state: 'ambiguous_user_follow' };
+        followBtn = candidates[0];
+      }
+
+      if (!followBtn) return { state: 'missing' };
+      if ((followBtn.textContent || '').includes('已关注') || followBtn.getAttribute('aria-pressed') === 'true') {
+        return { state: 'already_following' };
+      }
+
+      followBtn.click();
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      return ((followBtn.textContent || '').includes('已关注') || followBtn.getAttribute('aria-pressed') === 'true')
+        ? { state: 'followed' }
+        : { state: 'unknown' };
+    })()`);
+        if (result?.state === 'already_following') {
+            return buildResultRow(`Already followed ${target.kind}`, target.kind, rawTarget, 'already_applied');
+        }
+        if (result?.state === 'ambiguous_question_follow') {
+            throw new CliError('ACTION_NOT_AVAILABLE', 'Question follow control was not uniquely anchored on the requested question page');
+        }
+        if (result?.state === 'ambiguous_user_follow') {
+            throw new CliError('ACTION_NOT_AVAILABLE', 'User follow control was not uniquely anchored on the requested profile page');
+        }
+        if (result?.state === 'missing') {
+            throw new CliError('ACTION_FAILED', 'Zhihu follow control was missing before any write was dispatched');
+        }
+        if (result?.state !== 'followed') {
+            throw new CliError('OUTCOME_UNKNOWN', 'Zhihu follow click was dispatched, but the final state could not be verified safely');
+        }
+        return buildResultRow(`Followed ${target.kind}`, target.kind, rawTarget, 'applied');
+    },
+});

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

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

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

@@ -0,0 +1,45 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './follow.js';
+describe('zhihu follow', () => {
+    it('rejects missing --execute before any browser write path', async () => {
+        const cmd = getRegistry().get('zhihu/follow');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = { goto: vi.fn(), evaluate: vi.fn() };
+        await expect(cmd.func(page, { target: 'question:123' })).rejects.toMatchObject({ code: 'INVALID_INPUT' });
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+    it('rejects user pages where the primary follow control is not uniquely anchored', async () => {
+        const cmd = getRegistry().get('zhihu/follow');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'ambiguous_user_follow' }),
+        };
+        await expect(cmd.func(page, { target: 'user:alice', execute: true })).rejects.toMatchObject({
+            code: 'ACTION_NOT_AVAILABLE',
+        });
+    });
+    it('returns already_applied when already following', async () => {
+        const cmd = getRegistry().get('zhihu/follow');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'already_following' }),
+        };
+        await expect(cmd.func(page, { target: 'question:123', execute: true })).resolves.toEqual([
+            expect.objectContaining({ outcome: 'already_applied', target_type: 'question', target: 'question:123' }),
+        ]);
+    });
+    it('rejects question pages where the question follow control is not uniquely anchored', async () => {
+        const cmd = getRegistry().get('zhihu/follow');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'ambiguous_question_follow' }),
+        };
+        await expect(cmd.func(page, { target: 'question:123', execute: true })).rejects.toMatchObject({
+            code: 'ACTION_NOT_AVAILABLE',
+        });
+        expect(page.evaluate.mock.calls[0][0]).toContain('QuestionHeader');
+        expect(page.evaluate.mock.calls[0][0]).toContain('new Set(');
+    });
+});

package/dist/clis/zhihu/hot.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/zhihu/hot.js

@@ -0,0 +1,43 @@
+import { cli } from '@jackwener/opencli/registry';
+cli({
+    site: 'zhihu',
+    name: 'hot',
+    description: '知乎热榜',
+    domain: 'www.zhihu.com',
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of items to return' },
+    ],
+    columns: ['rank', 'title', 'heat', 'answers'],
+    pipeline: [
+        { navigate: 'https://www.zhihu.com' },
+        { evaluate: `(async () => {
+  const res = await fetch('https://www.zhihu.com/api/v3/feed/topstory/hot-lists/total?limit=50', {
+    credentials: 'include'
+  });
+  const text = await res.text();
+  const d = JSON.parse(
+    text.replace(/("id"\\s*:\\s*)(\\d{16,})/g, '$1"$2"')
+  );
+  return (d?.data || []).map((item) => {
+    const t = item.target || {};
+    const questionId = t.id == null ? '' : String(t.id);
+    return {
+      title: t.title,
+      url: 'https://www.zhihu.com/question/' + questionId,
+      answer_count: t.answer_count,
+      follower_count: t.follower_count,
+      heat: item.detail_text || '',
+    };
+  });
+})()
+` },
+        { map: {
+                rank: '${{ index + 1 }}',
+                title: '${{ item.title }}',
+                heat: '${{ item.heat }}',
+                answers: '${{ item.answer_count }}',
+                url: '${{ item.url }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/clis/zhihu/like.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/zhihu/like.js

@@ -0,0 +1,91 @@
+import { CliError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { assertAllowedKinds, parseTarget } from './target.js';
+import { buildResultRow, requireExecute } from './write-shared.js';
+cli({
+    site: 'zhihu',
+    name: 'like',
+    description: 'Like a Zhihu answer or article',
+    domain: 'zhihu.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'target', positional: true, required: true, help: 'Zhihu target URL or typed target' },
+        { name: 'execute', type: 'boolean', help: 'Actually perform the write action' },
+    ],
+    columns: ['status', 'outcome', 'message', 'target_type', 'target'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for zhihu like');
+        requireExecute(kwargs);
+        const rawTarget = String(kwargs.target);
+        const target = assertAllowedKinds('like', parseTarget(rawTarget));
+        await page.goto(target.url);
+        const result = await page.evaluate(`(async () => {
+      const targetKind = ${JSON.stringify(target.kind)};
+      const targetQuestionId = ${JSON.stringify(target.kind === 'answer' ? target.questionId : null)};
+      const targetAnswerId = ${JSON.stringify(target.kind === 'answer' ? target.id : null)};
+
+      let btn = null;
+      if (targetKind === 'answer') {
+        const block = Array.from(document.querySelectorAll('article, .AnswerItem, [data-zop-question-answer]')).find((node) => {
+          const dataAnswerId = node.getAttribute('data-answerid') || node.getAttribute('data-zop-question-answer') || '';
+          if (dataAnswerId && dataAnswerId.includes(targetAnswerId)) return true;
+          return Array.from(node.querySelectorAll('a[href*="/answer/"]')).some((link) => {
+            const href = link.getAttribute('href') || '';
+            return href.includes('/question/' + targetQuestionId + '/answer/' + targetAnswerId);
+          });
+        });
+        if (!block) return { state: 'wrong_answer' };
+        const candidates = Array.from(block?.querySelectorAll('button') || []).filter((node) => {
+          const text = (node.textContent || '').trim();
+          const inCommentItem = Boolean(node.closest('[data-comment-id], .CommentItem'));
+          return /赞同|赞/.test(text) && node.hasAttribute('aria-pressed') && !inCommentItem;
+        });
+        if (candidates.length !== 1) return { state: 'ambiguous_answer_like' };
+        btn = candidates[0];
+      } else {
+        const articleRoot =
+          document.querySelector('article')
+          || document.querySelector('.Post-Main')
+          || document.querySelector('[itemprop="articleBody"]')
+          || document;
+        const candidates = Array.from(articleRoot.querySelectorAll('button')).filter((node) => {
+          const text = (node.textContent || '').trim();
+          return /赞同|赞/.test(text) && node.hasAttribute('aria-pressed');
+        });
+        if (candidates.length !== 1) return { state: 'ambiguous_article_like' };
+        btn = candidates[0];
+      }
+
+      if (!btn) return { state: 'missing' };
+      if (btn.getAttribute('aria-pressed') === 'true') return { state: 'already_liked' };
+
+      btn.click();
+      await new Promise((resolve) => setTimeout(resolve, 1200));
+
+      return btn.getAttribute('aria-pressed') === 'true'
+        ? { state: 'liked' }
+        : { state: 'unknown' };
+    })()`);
+        if (result?.state === 'wrong_answer') {
+            throw new CliError('TARGET_NOT_FOUND', 'Resolved answer target no longer matches the requested answer:<questionId>:<answerId>');
+        }
+        if (result?.state === 'already_liked') {
+            return buildResultRow(`Already liked ${target.kind}`, target.kind, rawTarget, 'already_applied');
+        }
+        if (result?.state === 'ambiguous_answer_like') {
+            throw new CliError('ACTION_NOT_AVAILABLE', 'Answer like control was not uniquely anchored on the requested answer');
+        }
+        if (result?.state === 'ambiguous_article_like') {
+            throw new CliError('ACTION_NOT_AVAILABLE', 'Article like control was not uniquely anchored on the requested target');
+        }
+        if (result?.state === 'missing') {
+            throw new CliError('ACTION_FAILED', 'Zhihu like control was missing before any write was dispatched');
+        }
+        if (result?.state !== 'liked') {
+            throw new CliError('OUTCOME_UNKNOWN', 'Zhihu like click was dispatched, but the final state could not be verified safely');
+        }
+        return buildResultRow(`Liked ${target.kind}`, target.kind, rawTarget, 'applied');
+    },
+});

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

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

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

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './like.js';
+describe('zhihu like', () => {
+    it('rejects article pages where the like control is not uniquely anchored', async () => {
+        const cmd = getRegistry().get('zhihu/like');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'ambiguous_article_like' }),
+        };
+        await expect(cmd.func(page, { target: 'article:9', execute: true })).rejects.toMatchObject({
+            code: 'ACTION_NOT_AVAILABLE',
+        });
+    });
+    it('returns already_applied for an already-liked article target', async () => {
+        const cmd = getRegistry().get('zhihu/like');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'already_liked' }),
+        };
+        await expect(cmd.func(page, { target: 'article:9', execute: true })).resolves.toEqual([
+            expect.objectContaining({ outcome: 'already_applied', target_type: 'article', target: 'article:9' }),
+        ]);
+    });
+    it('anchors to the requested answer block before clicking like', async () => {
+        const cmd = getRegistry().get('zhihu/like');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'liked' }),
+        };
+        await expect(cmd.func(page, { target: 'answer:123:456', execute: true })).resolves.toEqual([
+            expect.objectContaining({ outcome: 'applied', target_type: 'answer', target: 'answer:123:456' }),
+        ]);
+        expect(page.goto).toHaveBeenCalledWith('https://www.zhihu.com/question/123/answer/456');
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+        expect(page.evaluate.mock.calls[0][0]).toContain('targetQuestionId');
+        expect(page.evaluate.mock.calls[0][0]).toContain('"123"');
+        expect(page.evaluate.mock.calls[0][0]).toContain('"456"');
+        expect(page.evaluate.mock.calls[0][0]).toContain("node.getAttribute('data-answerid')");
+        expect(page.evaluate.mock.calls[0][0]).toContain("node.getAttribute('data-zop-question-answer')");
+    });
+    it('rejects answer targets when the answer-level like control is not unique', async () => {
+        const cmd = getRegistry().get('zhihu/like');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'ambiguous_answer_like' }),
+        };
+        await expect(cmd.func(page, { target: 'answer:123:456', execute: true })).rejects.toMatchObject({
+            code: 'ACTION_NOT_AVAILABLE',
+        });
+    });
+    it('maps missing answer blocks to TARGET_NOT_FOUND', async () => {
+        const cmd = getRegistry().get('zhihu/like');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'wrong_answer' }),
+        };
+        await expect(cmd.func(page, { target: 'answer:123:456', execute: true })).rejects.toMatchObject({
+            code: 'TARGET_NOT_FOUND',
+        });
+        expect(page.evaluate.mock.calls[0][0]).toContain("if (!block) return { state: 'wrong_answer' }");
+    });
+});

package/dist/clis/zhihu/search.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/zhihu/search.js

@@ -0,0 +1,52 @@
+import { cli } from '@jackwener/opencli/registry';
+cli({
+    site: 'zhihu',
+    name: 'search',
+    description: '知乎搜索',
+    domain: 'www.zhihu.com',
+    args: [
+        { name: 'query', required: true, positional: true, help: 'Search query' },
+        { name: 'limit', type: 'int', default: 10, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'type', 'author', 'votes', 'url'],
+    pipeline: [
+        { navigate: 'https://www.zhihu.com' },
+        { evaluate: `(async () => {
+  const strip = (html) => (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').replace(/<em>/g, '').replace(/<\\/em>/g, '').trim();
+  const keyword = \${{ args.query | json }};
+  const limit = \${{ args.limit }};
+  const res = await fetch('https://www.zhihu.com/api/v4/search_v3?q=' + encodeURIComponent(keyword) + '&t=general&offset=0&limit=' + limit, {
+    credentials: 'include'
+  });
+  const d = await res.json();
+  return (d?.data || [])
+    .filter(item => item.type === 'search_result')
+    .map(item => {
+      const obj = item.object || {};
+      const q = obj.question || {};
+      return {
+        type: obj.type,
+        title: strip(obj.title || q.name || ''),
+        excerpt: strip(obj.excerpt || '').substring(0, 100),
+        author: obj.author?.name || '',
+        votes: obj.voteup_count || 0,
+        url: obj.type === 'answer'
+          ? 'https://www.zhihu.com/question/' + q.id + '/answer/' + obj.id
+          : obj.type === 'article'
+          ? 'https://zhuanlan.zhihu.com/p/' + obj.id
+          : 'https://www.zhihu.com/question/' + obj.id,
+      };
+    });
+})()
+` },
+        { map: {
+                rank: '${{ index + 1 }}',
+                title: '${{ item.title }}',
+                type: '${{ item.type }}',
+                author: '${{ item.author }}',
+                votes: '${{ item.votes }}',
+                url: '${{ item.url }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/clis/zhihu/target.d.ts

@@ -0,0 +1,24 @@
+export type ZhihuTarget = {
+    kind: 'user';
+    slug: string;
+    url: string;
+} | {
+    kind: 'question';
+    id: string;
+    url: string;
+} | {
+    kind: 'answer';
+    questionId: string;
+    id: string;
+    url: string;
+} | {
+    kind: 'article';
+    id: string;
+    url: string;
+};
+export declare function parseTarget(input: string): ZhihuTarget;
+export declare function assertAllowedKinds(command: string, target: ZhihuTarget): ZhihuTarget;
+export declare const __test__: {
+    parseTarget: typeof parseTarget;
+    assertAllowedKinds: typeof assertAllowedKinds;
+};