@jackwener/opencli 1.6.7 → 1.6.9

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

@@ -0,0 +1,54 @@
+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 () => {
+        const cmd = getRegistry().get('zhihu/comment');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ slug: 'alice' })
+                .mockResolvedValueOnce({ entryPathSafe: false })
+                .mockResolvedValueOnce({ wrongAnswer: false, rows: [], commentLinks: [] }),
+        };
+        await expect(cmd.func(page, { target: 'answer:1:2', text: 'hello', execute: true })).rejects.toMatchObject({ code: 'ACTION_NOT_AVAILABLE' });
+    });
+    it('requires exact editor replacement before accepting fallback proof', async () => {
+        const cmd = getRegistry().get('zhihu/comment');
+        const page = {
+            goto: 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',
+                },
+            }),
+        };
+        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/\"]')");
+    });
+});

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

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

package/dist/clis/zhihu/favorite.js

@@ -0,0 +1,224 @@
+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, ' ')
+        .replace(/\s+\d+\s*(条内容|个内容|items?)$/i, '')
+        .replace(/\s+(公开|私密|默认)$/i, '')
+        .trim();
+}
+cli({
+    site: 'zhihu',
+    name: 'favorite',
+    description: 'Favorite a Zhihu answer or article into a specific collection',
+    domain: 'zhihu.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'target', positional: true, required: true, help: 'Zhihu target URL or typed target' },
+        { name: 'collection', help: 'Collection name' },
+        { name: 'collection-id', help: 'Stable collection id' },
+        { name: 'execute', type: 'boolean', help: 'Actually perform the write action' },
+    ],
+    columns: ['status', 'outcome', 'message', 'target_type', 'target', 'collection_name', 'collection_id'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for zhihu favorite');
+        requireExecute(kwargs);
+        const rawTarget = String(kwargs.target);
+        const target = assertAllowedKinds('favorite', parseTarget(rawTarget));
+        const collectionName = typeof kwargs.collection === 'string' ? kwargs.collection : undefined;
+        const collectionId = typeof kwargs['collection-id'] === 'string' ? kwargs['collection-id'] : undefined;
+        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);
+
+      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);
+
+      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);
+            });
+          });
+          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)}`);
+        }
+        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 } : {}),
+        });
+    },
+});

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

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

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/like.d.ts

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