@jackwener/opencli 1.7.8 → 1.7.10

package/clis/zhihu/comment.test.js

@@ -2,53 +2,49 @@ import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
 import './comment.js';
 describe('zhihu comment', () => {
-    it('rejects composer paths that are not proven side-effect free', async () => {
+    it('registers as a cookie browser command', () => {
+        const cmd = getRegistry().get('zhihu/comment');
+        expect(cmd).toBeDefined();
+        expect(cmd.strategy).toBe('cookie');
+        expect(cmd.browser).toBe(true);
+    });
+    it('creates a comment via API and returns result', async () => {
         const cmd = getRegistry().get('zhihu/comment');
-        expect(cmd?.func).toBeTypeOf('function');
         const page = {
             goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
             evaluate: vi.fn()
                 .mockResolvedValueOnce({ slug: 'alice' })
-                .mockResolvedValueOnce({ entryPathSafe: false })
-                .mockResolvedValueOnce({ wrongAnswer: false, rows: [], commentLinks: [] }),
+                .mockResolvedValueOnce({ ok: true, id: 99, url: 'https://www.zhihu.com/api/v4/comments/99' }),
         };
-        await expect(cmd.func(page, { target: 'answer:1:2', text: 'hello', execute: true })).rejects.toMatchObject({ code: 'ACTION_NOT_AVAILABLE' });
+        const rows = await cmd.func(page, { target: 'answer:1:2', text: 'hello', execute: true });
+        expect(rows).toEqual([
+            expect.objectContaining({ outcome: 'created', author_identity: 'alice' }),
+        ]);
     });
-    it('requires exact editor replacement before accepting fallback proof', async () => {
+    it('throws on API error', async () => {
         const cmd = getRegistry().get('zhihu/comment');
         const page = {
             goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
             evaluate: vi.fn()
                 .mockResolvedValueOnce({ slug: 'alice' })
-                .mockResolvedValueOnce({ entryPathSafe: true })
-                .mockResolvedValueOnce({ wrongAnswer: false, rows: [], commentLinks: [] })
-                .mockResolvedValueOnce({ composerState: 'fresh_top_level' })
-                .mockResolvedValueOnce({ editorContent: 'hello', mode: 'top_level' })
-                .mockResolvedValueOnce({
-                proofType: 'fallback',
-                createdProof: {
-                    proof_type: 'comment_fallback',
-                    author_scope: 'current_user',
-                    target_scope: 'requested_target',
-                    comment_scope: 'top_level_only',
-                    content_match: 'exact_normalized',
-                    observed_after_submit: true,
-                    present_in_pre_submit_snapshot: false,
-                    new_matching_entries: 1,
-                    post_submit_matching_entries: 1,
-                    snapshot_scope: 'stabilized_expanded_target_comment_list',
-                },
-            }),
+                .mockResolvedValueOnce({ ok: false, status: 403, message: 'forbidden' }),
         };
-        await expect(cmd.func(page, { target: 'answer:1:2', text: 'hello', execute: true })).resolves.toEqual([
-            expect.objectContaining({ outcome: 'created', author_identity: 'alice', created_proof: expect.any(Object) }),
-        ]);
-        expect(page.evaluate.mock.calls[1][0]).toContain('topLevelCandidates.length === 1');
-        expect(page.evaluate.mock.calls[1][0]).not.toContain('commentTrigger');
-        expect(page.evaluate.mock.calls[2][0]).toContain("node.getAttribute('data-answerid')");
-        expect(page.evaluate.mock.calls[2][0]).toContain("node.getAttribute('data-zop-question-answer')");
-        expect(page.evaluate.mock.calls[5][0]).toContain('const readCommentAuthorSlug = (node) =>');
-        expect(page.evaluate.mock.calls[5][0]).toContain('const commentAuthorScopeSelector = ".CommentItemV2-head, .CommentItem-head, .CommentItemV2-meta, .CommentItem-meta, .CommentItemV2-metaSibling, [data-comment-author], [itemprop=\\"author\\"]"');
-        expect(page.evaluate.mock.calls[5][0]).not.toContain("card?.querySelector('a[href^=\"/people/\"]')");
+        await expect(cmd.func(page, { target: 'answer:1:2', text: 'hello', execute: true }))
+            .rejects.toMatchObject({ code: 'COMMAND_EXEC' });
+    });
+    it('requires the comment API response to include the created id', async () => {
+        const cmd = getRegistry().get('zhihu/comment');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ slug: 'alice' })
+                .mockResolvedValueOnce({ ok: false, status: 200, message: 'Comment API response did not include a created comment id' }),
+        };
+        await expect(cmd.func(page, { target: 'answer:1:2', text: 'hello', execute: true }))
+            .rejects.toMatchObject({ code: 'COMMAND_EXEC' });
+        expect(page.evaluate.mock.calls[1][0]).toContain('Comment API response did not include a created comment id');
     });
 });

package/clis/zhihu/favorite.js

@@ -2,9 +2,6 @@ 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';
-function rowKey(row) {
-    return row.id || `name:${normalizeCollectionName(row.name)}`;
-}
 function normalizeCollectionName(value) {
     return value
         .replace(/\s+/g, ' ')
@@ -17,7 +14,7 @@ cli({
     name: 'favorite',
     description: 'Favorite a Zhihu answer or article into a specific collection',
     domain: 'zhihu.com',
-    strategy: Strategy.UI,
+    strategy: Strategy.COOKIE,
     browser: true,
     args: [
         { name: 'target', positional: true, required: true, help: 'Zhihu target URL or typed target' },
@@ -37,188 +34,53 @@ cli({
         if ((collectionName ? 1 : 0) + (collectionId ? 1 : 0) !== 1) {
             throw new CliError('INVALID_INPUT', 'Use exactly one of --collection or --collection-id');
         }
-        await page.goto(target.url);
-        const preflight = 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)};
-      const wantedName = ${JSON.stringify(collectionName ?? null)};
-      const wantedId = ${JSON.stringify(collectionId ?? null)};
-
-      let scope = document;
-      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 { wrongAnswer: true, chooserRows: [] };
-        scope = block;
-      } else {
-        scope =
-          document.querySelector('article')
-          || document.querySelector('.Post-Main')
-          || document.querySelector('[itemprop="articleBody"]')
-          || document;
-      }
-
-      const favoriteButton = Array.from(scope.querySelectorAll('button')).find((node) => /收藏/.test(node.textContent || ''));
-      if (!favoriteButton) return { wrongAnswer: false, missingChooser: true, chooserRows: [] };
-      favoriteButton.click();
-      await new Promise((resolve) => setTimeout(resolve, 600));
-
-      const chooserRows = Array.from(document.querySelectorAll('[role="dialog"] li, [role="dialog"] [role="checkbox"], [role="dialog"] button'))
-        .map((node) => {
-          const text = (node.textContent || '').trim();
-          const id = node.getAttribute('data-id') || node.getAttribute('data-collection-id') || '';
-          const selected = node.getAttribute('aria-checked') === 'true'
-            || node.getAttribute('aria-pressed') === 'true'
-            || /已选|已收藏/.test(text);
-          return text ? { id, name: text, selected } : null;
-        })
-        .filter(Boolean);
+        await page.goto('https://www.zhihu.com');
+        await page.wait(2);
+        const apiResult = await page.evaluate(`(async () => {
+            var collectionId = ${JSON.stringify(collectionId || null)};
+            var collectionName = ${JSON.stringify(collectionName || null)};
+            var targetKind = ${JSON.stringify(target.kind)};
+            var targetId = ${JSON.stringify(target.id)};
+            var normalizeCollectionName = function(value) {
+                return String(value || '')
+                    .replace(/\\s+/g, ' ')
+                    .replace(/\\s+\\d+\\s*(条内容|个内容|items?)$/i, '')
+                    .replace(/\\s+(公开|私密|默认)$/i, '')
+                    .trim()
+                    .toLowerCase();
+            };
 
-      return {
-        wrongAnswer: false,
-        missingChooser: chooserRows.length === 0,
-        chooserRows,
-        targetRowId: wantedId,
-        targetRowName: wantedName,
-      };
-    })()`);
-        if (preflight.wrongAnswer) {
-            throw new CliError('TARGET_NOT_FOUND', 'Resolved answer target no longer matches the requested answer:<questionId>:<answerId>');
-        }
-        if (preflight.missingChooser) {
-            throw new CliError('ACTION_NOT_AVAILABLE', 'Favorite chooser did not open on the requested target');
-        }
-        const matchingRows = preflight.chooserRows.filter((row) => (collectionId
-            ? row.id === collectionId
-            : normalizeCollectionName(row.name) === normalizeCollectionName(collectionName || '')));
-        if (collectionId && !matchingRows.some((row) => row.id === collectionId)) {
-            throw new CliError('ACTION_NOT_AVAILABLE', 'Favorite chooser could not confirm the requested stable collection id');
-        }
-        if (!collectionId && matchingRows.length !== 1) {
-            throw new CliError('ACTION_NOT_AVAILABLE', 'Favorite chooser could not prove that the requested collection name is globally unique');
-        }
-        const targetRow = matchingRows[0];
-        const targetRowKey = rowKey(targetRow);
-        const selectedBefore = preflight.chooserRows.filter((row) => row.selected).map(rowKey);
-        const verify = 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)};
-      const targetWasSelected = ${JSON.stringify(targetRow.selected)};
-      const wantedName = ${JSON.stringify(collectionName ?? null)};
-      const wantedId = ${JSON.stringify(collectionId ?? null)};
-      const normalizeCollectionName = (value) => String(value || '')
-        .replace(/\\s+/g, ' ')
-        .replace(/\\s+\\d+\\s*(条内容|个内容|items?)$/i, '')
-        .replace(/\\s+(公开|私密|默认)$/i, '')
-        .trim();
-      const rowKey = (row) => row.id || 'name:' + normalizeCollectionName(row.name);
+            if (!collectionId && collectionName) {
+                var listResp = await fetch('https://www.zhihu.com/api/v4/people/self/collections?limit=50', { credentials: 'include' });
+                if (!listResp.ok) return { ok: false, message: 'Failed to list collections: HTTP ' + listResp.status };
+                var listData = {};
+                try { listData = await listResp.json(); } catch(e) {
+                    return { ok: false, message: 'Failed to parse collection list' };
+                }
+                var needle = normalizeCollectionName(collectionName);
+                var matches = (listData.data || []).filter(function(c) { return normalizeCollectionName(c.title) === needle; });
+                if (matches.length === 0) return { ok: false, message: 'Collection not found: ' + collectionName };
+                if (matches.length > 1) return { ok: false, message: 'Collection name is ambiguous: ' + collectionName };
+                collectionId = String(matches[0].id);
+            }
 
-      const chooserSelector = '[role="dialog"] li, [role="dialog"] [role="checkbox"], [role="dialog"] button';
-      const readChooserRows = () => Array.from(document.querySelectorAll(chooserSelector))
-        .map((node) => {
-          const text = (node.textContent || '').trim();
-          const id = node.getAttribute('data-id') || node.getAttribute('data-collection-id') || '';
-          const selected = node.getAttribute('aria-checked') === 'true'
-            || node.getAttribute('aria-pressed') === 'true'
-            || /已选|已收藏/.test(text);
-          return text ? { id, name: text, selected } : null;
-        })
-        .filter(Boolean);
-      const waitForChooserRows = async (expectedPresent) => {
-        for (let attempt = 0; attempt < 10; attempt += 1) {
-          const rows = readChooserRows();
-          if (expectedPresent ? rows.length > 0 : rows.length === 0) return rows;
-          await new Promise((resolve) => setTimeout(resolve, 150));
-        }
-        return readChooserRows();
-      };
-      const closeChooser = async () => {
-        const closeButton = Array.from(document.querySelectorAll('[role="dialog"] button, [role="dialog"] [role="button"]')).find((node) => {
-          const text = (node.textContent || '').trim();
-          const aria = node.getAttribute('aria-label') || '';
-          return /关闭|取消|收起/.test(text) || /关闭|cancel|close/i.test(aria);
-        });
-        closeButton && closeButton.click();
-        return waitForChooserRows(false);
-      };
-      const reopenChooser = async () => {
-        let scope = document;
-        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);
+            var resp = await fetch('https://www.zhihu.com/api/v4/favlists/' + collectionId + '/items', {
+                method: 'POST',
+                credentials: 'include',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ item_id: targetId, item_type: targetKind }),
             });
-          });
-          if (!block) return [];
-          scope = block;
-        } else {
-          scope =
-            document.querySelector('article')
-            || document.querySelector('.Post-Main')
-            || document.querySelector('[itemprop="articleBody"]')
-            || document;
-        }
-        const favoriteButton = Array.from(scope.querySelectorAll('button')).find((node) => /收藏/.test(node.textContent || ''));
-        favoriteButton && favoriteButton.click();
-        return waitForChooserRows(true);
-      };
-
-      let chooserRows = readChooserRows();
-      let sawChooserClose = false;
-      if (!targetWasSelected) {
-        const row = Array.from(document.querySelectorAll('[role="dialog"] li, [role="dialog"] [role="checkbox"], [role="dialog"] button')).find((node) => {
-          const text = (node.textContent || '').trim();
-          const id = node.getAttribute('data-id') || node.getAttribute('data-collection-id') || '';
-          return wantedId ? id === wantedId : normalizeCollectionName(text) === normalizeCollectionName(wantedName);
-        });
-        row && row.click();
-        await new Promise((resolve) => setTimeout(resolve, 300));
-        const submit = Array.from(document.querySelectorAll('[role="dialog"] button')).find((node) => /完成|确定|保存/.test(node.textContent || ''));
-        submit && submit.click();
-        chooserRows = await waitForChooserRows(false);
-        sawChooserClose = chooserRows.length === 0;
-      } else {
-        chooserRows = await closeChooser();
-        sawChooserClose = chooserRows.length === 0;
-      }
-      if (sawChooserClose) {
-        chooserRows = await reopenChooser();
-      }
-
-      return {
-        persisted: sawChooserClose && chooserRows.length > 0,
-        readbackSource: sawChooserClose && chooserRows.length > 0 ? 'reopened_chooser' : (chooserRows.length > 0 ? 'same_modal' : 'missing'),
-        selectedAfter: chooserRows.filter((row) => row.selected).map(rowKey),
-        targetSelected: chooserRows.some((row) => rowKey(row) === ${JSON.stringify(targetRowKey)} && row.selected),
-      };
-    })()`);
-        if (!verify.persisted) {
-            throw new CliError('OUTCOME_UNKNOWN', 'Favorite action may have been applied, but persisted read-back was unavailable');
-        }
-        if (verify.readbackSource !== 'reopened_chooser') {
-            throw new CliError('OUTCOME_UNKNOWN', 'Favorite state was not re-read from a reopened chooser after submit');
-        }
-        if (!verify.targetSelected) {
-            throw new CliError('OUTCOME_UNKNOWN', 'Favorite chooser remained readable, but the requested collection was not confirmed as selected');
-        }
-        if (!selectedBefore.every((row) => verify.selectedAfter.includes(row))) {
-            throw new CliError('OUTCOME_UNKNOWN', `Favorite action changed unrelated collection membership: before=${JSON.stringify(selectedBefore)} after=${JSON.stringify(verify.selectedAfter)}`);
+            if (resp.ok || resp.status === 204) return { ok: true, collectionId: collectionId };
+            var data = {};
+            try { data = await resp.json(); } catch(e) {}
+            return { ok: false, message: data.error ? data.error.message : 'HTTP ' + resp.status };
+        })()`);
+        if (!apiResult?.ok) {
+            throw new CliError('COMMAND_EXEC', apiResult?.message || 'Failed to favorite');
         }
-        const outcome = targetRow.selected ? 'already_applied' : 'applied';
-        return buildResultRow(targetRow.selected ? `Already favorited ${target.kind}` : `Favorited ${target.kind}`, target.kind, rawTarget, outcome, {
-            collection_name: collectionName ?? targetRow.name,
-            ...(targetRow.id ? { collection_id: targetRow.id } : {}),
+        return buildResultRow(`Favorited ${target.kind} ${target.id}`, target.kind, rawTarget, 'applied', {
+            collection_name: collectionName || '',
+            collection_id: apiResult.collectionId || collectionId || '',
         });
     },
 });

package/clis/zhihu/favorite.test.js

@@ -2,195 +2,58 @@ 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 () => {
+    it('registers as a cookie browser command', () => {
         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();
+        expect(cmd).toBeDefined();
+        expect(cmd.strategy).toBe('cookie');
     });
-    it('requires persisted read-back and preserves previously selected collections', async () => {
+    it('favorites via API with collection-id', 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,
-            }),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValueOnce({ ok: true, collectionId: '123' }),
         };
-        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");
+        const rows = await cmd.func(page, { target: 'answer:1:2', 'collection-id': '123', execute: true });
+        expect(rows).toEqual([expect.objectContaining({ outcome: 'applied', collection_id: '123' })]);
     });
-    it('requires persisted read-back before returning already_applied', async () => {
+    it('throws on API error', 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,
-            }),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValueOnce({ ok: false, message: 'collection not found' }),
         };
-        await expect(cmd.func(page, { target: 'article:1', collection: '默认收藏夹', execute: true })).resolves.toEqual([
-            expect.objectContaining({ outcome: 'already_applied', collection_name: '默认收藏夹' }),
-        ]);
+        await expect(cmd.func(page, { target: 'answer:1:2', 'collection-id': '123', execute: true }))
+            .rejects.toMatchObject({ code: 'COMMAND_EXEC' });
     });
-    it('accepts --collection-id as the stable selector path', async () => {
+    it('requires exact normalized collection-name matches', 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,
-            }),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValueOnce({ ok: false, message: 'Collection not found: AI' }),
         };
-        await expect(cmd.func(page, { target: 'article:1', 'collection-id': 'fav-b', execute: true })).resolves.toEqual([
-            expect.objectContaining({ outcome: 'applied', collection_id: 'fav-b' }),
-        ]);
+        await expect(cmd.func(page, { target: 'answer:1:2', collection: 'AI', execute: true }))
+            .rejects.toMatchObject({ code: 'COMMAND_EXEC' });
+        expect(page.evaluate.mock.calls[0][0]).toContain('normalizeCollectionName(c.title) === needle');
+        expect(page.evaluate.mock.calls[0][0]).not.toContain('.includes(needle)');
     });
-    it('rejects duplicate collection names before selecting any row', async () => {
+    it('fails fast on ambiguous collection-name matches', 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 },
-                ],
-            }),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValueOnce({ ok: false, message: 'Collection name is ambiguous: 默认收藏夹' }),
         };
-        await expect(cmd.func(page, { target: 'article:1', collection: '默认收藏夹', execute: true })).rejects.toMatchObject({ code: 'ACTION_NOT_AVAILABLE' });
+        await expect(cmd.func(page, { target: 'answer:1:2', collection: '默认收藏夹', execute: true }))
+            .rejects.toMatchObject({ code: 'COMMAND_EXEC' });
+        expect(page.evaluate.mock.calls[0][0]).toContain('matches.length > 1');
     });
-    it('rejects optimistic chooser state that was not re-read from a reopened chooser', async () => {
+    it('requires exactly one of --collection or --collection-id', 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')");
+        const page = { goto: vi.fn(), wait: vi.fn(), evaluate: vi.fn() };
+        await expect(cmd.func(page, { target: 'answer:1:2', execute: true }))
+            .rejects.toMatchObject({ code: 'INVALID_INPUT' });
     });
 });