@jackwener/opencli 1.6.7 → 1.6.9

package/dist/clis/zhihu/answer.js

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

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

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

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

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

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

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

package/dist/clis/zhihu/comment.js

@@ -0,0 +1,335 @@
+import { CliError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { assertAllowedKinds, parseTarget } from './target.js';
+import { buildResultRow, requireExecute, resolveCurrentUserIdentity, resolvePayload } from './write-shared.js';
+const COMMENT_AUTHOR_SCOPE_SELECTOR = '.CommentItemV2-head, .CommentItem-head, .CommentItemV2-meta, .CommentItem-meta, .CommentItemV2-metaSibling, [data-comment-author], [itemprop="author"]';
+cli({
+    site: 'zhihu',
+    name: 'comment',
+    description: 'Create a top-level comment on 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: 'text', positional: true, help: 'Comment text' },
+        { name: 'file', help: 'Comment text file path' },
+        { name: 'execute', type: 'boolean', help: 'Actually perform the write action' },
+    ],
+    columns: ['status', 'outcome', 'message', 'target_type', 'target', 'author_identity', 'created_url', 'created_proof'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for zhihu comment');
+        requireExecute(kwargs);
+        const rawTarget = String(kwargs.target);
+        const target = assertAllowedKinds('comment', parseTarget(rawTarget));
+        const payload = await resolvePayload(kwargs);
+        await page.goto(target.url);
+        const authorIdentity = await resolveCurrentUserIdentity(page);
+        const entryPath = await page.evaluate(`(() => {
+      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 restoredDraft = !!document.querySelector('[contenteditable="true"][data-draft-restored], textarea[data-draft-restored]');
+      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 { entryPathSafe: false, wrongAnswer: true };
+        scope = block;
+      } else {
+        scope =
+          document.querySelector('article')
+          || document.querySelector('.Post-Main')
+          || document.querySelector('[itemprop="articleBody"]')
+          || document;
+      }
+      const topLevelCandidates = Array.from(scope.querySelectorAll('[contenteditable="true"], textarea')).map((editor) => {
+        const container = editor.closest('form, .CommentEditor, .CommentForm, .CommentsV2-footer, [data-comment-editor]') || editor.parentElement;
+        const replyHint = editor.getAttribute('data-reply-to') || '';
+        const text = 'value' in editor ? editor.value || '' : (editor.textContent || '');
+        const nestedReply = Boolean(container?.closest('[data-comment-id], .CommentItem'));
+        return { editor, container, replyHint, text, nestedReply };
+      }).filter((candidate) => candidate.container && !candidate.nestedReply);
+      return {
+        entryPathSafe: topLevelCandidates.length === 1
+          && !restoredDraft
+          && !topLevelCandidates[0].replyHint
+          && !String(topLevelCandidates[0].text || '').trim(),
+        wrongAnswer: false,
+      };
+    })()`);
+        if (entryPath.wrongAnswer) {
+            throw new CliError('TARGET_NOT_FOUND', 'Resolved answer target no longer matches the requested answer:<questionId>:<answerId>');
+        }
+        if (!entryPath.entryPathSafe) {
+            throw new CliError('ACTION_NOT_AVAILABLE', 'Comment entry path was not proven side-effect free');
+        }
+        const beforeSubmitSnapshot = await page.evaluate(`(() => {
+      const normalize = (value) => value.replace(/\\s+/g, ' ').trim();
+      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 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, rows: [], commentLinks: [] };
+        scope = block;
+      } else {
+        scope =
+          document.querySelector('article')
+          || document.querySelector('.Post-Main')
+          || document.querySelector('[itemprop="articleBody"]')
+          || document;
+      }
+      return {
+        wrongAnswer: false,
+        rows: Array.from(scope.querySelectorAll('[data-comment-id], .CommentItem')).map((node) => ({
+          id: node.getAttribute('data-comment-id') || '',
+          text: normalize(node.textContent || ''),
+        })),
+        commentLinks: Array.from(scope.querySelectorAll('a[href*="/comment/"]'))
+          .map((node) => node.getAttribute('href') || '')
+          .filter(Boolean),
+      };
+    })()`);
+        if (beforeSubmitSnapshot.wrongAnswer) {
+            throw new CliError('TARGET_NOT_FOUND', 'Resolved answer target no longer matches the requested answer:<questionId>:<answerId>');
+        }
+        const composer = 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 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 { composerState: 'wrong_answer' };
+        scope = block;
+      } else {
+        scope =
+          document.querySelector('article')
+          || document.querySelector('.Post-Main')
+          || document.querySelector('[itemprop="articleBody"]')
+          || document;
+      }
+      const topLevelCandidates = Array.from(scope.querySelectorAll('[contenteditable="true"], textarea')).map((editor) => {
+        const container = editor.closest('form, .CommentEditor, .CommentForm, .CommentsV2-footer, [data-comment-editor]') || editor.parentElement;
+        const replyHint = editor.getAttribute('data-reply-to') || '';
+        const text = 'value' in editor ? editor.value || '' : (editor.textContent || '');
+        const nestedReply = Boolean(container?.closest('[data-comment-id], .CommentItem'));
+        return { editor, container, replyHint, text, nestedReply };
+      }).filter((candidate) => candidate.container && !candidate.nestedReply);
+      if (topLevelCandidates.length !== 1) return { composerState: 'unsafe' };
+      return {
+        composerState: !topLevelCandidates[0].replyHint && !topLevelCandidates[0].text.trim() ? 'fresh_top_level' : 'unsafe',
+      };
+    })()`);
+        if (composer.composerState === 'wrong_answer') {
+            throw new CliError('TARGET_NOT_FOUND', 'Resolved answer target no longer matches the requested answer:<questionId>:<answerId>');
+        }
+        if (composer.composerState !== 'fresh_top_level') {
+            throw new CliError('ACTION_NOT_AVAILABLE', 'Comment composer was not a fresh top-level composer');
+        }
+        const editorCheck = await page.evaluate(`(async () => {
+      const textToInsert = ${JSON.stringify(payload)};
+      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 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 { editorContent: '', mode: 'wrong_answer' };
+        scope = block;
+      } else {
+        scope =
+          document.querySelector('article')
+          || document.querySelector('.Post-Main')
+          || document.querySelector('[itemprop="articleBody"]')
+          || document;
+      }
+      const topLevelCandidates = Array.from(scope.querySelectorAll('[contenteditable="true"], textarea')).map((editor) => {
+        const container = editor.closest('form, .CommentEditor, .CommentForm, .CommentsV2-footer, [data-comment-editor]') || editor.parentElement;
+        const nestedReply = Boolean(container?.closest('[data-comment-id], .CommentItem'));
+        return { editor, container, nestedReply };
+      }).filter((candidate) => candidate.container && !candidate.nestedReply);
+      if (topLevelCandidates.length !== 1) return { editorContent: '', mode: 'missing' };
+      const { editor } = topLevelCandidates[0];
+      editor.focus();
+      if ('value' in editor) {
+        editor.value = '';
+        editor.dispatchEvent(new Event('input', { bubbles: true }));
+        editor.value = textToInsert;
+        editor.dispatchEvent(new Event('input', { bubbles: true }));
+      } else {
+        editor.textContent = '';
+        document.execCommand('insertText', false, textToInsert);
+        editor.dispatchEvent(new InputEvent('input', { bubbles: true, data: textToInsert, inputType: 'insertText' }));
+      }
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      const content = 'value' in editor ? editor.value : (editor.textContent || '');
+      const replyHint = editor.getAttribute('data-reply-to') || '';
+      return { editorContent: content, mode: replyHint ? 'reply' : 'top_level' };
+    })()`);
+        if (editorCheck.mode === 'wrong_answer') {
+            throw new CliError('TARGET_NOT_FOUND', 'Resolved answer target no longer matches the requested answer:<questionId>:<answerId>');
+        }
+        if (editorCheck.mode !== 'top_level' || editorCheck.editorContent !== payload) {
+            throw new CliError('OUTCOME_UNKNOWN', 'Comment editor content did not exactly match the requested payload before submit');
+        }
+        const proof = await page.evaluate(`(async () => {
+      const normalize = (value) => value.replace(/\\s+/g, ' ').trim();
+      const commentAuthorScopeSelector = ${JSON.stringify(COMMENT_AUTHOR_SCOPE_SELECTOR)};
+      const readCommentAuthorSlug = (node) => {
+        const authorScopes = Array.from(node.querySelectorAll(commentAuthorScopeSelector));
+        const slugs = Array.from(new Set(authorScopes
+          .flatMap((scope) => Array.from(scope.querySelectorAll('a[href^="/people/"]')))
+          .map((link) => (link.getAttribute('href') || '').match(/^\\/people\\/([A-Za-z0-9_-]+)/)?.[1] || null)
+          .filter(Boolean)));
+        return slugs.length === 1 ? slugs[0] : null;
+      };
+      const 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 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 { proofType: 'wrong_answer' };
+        scope = block;
+      } else {
+        scope =
+          document.querySelector('article')
+          || document.querySelector('.Post-Main')
+          || document.querySelector('[itemprop="articleBody"]')
+          || document;
+      }
+
+      const topLevelCandidates = Array.from(scope.querySelectorAll('[contenteditable="true"], textarea')).map((editor) => {
+        const container = editor.closest('form, [role="dialog"], .CommentEditor, .CommentForm, .CommentsV2-footer, [data-comment-editor]') || editor.parentElement;
+        const nestedReply = Boolean(container?.closest('[data-comment-id], .CommentItem'));
+        return { editor, container, nestedReply };
+      }).filter((candidate) => candidate.container && !candidate.nestedReply);
+      if (topLevelCandidates.length !== 1) return { proofType: 'unknown' };
+      const submitScope = topLevelCandidates[0].container || scope;
+      const submit = Array.from(submitScope.querySelectorAll('button')).find((node) => /发布|评论|发送/.test(node.textContent || ''));
+      submit && submit.click();
+      await new Promise((resolve) => setTimeout(resolve, 1200));
+      const createdLink = Array.from(scope.querySelectorAll('a[href*="/comment/"]')).find((node) => {
+        const href = node.getAttribute('href') || '';
+        return href.includes('/comment/') && !${JSON.stringify(beforeSubmitSnapshot.commentLinks ?? [])}.includes(href);
+      });
+
+      if (createdLink) {
+        const card = createdLink.closest('[data-comment-id], .CommentItem, li');
+        const authorSlug = card ? readCommentAuthorSlug(card) : null;
+        const contentNode =
+          card?.querySelector('[data-comment-content], .RichContent-inner, .CommentItemV2-content, .CommentContent')
+          || card;
+        const text = normalize(contentNode?.textContent || '');
+        const nestedReply = Boolean(card?.closest('ul ul, ol ol, li li') || card?.parentElement?.closest('[data-comment-id], .CommentItem'));
+        return {
+          proofType: 'stable_url',
+          createdUrl: new URL(createdLink.getAttribute('href') || '', location.origin).href,
+          commentScope: nestedReply ? 'nested_reply' : 'top_level_only',
+          authorIdentity: authorSlug,
+          targetMatches: text === normalize(${JSON.stringify(payload)}),
+        };
+      }
+
+      const currentUserSlug = ${JSON.stringify(authorIdentity)};
+      const beforeIds = new Set(${JSON.stringify((beforeSubmitSnapshot.rows ?? []).map((row) => row.id).filter(Boolean))});
+      const beforeTexts = new Set(${JSON.stringify((beforeSubmitSnapshot.rows ?? []).map((row) => row.text).filter(Boolean))});
+      const normalizedPayload = normalize(${JSON.stringify(payload)});
+      const after = Array.from(scope.querySelectorAll('[data-comment-id], .CommentItem')).map((node) => {
+        return {
+          id: node.getAttribute('data-comment-id') || '',
+          text: normalize(node.textContent || ''),
+          authorSlug: readCommentAuthorSlug(node),
+          topLevel: !node.closest('ul ul, ol ol, li li') && !node.parentElement?.closest('[data-comment-id], .CommentItem'),
+        };
+      });
+
+      const matching = after.filter((row) =>
+        !beforeIds.has(row.id)
+        && row.authorSlug === currentUserSlug
+        && row.topLevel
+        && row.text === normalizedPayload
+        && !beforeTexts.has(row.text)
+      );
+
+      return matching.length === 1
+        ? {
+            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: after.filter((row) =>
+                row.authorSlug === currentUserSlug && row.topLevel && row.text === normalizedPayload
+              ).length,
+              snapshot_scope: ${JSON.stringify(target.kind === 'answer'
+            ? 'stabilized_expanded_target_answer_comment_list'
+            : 'stabilized_expanded_target_article_comment_list')},
+            },
+          }
+        : { proofType: 'unknown' };
+    })()`);
+        if (proof.proofType === 'wrong_answer') {
+            throw new CliError('TARGET_NOT_FOUND', 'Resolved answer target no longer matches the requested answer:<questionId>:<answerId>');
+        }
+        if (proof.proofType === 'fallback') {
+            return buildResultRow(`Commented on ${target.kind}`, target.kind, rawTarget, 'created', {
+                author_identity: authorIdentity,
+                created_proof: proof.createdProof,
+            });
+        }
+        if (proof.proofType !== 'stable_url') {
+            throw new CliError('OUTCOME_UNKNOWN', 'Comment submit was dispatched, but the created object could not be proven safely');
+        }
+        if (proof.commentScope !== 'top_level_only' || proof.authorIdentity !== authorIdentity || !proof.targetMatches) {
+            throw new CliError('OUTCOME_UNKNOWN', 'Stable comment URL was found, but authorship or top-level scope could not be proven safely');
+        }
+        return buildResultRow(`Commented on ${target.kind}`, target.kind, rawTarget, 'created', {
+            author_identity: authorIdentity,
+            created_url: proof.createdUrl,
+        });
+    },
+});

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

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