@sovovs/bycli 2.1.26 → 2.1.28

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/create-draft.js

@@ -102,21 +102,52 @@ async function fillField(page, selector, value) {
 }
 
 async function fillContent(page, text) {
-    return page.evaluate(`(() => {
+    var result = await page.evaluate(`(() => {
+        var normalize = value => String(value ?? '').replace(/\\r\\n?/g, '\\n').trim();
+        var expected = normalize(${JSON.stringify(text)});
+        var instances = window.UE && window.UE.instants ? Object.values(window.UE.instants) : [];
+        var ueditor = instances.find(instance => instance
+            && typeof instance.setContent === 'function'
+            && typeof instance.getContentTxt === 'function');
+        if (ueditor && typeof ueditor.setContent === 'function' && typeof ueditor.getContentTxt === 'function') {
+            ueditor.setContent(${JSON.stringify(text)});
+            var ueditorActual = normalize(ueditor.getContentTxt());
+            if (ueditorActual === expected) {
+                return { ok: true, value: ueditorActual };
+            }
+        }
         var editors = document.querySelectorAll('div[contenteditable="true"]');
         var editor = editors[editors.length - 1];
         if (!editor) return { ok: false, reason: 'content editor not found' };
         editor.focus();
         if (editor.querySelector('[contenteditable="false"]')) editor.innerHTML = '';
-        document.execCommand('selectAll', false, null);
-        document.execCommand('insertText', false, ${JSON.stringify(text)});
-        editor.dispatchEvent(new InputEvent('input', { bubbles: true }));
+        var selection = window.getSelection();
+        if (!selection) return { ok: false, reason: 'text selection is unavailable' };
+        var range = document.createRange();
+        range.selectNodeContents(editor);
+        selection.removeAllRanges();
+        selection.addRange(range);
+        return { ok: false, nativeTargetFocused: true };
+    })()`);
+
+    if (!result?.nativeTargetFocused || typeof page.nativeType !== 'function') return result;
+
+    try {
+        await page.nativeType(text);
+    } catch {
+        return result;
+    }
+
+    return page.evaluate(`(() => {
         var normalize = value => String(value ?? '').replace(/\\r\\n?/g, '\\n').trim();
         var expected = normalize(${JSON.stringify(text)});
+        var editors = document.querySelectorAll('div[contenteditable="true"]');
+        var editor = editors[editors.length - 1];
+        if (!editor) return { ok: false, reason: 'content editor not found' };
         var actual = normalize(editor.innerText ?? editor.textContent ?? '');
         return actual === expected
             ? { ok: true, value: actual }
-            : { ok: false, reason: 'value mismatch', value: actual };
+            : { ok: false, reason: 'editor content verification failed', value: actual };
     })()`);
 }
 

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.26",
+  "version": "2.1.28",
   "publishConfig": {
     "access": "public"
   },