@jackwener/opencli 1.6.0 → 1.6.2

package/src/clis/yuanbao/ask.ts

@@ -0,0 +1,522 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import TurndownService from 'turndown';
+import { CommandExecutionError, TimeoutError } from '../../errors.js';
+import { YUANBAO_DOMAIN, YUANBAO_URL, 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;
+
+type YuanbaoSendResult = {
+  ok?: boolean;
+  action?: string;
+  reason?: string;
+  detail?: string;
+};
+
+type YuanbaoToggleState = {
+  enabled: boolean;
+  found: boolean;
+};
+
+function sendFailure(reason?: string, detail?: string) {
+  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: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function normalizeBooleanFlag(value: unknown, fallback: boolean): boolean {
+  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(): TurndownService {
+  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 as Element;
+      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 as Element;
+      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: string): string {
+  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: string, promptText: string): string {
+  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: string[],
+  currentLines: string[],
+  promptText: string,
+): string {
+  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: string[],
+  baselineCount: number,
+  promptText: string,
+): string {
+  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: string, stableCount: number, nextText: string) {
+  if (!nextText) return { previousText: '', stableCount: 0 };
+  if (nextText === previousText) return { previousText, stableCount: stableCount + 1 };
+  return { previousText: nextText, stableCount: 0 };
+}
+
+
+function getTranscriptLinesScript(): string {
+  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: IPage): Promise<string[]> {
+  const result = await page.evaluate(getTranscriptLinesScript());
+  return Array.isArray(result) ? result.map(normalizeText).filter(Boolean) : [];
+}
+
+async function getYuanbaoAssistantMessages(page: IPage): Promise<string[]> {
+  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: IPage): Promise<YuanbaoToggleState> {
+  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 as YuanbaoToggleState;
+}
+
+async function setYuanbaoInternetSearch(page: IPage, enabled: boolean): Promise<void> {
+  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: IPage): Promise<YuanbaoToggleState> {
+  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 as YuanbaoToggleState;
+}
+
+async function setYuanbaoDeepThink(page: IPage, enabled: boolean): Promise<void> {
+  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: IPage, prompt: string): Promise<YuanbaoSendResult> {
+  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' };
+  })()`) as YuanbaoSendResult;
+}
+
+async function waitForYuanbaoResponse(
+  page: IPage,
+  baselineAssistantCount: number,
+  beforeLines: string[],
+  prompt: string,
+  timeoutSeconds: number,
+): Promise<string | null | 'blocked'> {
+  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: IPage, kwargs: any) => {
+    const prompt = kwargs.prompt as string;
+    const timeout = parseInt(kwargs.timeout as string, 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/src/clis/yuanbao/new.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { IPage } from '../../types.js';
+import { AuthRequiredError } from '../../errors.js';
+import { newCommand } from './new.js';
+
+function createNewPageMock(overrides: {
+  currentUrl?: string;
+  triggerAction?: 'clicked' | 'navigate';
+  hasLoginGate?: boolean;
+  composerText?: string;
+} = {}): IPage {
+  const currentUrl = overrides.currentUrl ?? 'https://yuanbao.tencent.com/';
+  const triggerAction = overrides.triggerAction ?? 'clicked';
+  const hasLoginGate = overrides.hasLoginGate ?? false;
+  const composerText = overrides.composerText ?? '';
+
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockImplementation(async (script: string) => {
+      if (script === 'window.location.href') return currentUrl;
+      if (script.includes('微信扫码登录')) return hasLoginGate;
+      if (script.includes('.ql-editor, [contenteditable="true"]')) return composerText;
+      if (script.includes('const trigger = Array.from(document.querySelectorAll')) return triggerAction;
+      throw new Error(`Unexpected evaluate script in test: ${script.slice(0, 80)}`);
+    }),
+  } as unknown as IPage;
+}
+
+describe('yuanbao new command', () => {
+  it('throws AuthRequiredError when Yuanbao shows a login gate', async () => {
+    const page = createNewPageMock({ hasLoginGate: true });
+
+    await expect(newCommand.func!(page, {})).rejects.toBeInstanceOf(AuthRequiredError);
+  });
+});

package/src/clis/yuanbao/new.ts

@@ -0,0 +1,81 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { YUANBAO_DOMAIN, YUANBAO_URL, IS_VISIBLE_JS, authRequired, ensureYuanbaoPage, hasLoginGate } from './shared.js';
+
+async function getCurrentUrl(page: IPage): Promise<string> {
+  const result = await page.evaluate('window.location.href').catch(() => '');
+  return typeof result === 'string' ? result : '';
+}
+
+async function getComposerText(page: IPage): Promise<string> {
+  const result = await page.evaluate(`(() => {
+    const composer = document.querySelector('.ql-editor, [contenteditable="true"]');
+    return composer ? (composer.textContent || '').trim() : '';
+  })()`);
+
+  return typeof result === 'string' ? result.trim() : '';
+}
+
+async function startNewYuanbaoChat(page: IPage): Promise<'clicked' | 'navigate' | 'blocked'> {
+  await ensureYuanbaoPage(page);
+
+  if (await hasLoginGate(page)) return 'blocked';
+
+  const beforeUrl = await getCurrentUrl(page);
+  const action = await page.evaluate(`(() => {
+    ${IS_VISIBLE_JS}
+
+    const trigger = Array.from(document.querySelectorAll('.yb-common-nav__trigger[data-desc="new-chat"]'))
+      .find((node) => isVisible(node));
+
+    if (trigger instanceof HTMLElement) {
+      trigger.click();
+      return 'clicked';
+    }
+
+    return 'navigate';
+  })()`) as 'clicked' | 'navigate';
+
+  if (action === 'navigate') {
+    await page.goto(YUANBAO_URL, { waitUntil: 'load', settleMs: 2500 });
+    await page.wait(1);
+    if (await hasLoginGate(page)) return 'blocked';
+    return 'navigate';
+  }
+
+  await page.wait(1);
+
+  if (await hasLoginGate(page)) return 'blocked';
+
+  const afterUrl = await getCurrentUrl(page);
+  const composerText = await getComposerText(page);
+  if (afterUrl !== beforeUrl || !composerText) return 'clicked';
+
+  await page.goto(YUANBAO_URL, { waitUntil: 'load', settleMs: 2500 });
+  await page.wait(1);
+  return 'navigate';
+}
+
+export const newCommand = cli({
+  site: 'yuanbao',
+  name: 'new',
+  description: 'Start a new conversation in Yuanbao web chat',
+  domain: YUANBAO_DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [],
+  columns: ['Status', 'Action'],
+  func: async (page: IPage) => {
+    const action = await startNewYuanbaoChat(page);
+
+    if (action === 'blocked') {
+      throw authRequired('Yuanbao opened a login gate instead of starting a new chat.');
+    }
+
+    return [{
+      Status: 'Success',
+      Action: action === 'navigate' ? 'Reloaded Yuanbao homepage as fallback' : 'Clicked New chat',
+    }];
+  },
+});

package/src/clis/yuanbao/shared.ts

@@ -0,0 +1,57 @@
+import type { IPage } from '../../types.js';
+import { AuthRequiredError } from '../../errors.js';
+
+export const YUANBAO_DOMAIN = 'yuanbao.tencent.com';
+export const YUANBAO_URL = 'https://yuanbao.tencent.com/';
+
+const SESSION_HINT = 'Likely login/auth/challenge/session issue in the existing yuanbao.tencent.com browser session.';
+
+/**
+ * Reusable visibility check for injected browser scripts.
+ * Embed in page.evaluate strings via `${IS_VISIBLE_JS}`.
+ */
+export const IS_VISIBLE_JS = `const isVisible = (node) => {
+  if (!(node instanceof HTMLElement)) return false;
+  const rect = node.getBoundingClientRect();
+  const style = window.getComputedStyle(node);
+  return rect.width > 0
+    && rect.height > 0
+    && style.display !== 'none'
+    && style.visibility !== 'hidden';
+};`;
+
+export function authRequired(message: string) {
+  return new AuthRequiredError(YUANBAO_DOMAIN, `${message} ${SESSION_HINT}`);
+}
+
+export async function isOnYuanbao(page: IPage): Promise<boolean> {
+  const url = await page.evaluate('window.location.href').catch(() => '');
+  if (typeof url !== 'string' || !url) return false;
+
+  try {
+    const hostname = new URL(url).hostname;
+    return hostname === YUANBAO_DOMAIN || hostname.endsWith(`.${YUANBAO_DOMAIN}`);
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureYuanbaoPage(page: IPage): Promise<void> {
+  if (!(await isOnYuanbao(page))) {
+    await page.goto(YUANBAO_URL, { waitUntil: 'load', settleMs: 2500 });
+    await page.wait(1);
+  }
+}
+
+export async function hasLoginGate(page: IPage): Promise<boolean> {
+  const result = await page.evaluate(`(() => {
+    const bodyText = document.body.innerText || '';
+    const hasWechatLoginText = bodyText.includes('微信扫码登录');
+    const hasWechatIframe = Array.from(document.querySelectorAll('iframe'))
+      .some((frame) => (frame.getAttribute('src') || '').includes('open.weixin.qq.com/connect/qrconnect'));
+
+    return hasWechatLoginText || hasWechatIframe;
+  })()`);
+
+  return Boolean(result);
+}