@jackwener/opencli 1.6.8 → 1.6.9

package/dist/clis/quark/utils.js

@@ -0,0 +1,146 @@
+import { ArgumentError, AuthRequiredError, CommandExecutionError, getErrorMessage } from '@jackwener/opencli/errors';
+export const SHARE_API = 'https://drive-h.quark.cn/1/clouddrive/share/sharepage';
+export const DRIVE_API = 'https://drive-pc.quark.cn/1/clouddrive/file';
+export const TASK_API = 'https://drive-pc.quark.cn/1/clouddrive/task';
+const QUARK_DOMAIN = 'pan.quark.cn';
+const AUTH_HINT = 'Quark Drive requires a logged-in browser session';
+function isAuthFailure(message, status) {
+    if (status === 401 || status === 403)
+        return true;
+    return /not logged in|login required|please log in|authentication required|unauthorized|forbidden|未登录|请先登录|需要登录|登录/.test(message.toLowerCase());
+}
+function getErrorStatus(error) {
+    if (!error || typeof error !== 'object' || !('status' in error))
+        return undefined;
+    const status = error.status;
+    return typeof status === 'number' ? status : undefined;
+}
+function unwrapApiData(resp, action) {
+    if (resp.status === 200)
+        return resp.data;
+    if (isAuthFailure(resp.message, resp.status)) {
+        throw new AuthRequiredError(QUARK_DOMAIN, AUTH_HINT);
+    }
+    throw new CommandExecutionError(`quark: ${action}: ${resp.message}`);
+}
+export function extractPwdId(url) {
+    const m = url.match(/\/s\/([a-zA-Z0-9]+)/);
+    if (m)
+        return m[1];
+    if (/^[a-zA-Z0-9]+$/.test(url))
+        return url;
+    throw new ArgumentError(`Invalid Quark share URL: ${url}`);
+}
+export async function fetchJson(page, url, options) {
+    const method = options?.method || 'GET';
+    const body = options?.body ? JSON.stringify(options.body) : undefined;
+    const js = `fetch(${JSON.stringify(url)}, {
+    method: ${JSON.stringify(method)},
+    headers: { 'Content-Type': 'application/json' },
+    credentials: 'include',
+    ${body ? `body: ${JSON.stringify(body)},` : ''}
+  }).then(async r => {
+    const ct = r.headers.get('content-type') || '';
+    if (!ct.includes('json')) {
+      const text = await r.text().catch(() => '');
+      throw Object.assign(new Error('Non-JSON response: ' + text.slice(0, 200)), { status: r.status });
+    }
+    return r.json();
+  })`;
+    try {
+        return await page.evaluate(js);
+    }
+    catch (error) {
+        if (isAuthFailure(getErrorMessage(error), getErrorStatus(error))) {
+            throw new AuthRequiredError(QUARK_DOMAIN, AUTH_HINT);
+        }
+        throw error;
+    }
+}
+export async function apiGet(page, url) {
+    const resp = await fetchJson(page, url);
+    return unwrapApiData(resp, 'API error');
+}
+export async function apiPost(page, url, body) {
+    const resp = await fetchJson(page, url, { method: 'POST', body });
+    return unwrapApiData(resp, 'API error');
+}
+export async function getToken(page, pwdId, passcode = '') {
+    const data = await fetchJson(page, `${SHARE_API}/token?pr=ucpro&fr=pc`, {
+        method: 'POST',
+        body: { pwd_id: pwdId, passcode, support_visit_limit_private_share: true },
+    });
+    return unwrapApiData(data, 'Failed to get token').stoken;
+}
+export async function getShareList(page, pwdId, stoken, pdirFid = '0', options) {
+    const allFiles = [];
+    let pageNum = 1;
+    let total = 0;
+    do {
+        const sortParam = options?.sort ? `&_sort=${options.sort}` : '';
+        const url = `${SHARE_API}/detail?pr=ucpro&fr=pc&ver=2&pwd_id=${pwdId}&stoken=${encodeURIComponent(stoken)}&pdir_fid=${pdirFid}&force=0&_page=${pageNum}&_size=200&_fetch_total=1${sortParam}`;
+        const data = await fetchJson(page, url);
+        const files = unwrapApiData(data, 'Failed to get share list')?.list || [];
+        allFiles.push(...files);
+        total = data.metadata?._total || 0;
+        pageNum++;
+    } while (allFiles.length < total);
+    return allFiles;
+}
+export async function listMyDrive(page, pdirFid) {
+    const allFiles = [];
+    let pageNum = 1;
+    let total = 0;
+    do {
+        const url = `${DRIVE_API}/sort?pr=ucpro&fr=pc&pdir_fid=${pdirFid}&_page=${pageNum}&_size=200&_fetch_total=1&_sort=file_type:asc,file_name:asc`;
+        const data = await fetchJson(page, url);
+        const files = unwrapApiData(data, 'Failed to list drive')?.list || [];
+        allFiles.push(...files);
+        total = data.metadata?._total || 0;
+        pageNum++;
+    } while (allFiles.length < total);
+    return allFiles;
+}
+export async function findFolder(page, path) {
+    const parts = path.split('/').filter(Boolean);
+    let currentFid = '0';
+    for (const part of parts) {
+        const files = await listMyDrive(page, currentFid);
+        const existing = files.find(f => f.dir && f.file_name === part);
+        if (existing) {
+            currentFid = existing.fid;
+        }
+        else {
+            throw new CommandExecutionError(`quark: Folder "${part}" not found in "${path}"`);
+        }
+    }
+    return currentFid;
+}
+export function formatDate(ts) {
+    if (!ts)
+        return '';
+    const d = new Date(ts);
+    return d.toISOString().replace('T', ' ').slice(0, 19);
+}
+export function formatSize(bytes) {
+    if (bytes <= 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${units[i]}`;
+}
+export async function getTaskStatus(page, taskId) {
+    const url = `${TASK_API}?pr=ucpro&fr=pc&task_id=${taskId}&retry_index=0`;
+    return apiGet(page, url);
+}
+export async function pollTask(page, taskId, onDone, maxAttempts = 30, intervalMs = 500) {
+    for (let i = 0; i < maxAttempts; i++) {
+        await new Promise(r => setTimeout(r, intervalMs));
+        const task = await getTaskStatus(page, taskId);
+        if (task?.status === 2) {
+            onDone?.(task);
+            return true;
+        }
+    }
+    return false;
+}

package/dist/clis/quark/utils.test.d.ts

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

package/dist/clis/quark/utils.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { apiGet, apiPost, extractPwdId, getShareList, getToken } from './utils.js';
+function makePage(evaluateImpl) {
+    return {
+        evaluate: vi.fn(evaluateImpl),
+    };
+}
+describe('quark utils', () => {
+    it('extractPwdId accepts share URLs and raw ids', () => {
+        expect(extractPwdId('https://pan.quark.cn/s/abc123')).toBe('abc123');
+        expect(extractPwdId('abc123')).toBe('abc123');
+    });
+    it('maps JSON auth failures to AuthRequiredError', async () => {
+        const page = makePage(async () => ({
+            status: 401,
+            code: 401,
+            message: '未登录',
+            data: null,
+        }));
+        await expect(apiGet(page, 'https://drive-pc.quark.cn/test')).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+    it('maps non-JSON auth pages to AuthRequiredError', async () => {
+        const page = makePage(async () => {
+            const error = Object.assign(new Error('Non-JSON response: <html><title>登录</title></html>'), { status: 401 });
+            throw error;
+        });
+        await expect(apiPost(page, 'https://drive-pc.quark.cn/test', {})).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+    it('keeps generic API failures as CommandExecutionError', async () => {
+        const page = makePage(async () => ({
+            status: 500,
+            code: 500,
+            message: 'server busy',
+            data: null,
+        }));
+        await expect(apiGet(page, 'https://drive-pc.quark.cn/test')).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+    it('unwraps successful token responses', async () => {
+        const page = makePage(async () => ({
+            status: 200,
+            code: 0,
+            message: 'ok',
+            data: { stoken: 'token123' },
+        }));
+        await expect(getToken(page, 'abc123')).resolves.toBe('token123');
+    });
+    it('maps share-tree detail auth failures to AuthRequiredError', async () => {
+        const page = makePage(async () => ({
+            status: 401,
+            code: 401,
+            message: '请先登录',
+            data: null,
+            metadata: { _total: 0 },
+        }));
+        await expect(getShareList(page, 'abc123', 'token123')).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+});

package/dist/clis/twitter/reply.js

@@ -240,18 +240,13 @@ cli({
                 localImagePath = await downloadRemoteImage(kwargs['image-url']);
                 cleanupDir = path.dirname(localImagePath);
             }
-            // Dedicated composer is more reliable for image replies because the media
-            // toolbar and file input are consistently present there.
+            // Dedicated composer is more reliable than the inline tweet page reply box.
+            await page.goto(buildReplyComposerUrl(kwargs.url), { waitUntil: 'load', settleMs: 2500 });
+            await page.wait({ selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
             if (localImagePath) {
-                await page.goto(buildReplyComposerUrl(kwargs.url));
-                await page.wait({ selector: '[data-testid="tweetTextarea_0"]' });
                 await page.wait({ selector: REPLY_FILE_INPUT_SELECTOR, timeout: 20 });
                 await attachReplyImage(page, localImagePath);
             }
-            else {
-                await page.goto(kwargs.url);
-                await page.wait({ selector: '[data-testid="primaryColumn"]' });
-            }
             const result = await submitReply(page, kwargs.text);
             if (result.ok) {
                 await page.wait(3); // Wait for network submission to complete

package/dist/clis/twitter/reply.test.js

@@ -34,7 +34,7 @@ function createPageMock(evaluateResults, overrides = {}) {
     };
 }
 describe('twitter reply command', () => {
-    it('keeps the text-only reply flow working', async () => {
+    it('uses the dedicated reply composer for text-only replies too', async () => {
         const cmd = getRegistry().get('twitter/reply');
         expect(cmd?.func).toBeTypeOf('function');
         const page = createPageMock([
@@ -44,8 +44,8 @@ describe('twitter reply command', () => {
             url: 'https://x.com/_kop6/status/2040254679301718161?s=20',
             text: 'text-only reply',
         });
-        expect(page.goto).toHaveBeenCalledWith('https://x.com/_kop6/status/2040254679301718161?s=20');
-        expect(page.wait).toHaveBeenCalledWith({ selector: '[data-testid="primaryColumn"]' });
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/compose/post?in_reply_to=2040254679301718161', { waitUntil: 'load', settleMs: 2500 });
+        expect(page.wait).toHaveBeenCalledWith({ selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
         expect(result).toEqual([
             {
                 status: 'success',
@@ -72,8 +72,8 @@ describe('twitter reply command', () => {
             text: 'reply with image',
             image: imagePath,
         });
-        expect(page.goto).toHaveBeenCalledWith('https://x.com/compose/post?in_reply_to=2040254679301718161');
-        expect(page.wait).toHaveBeenNthCalledWith(1, { selector: '[data-testid="tweetTextarea_0"]' });
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/compose/post?in_reply_to=2040254679301718161', { waitUntil: 'load', settleMs: 2500 });
+        expect(page.wait).toHaveBeenNthCalledWith(1, { selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
         expect(page.wait).toHaveBeenNthCalledWith(2, { selector: 'input[type="file"][data-testid="fileInput"]', timeout: 20 });
         expect(setFileInput).toHaveBeenCalledWith([imagePath], 'input[type="file"][data-testid="fileInput"]');
         expect(result).toEqual([

package/dist/clis/xiaohongshu/note.js

@@ -37,9 +37,14 @@ cli({
         const title = clean(document.querySelector('#detail-title, .title'))
         const desc = clean(document.querySelector('#detail-desc, .desc, .note-text'))
         const author = clean(document.querySelector('.username, .author-wrapper .name'))
-        const likes = clean(document.querySelector('.like-wrapper .count'))
-        const collects = clean(document.querySelector('.collect-wrapper .count'))
-        const comments = clean(document.querySelector('.chat-wrapper .count'))
+        // Scope to .interact-container — the post's main interaction bar.
+        // Without scoping, .like-wrapper / .chat-wrapper also match each
+        // comment's like/reply buttons in the comment section, and
+        // querySelector returns the FIRST match (a comment's count, not the
+        // post's). The post's true counts live inside .interact-container.
+        const likes = clean(document.querySelector('.interact-container .like-wrapper .count'))
+        const collects = clean(document.querySelector('.interact-container .collect-wrapper .count'))
+        const comments = clean(document.querySelector('.interact-container .chat-wrapper .count'))
 
         // Try to extract tags/topics
         const tags = []

package/dist/clis/xiaohongshu/note.test.js

@@ -170,6 +170,17 @@ describe('xiaohongshu note', () => {
         expect(result.find((r) => r.field === 'collects').value).toBe('0');
         expect(result.find((r) => r.field === 'comments').value).toBe('0');
     });
+    it('scopes metric selectors to .interact-container to avoid matching comment like buttons', async () => {
+        const page = createPageMock({
+            loginWall: false, notFound: false,
+            title: 'Test', desc: '', author: 'Author', likes: '10', collects: '5', comments: '3', tags: [],
+        });
+        await command.func(page, { 'note-id': 'abc123' });
+        const evaluateScript = page.evaluate.mock.calls[0][0];
+        expect(evaluateScript).toContain('.interact-container .like-wrapper .count');
+        expect(evaluateScript).toContain('.interact-container .collect-wrapper .count');
+        expect(evaluateScript).toContain('.interact-container .chat-wrapper .count');
+    });
     it('omits tags row when no tags present', async () => {
         const page = createPageMock({
             loginWall: false, notFound: false,

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

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

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 {};