@sovovs/bycli 2.1.25 → 2.1.27

package/clis/weixin/_wechat/article-fallback-policy.js

@@ -1,5 +1,5 @@
 import {
-  AuthRequiredError, CommandExecutionError, EmptyResultError,
+  AuthRequiredError, CliError, CommandExecutionError, EmptyResultError, RateLimitedError,
 } from '@sovovs/bycli/errors';
 import { buildSecretSet, redactText } from './redact.js';
 
@@ -16,12 +16,17 @@ function safePhase(error, secrets) {
 }
 
 export function isEligibleArticleFallbackError(error) {
-  return error instanceof CommandExecutionError || error instanceof EmptyResultError;
+  return error instanceof CommandExecutionError
+    || error instanceof EmptyResultError
+    || (error instanceof CliError && error.code === 'RATE_LIMITED');
 }
 
 export function withMissingFallbackName(operation, error) {
   const hint = `${error.hint ? `${error.hint} ` : ''}Sogou fallback requires the exact official-account name in --name.`;
   if (error instanceof EmptyResultError) return new EmptyResultError(operation, hint);
+  if (error instanceof CliError && error.code === 'RATE_LIMITED') {
+    return new RateLimitedError(error.message, hint);
+  }
   return new CommandExecutionError(error.message, hint);
 }
 
@@ -31,11 +36,17 @@ export function combineArticleFallbackErrors({
   fallbackError,
   credentials,
 }) {
-  if (fallbackError instanceof AuthRequiredError) return fallbackError;
   const secrets = buildSecretSet(credentials);
   const primary = safePhase(primaryError, secrets);
   const fallback = safePhase(fallbackError, secrets);
   const hint = `Primary (${primary.code}): ${primary.summary}; fallback (${fallback.code}): ${fallback.summary}`;
+  if (primaryError instanceof CliError && primaryError.code === 'RATE_LIMITED') {
+    return new RateLimitedError(
+      'Weixin article index was rate limited and Sogou fallback failed',
+      hint,
+    );
+  }
+  if (fallbackError instanceof AuthRequiredError) return fallbackError;
   if (primaryError instanceof EmptyResultError && fallbackError instanceof EmptyResultError) {
     return new EmptyResultError(operation, hint);
   }

package/clis/weixin/_wechat/article-index.js

@@ -1,4 +1,4 @@
-import { AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { AuthRequiredError, CommandExecutionError, RateLimitedError } from '@sovovs/bycli/errors';
 import { buildSecretSet, redactText } from './redact.js';
 
 const DOMAIN = 'mp.weixin.qq.com';
@@ -34,8 +34,8 @@ export function mapArticleIndexPayload(payload) {
     throw new AuthRequiredError(DOMAIN, 'WeChat article-index credentials have expired');
   }
   if (ret === 200013 && normalizedMessage === 'freq control') {
-    throw commandError(
-      'was rate limited (ret=200013)',
+    throw new RateLimitedError(
+      'WeChat appmsgpublish was rate limited (ret=200013)',
       'Wait before retrying the WeChat article-index request; repeated retries may extend frequency control.',
     );
   }
@@ -122,6 +122,10 @@ function transportError(error, credentials) {
   const redactedHint = hint ? redactText(hint, secrets) : undefined;
   if (error instanceof AuthRequiredError && error.domain === DOMAIN
     && redactedMessage === message && redactedHint === hint) return error;
+  if (error instanceof RateLimitedError) {
+    if (redactedMessage === message && redactedHint === hint) return error;
+    return new RateLimitedError(redactedMessage, redactedHint);
+  }
   if (isWechatVerificationResponse(redactedMessage, redactedHint)) {
     return new AuthRequiredError(
       DOMAIN,

package/clis/weixin/_wechat/sogou-fallback.js

@@ -4,6 +4,7 @@ import {
 import { resolveWechatArticleUrl } from './article-link.js';
 import { redactText } from './redact.js';
 import {
+  buildSogouSearchUrl,
   DEFAULT_SOGOU_MAX_PAGES,
   normalizePositiveInteger,
   searchSogouArticlePage,
@@ -92,6 +93,32 @@ function safeResolutionError(error) {
   return redactText(message, []) || 'Sogou article link resolution failed';
 }
 
+async function replaceWithFreshSogouPage(page, accountName) {
+  if (typeof page?.closeWindow !== 'function'
+      || typeof page?.newTab !== 'function'
+      || typeof page?.setActivePage !== 'function') {
+    throw new CommandExecutionError(
+      'weixin Sogou fallback cannot create an isolated browser page',
+      'Update byCLI and Browser Bridge, then retry the command.',
+    );
+  }
+  const searchUrl = buildSogouSearchUrl(accountName, 1);
+  let createdPage;
+  try {
+    await page.closeWindow();
+    createdPage = await page.newTab(searchUrl);
+    if (!createdPage) throw new Error('Browser Bridge returned no page identity');
+    page.setActivePage(createdPage);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new CommandExecutionError(
+      'weixin Sogou fallback failed to create an isolated browser page',
+      detail,
+    );
+  }
+  return searchUrl;
+}
+
 export async function collectSogouAccountArticles({
   page,
   accountName,
@@ -101,6 +128,7 @@ export async function collectSogouAccountArticles({
   resolveUrl = resolveWechatArticleUrl,
   resolutionPolicy = 'atomic',
   scanStartedAt = Date.now(),
+  freshPage = false,
 }) {
   const normalizedName = String(accountName ?? '').trim();
   if (!normalizedName) {
@@ -125,12 +153,21 @@ export async function collectSogouAccountArticles({
   let pagesScanned = 0;
   let coverage = 'max-pages-reached';
   let firstSeen = 0;
+  const preloadedFirstPageUrl = freshPage
+    ? await replaceWithFreshSogouPage(page, normalizedName)
+    : undefined;
 
   for (let pageNo = 1; pageNo <= pageLimit; pageNo += 1) {
-    const result = await searchPage(page, { query: normalizedName, pageNo });
+    const result = await searchPage(page, {
+      query: normalizedName,
+      pageNo,
+      preloadedUrl: pageNo === 1 ? preloadedFirstPageUrl : undefined,
+    });
     pagesScanned += 1;
     if (result.state === 'empty') {
-      coverage = 'search-exhausted';
+      coverage = result.reason === 'result-cap'
+        ? 'result-cap-reached'
+        : 'search-exhausted';
       break;
     }
     if (seenFingerprints.has(result.fingerprint)) {
@@ -160,9 +197,14 @@ export async function collectSogouAccountArticles({
   }
 
   if (candidates.length === 0) {
-    const coverageHint = coverage === 'max-pages-reached'
-      ? `Scanned ${pagesScanned} pages and reached the page cap; later pages may still contain a match.`
-      : `Sogou search exhausted after ${pagesScanned} pages.`;
+    let coverageHint;
+    if (coverage === 'max-pages-reached') {
+      coverageHint = `Scanned ${pagesScanned} pages and reached the page cap; later pages may still contain a match.`;
+    } else if (coverage === 'result-cap-reached') {
+      coverageHint = 'Sogou stopped anonymous browsing at its 100-result visibility cap; hidden results may still contain a match.';
+    } else {
+      coverageHint = `Sogou search exhausted after ${pagesScanned} pages.`;
+    }
     throw new EmptyResultError(
       'weixin Sogou account fallback',
       `No Sogou articles matched the exact official-account name "${normalizedName}"; similarly named accounts were excluded. ${coverageHint}`,

package/clis/weixin/_wechat/sogou-search.js

@@ -4,6 +4,8 @@ import {
 
 const SOGOU_WEIXIN_DOMAIN = 'weixin.sogou.com';
 export const DEFAULT_SOGOU_MAX_PAGES = 50;
+const MAX_SOGOU_SHELL_ATTEMPTS = 2;
+const SOGOU_SHELL_RETRY_DELAY_SECONDS = 2;
 
 export function normalizePositiveInteger(value, name, defaultValue, maxValue) {
   if (value === undefined || value === null) return defaultValue;
@@ -52,9 +54,11 @@ export function buildExtractSogouSearchResultsEvaluate() {
       }
     };
 
-    const bodyText = clean(document.body && document.body.innerText);
+    const bodyText = clean(document.body && (document.body.innerText || document.body.textContent));
     const blocked = /验证码|安全验证|异常访问|访问过于频繁|请输入验证码/.test(bodyText);
-    const empty = /没有找到相关的微信文章|未找到相关|暂无相关|没有找到/.test(bodyText)
+    const resultCap = /当前只显示\s*100\s*条结果/.test(bodyText);
+    const empty = resultCap
+      || /没有找到相关的微信文章|未找到相关|暂无相关|没有找到/.test(bodyText)
       || Boolean(document.querySelector('.no-result, .no_result, .s-noresult'));
     const cards = Array.from(document.querySelectorAll('.news-list li'));
     const extracted = cards.map((item) => {
@@ -78,6 +82,7 @@ export function buildExtractSogouSearchResultsEvaluate() {
     return {
       blocked,
       empty,
+      resultCap,
       invalidCount: extracted.length - rows.length,
       rows,
     };
@@ -88,56 +93,86 @@ function fingerprintRows(rows) {
   return rows.map(row => `${row.title}\u0000${row.url}`).join('\u0001');
 }
 
-export async function searchSogouArticlePage(page, { query, pageNo }) {
-  const normalizedQuery = String(query ?? '').trim();
-  if (!normalizedQuery) {
-    throw new ArgumentError(
-      'A search query is required.',
-      'Pass a non-empty keyword to search Weixin articles via Sogou.',
-    );
-  }
-  const normalizedPage = normalizePositiveInteger(pageNo, 'page', 1);
-  const searchUrl = buildSogouSearchUrl(normalizedQuery, normalizedPage);
-  let payload;
+function buildSogouRetryUrl(searchUrl, retryNo) {
+  const retryUrl = new URL(searchUrl);
+  retryUrl.searchParams.set('_bycli_retry', String(retryNo));
+  return retryUrl.toString();
+}
+
+async function loadSogouPayload(page, searchUrl, delayBeforeSeconds = 0, navigate = true) {
   try {
-    await page.goto(searchUrl);
+    if (delayBeforeSeconds > 0) await page.wait(delayBeforeSeconds);
+    if (navigate) await page.goto(searchUrl);
     await page.wait(2);
-    payload = await page.evaluate(buildExtractSogouSearchResultsEvaluate());
+    return await page.evaluate(buildExtractSogouSearchResultsEvaluate());
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
-    throw new CommandExecutionError('weixin sougousearch failed while loading Sogou results', detail);
-  }
-  if (!payload || typeof payload !== 'object' || !Array.isArray(payload.rows)) {
     throw new CommandExecutionError(
-      'weixin sougousearch returned an unreadable browser payload',
-      'Sogou Weixin may have changed its result page structure.',
+      'weixin sougousearch failed while loading Sogou results',
+      detail,
     );
   }
-  if (payload.blocked) {
-    throw new AuthRequiredError(
-      SOGOU_WEIXIN_DOMAIN,
-      'Sogou Weixin requires verification. Complete it in the open browser tab and run the command again.',
-    );
-  }
-  if (payload.invalidCount > 0) {
-    throw new CommandExecutionError(
-      'Sogou Weixin returned article cards without required title or URL',
-      'The result page structure may have changed; refusing to return a partial result set.',
+}
+
+export async function searchSogouArticlePage(page, { query, pageNo, preloadedUrl }) {
+  const normalizedQuery = String(query ?? '').trim();
+  if (!normalizedQuery) {
+    throw new ArgumentError(
+      'A search query is required.',
+      'Pass a non-empty keyword to search Weixin articles via Sogou.',
     );
   }
-  if (payload.rows.length === 0 && payload.empty) {
-    return { state: 'empty', page: normalizedPage, fingerprint: '', rows: [] };
-  }
-  if (payload.rows.length === 0) {
-    throw new CommandExecutionError(
-      'weixin sougousearch did not expose article result cards',
-      'Sogou Weixin may have changed its selectors or returned a transient shell page.',
+  const normalizedPage = normalizePositiveInteger(pageNo, 'page', 1);
+  const searchUrl = buildSogouSearchUrl(normalizedQuery, normalizedPage);
+  for (let attempt = 1; attempt <= MAX_SOGOU_SHELL_ATTEMPTS; attempt += 1) {
+    const usePreloadedPage = attempt === 1 && preloadedUrl === searchUrl;
+    const navigationUrl = attempt === 1
+      ? searchUrl
+      : buildSogouRetryUrl(searchUrl, attempt - 1);
+    const payload = await loadSogouPayload(
+      page,
+      navigationUrl,
+      attempt > 1 ? SOGOU_SHELL_RETRY_DELAY_SECONDS : 0,
+      !usePreloadedPage,
     );
+    if (!payload || typeof payload !== 'object' || !Array.isArray(payload.rows)) {
+      throw new CommandExecutionError(
+        'weixin sougousearch returned an unreadable browser payload',
+        'Sogou Weixin may have changed its result page structure.',
+      );
+    }
+    if (payload.blocked) {
+      throw new AuthRequiredError(
+        SOGOU_WEIXIN_DOMAIN,
+        'Sogou Weixin requires verification. Complete it in the open browser tab and run the command again.',
+      );
+    }
+    if (payload.invalidCount > 0) {
+      throw new CommandExecutionError(
+        'Sogou Weixin returned article cards without required title or URL',
+        'The result page structure may have changed; refusing to return a partial result set.',
+      );
+    }
+    if (payload.rows.length === 0 && payload.empty) {
+      return {
+        state: 'empty',
+        reason: payload.resultCap ? 'result-cap' : 'no-results',
+        page: normalizedPage,
+        fingerprint: '',
+        rows: [],
+      };
+    }
+    if (payload.rows.length > 0) {
+      return {
+        state: 'results',
+        page: normalizedPage,
+        fingerprint: fingerprintRows(payload.rows),
+        rows: payload.rows,
+      };
+    }
   }
-  return {
-    state: 'results',
-    page: normalizedPage,
-    fingerprint: fingerprintRows(payload.rows),
-    rows: payload.rows,
-  };
+  throw new CommandExecutionError(
+    'weixin sougousearch did not expose article result cards',
+    'Sogou Weixin returned a transient shell page on both bounded attempts.',
+  );
 }

package/clis/weixin/articles.js

@@ -48,7 +48,7 @@ export const articlesCommand = cli({
       if (!accountName) throw withMissingFallbackName('weixin articles', primaryError);
       try {
         const fallback = await collectSogouAccountArticles({
-          page, accountName, limit: args.limit, maxPages: args['max-pages'],
+          page, accountName, limit: args.limit, maxPages: args['max-pages'], freshPage: true,
         });
         articles = fallback.articles;
         source = fallback.source;

package/clis/weixin/create-draft.js

@@ -1,7 +1,7 @@
 import * as nodeFs from 'node:fs';
 import * as nodePath from 'node:path';
 import { cli, Strategy } from '@sovovs/bycli/registry';
-import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
 
 const WEIXIN_DOMAIN = 'mp.weixin.qq.com';
 const WEIXIN_HOME = 'https://mp.weixin.qq.com/';
@@ -66,13 +66,19 @@ async function navigateToEditor(page) {
     await page.wait(3);
     const token = await getToken(page);
     if (!token) {
-        throw new CommandExecutionError('Could not extract session token. Please log in to mp.weixin.qq.com');
+        throw new AuthRequiredError(
+            WEIXIN_DOMAIN,
+            'Could not extract session token. Please log in to mp.weixin.qq.com',
+        );
     }
     await page.goto(`https://mp.weixin.qq.com/cgi-bin/appmsg?t=media/appmsg_edit_v2&action=edit&isNew=1&type=77&token=${token}&lang=zh_CN`);
     await page.wait(4);
     const hasTitle = await page.evaluate('!!document.querySelector("textarea#title")');
     if (!hasTitle) {
-        throw new CommandExecutionError('Article editor did not load. Session may have expired');
+        throw new AuthRequiredError(
+            WEIXIN_DOMAIN,
+            'Article editor did not load. Session may have expired',
+        );
     }
 }
 

package/clis/weixin/save-articles.js

@@ -196,7 +196,7 @@ export const saveArticlesCommand = cli({
       try {
         const fallback = await collectSogouAccountArticles({
           page, accountName, limit: args.limit, maxPages: args['max-pages'],
-          resolutionPolicy: 'rows',
+          resolutionPolicy: 'rows', freshPage: true,
         });
         articles = fallback.articles;
         resolutionFailures = fallback.resolutionFailures;

package/dist/src/errors.d.ts

@@ -14,7 +14,7 @@
  *   2   Argument / usage error          (ArgumentError)
  *  66   No input / empty result         (EmptyResultError)
  *  69   Service unavailable             (BrowserConnectError, adapter load failures)
- *  75   Temporary failure, retry later  (TimeoutError)   EX_TEMPFAIL
+ *  75   Temporary failure, retry later  (TimeoutError, RateLimitedError)   EX_TEMPFAIL
  *  77   Permission denied / auth needed (AuthRequiredError)
  *  78   Configuration error             (ConfigError)
  * 130   Interrupted by Ctrl-C           (set by tui.ts SIGINT handler)
@@ -51,6 +51,9 @@ export declare class BrowserConnectError extends CliError {
 export declare class CommandExecutionError extends CliError {
     constructor(message: string, hint?: string);
 }
+export declare class RateLimitedError extends CliError {
+    constructor(message: string, hint?: string);
+}
 export declare class ConfigError extends CliError {
     constructor(message: string, hint?: string);
 }

package/dist/src/errors.js

@@ -59,6 +59,11 @@ export class CommandExecutionError extends CliError {
         super('COMMAND_EXEC', message, hint, EXIT_CODES.GENERIC_ERROR);
     }
 }
+export class RateLimitedError extends CliError {
+    constructor(message, hint) {
+        super('RATE_LIMITED', message, hint, EXIT_CODES.TEMPFAIL);
+    }
+}
 export class ConfigError extends CliError {
     constructor(message, hint) {
         super('CONFIG', message, hint, EXIT_CODES.CONFIG_ERROR);

package/package.json

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