@sovovs/bycli 2.1.61 → 2.1.63

package/cli-manifest.json

@@ -34388,6 +34388,130 @@
     "sourceFile": "zhihu/answer-detail.js",
     "navigateBefore": "https://www.zhihu.com"
   },
+  {
+    "site": "zhihu",
+    "name": "answer-waiting-draft",
+    "description": "保存知乎回答草稿（新回答或已有回答的编辑草稿，不发布）",
+    "access": "write",
+    "domain": "www.zhihu.com",
+    "strategy": "cookie",
+    "browser": "conditional",
+    "args": [
+      {
+        "name": "target",
+        "type": "str",
+        "required": true,
+        "positional": true,
+        "help": "Question ID, question/own-answer URL, question:<id>, or answer:<questionId>:<answerId>"
+      },
+      {
+        "name": "text",
+        "type": "str",
+        "required": false,
+        "positional": true,
+        "help": "Plain-text answer body; use either text or --file"
+      },
+      {
+        "name": "file",
+        "type": "str",
+        "required": false,
+        "help": "UTF-8 text file containing the answer body"
+      },
+      {
+        "name": "mode",
+        "type": "str",
+        "default": "auto",
+        "required": false,
+        "help": "auto detects new/edit; new refuses an existing answer; edit requires your existing answer",
+        "choices": [
+          "auto",
+          "new",
+          "edit"
+        ]
+      },
+      {
+        "name": "existing",
+        "type": "str",
+        "default": "error",
+        "required": false,
+        "help": "Policy when the editor already has content; identical text is left unchanged",
+        "choices": [
+          "error",
+          "replace",
+          "append",
+          "prepend"
+        ]
+      },
+      {
+        "name": "separator",
+        "type": "str",
+        "default": "\n\n",
+        "required": false,
+        "help": "Literal separator for append/prepend (default: a blank line)"
+      },
+      {
+        "name": "prefix",
+        "type": "str",
+        "required": false,
+        "help": "Literal text before the supplied body (include any desired newline)"
+      },
+      {
+        "name": "suffix",
+        "type": "str",
+        "required": false,
+        "help": "Literal text after the supplied body (include any desired newline)"
+      },
+      {
+        "name": "expected-title",
+        "type": "str",
+        "required": false,
+        "help": "Require an exact question title before editing"
+      },
+      {
+        "name": "timeout",
+        "type": "int",
+        "default": 30,
+        "required": false,
+        "help": "Total editor/save verification wait budget in seconds (1–120)"
+      },
+      {
+        "name": "close-editor",
+        "type": "boolean",
+        "default": true,
+        "required": false,
+        "help": "Close editor after verified save; false leaves it open (combine with --keep-tab true)"
+      },
+      {
+        "name": "dry-run",
+        "type": "boolean",
+        "required": false,
+        "help": "Preview resolved input locally without opening or modifying the editor"
+      },
+      {
+        "name": "execute",
+        "type": "boolean",
+        "required": false,
+        "help": "Actually save the draft; never publishes an answer"
+      }
+    ],
+    "columns": [
+      "status",
+      "outcome",
+      "question_id",
+      "answer_id",
+      "mode",
+      "url",
+      "characters",
+      "verified",
+      "published",
+      "editor_open",
+      "message"
+    ],
+    "type": "js",
+    "modulePath": "zhihu/answer-waiting-draft.js",
+    "sourceFile": "zhihu/answer-waiting-draft.js",
+    "navigateBefore": false
+  },
   {
     "site": "zhihu",
     "name": "collection",
@@ -34829,6 +34953,50 @@
     "sourceFile": "zhihu/search.js",
     "navigateBefore": "https://www.zhihu.com"
   },
+  {
+    "site": "zhihu",
+    "name": "waiting",
+    "description": "知乎写回答（等你来答）问题列表",
+    "access": "read",
+    "domain": "www.zhihu.com",
+    "strategy": "cookie",
+    "browser": true,
+    "args": [
+      {
+        "name": "type",
+        "type": "str",
+        "default": "recommend",
+        "required": false,
+        "help": "Question category: recommend 为你推荐, invited 邀请回答, latest 最新问题, hot 人气问题",
+        "choices": [
+          "recommend",
+          "invited",
+          "latest",
+          "hot"
+        ]
+      },
+      {
+        "name": "limit",
+        "type": "int",
+        "default": 20,
+        "required": false,
+        "help": "Maximum questions to return (1–1000; stops when the page stops loading)"
+      }
+    ],
+    "columns": [
+      "rank",
+      "id",
+      "title",
+      "views",
+      "answers",
+      "followers",
+      "url"
+    ],
+    "type": "js",
+    "modulePath": "zhihu/waiting.js",
+    "sourceFile": "zhihu/waiting.js",
+    "navigateBefore": "https://www.zhihu.com"
+  },
   {
     "site": "zlibrary",
     "name": "info",

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/extension/README.md

@@ -9,6 +9,9 @@ commands.
 - `debugger`: sends CDP commands to byCLI-controlled or bound tabs.
 - `tabs` / `tabGroups`: manages the dedicated byCLI automation container and
   reports selected tab metadata back to the CLI.
+- `system.display`: reads logical display work areas so owned windows fit the
+  usable screen space, including headless virtual displays. It does not change
+  display settings.
 - `cookies`: reads cookies for browser-backed adapters that need authenticated
   fetches.
 - `downloads`: surfaces download lifecycle to `bycli browser wait download`.
@@ -17,6 +20,22 @@ commands.
   filters by the command's filename/URL pattern and timeout, and does not modify,
   redirect, or persist browser download history.
 
+## Owned Window Placement
+
+New byCLI windows use up to 1280 × 900 logical pixels, capped by the selected
+display's work area. The last-focused normal Chrome window selects the display;
+the primary display is the fallback. Existing owned normal windows stay on the
+display with their largest intersection, keeping smaller sizes and positions
+that already fit. Bounds are corrected on reuse, lease restoration and display
+changes without changing focus. Borrowed user windows and minimized, maximized
+or fullscreen window states are preserved.
+Dragging an owned tab into a user window does not transfer window ownership
+during lease restoration. A move, resize or state change while display metadata
+is being read also takes precedence over that pending correction.
+
+If display metadata is unavailable, byCLI logs a warning. New windows use
+Chrome's natural size and placement, and existing windows retain their bounds.
+
 Suggested Chrome Web Store justification for `downloads`:
 
 > This extension uses `chrome.downloads` to surface download lifecycle

package/extension/dist/background.js

@@ -1558,6 +1558,46 @@ function checkUrlSyntax(input, opts = {}) {
   return { ok: true, url: parsed.toString(), hostname, isIpLiteral: false };
 }
 
+function hasUsableBounds(bounds) {
+  return !!bounds && Number.isFinite(bounds.left) && Number.isFinite(bounds.top) && Number.isFinite(bounds.width) && Number.isFinite(bounds.height) && bounds.width >= 1 && bounds.height >= 1;
+}
+function selectWindowWorkArea(displays, reference) {
+  const usable = displays.filter((display) => display.isEnabled && display.activeState !== "inactive" && hasUsableBounds(display.workArea));
+  if (usable.length === 0) return null;
+  let selected = usable.find((display) => display.isPrimary) ?? usable[0];
+  let largestIntersection = 0;
+  if (hasUsableBounds(reference)) {
+    for (const display of usable) {
+      const area = display.workArea;
+      const width = Math.max(0, Math.min(reference.left + reference.width, area.left + area.width) - Math.max(reference.left, area.left));
+      const height = Math.max(0, Math.min(reference.top + reference.height, area.top + area.height) - Math.max(reference.top, area.top));
+      const intersection = width * height;
+      if (intersection > largestIntersection) {
+        largestIntersection = intersection;
+        selected = display;
+      }
+    }
+  }
+  return selected.workArea;
+}
+function createOwnedWindowBounds(area) {
+  return {
+    left: area.left,
+    top: area.top,
+    width: Math.min(1280, area.width),
+    height: Math.min(900, area.height)
+  };
+}
+function constrainOwnedWindowBounds(window, area) {
+  if (!hasUsableBounds(window)) return null;
+  const width = Math.min(window.width, area.width);
+  const height = Math.min(window.height, area.height);
+  const left = Math.min(Math.max(window.left, area.left), area.left + area.width - width);
+  const top = Math.min(Math.max(window.top, area.top), area.top + area.height - height);
+  if (width === window.width && height === window.height && left === window.left && top === window.top) return null;
+  return { left, top, width, height };
+}
+
 const EXTENSION_CAPABILITIES = ["focus-window-v1", "ima-reader-v1"];
 let ws = null;
 let reconnectTimer = null;
@@ -2047,7 +2087,86 @@ async function focusOwnedWindowIfRequested(windowId, mode) {
   if (typeof updateWindow === "function") await updateWindow(windowId, { focused: true }).catch(() => {
   });
 }
+async function getOwnedWindowWorkArea(reference) {
+  try {
+    if (typeof chrome.system?.display?.getInfo !== "function") throw new Error("system.display API unavailable");
+    const displays = await chrome.system.display.getInfo();
+    const area = selectWindowWorkArea(displays, reference);
+    if (!area) throw new Error("no enabled displays with a valid work area");
+    return area;
+  } catch (err) {
+    console.warn(`[bycli] Unable to query display work area: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+async function getNewOwnedWindowBounds() {
+  let reference;
+  try {
+    if (typeof chrome.windows.getLastFocused === "function") {
+      const lastFocused = await chrome.windows.getLastFocused({ windowTypes: ["normal"] });
+      if (lastFocused.type === "normal") reference = lastFocused;
+    }
+  } catch {
+  }
+  const area = await getOwnedWindowWorkArea(reference);
+  return area ? createOwnedWindowBounds(area) : void 0;
+}
+const ownedWindowGeometryUpdates = /* @__PURE__ */ new Map();
+const excludedOwnedWindowIds = /* @__PURE__ */ new Set();
+function isKnownOwnedWindow(windowId) {
+  return Object.values(ownedContainers).some((container) => container.windowId === windowId) || [...automationSessions.values()].some((session) => session.owned && session.windowId === windowId);
+}
+function rememberOwnedTabDrift(tab, ownedWindowId) {
+  if (tab.windowId !== ownedWindowId && !isKnownOwnedWindow(tab.windowId)) {
+    excludedOwnedWindowIds.add(tab.windowId);
+  }
+}
+async function rememberOwnedGroupDrift(groupId, ownedWindowId) {
+  if (groupId === null) return;
+  try {
+    const group = await chrome.tabGroups.get(groupId);
+    if (group.windowId !== ownedWindowId && !isKnownOwnedWindow(group.windowId)) {
+      excludedOwnedWindowIds.add(group.windowId);
+    }
+  } catch {
+  }
+}
+async function constrainOwnedWindowGeometry(windowId) {
+  const previous = ownedWindowGeometryUpdates.get(windowId) ?? Promise.resolve();
+  const next = previous.catch(() => void 0).then(async () => {
+    if (!isKnownOwnedWindow(windowId)) return;
+    try {
+      const window = await chrome.windows.get(windowId);
+      if (window.type !== "normal" || window.state !== "normal") return;
+      const originalBounds = { left: window.left, top: window.top, width: window.width, height: window.height };
+      const area = await getOwnedWindowWorkArea(window);
+      if (!area || !isKnownOwnedWindow(windowId)) return;
+      const current = await chrome.windows.get(windowId);
+      if (!isKnownOwnedWindow(windowId) || current.type !== "normal" || current.state !== "normal" || current.left !== originalBounds.left || current.top !== originalBounds.top || current.width !== originalBounds.width || current.height !== originalBounds.height) return;
+      const bounds = constrainOwnedWindowBounds(current, area);
+      if (bounds) await chrome.windows.update(windowId, bounds);
+    } catch (err) {
+      console.warn(`[bycli] Failed to constrain owned window ${windowId} geometry: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  });
+  const tracked = next.finally(() => {
+    if (ownedWindowGeometryUpdates.get(windowId) === tracked) ownedWindowGeometryUpdates.delete(windowId);
+  });
+  ownedWindowGeometryUpdates.set(windowId, tracked);
+  await tracked;
+}
+chrome.system?.display?.onDisplayChanged?.addListener(async () => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const container of Object.values(ownedContainers)) {
+    if (container.windowId !== null) ids.add(container.windowId);
+  }
+  for (const session of automationSessions.values()) {
+    if (session.owned) ids.add(session.windowId);
+  }
+  await Promise.all([...ids].map(constrainOwnedWindowGeometry));
+});
 async function toOwnedContainerDiscoveryCandidate(group) {
+  if (excludedOwnedWindowIds.has(group.windowId)) return null;
   try {
     const chromeWindow = await chrome.windows.get(group.windowId);
     const reusableTabId = await findReusableOwnedContainerTab(group.windowId, group.id);
@@ -2074,6 +2193,7 @@ async function discoverOwnedContainerFromTabGroup(role) {
   if (container.groupId !== null) {
     try {
       const group = await chrome.tabGroups.get(container.groupId);
+      if (excludedOwnedWindowIds.has(group.windowId)) throw new Error("Owned group moved to a user window");
       await chrome.windows.get(group.windowId);
       container.windowId = group.windowId;
       return { windowId: group.windowId, groupId: group.id };
@@ -2139,8 +2259,11 @@ async function ensureOwnedContainerWindow(role, initialUrl, mode = "background")
 async function ensureOwnedContainerWindowUnlocked(role, initialUrl, mode = "background") {
   const container = ownedContainers[role];
   if (container.windowId !== null) {
+    const knownWindowId = container.windowId;
+    const knownGroupId = container.groupId;
     try {
       await chrome.windows.get(container.windowId);
+      await constrainOwnedWindowGeometry(container.windowId);
       await focusOwnedWindowIfRequested(container.windowId, mode);
       const initialTabId2 = await findReusableOwnedContainerTab(container.windowId, await getOwnedContainerGroupId(role, container.windowId));
       await ensureOwnedContainerTabGroup(role, container.windowId, [initialTabId2]);
@@ -2149,12 +2272,16 @@ async function ensureOwnedContainerWindowUnlocked(role, initialUrl, mode = "back
         initialTabId: initialTabId2
       };
     } catch {
-      container.windowId = null;
-      container.groupId = null;
+      await rememberOwnedGroupDrift(knownGroupId, knownWindowId);
+      if (container.windowId === knownWindowId && container.groupId === knownGroupId) {
+        container.windowId = null;
+        container.groupId = null;
+      }
     }
   }
   const discovered = await discoverOwnedContainerFromTabGroup(role);
   if (discovered) {
+    await constrainOwnedWindowGeometry(discovered.windowId);
     await focusOwnedWindowIfRequested(discovered.windowId, mode);
     const initialTabId2 = await findReusableOwnedContainerTab(discovered.windowId, discovered.groupId);
     await ensureOwnedContainerTabGroup(role, discovered.windowId, [initialTabId2]);
@@ -2168,8 +2295,7 @@ async function ensureOwnedContainerWindowUnlocked(role, initialUrl, mode = "back
   const win = await chrome.windows.create({
     url: startUrl,
     focused: mode === "foreground",
-    width: 1280,
-    height: 900,
+    ...await getNewOwnedWindowBounds(),
     type: "normal"
   });
   container.windowId = win.id;
@@ -2264,9 +2390,14 @@ async function getAutomationWindow(leaseKey, initialUrl) {
       const tabId = existing.preferredTabId;
       if (tabId !== null) {
         const tab = await chrome.tabs.get(tabId);
-        if (isDebuggableUrl(tab.url)) return tab.windowId;
+        rememberOwnedTabDrift(tab, existing.windowId);
+        if (isDebuggableUrl(tab.url) && tab.windowId === existing.windowId) {
+          await constrainOwnedWindowGeometry(existing.windowId);
+          return existing.windowId;
+        }
       }
       await chrome.windows.get(existing.windowId);
+      await constrainOwnedWindowGeometry(existing.windowId);
       return existing.windowId;
     } catch {
       await removeLeaseSession(leaseKey);
@@ -2277,10 +2408,15 @@ async function getAutomationWindow(leaseKey, initialUrl) {
   return (await ensureOwnedContainerWindow(role, initialUrl, getWindowModeForOwnedPage(leaseKey, url))).windowId;
 }
 chrome.windows.onRemoved.addListener(async (windowId) => {
+  excludedOwnedWindowIds.delete(windowId);
   for (const container of Object.values(ownedContainers)) {
     if (container.windowId === windowId) {
-      container.windowId = null;
-      container.groupId = null;
+      const knownGroupId = container.groupId;
+      await rememberOwnedGroupDrift(knownGroupId, windowId);
+      if (container.windowId === windowId && container.groupId === knownGroupId) {
+        container.windowId = null;
+        container.groupId = null;
+      }
     }
   }
   for (const [leaseKey, expected] of [...automationSessions.entries()]) {
@@ -2535,8 +2671,14 @@ async function resolveTabUnlocked(tabId, leaseKey, initialUrl, blankFirst = fals
     try {
       const tab = await chrome.tabs.get(tabId);
       const session = existingSession;
+      if (session?.owned && (session.preferredTabId === tabId || session.preferredTabId === null)) {
+        rememberOwnedTabDrift(tab, session.windowId);
+      }
       const matchesSession = session ? session.preferredTabId !== null ? session.preferredTabId === tabId : tab.windowId === session.windowId : false;
-      if (isDebuggableUrl(tab.url) && matchesSession) return { tabId, tab };
+      if (isDebuggableUrl(tab.url) && matchesSession) {
+        if (session?.owned && tab.windowId === session.windowId) await constrainOwnedWindowGeometry(session.windowId);
+        return { tabId, tab };
+      }
       if (session && !session.owned) {
         throw new CommandFailure(
           matchesSession ? "bound_tab_not_debuggable" : "bound_tab_mismatch",
@@ -2550,6 +2692,7 @@ async function resolveTabUnlocked(tabId, leaseKey, initialUrl, blankFirst = fals
           await chrome.tabs.move(tabId, { windowId: session.windowId, index: -1 });
           const moved = await chrome.tabs.get(tabId);
           if (moved.windowId === session.windowId && isDebuggableUrl(moved.url)) {
+            if (session.owned) await constrainOwnedWindowGeometry(session.windowId);
             return { tabId, tab: moved };
           }
         } catch (moveErr) {
@@ -2576,7 +2719,11 @@ async function resolveTabUnlocked(tabId, leaseKey, initialUrl, blankFirst = fals
     const session = existingSession;
     try {
       const preferredTab = await chrome.tabs.get(existingPreferredTabId);
-      if (isDebuggableUrl(preferredTab.url)) return { tabId: preferredTab.id, tab: preferredTab };
+      if (session.owned) rememberOwnedTabDrift(preferredTab, session.windowId);
+      if (isDebuggableUrl(preferredTab.url)) {
+        if (session.owned && preferredTab.windowId === session.windowId) await constrainOwnedWindowGeometry(session.windowId);
+        return { tabId: preferredTab.id, tab: preferredTab };
+      }
       if (!session.owned) {
         throw new CommandFailure(
           "bound_tab_not_debuggable",
@@ -2871,6 +3018,8 @@ async function handleFocusUnlocked(cmd, leaseKey) {
   if (activatedTab.id !== tabId || activatedTab.windowId !== focusLease.windowId) {
     return { id: cmd.id, ok: false, error: "Current automation session tab changed window during focus" };
   }
+  await constrainOwnedWindowGeometry(focusLease.windowId);
+  if (!isFocusLeaseCurrent(leaseKey, focusLease)) return focusLeaseChangedResult(cmd.id);
   await updateWindow(focusLease.windowId, { focused: true });
   if (!isFocusLeaseCurrent(leaseKey, focusLease)) return focusLeaseChangedResult(cmd.id);
   return { id: cmd.id, ok: true, data: { focused: true } };
@@ -2964,12 +3113,16 @@ async function handleTabSelectUnlocked(cmd, leaseKey) {
     if (!session || tab.windowId !== session.windowId) {
       return { id: cmd.id, ok: false, error: "Page is not in the automation container" };
     }
+    if (session.owned) await constrainOwnedWindowGeometry(session.windowId);
     await chrome.tabs.update(cmdTabId, { active: true });
     return pageScopedResult(cmd.id, cmdTabId, { selected: true });
   }
   const tabs = await listAutomationWebTabsUnlocked(leaseKey);
   const target = tabs[cmd.index];
   if (!target?.id) return { id: cmd.id, ok: false, error: `Tab index ${cmd.index} not found` };
+  if (lockedSession?.owned && target.windowId === lockedSession.windowId) {
+    await constrainOwnedWindowGeometry(lockedSession.windowId);
+  }
   await chrome.tabs.update(target.id, { active: true });
   return pageScopedResult(cmd.id, target.id, { selected: true });
 }
@@ -3285,13 +3438,20 @@ async function reconcileTargetLeaseRegistry() {
   for (const role of Object.keys(ownedContainers)) {
     ownedContainers[role].windowId = registry.ownedContainers[role]?.windowId ?? null;
     ownedContainers[role].groupId = registry.ownedContainers[role]?.groupId ?? null;
+  }
+  for (const role of Object.keys(ownedContainers)) {
     const windowId = ownedContainers[role].windowId;
+    const groupId = ownedContainers[role].groupId;
     if (windowId !== null) {
       try {
         await chrome.windows.get(windowId);
+        await constrainOwnedWindowGeometry(windowId);
       } catch {
-        ownedContainers[role].windowId = null;
-        ownedContainers[role].groupId = null;
+        await rememberOwnedGroupDrift(groupId, windowId);
+        if (ownedContainers[role].windowId === windowId && ownedContainers[role].groupId === groupId) {
+          ownedContainers[role].windowId = null;
+          ownedContainers[role].groupId = null;
+        }
       }
     }
   }
@@ -3302,6 +3462,8 @@ async function reconcileTargetLeaseRegistry() {
     try {
       const tab = await chrome.tabs.get(tabId);
       if (!isDebuggableUrl(tab.url)) continue;
+      if (stored.owned && (!Number.isInteger(stored.windowId) || stored.windowId < 0)) continue;
+      if (stored.owned) rememberOwnedTabDrift(tab, stored.windowId);
       if (stored.lifecycle === "ephemeral" || stored.lifecycle === "persistent" || stored.lifecycle === "pinned") {
         sessionLifecycleOverrides.set(leaseKey, stored.lifecycle);
       }
@@ -3309,7 +3471,9 @@ async function reconcileTargetLeaseRegistry() {
         session: typeof stored.session === "string" ? stored.session : getSessionFromKey(leaseKey),
         surface: stored.surface === "adapter" ? "adapter" : getSurfaceFromKey(leaseKey),
         kind: stored.kind === "bound" || stored.owned === false ? "bound" : "owned",
-        windowId: tab.windowId,
+        // A leased tab can be dragged into a user window while the worker is
+        // stopped. Its current location does not transfer window ownership.
+        windowId: stored.owned ? stored.windowId : tab.windowId,
         owned: stored.owned,
         preferredTabId: tabId
       });
@@ -3319,9 +3483,10 @@ async function reconcileTargetLeaseRegistry() {
         idleTimer: null,
         idleDeadlineAt: stored.idleDeadlineAt
       });
-      if (session.owned) {
+      if (session.owned && tab.windowId === session.windowId) {
         const role = getOwnedWindowRole(leaseKey);
         if (ownedContainers[role].windowId === null) ownedContainers[role].windowId = tab.windowId;
+        await constrainOwnedWindowGeometry(tab.windowId);
         await ensureOwnedContainerTabGroup(role, tab.windowId, [tabId]);
       }
       const remaining = stored.idleDeadlineAt > 0 ? stored.idleDeadlineAt - Date.now() : timeout;

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "byCLI",
-  "version": "2.1.23",
+  "version": "2.1.24",
   "description": "Browser automation bridge for the byCLI CLI tool. Executes commands in Chrome tab leases via a local daemon.",
   "permissions": [
     "debugger",
@@ -11,6 +11,7 @@
     "alarms",
     "storage",
     "tabGroups",
+    "system.display",
     "downloads"
   ],
   "host_permissions": [

package/package.json

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