@sovovs/bycli 2.1.60 → 2.1.62

package/clis/iwhalecloud/list.js

@@ -0,0 +1,59 @@
+import { cli } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
+import { metadata, SORT_FIELDS, integer, folderId, connect, request, mailRow, listColumns } from './client.js';
+
+export async function runList(page, args) {
+  const limit = integer(args.limit ?? 20, 'limit', 1, 10000);
+  let offset = integer(args.offset ?? 0, 'offset', 0, 2147483647);
+  const sort = String(args.sort ?? 'default');
+  const order = String(args.order ?? 'default');
+  if (sort !== 'default' && !Object.hasOwn(SORT_FIELDS, sort)) throw new ArgumentError(`Unknown sort: ${sort}`);
+  if (!['default', 'asc', 'desc'].includes(order)) throw new ArgumentError('order must be default, asc or desc');
+  if (sort === 'default' && order !== 'default') throw new ArgumentError('Specify --sort to use --order; default preserves server ordering');
+  const folder = folderId(args);
+  await connect(page);
+  const rows = [];
+  const seen = new Set();
+  while (rows.length < limit) {
+    // Split the validated total into server pages; do not cap the caller's total.
+    const remaining = limit - rows.length;
+    const batchSize = remaining > 100 ? 100 : remaining;
+    const body = { __type: 'FindItemRequest:#Exchange',
+      ItemShape: { __type: 'ItemResponseShape:#Exchange', BaseShape: 'AllProperties' },
+      ParentFolderIds: [folder], Traversal: 'Shallow',
+      Paging: { __type: 'IndexedPageView:#Exchange', BasePoint: 'Beginning', Offset: offset, MaxEntriesReturned: batchSize } };
+    if (sort !== 'default') {
+      const ascending = order === 'asc' || (order === 'default' && ['from', 'to', 'subject'].includes(sort));
+      body.SortOrder = [{ __type: 'SortResults:#Exchange', Order: ascending ? 'Ascending' : 'Descending',
+        Path: { __type: 'PropertyUri:#Exchange', FieldURI: SORT_FIELDS[sort] } }];
+      if (sort !== 'date') body.SortOrder.push({ __type: 'SortResults:#Exchange', Order: 'Descending',
+        Path: { __type: 'PropertyUri:#Exchange', FieldURI: 'DateTimeReceived' } });
+    }
+    const message = await request(page, 'FindItem', body);
+    const root = message.RootFolder;
+    if (!root || !Array.isArray(root.Items)) throw new CommandExecutionError('OWA FindItem returned invalid items');
+    for (const item of root.Items) {
+      const row = mailRow(item);
+      if (seen.has(row.emailId)) throw new CommandExecutionError('Mailbox changed while paging; repeat list to avoid incomplete results');
+      seen.add(row.emailId); rows.push(row);
+      if (rows.length === limit) break;
+    }
+    if (root.IncludesLastItemInRange === true || rows.length >= limit) break;
+    const next = root.IndexedPagingOffset;
+    if (!root.Items.length || !Number.isSafeInteger(next) || next <= offset) throw new CommandExecutionError('OWA pagination did not advance');
+    offset = next;
+  }
+  if (!rows.length) throw new EmptyResultError('iwhalecloud list', 'No mail at this folder/offset');
+  return rows;
+}
+
+cli({ ...metadata, name: 'list', description: '浩鲸邮箱邮件列表：服务端分页、默认排序及 9 种字段排序',
+  example: 'bycli iwhalecloud list --sort date --order desc --limit 50 -f yaml',
+  args: [
+    { name: 'folder', default: 'inbox', choices: ['inbox', 'sent', 'drafts', 'trash', 'spam'], help: '邮件文件夹' },
+    { name: 'folder-id', help: '自定义文件夹的 OWA FolderId，优先于 --folder' },
+    { name: 'limit', type: 'int', default: 20, help: '返回数量，1–10000；自动分页' },
+    { name: 'offset', type: 'int', default: 0, help: '服务端起始偏移，0 表示第一封' },
+    { name: 'sort', default: 'default', choices: ['default', ...Object.keys(SORT_FIELDS)], help: 'default 保留服务端默认顺序' },
+    { name: 'order', default: 'default', choices: ['default', 'asc', 'desc'], help: '默认：姓名/主题升序，其余降序；显式方向须指定 --sort' },
+  ], columns: listColumns, func: runList });

package/clis/iwhalecloud/read.js

@@ -0,0 +1,25 @@
+import { cli } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { metadata, idArg, requiredId, connect, getMail, mailRow, listColumns, attachmentsOf } from './client.js';
+
+export async function runRead(page, args) {
+  const id = requiredId(args.emailId);
+  const bodyType = String(args['body-type'] ?? 'text');
+  if (!['text', 'html'].includes(bodyType)) throw new ArgumentError('body-type must be text or html');
+  await connect(page);
+  const item = await getMail(page, id, bodyType);
+  if (typeof item.Body?.Value !== 'string' || item.Body.IsTruncated === true) {
+    throw new CommandExecutionError('OWA did not return a complete mail body', 'Open the mail in Outlook to check content restrictions');
+  }
+  const recipients = entries => (entries ?? []).map(entry => {
+    const mailbox = entry.Mailbox ?? entry;
+    return { name: mailbox.Name ?? '', email: mailbox.EmailAddress ?? '' };
+  });
+  return [{ ...mailRow(item), to: recipients(item.ToRecipients), cc: recipients(item.CcRecipients), bcc: recipients(item.BccRecipients),
+    recipientCounts: item.RecipientCounts ?? {}, bodyType: item.Body?.BodyType ?? bodyType, body: item.Body?.Value ?? '',
+    attachments: attachmentsOf(item) }];
+}
+cli({ ...metadata, name: 'read', description: '读取浩鲸邮件完整正文、收件人和附件列表（不标记已读）',
+  example: 'bycli iwhalecloud read "<emailId>" -f yaml',
+  args: [idArg, { name: 'body-type', default: 'text', choices: ['text', 'html'], help: '正文格式' }],
+  columns: [...listColumns, 'to', 'cc', 'bcc', 'recipientCounts', 'bodyType', 'body', 'attachments'], func: runRead });

package/clis/zhihu/answer-waiting-draft.js

@@ -0,0 +1,127 @@
+import { AuthRequiredError, CliError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { resolvePayload } from './write-shared.js';
+import { resolveDraftOptions, normalizeDraftText, planDraftContent, inspectDraftPage, clickDraftControl, prepareDraftInsertion, draftScript } from './draft-shared.js';
+
+async function inspect(page, options) {
+    const state = await page.evaluate(draftScript(inspectDraftPage, options.questionId));
+    if (state?.status === 'auth') throw new AuthRequiredError('www.zhihu.com', 'Log into Zhihu before saving an answer draft');
+    if (state?.status === 'wrong_target' || (options.answerId && state?.answerId && state.answerId !== options.answerId)) {
+        throw new CliError('TARGET_MISMATCH', 'Browser is not on the requested Zhihu question or answer');
+    }
+    if (state?.status === 'deleted') throw new CliError('ACTION_NOT_AVAILABLE', 'Your answer is deleted; Zhihu only offers undo deletion', 'Choose another question, or manage the deleted answer manually in Zhihu');
+    if (state?.status === 'ambiguous') throw new CliError('ACTION_NOT_AVAILABLE', 'Multiple answer editors are visible');
+    if (options.expectedTitle && state?.title && state.title !== options.expectedTitle) {
+        throw new CliError('TARGET_MISMATCH', 'Question title does not match --expected-title');
+    }
+    return state;
+}
+
+async function openEditor(page, options) {
+    const opened = new Set();
+    let previous = '';
+    for (let attempt = 0; attempt < options.timeout * 2 && Date.now() <= options.deadline; attempt++) {
+        const state = await inspect(page, options);
+        if (state?.status === 'editor' && state.title) {
+            if ((options.mode !== 'auto' && state.mode !== options.mode) || (options.answerId && state.mode !== 'edit')) {
+                throw new CliError('ACTION_NOT_AVAILABLE', `Requested mode ${options.mode} does not match the ${state.mode} answer editor`);
+            }
+            // Let the editor hydrate before reading or changing its old content.
+            const signature = JSON.stringify([state.url, state.mode, state.text, state.hasRichContent]);
+            if (signature === previous) return state;
+            previous = signature;
+        } else if (state?.ownAnswerUrl) {
+            if (options.mode === 'new') throw new CliError('ACTION_NOT_AVAILABLE', 'You already have an answer to this question; use --mode edit or auto');
+            if (!opened.has(state.ownAnswerUrl)) {
+                opened.add(state.ownAnswerUrl);
+                await page.goto(`${state.ownAnswerUrl}#write`);
+            }
+        } else if (state?.status === 'page' && !opened.has(state.url)) {
+            if (await page.evaluate(draftScript(clickDraftControl, options.questionId, 'open'))) opened.add(state.url);
+        }
+        await page.wait(0.5);
+    }
+    throw new CliError('ACTION_NOT_AVAILABLE', 'Could not open a stable Zhihu answer editor', 'Open the question in Chrome and check the answer editor, or increase --timeout');
+}
+
+async function waitSaved(page, options, expected) {
+    for (let attempt = 0; attempt < options.timeout * 2 && Date.now() <= options.deadline; attempt++) {
+        const state = await inspect(page, options);
+        if (state?.status === 'editor' && normalizeDraftText(state.text) === normalizeDraftText(expected) && state.saved) return state;
+        await page.wait(0.5);
+    }
+    throw new CliError('DRAFT_SAVE_TIMEOUT', 'Could not confirm that Zhihu saved the complete draft', 'Inspect the editor before retrying; some content may already have been saved');
+}
+
+cli({
+    site: 'zhihu', name: 'answer-waiting-draft', access: 'write',
+    description: '保存知乎回答草稿（新回答或已有回答的编辑草稿，不发布）',
+    domain: 'www.zhihu.com', strategy: Strategy.COOKIE,
+    browser: kwargs => !resolveDraftOptions(kwargs).dryRun, navigateBefore: false,
+    validateArgs: kwargs => {
+        const options = resolveDraftOptions(kwargs);
+        if (!options.execute && !options.dryRun) throw new CliError('INVALID_INPUT', 'Use --execute to save a draft or --dry-run to preview');
+    },
+    args: [
+        { name: 'target', positional: true, required: true, help: 'Question ID, question/own-answer URL, question:<id>, or answer:<questionId>:<answerId>' },
+        { name: 'text', positional: true, help: 'Plain-text answer body; use either text or --file' },
+        { name: 'file', help: 'UTF-8 text file containing the answer body' },
+        { name: 'mode', default: 'auto', choices: ['auto', 'new', 'edit'], help: 'auto detects new/edit; new refuses an existing answer; edit requires your existing answer' },
+        { name: 'existing', default: 'error', choices: ['error', 'replace', 'append', 'prepend'], help: 'Policy when the editor already has content; identical text is left unchanged' },
+        { name: 'separator', default: '\n\n', help: 'Literal separator for append/prepend (default: a blank line)' },
+        { name: 'prefix', help: 'Literal text before the supplied body (include any desired newline)' },
+        { name: 'suffix', help: 'Literal text after the supplied body (include any desired newline)' },
+        { name: 'expected-title', help: 'Require an exact question title before editing' },
+        { name: 'timeout', type: 'int', default: 30, help: 'Total editor/save verification wait budget in seconds (1–120)' },
+        { name: 'close-editor', type: 'boolean', default: true, help: 'Close editor after verified save; false leaves it open (combine with --keep-tab true)' },
+        { name: 'dry-run', type: 'boolean', help: 'Preview resolved input locally without opening or modifying the editor' },
+        { name: 'execute', type: 'boolean', help: 'Actually save the draft; never publishes an answer' },
+    ],
+    columns: ['status', 'outcome', 'question_id', 'answer_id', 'mode', 'url', 'characters', 'verified', 'published', 'editor_open', 'message'],
+    func: async (page, kwargs) => {
+        const options = resolveDraftOptions(kwargs);
+        if (!options.execute && !options.dryRun) throw new CliError('INVALID_INPUT', 'Use --execute to save a draft or --dry-run to preview');
+        const body = await resolvePayload(kwargs);
+        const payload = normalizeDraftText(options.prefix + body + options.suffix);
+        if (!payload || payload.length > 50000) throw new CliError('INVALID_INPUT', 'Draft content must contain 1–50000 characters, including prefix and suffix');
+        if (options.dryRun) return [{ status: 'preview', outcome: 'preview', question_id: options.questionId,
+            answer_id: options.answerId, mode: options.mode, url: `${options.url}#write`, characters: [...payload].length,
+            verified: false, published: false, editor_open: false, message: 'Local input preview; existing browser content has not been inspected',
+            content: payload, existing: options.existing, separator: options.separator }];
+        if (!page || typeof page.insertText !== 'function') throw new CommandExecutionError('Browser session with native text insertion is required for zhihu answer-waiting-draft');
+        options.deadline = Date.now() + options.timeout * 1000;
+        await page.goto(`${options.url}#write`);
+        const initial = await openEditor(page, options);
+        if (initial.hasRichContent && !initial.text && options.existing === 'error') throw new CliError('DRAFT_EXISTS', 'The editor contains rich content', 'Choose --existing replace, append, or prepend');
+        const plan = planDraftContent(initial.text, payload, options.existing, options.separator, initial.hasRichContent);
+        if (plan.expected.length > 50000) throw new CliError('INVALID_INPUT', 'Combined draft content exceeds 50000 characters');
+        if (plan.changed) {
+            const prepared = await page.evaluate(draftScript(prepareDraftInsertion, options.questionId, initial.text, plan.position));
+            if (!prepared?.ok) throw new CliError('DRAFT_CONFLICT', `Could not prepare the editor: ${prepared?.reason || 'unknown state'}`, 'Inspect the draft before retrying');
+            // Native input updates Draft.js state. Do not assign innerHTML/textContent.
+            await page.insertText(plan.insertion);
+        }
+        const saved = await waitSaved(page, options, plan.expected);
+        if (saved.canSaveAndLeave) await page.evaluate(draftScript(clickDraftControl, options.questionId, 'save'));
+        // Reload from Zhihu and reopen: a local DOM update or stale save badge is
+        // insufficient evidence of a persisted draft.
+        const draftUrl = saved.url.split('#')[0];
+        await page.goto('about:blank');
+        await page.goto(`${draftUrl}#write`);
+        const restored = await openEditor(page, options);
+        if (normalizeDraftText(restored.text) !== normalizeDraftText(plan.expected) || restored.mode !== initial.mode || !restored.saved) {
+            throw new CliError('DRAFT_VERIFY_FAILED', 'Reloaded draft does not match the requested content', 'Inspect the existing draft before retrying; no answer was published');
+        }
+        let editorOpen = true;
+        if (options.closeEditor) {
+            const closed = await page.evaluate(draftScript(clickDraftControl, options.questionId, 'save'));
+            if (!closed) await page.goto(draftUrl);
+            const final = await inspect(page, options);
+            editorOpen = final?.status === 'editor';
+        }
+        return [{ status: 'success', outcome: plan.changed ? 'saved' : 'unchanged', question_id: options.questionId,
+            answer_id: restored.answerId || '', mode: restored.mode, url: `${draftUrl}#write`, characters: [...normalizeDraftText(plan.expected)].length,
+            verified: true, published: false, editor_open: editorOpen,
+            message: restored.mode === 'edit' ? 'Existing answer’s edit draft saved and verified; changes not submitted' : 'New answer draft saved and verified; answer not published' }];
+    },
+});

package/clis/zhihu/draft-shared.js

@@ -0,0 +1,147 @@
+import { CliError } from '@sovovs/bycli/errors';
+import { parseTarget } from './target.js';
+
+export function normalizeDraftText(text) {
+    return String(text).replace(/\r\n?/g, '\n').replace(/\u00a0/g, ' ').replace(/[\u200b\ufeff]/g, '').trim();
+}
+
+function booleanOption(value, fallback, name) {
+    if (value === undefined) return fallback;
+    if (value === true || value === 'true') return true;
+    if (value === false || value === 'false') return false;
+    throw new CliError('INVALID_INPUT', `${name} must be true or false`);
+}
+
+export function resolveDraftOptions(kwargs) {
+    const raw = String(kwargs.target ?? '').trim();
+    const target = parseTarget(/^\d+$/.test(raw) ? `question:${raw}` : raw);
+    if (!['question', 'answer'].includes(target.kind)) {
+        throw new CliError('UNSUPPORTED_TARGET', 'answer-waiting-draft requires a question or your own answer');
+    }
+    const mode = kwargs.mode ?? 'auto';
+    const existing = kwargs.existing ?? 'error';
+    const timeout = Number(kwargs.timeout ?? 30);
+    if (!['auto', 'new', 'edit'].includes(mode)) throw new CliError('INVALID_INPUT', 'Mode must be auto, new, or edit');
+    if (!['error', 'replace', 'append', 'prepend'].includes(existing)) throw new CliError('INVALID_INPUT', 'Existing content policy must be error, replace, append, or prepend');
+    if (!Number.isInteger(timeout) || timeout < 1 || timeout > 120) throw new CliError('INVALID_INPUT', 'Timeout must be an integer from 1 to 120 seconds');
+    if (mode === 'new' && target.kind === 'answer') throw new CliError('INVALID_INPUT', 'Mode new cannot target an existing answer');
+    const dryRun = booleanOption(kwargs['dry-run'], false, '--dry-run');
+    const execute = booleanOption(kwargs.execute, false, '--execute');
+    if (dryRun && execute) throw new CliError('INVALID_INPUT', 'Use --dry-run or --execute, not both');
+    return {
+        questionId: target.kind === 'question' ? target.id : target.questionId,
+        answerId: target.kind === 'answer' ? target.id : '',
+        url: target.url, mode, existing, timeout, dryRun, execute,
+        closeEditor: booleanOption(kwargs['close-editor'], true, '--close-editor'),
+        separator: kwargs.separator ?? '\n\n',
+        prefix: kwargs.prefix ?? '', suffix: kwargs.suffix ?? '',
+        expectedTitle: kwargs['expected-title'] ?? '',
+    };
+}
+
+export function planDraftContent(current, payload, policy, separator, hasRichContent = false) {
+    const before = normalizeDraftText(current);
+    const incoming = normalizeDraftText(payload);
+    if (before === incoming) return { changed: false, expected: before, insertion: '', position: 'replace' };
+    if ((before || hasRichContent) && policy === 'error') {
+        throw new CliError('DRAFT_EXISTS', 'The editor already contains different text', 'Use --existing replace, append, or prepend to choose how to update it');
+    }
+    if (!before) separator = '';
+    if ((before || hasRichContent) && policy === 'append') return { changed: true, expected: before + separator + incoming, insertion: separator + incoming, position: 'append' };
+    if ((before || hasRichContent) && policy === 'prepend') return { changed: true, expected: incoming + separator + before, insertion: incoming + separator, position: 'prepend' };
+    return { changed: true, expected: incoming, insertion: incoming, position: 'replace' };
+}
+
+// These functions run in the browser. Keep them self-contained for serialization
+// and fixture tests; only inspect the question's answer form, never comments.
+export function inspectDraftPage(questionId) {
+    const clean = text => String(text || '').replace(/\r\n?/g, '\n').replace(/\u00a0/g, ' ').replace(/[\u200b\ufeff]/g, '').trim();
+    const visible = node => {
+        for (let n = node; n; n = n.parentElement) {
+            if (n.hidden || n.getAttribute('aria-hidden') === 'true') return false;
+            const style = getComputedStyle(n);
+            if (style.display === 'none' || style.visibility === 'hidden') return false;
+        }
+        return true;
+    };
+    if (/^\/(signin|signup|account\/unhuman)(\/|$)/.test(location.pathname)) return { status: 'auth' };
+    const path = location.pathname.match(/^\/question\/(\d+)(?:\/answer\/(\d+))?\/?$/);
+    if (location.origin !== 'https://www.zhihu.com' || path?.[1] !== questionId) return { status: 'wrong_target' };
+    const title = clean(document.querySelector('h1')?.textContent);
+    if (Array.from(document.querySelectorAll('button')).some(b => visible(b) && clean(b.textContent) === '撤销删除')) return { status: 'deleted', title };
+    let ownAnswerUrl = '';
+    for (const link of document.querySelectorAll('a[href]')) {
+        if (clean(link.textContent) !== '查看我的回答' || !visible(link)) continue;
+        const url = new URL(link.getAttribute('href'), location.href);
+        if (url.origin === location.origin && new RegExp('^/question/' + questionId + '/answer/\\d+/?$').test(url.pathname)) {
+            ownAnswerUrl = url.origin + url.pathname;
+            break;
+        }
+    }
+    const forms = Array.from(document.querySelectorAll('form.AnswerForm')).filter(visible);
+    const editors = forms.flatMap(form => Array.from(form.querySelectorAll('.public-DraftEditor-content[contenteditable="true"]')).filter(visible));
+    const base = { url: location.href, title, answerId: path[2] || '', ownAnswerUrl };
+    if (editors.length > 1) return { ...base, status: 'ambiguous' };
+    if (!editors.length) return { ...base, status: 'page' };
+    const editor = editors[0];
+    const form = editor.closest('form.AnswerForm');
+    const labels = Array.from(form.querySelectorAll('button')).filter(visible).map(b => clean(b.textContent));
+    const mode = labels.includes('提交修改') ? 'edit' : labels.includes('发布回答') ? 'new' : '';
+    if (!mode) return { ...base, status: 'page' };
+    const blocks = Array.from(editor.querySelectorAll('[data-block="true"]'));
+    const text = clean(blocks.length ? blocks.map(b => b.textContent).join('\n') : editor.innerText || editor.textContent);
+    const tip = form.querySelector('.DraftStatusTip');
+    const saved = !!tip && !!tip.querySelector('.ZDI--CloudCheck24') && !/保存中|失败/.test(tip.textContent);
+    return { ...base, status: 'editor', mode, text, saved,
+        saveText: clean(tip?.textContent),
+        hasRichContent: !!editor.querySelector('img, video, audio, iframe, table, pre') || blocks.some(b => b.className && !b.classList.contains('Editable-unstyled')),
+        canSaveAndLeave: labels.includes('保存草稿并离开'),
+    };
+}
+
+export function clickDraftControl(questionId, action) {
+    if (location.origin !== 'https://www.zhihu.com' || !new RegExp('^/question/' + questionId + '(?:/answer/\\d+)?/?$').test(location.pathname)) return false;
+    const clean = text => String(text || '').replace(/[\u200b\ufeff]/g, '').trim();
+    const visible = node => {
+        for (let n = node; n; n = n.parentElement) {
+            if (n.hidden || n.getAttribute('aria-hidden') === 'true' || getComputedStyle(n).display === 'none' || getComputedStyle(n).visibility === 'hidden') return false;
+        }
+        return true;
+    };
+    const allowed = action === 'save' ? ['保存草稿并离开'] : action === 'open' ? ['编辑回答', '写回答'] : [];
+    const scope = action === 'save' ? 'form.AnswerForm button' : 'button';
+    const button = Array.from(document.querySelectorAll(scope)).find(b => allowed.includes(clean(b.textContent)) && !b.disabled && visible(b));
+    if (!button) return false;
+    button.click();
+    return true;
+}
+
+export function prepareDraftInsertion(questionId, expectedText, position) {
+    if (location.origin !== 'https://www.zhihu.com' || !new RegExp('^/question/' + questionId + '(?:/answer/\\d+)?/?$').test(location.pathname)) return { ok: false, reason: 'wrong_target' };
+    const visible = node => {
+        for (let n = node; n; n = n.parentElement) {
+            if (n.hidden || n.getAttribute('aria-hidden') === 'true' || getComputedStyle(n).display === 'none' || getComputedStyle(n).visibility === 'hidden') return false;
+        }
+        return true;
+    };
+    const editors = Array.from(document.querySelectorAll('form.AnswerForm .public-DraftEditor-content[contenteditable="true"]')).filter(visible);
+    if (editors.length !== 1) return { ok: false, reason: 'ambiguous_editor' };
+    const editor = editors[0];
+    const clean = text => String(text || '').replace(/\r\n?/g, '\n').replace(/\u00a0/g, ' ').replace(/[\u200b\ufeff]/g, '').trim();
+    const blocks = Array.from(editor.querySelectorAll('[data-block="true"]'));
+    const current = clean(blocks.length ? blocks.map(b => b.textContent).join('\n') : editor.innerText || editor.textContent);
+    if (current !== clean(expectedText)) return { ok: false, reason: 'content_changed' };
+    if (!['replace', 'append', 'prepend'].includes(position)) return { ok: false, reason: 'invalid_position' };
+    editor.focus();
+    const range = document.createRange();
+    range.selectNodeContents(editor);
+    if (position !== 'replace') range.collapse(position === 'prepend');
+    const selection = window.getSelection();
+    selection.removeAllRanges();
+    selection.addRange(range);
+    return { ok: true };
+}
+
+export function draftScript(fn, ...args) {
+    return `(${fn.toString()})(${args.map(arg => JSON.stringify(arg)).join(',')})`;
+}

package/clis/zhihu/waiting.js

@@ -0,0 +1,100 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { AuthRequiredError, CliError } from '@sovovs/bycli/errors';
+
+// Serialized into the browser; keep this function self-contained. Use the
+// semantic list and question URLs rather than Zhihu's generated CSS hashes.
+export function readWaitingPage(expectedLabel) {
+    if (/^\/(?:signin|signup|account\/unhuman)(?:\/|$)/.test(location.pathname)) {
+        return { status: 'auth', items: [] };
+    }
+    if (expectedLabel && document.querySelector('[role="tab"][aria-selected="true"]')?.textContent.trim() !== expectedLabel) {
+        return { status: 'missing', items: [] };
+    }
+    const list = document.querySelector('.QuestionWaiting-questions');
+    if (!list) return { status: 'missing', items: [] };
+    const items = [];
+    for (const link of list.querySelectorAll('a[href]')) {
+        const url = new URL(link.getAttribute('href'), location.href);
+        const id = url.pathname.match(/^\/question\/(\d+)\/?$/)?.[1];
+        if (url.origin !== 'https://www.zhihu.com' || !id) continue;
+        const titleNode = link.cloneNode(true);
+        // The title link may have a block badge such as “新问” or “飙升”.
+        titleNode.querySelectorAll('div').forEach(node => node.remove());
+        const title = titleNode.textContent.trim();
+        if (!title) continue;
+        const metadata = link.nextElementSibling?.textContent || '';
+        const count = label => {
+            const match = metadata.match(new RegExp('([\\d,]+(?:\\.\\d+)?)\\s*([万亿]?)\\s*' + label));
+            if (!match) return null;
+            const multiplier = match[2] === '万' ? 10000 : match[2] === '亿' ? 100000000 : 1;
+            return Math.round(Number(match[1].replace(/,/g, '')) * multiplier);
+        };
+        items.push({ id, title, views: count('浏览'), answers: count('回答'), followers: count('关注'),
+            url: `https://www.zhihu.com/question/${id}` });
+    }
+    return { status: 'ready', items };
+}
+
+const CATEGORIES = {
+    recommend: { query: '', label: '为你推荐' },
+    invited: { query: '?type=invite', label: '邀请回答' },
+    latest: { query: '?type=new', label: '最新问题' },
+    hot: { query: '?type=hot', label: '人气问题' },
+};
+
+cli({
+    site: 'zhihu',
+    name: 'waiting',
+    access: 'read',
+    description: '知乎写回答（等你来答）问题列表',
+    domain: 'www.zhihu.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'type', default: 'recommend', choices: Object.keys(CATEGORIES), help: 'Question category: recommend 为你推荐, invited 邀请回答, latest 最新问题, hot 人气问题' },
+        { name: 'limit', type: 'int', default: 20, help: 'Maximum questions to return (1–1000; stops when the page stops loading)' },
+    ],
+    columns: ['rank', 'id', 'title', 'views', 'answers', 'followers', 'url'],
+    func: async (page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 20);
+        if (!Number.isInteger(limit) || limit < 1 || limit > 1000) {
+            throw new CliError('INVALID_INPUT', 'Limit must be a positive integer no greater than 1000', 'Example: bycli zhihu waiting --limit 20');
+        }
+        const type = kwargs.type ?? 'recommend';
+        if (!Object.hasOwn(CATEGORIES, type)) {
+            throw new CliError('INVALID_INPUT', 'Type must be one of: recommend, invited, latest, hot', 'Example: bycli zhihu waiting --type latest');
+        }
+        const category = CATEGORIES[type];
+        await page.goto(`https://www.zhihu.com/question/waiting${category.query}`);
+        const rows = [];
+        const seen = new Set();
+        let idle = 0;
+        let missing = 0;
+        // Bound both stalled loading and a feed that continually changes.
+        for (let round = 0; round < 120; round++) {
+            const state = await page.evaluate(`(${readWaitingPage.toString()})(${JSON.stringify(category.label)})`);
+            if (state?.status === 'auth') {
+                throw new AuthRequiredError('www.zhihu.com', 'Log into Zhihu and open https://www.zhihu.com/question/waiting');
+            }
+            if (state?.status !== 'ready' || !Array.isArray(state.items)) {
+                if (++missing >= 5) {
+                    throw new CliError('DOM_CHANGED', 'Zhihu waiting question list was not found', 'Open https://www.zhihu.com/question/waiting and check that the question list is visible');
+                }
+                await page.wait(1);
+                continue;
+            }
+            missing = 0;
+            const before = rows.length;
+            for (const item of state.items) {
+                if (seen.has(item.id)) continue;
+                seen.add(item.id);
+                rows.push({ rank: rows.length + 1, ...item });
+                if (rows.length >= limit) return rows;
+            }
+            idle = rows.length === before ? idle + 1 : 0;
+            if (idle >= 3) break;
+            await page.scroll('down', 10000);
+            await page.wait(1.5);
+        }
+        return rows;
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sovovs/bycli",
-  "version": "2.1.60",
+  "version": "2.1.62",
   "publishConfig": {
     "access": "public"
   },