@jackwener/opencli 1.6.1 → 1.6.2

package/dist/clis/xiaohongshu/search.js

@@ -7,6 +7,28 @@
  */
 import { cli, Strategy } from '../../registry.js';
 import { AuthRequiredError } from '../../errors.js';
+/**
+ * Wait for search results or login wall using MutationObserver (max 5s).
+ * Returns 'content' if note items appeared, 'login_wall' if login gate
+ * detected, or 'timeout' if neither appeared within the deadline.
+ */
+const WAIT_FOR_CONTENT_JS = `
+  new Promise((resolve) => {
+    const detect = () => {
+      if (document.querySelector('section.note-item')) return 'content';
+      if (/登录后查看搜索结果/.test(document.body?.innerText || '')) return 'login_wall';
+      return null;
+    };
+    const found = detect();
+    if (found) return resolve(found);
+    const observer = new MutationObserver(() => {
+      const result = detect();
+      if (result) { observer.disconnect(); resolve(result); }
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+    setTimeout(() => { observer.disconnect(); resolve('timeout'); }, 5000);
+  })
+`;
 /**
  * Extract approximate publish date from a Xiaohongshu note URL.
  * XHS note IDs follow MongoDB ObjectID format where the first 8 hex
@@ -39,22 +61,17 @@ cli({
     func: async (page, kwargs) => {
         const keyword = encodeURIComponent(kwargs.query);
         await page.goto(`https://www.xiaohongshu.com/search_result?keyword=${keyword}&source=web_search_result_notes`);
-        await page.wait(3);
-        // Early login-wall detection: XHS may show a login gate instead of
-        // results. Check *before* autoScroll to avoid crashing on a page
-        // that has no meaningful content to scroll through.
-        const loginCheck = await page.evaluate(`
-      (() => /登录后查看搜索结果/.test(document.body?.innerText || ''))()
-    `);
-        if (loginCheck) {
+        // Wait for search results to render (or login wall to appear).
+        // Uses MutationObserver to resolve as soon as content appears,
+        // instead of a fixed delay + blind retry.
+        const waitResult = await page.evaluate(WAIT_FOR_CONTENT_JS);
+        if (waitResult === 'login_wall') {
             throw new AuthRequiredError('www.xiaohongshu.com', 'Xiaohongshu search results are blocked behind a login wall');
         }
         // Scroll a couple of times to load more results
         await page.autoScroll({ times: 2 });
         const payload = await page.evaluate(`
       (() => {
-        const loginWall = /登录后查看搜索结果/.test(document.body.innerText || '');
-
         const normalizeUrl = (href) => {
           if (!href) return '';
           if (href.startsWith('http://') || href.startsWith('https://')) return href;
@@ -98,18 +115,10 @@ cli({
           });
         });
 
-        return {
-          loginWall,
-          results,
-        };
+        return results;
       })()
     `);
-        if (!payload || typeof payload !== 'object')
-            return [];
-        if (payload.loginWall) {
-            throw new AuthRequiredError('www.xiaohongshu.com', 'Xiaohongshu search results are blocked behind a login wall');
-        }
-        const data = Array.isArray(payload.results) ? payload.results : [];
+        const data = Array.isArray(payload) ? payload : [];
         return data
             .filter((item) => item.title)
             .slice(0, kwargs.limit)

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

@@ -17,8 +17,6 @@ function createPageMock(evaluateResults) {
         getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
         wait: vi.fn().mockResolvedValue(undefined),
         tabs: vi.fn().mockResolvedValue([]),
-        closeTab: vi.fn().mockResolvedValue(undefined),
-        newTab: vi.fn().mockResolvedValue(undefined),
         selectTab: vi.fn().mockResolvedValue(undefined),
         networkRequests: vi.fn().mockResolvedValue([]),
         consoleMessages: vi.fn().mockResolvedValue([]),
@@ -36,8 +34,8 @@ describe('xiaohongshu search', () => {
         const cmd = getRegistry().get('xiaohongshu/search');
         expect(cmd?.func).toBeTypeOf('function');
         const page = createPageMock([
-            // First evaluate: early login-wall check (returns true)
-            true,
+            // First evaluate: MutationObserver wait (login wall detected)
+            'login_wall',
         ]);
         await expect(cmd.func(page, { query: '特斯拉', limit: 5 })).rejects.toThrow('Xiaohongshu search results are blocked behind a login wall');
         // autoScroll must NOT be called when a login wall is detected early
@@ -49,21 +47,18 @@ describe('xiaohongshu search', () => {
         const detailUrl = 'https://www.xiaohongshu.com/search_result/68e90be80000000004022e66?xsec_token=test-token&xsec_source=';
         const authorUrl = 'https://www.xiaohongshu.com/user/profile/635a9c720000000018028b40?xsec_token=user-token&xsec_source=pc_search';
         const page = createPageMock([
-            // First evaluate: early login-wall check (returns false → no wall)
-            false,
-            // Second evaluate: main DOM extraction
-            {
-                loginWall: false,
-                results: [
-                    {
-                        title: '某鱼买FSD被坑了4万',
-                        author: '随风',
-                        likes: '261',
-                        url: detailUrl,
-                        author_url: authorUrl,
-                    },
-                ],
-            },
+            // First evaluate: MutationObserver wait (content appeared)
+            'content',
+            // Second evaluate: main DOM extraction (returns array directly)
+            [
+                {
+                    title: '某鱼买FSD被坑了4万',
+                    author: '随风',
+                    likes: '261',
+                    url: detailUrl,
+                    author_url: authorUrl,
+                },
+            ],
         ]);
         const result = await cmd.func(page, { query: '特斯拉', limit: 1 });
         // Should only do one goto (the search page itself), no per-note detail navigation
@@ -84,41 +79,54 @@ describe('xiaohongshu search', () => {
         const cmd = getRegistry().get('xiaohongshu/search');
         expect(cmd?.func).toBeTypeOf('function');
         const page = createPageMock([
-            // First evaluate: early login-wall check (returns false → no wall)
-            false,
-            // Second evaluate: main DOM extraction
-            {
-                loginWall: false,
-                results: [
-                    {
-                        title: 'Result A',
-                        author: 'UserA',
-                        likes: '10',
-                        url: 'https://www.xiaohongshu.com/search_result/aaa',
-                        author_url: '',
-                    },
-                    {
-                        title: '',
-                        author: 'UserB',
-                        likes: '5',
-                        url: 'https://www.xiaohongshu.com/search_result/bbb',
-                        author_url: '',
-                    },
-                    {
-                        title: 'Result C',
-                        author: 'UserC',
-                        likes: '3',
-                        url: 'https://www.xiaohongshu.com/search_result/ccc',
-                        author_url: '',
-                    },
-                ],
-            },
+            // First evaluate: MutationObserver wait (content appeared)
+            'content',
+            // Second evaluate: main DOM extraction (returns array directly)
+            [
+                {
+                    title: 'Result A',
+                    author: 'UserA',
+                    likes: '10',
+                    url: 'https://www.xiaohongshu.com/search_result/aaa',
+                    author_url: '',
+                },
+                {
+                    title: '',
+                    author: 'UserB',
+                    likes: '5',
+                    url: 'https://www.xiaohongshu.com/search_result/bbb',
+                    author_url: '',
+                },
+                {
+                    title: 'Result C',
+                    author: 'UserC',
+                    likes: '3',
+                    url: 'https://www.xiaohongshu.com/search_result/ccc',
+                    author_url: '',
+                },
+            ],
         ]);
         const result = (await cmd.func(page, { query: '测试', limit: 1 }));
         // limit=1 should return only the first valid-titled result
         expect(result).toHaveLength(1);
         expect(result[0]).toMatchObject({ rank: 1, title: 'Result A' });
     });
+    it('waits for content via MutationObserver before extracting', async () => {
+        const cmd = getRegistry().get('xiaohongshu/search');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            // First evaluate: MutationObserver wait (content appeared)
+            'content',
+            // Second evaluate: extraction (returns empty array)
+            [],
+        ]);
+        const result = (await cmd.func(page, { query: '测试等待', limit: 5 }));
+        expect(result).toHaveLength(0);
+        // Only one navigation, no retry
+        expect(page.goto).toHaveBeenCalledTimes(1);
+        // Two evaluate calls: wait + extraction
+        expect(page.evaluate).toHaveBeenCalledTimes(2);
+    });
 });
 describe('noteIdToDate (ObjectID timestamp parsing)', () => {
     it('parses a known note ID to the correct China-timezone date', () => {

package/dist/clis/yuanbao/ask.d.ts

@@ -0,0 +1,21 @@
+import { isOnYuanbao } from './shared.js';
+declare function normalizeBooleanFlag(value: unknown, fallback: boolean): boolean;
+export declare function convertYuanbaoHtmlToMarkdown(value: string): string;
+export declare function sanitizeYuanbaoResponseText(value: string, promptText: string): string;
+export declare function collectYuanbaoTranscriptAdditions(beforeLines: string[], currentLines: string[], promptText: string): string;
+export declare function pickLatestYuanbaoAssistantCandidate(messages: string[], baselineCount: number, promptText: string): string;
+export declare function updateStableState(previousText: string, stableCount: number, nextText: string): {
+    previousText: string;
+    stableCount: number;
+};
+export declare const askCommand: import("../../registry.js").CliCommand;
+export declare const __test__: {
+    collectYuanbaoTranscriptAdditions: typeof collectYuanbaoTranscriptAdditions;
+    convertYuanbaoHtmlToMarkdown: typeof convertYuanbaoHtmlToMarkdown;
+    isOnYuanbao: typeof isOnYuanbao;
+    normalizeBooleanFlag: typeof normalizeBooleanFlag;
+    pickLatestYuanbaoAssistantCandidate: typeof pickLatestYuanbaoAssistantCandidate;
+    sanitizeYuanbaoResponseText: typeof sanitizeYuanbaoResponseText;
+    updateStableState: typeof updateStableState;
+};
+export {};

package/dist/clis/yuanbao/ask.js

@@ -0,0 +1,427 @@
+import { cli, Strategy } from '../../registry.js';
+import TurndownService from 'turndown';
+import { CommandExecutionError, TimeoutError } from '../../errors.js';
+import { YUANBAO_DOMAIN, IS_VISIBLE_JS, authRequired, isOnYuanbao, ensureYuanbaoPage, hasLoginGate } from './shared.js';
+const YUANBAO_RESPONSE_POLL_INTERVAL_SECONDS = 2;
+const YUANBAO_MIN_WAIT_MS = 8_000;
+const YUANBAO_STABLE_POLLS_REQUIRED = 3;
+function sendFailure(reason, detail) {
+    const suffix = detail ? ` Detail: ${detail}` : '';
+    return new CommandExecutionError(`${reason || 'Unknown Yuanbao send failure.'}${suffix}`, 'Make sure the Yuanbao chat composer is visible and ready before retrying.');
+}
+function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeBooleanFlag(value, fallback) {
+    if (typeof value === 'boolean')
+        return value;
+    if (value == null || value === '')
+        return fallback;
+    const normalized = String(value).trim().toLowerCase();
+    return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
+}
+function createYuanbaoTurndown() {
+    const td = new TurndownService({
+        headingStyle: 'atx',
+        codeBlockStyle: 'fenced',
+        bulletListMarker: '-',
+    });
+    td.addRule('linebreak', {
+        filter: 'br',
+        replacement: () => '\n',
+    });
+    td.addRule('table', {
+        filter: 'table',
+        replacement: (content) => `\n\n${content}\n\n`,
+    });
+    td.addRule('tableSection', {
+        filter: ['thead', 'tbody', 'tfoot'],
+        replacement: (content) => content,
+    });
+    td.addRule('tableRow', {
+        filter: 'tr',
+        replacement: (content, node) => {
+            const element = node;
+            const cells = Array.from(element.children);
+            const isHeaderRow = element.parentElement?.tagName === 'THEAD'
+                || (cells.length > 0 && cells.every((cell) => cell.tagName === 'TH'));
+            const row = `${content}\n`;
+            if (!isHeaderRow)
+                return row;
+            const separator = `| ${cells.map(() => '---').join(' | ')} |\n`;
+            return `${row}${separator}`;
+        },
+    });
+    td.addRule('tableCell', {
+        filter: ['th', 'td'],
+        replacement: (content, node) => {
+            const element = node;
+            const index = element.parentElement ? Array.from(element.parentElement.children).indexOf(element) : 0;
+            const prefix = index === 0 ? '| ' : ' ';
+            return `${prefix}${content.trim()} |`;
+        },
+    });
+    return td;
+}
+const yuanbaoTurndown = createYuanbaoTurndown();
+export function convertYuanbaoHtmlToMarkdown(value) {
+    const markdown = yuanbaoTurndown.turndown(value || '');
+    return markdown
+        .replace(/\u00a0/g, ' ')
+        .replace(/\n{4,}/g, '\n\n\n')
+        .replace(/[ \t]+$/gm, '')
+        .trim();
+}
+export function sanitizeYuanbaoResponseText(value, promptText) {
+    let sanitized = value
+        .replace(/内容由AI生成，仅供参考/gi, '')
+        .replace(/重新回答/gi, '')
+        .trim();
+    if (/^(正在搜索资料|搜索资料中|正在思考|思考中)[.。…]*$/u.test(sanitized)) {
+        return '';
+    }
+    const prompt = promptText.trim();
+    if (!prompt)
+        return sanitized;
+    if (sanitized === prompt)
+        return '';
+    for (const separator of ['\n\n', '\n', '\r\n\r\n', '\r\n', ' ']) {
+        const prefix = `${prompt}${separator}`;
+        if (sanitized.startsWith(prefix)) {
+            sanitized = sanitized.slice(prefix.length).trim();
+            break;
+        }
+    }
+    return sanitized;
+}
+export function collectYuanbaoTranscriptAdditions(beforeLines, currentLines, promptText) {
+    const beforeSet = new Set(beforeLines);
+    const additions = currentLines
+        .filter((line) => !beforeSet.has(line))
+        .map((line) => sanitizeYuanbaoResponseText(line, promptText))
+        .filter((line) => line && line !== promptText);
+    return additions.join('\n').trim();
+}
+export function pickLatestYuanbaoAssistantCandidate(messages, baselineCount, promptText) {
+    const freshMessages = messages
+        .slice(Math.max(0, baselineCount))
+        .map((message) => sanitizeYuanbaoResponseText(message, promptText))
+        .filter(Boolean);
+    for (let i = freshMessages.length - 1; i >= 0; i -= 1) {
+        if (freshMessages[i] !== promptText.trim())
+            return freshMessages[i];
+    }
+    return '';
+}
+export function updateStableState(previousText, stableCount, nextText) {
+    if (!nextText)
+        return { previousText: '', stableCount: 0 };
+    if (nextText === previousText)
+        return { previousText, stableCount: stableCount + 1 };
+    return { previousText: nextText, stableCount: 0 };
+}
+function getTranscriptLinesScript() {
+    return `
+    (() => {
+      const clean = (value) => (value || '')
+        .replace(/\\u00a0/g, ' ')
+        .replace(/\\n{3,}/g, '\\n\\n')
+        .trim();
+
+      const root = (
+        document.querySelector('.agent-dialogue__content--common')
+        || document.querySelector('.agent-dialogue__content')
+        || document.querySelector('.agent-dialogue')
+        || document.body
+      ).cloneNode(true);
+
+      const removableSelectors = [
+        '.agent-dialogue__content--common__input',
+        '.agent-dialogue__tool',
+        '.agent-dialogue__content-copyright',
+        '.index_chatLandingBox__G7hAT',
+        '.index_chatLandingBoxMobile__J8i8v',
+        '.index_chatLandingHintList__M69Lr',
+        '.yb-nav',
+        '.agent-dialogue__content--common__input .ql-toolbar',
+        '.agent-dialogue__content--common__input .ql-container',
+        '.agent-dialogue__content--common__input .ql-editor',
+        '[role="dialog"]',
+        'iframe',
+        'button',
+        'script',
+        'style',
+        'noscript',
+      ];
+
+      for (const selector of removableSelectors) {
+        root.querySelectorAll(selector).forEach((node) => node.remove());
+      }
+
+      const stopLines = new Set([
+        '元宝',
+        'DeepSeek',
+        '深度思考',
+        '联网搜索',
+        '工具',
+        '登录',
+        '安装电脑版',
+        '内容由AI生成，仅供参考',
+        '有问题，尽管问，shift+enter换行',
+        '立即创建团队',
+        '微信',
+        '手机',
+        'QQ',
+        '微信扫码登录',
+        '扫码默认已阅读并同意',
+        '用户服务协议',
+        '隐私协议',
+      ]);
+
+      const noisyPatterns = [
+        /^支持文件格式[:：]/,
+        /^文件拖动到此处即可上传/,
+        /^下载元宝电脑版/,
+      ];
+
+      return clean(root.innerText || root.textContent || '')
+        .split('\\n')
+        .map((line) => clean(line))
+        .filter((line) => line
+          && line.length <= 4000
+          && !stopLines.has(line)
+          && !noisyPatterns.some((pattern) => pattern.test(line)));
+    })()
+  `;
+}
+async function getYuanbaoTranscriptLines(page) {
+    const result = await page.evaluate(getTranscriptLinesScript());
+    return Array.isArray(result) ? result.map(normalizeText).filter(Boolean) : [];
+}
+async function getYuanbaoAssistantMessages(page) {
+    const result = await page.evaluate(`(() => {
+    ${IS_VISIBLE_JS}
+
+    const roots = Array.from(document.querySelectorAll('.agent-chat__list__item--ai'))
+      .filter((node) => isVisible(node));
+
+    return roots.map((root) => {
+      const doneContent = root.querySelector('.hyc-content-md-done');
+      const markdownContent = doneContent || root.querySelector('.hyc-content-md');
+      const speechContent = root.querySelector('.agent-chat__speech-text');
+      const bubbleContent = root.querySelector('.agent-chat__bubble__content');
+      const content = markdownContent || speechContent || bubbleContent;
+
+      if (content instanceof HTMLElement) {
+        return content.innerHTML || content.textContent || '';
+      }
+
+      return root instanceof HTMLElement ? (root.innerHTML || root.textContent || '') : '';
+    }).filter(Boolean);
+  })()`);
+    return Array.isArray(result)
+        ? result
+            .map((value) => convertYuanbaoHtmlToMarkdown(typeof value === 'string' ? value : ''))
+            .map(normalizeText)
+            .filter(Boolean)
+        : [];
+}
+async function getYuanbaoInternetSearchState(page) {
+    const result = await page.evaluate(`(() => {
+    ${IS_VISIBLE_JS}
+
+    const button = Array.from(document.querySelectorAll('[dt-button-id="internet_search"]'))
+      .find((node) => isVisible(node));
+
+    if (!(button instanceof HTMLElement)) return { found: false, enabled: false };
+
+    const attr = button.getAttribute('dt-internet-search') || '';
+    const className = button.className || '';
+    return {
+      found: true,
+      enabled: attr === 'openInternetSearch' || className.includes('index_v2_active__'),
+    };
+  })()`);
+    return result;
+}
+async function setYuanbaoInternetSearch(page, enabled) {
+    const current = await getYuanbaoInternetSearchState(page);
+    if (!current.found || current.enabled === enabled)
+        return;
+    await page.evaluate(`(() => {
+    ${IS_VISIBLE_JS}
+
+    const button = Array.from(document.querySelectorAll('[dt-button-id="internet_search"]'))
+      .find((node) => isVisible(node));
+
+    if (button instanceof HTMLElement) button.click();
+  })()`);
+    await page.wait(0.5);
+}
+async function getYuanbaoDeepThinkState(page) {
+    const result = await page.evaluate(`(() => {
+    ${IS_VISIBLE_JS}
+
+    const button = Array.from(document.querySelectorAll('[dt-button-id="deep_think"]'))
+      .find((node) => isVisible(node));
+
+    if (!(button instanceof HTMLElement)) return { found: false, enabled: false };
+
+    const className = button.className || '';
+    return {
+      found: true,
+      enabled: className.includes('ThinkSelector_selected__'),
+    };
+  })()`);
+    return result;
+}
+async function setYuanbaoDeepThink(page, enabled) {
+    const current = await getYuanbaoDeepThinkState(page);
+    if (!current.found || current.enabled === enabled)
+        return;
+    await page.evaluate(`(() => {
+    ${IS_VISIBLE_JS}
+
+    const button = Array.from(document.querySelectorAll('[dt-button-id="deep_think"]'))
+      .find((node) => isVisible(node));
+
+    if (button instanceof HTMLElement) button.click();
+  })()`);
+    await page.wait(0.5);
+}
+async function sendYuanbaoMessage(page, prompt) {
+    return await page.evaluate(`(async () => {
+    const waitFor = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    ${IS_VISIBLE_JS}
+
+    const composer = Array.from(document.querySelectorAll('.ql-editor[contenteditable="true"], .ql-editor, [contenteditable="true"]'))
+      .find(isVisible);
+
+    if (!(composer instanceof HTMLElement)) {
+      return {
+        ok: false,
+        reason: 'Yuanbao composer was not found.',
+      };
+    }
+
+    try {
+      composer.focus();
+      const selection = window.getSelection();
+      const range = document.createRange();
+      range.selectNodeContents(composer);
+      range.collapse(false);
+      selection?.removeAllRanges();
+      selection?.addRange(range);
+      composer.textContent = '';
+      document.execCommand('insertText', false, ${JSON.stringify(prompt)});
+      composer.dispatchEvent(new InputEvent('input', { bubbles: true, data: ${JSON.stringify(prompt)}, inputType: 'insertText' }));
+      await waitFor(200);
+    } catch (error) {
+      return {
+        ok: false,
+        reason: 'Failed to insert the prompt into the Yuanbao composer.',
+        detail: error instanceof Error ? error.message : String(error),
+      };
+    }
+
+    const submit = Array.from(document.querySelectorAll('a[class*="send-btn"], button[class*="send-btn"]'))
+      .find((node) => {
+        if (!(node instanceof HTMLElement) || !isVisible(node)) return false;
+        const className = node.className || '';
+        if (typeof className === 'string' && className.includes('disabled')) return false;
+        return true;
+      });
+
+    if (submit instanceof HTMLElement) {
+      submit.click();
+      return { ok: true, action: 'click' };
+    }
+
+    composer.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+    composer.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+    return { ok: true, action: 'enter' };
+  })()`);
+}
+async function waitForYuanbaoResponse(page, baselineAssistantCount, beforeLines, prompt, timeoutSeconds) {
+    const startTime = Date.now();
+    let previousText = '';
+    let stableCount = 0;
+    let latestCandidate = '';
+    while (Date.now() - startTime < timeoutSeconds * 1000) {
+        await page.wait(YUANBAO_RESPONSE_POLL_INTERVAL_SECONDS);
+        if (await hasLoginGate(page))
+            return 'blocked';
+        const assistantMessages = await getYuanbaoAssistantMessages(page);
+        const assistantCandidate = pickLatestYuanbaoAssistantCandidate(assistantMessages, baselineAssistantCount, prompt);
+        const candidate = assistantCandidate || collectYuanbaoTranscriptAdditions(beforeLines, await getYuanbaoTranscriptLines(page), prompt);
+        if (!candidate)
+            continue;
+        latestCandidate = candidate;
+        const nextState = updateStableState(previousText, stableCount, candidate);
+        previousText = nextState.previousText;
+        stableCount = nextState.stableCount;
+        const waitedLongEnough = Date.now() - startTime >= YUANBAO_MIN_WAIT_MS;
+        if (waitedLongEnough && stableCount >= YUANBAO_STABLE_POLLS_REQUIRED)
+            return candidate;
+    }
+    return latestCandidate || null;
+}
+export const askCommand = cli({
+    site: 'yuanbao',
+    name: 'ask',
+    description: 'Send a prompt to Yuanbao web chat and wait for the assistant response',
+    domain: YUANBAO_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    defaultFormat: 'plain',
+    timeoutSeconds: 180,
+    args: [
+        { name: 'prompt', required: true, positional: true, help: 'Prompt to send' },
+        { name: 'timeout', required: false, help: 'Max seconds to wait (default: 60)', default: '60' },
+        { name: 'search', type: 'boolean', required: false, help: 'Enable Yuanbao internet search (default: true)', default: true },
+        { name: 'think', type: 'boolean', required: false, help: 'Enable Yuanbao deep thinking (default: false)', default: false },
+    ],
+    columns: ['Role', 'Text'],
+    func: async (page, kwargs) => {
+        const prompt = kwargs.prompt;
+        const timeout = parseInt(kwargs.timeout, 10) || 60;
+        const useSearch = normalizeBooleanFlag(kwargs.search, true);
+        const useThink = normalizeBooleanFlag(kwargs.think, false);
+        await ensureYuanbaoPage(page);
+        if (await hasLoginGate(page)) {
+            throw authRequired('Yuanbao opened a login gate before sending the prompt.');
+        }
+        await setYuanbaoInternetSearch(page, useSearch);
+        await setYuanbaoDeepThink(page, useThink);
+        const beforeAssistantMessages = await getYuanbaoAssistantMessages(page);
+        const beforeLines = await getYuanbaoTranscriptLines(page);
+        const sendResult = await sendYuanbaoMessage(page, prompt);
+        if (!sendResult?.ok) {
+            if (await hasLoginGate(page)) {
+                throw authRequired('Yuanbao opened a login gate instead of accepting the prompt.');
+            }
+            throw sendFailure(sendResult?.reason, sendResult?.detail);
+        }
+        const response = await waitForYuanbaoResponse(page, beforeAssistantMessages.length, beforeLines, prompt, timeout);
+        if (response === 'blocked') {
+            throw authRequired('Yuanbao opened a login gate instead of returning a chat response.');
+        }
+        if (!response) {
+            throw new TimeoutError('yuanbao ask', timeout, 'No Yuanbao response was observed before the timeout. Retry with --timeout, and verify the current browser session is still interactive.');
+        }
+        return [
+            { Role: 'User', Text: prompt },
+            { Role: 'Assistant', Text: response },
+        ];
+    },
+});
+export const __test__ = {
+    collectYuanbaoTranscriptAdditions,
+    convertYuanbaoHtmlToMarkdown,
+    isOnYuanbao,
+    normalizeBooleanFlag,
+    pickLatestYuanbaoAssistantCandidate,
+    sanitizeYuanbaoResponseText,
+    updateStableState,
+};

package/dist/clis/yuanbao/ask.test.d.ts

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