@sovovs/bycli 2.1.23 → 2.1.25

package/cli-manifest.json

@@ -27869,7 +27869,7 @@
         "name": "name",
         "type": "str",
         "required": false,
-        "help": "Optional official-account name for display context"
+        "help": "Official-account name; exact case-insensitive match required for browser Sogou fallback"
       },
       {
         "name": "limit",
@@ -27900,7 +27900,9 @@
       "author",
       "digest",
       "publishedAt",
-      "url"
+      "url",
+      "source",
+      "coverage"
     ],
     "type": "js",
     "modulePath": "weixin/articles.js",
@@ -28084,7 +28086,9 @@
       "publish_time",
       "status",
       "size",
-      "saved"
+      "saved",
+      "source_url",
+      "resolved_url"
     ],
     "type": "js",
     "modulePath": "weixin/download.js",
@@ -28094,7 +28098,7 @@
   {
     "site": "weixin",
     "name": "download-publish-data",
-    "description": "Match a Weixin published article and save its content analysis as Markdown",
+    "description": "Match a Weixin published article and save its Excel data and Markdown analysis",
     "access": "write",
     "domain": "mp.weixin.qq.com",
     "strategy": "intercept",
@@ -28118,7 +28122,7 @@
         "type": "str",
         "default": "./weixin-publish-data",
         "required": false,
-        "help": "Directory for generated Markdown reports"
+        "help": "Directory for generated Excel data and Markdown reports"
       },
       {
         "name": "max-pages",
@@ -28141,8 +28145,9 @@
       "url",
       "status",
       "markdownPath",
+      "markdownSize",
       "dataPath",
-      "size",
+      "dataSize",
       "error"
     ],
     "type": "js",
@@ -28261,7 +28266,7 @@
         "name": "name",
         "type": "str",
         "required": false,
-        "help": "Official-account name used in Markdown metadata"
+        "help": "Official-account name; exact case-insensitive match required for browser Sogou fallback"
       },
       {
         "name": "output",
@@ -28300,7 +28305,9 @@
       "stage",
       "path",
       "error",
-      "url"
+      "url",
+      "source",
+      "coverage"
     ],
     "type": "js",
     "modulePath": "weixin/save-articles.js",

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

@@ -0,0 +1,46 @@
+import {
+  AuthRequiredError, CommandExecutionError, EmptyResultError,
+} from '@sovovs/bycli/errors';
+import { buildSecretSet, redactText } from './redact.js';
+
+function safePhase(error, secrets) {
+  const message = error instanceof Error ? error.message : String(error);
+  const hint = error && typeof error === 'object' && typeof error.hint === 'string'
+    ? error.hint : '';
+  const summary = hint ? `${message} (${hint})` : message;
+  return {
+    code: error && typeof error === 'object' && typeof error.code === 'string'
+      ? error.code : 'UNKNOWN',
+    summary: redactText(summary, secrets),
+  };
+}
+
+export function isEligibleArticleFallbackError(error) {
+  return error instanceof CommandExecutionError || error instanceof EmptyResultError;
+}
+
+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);
+  return new CommandExecutionError(error.message, hint);
+}
+
+export function combineArticleFallbackErrors({
+  operation,
+  primaryError,
+  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 EmptyResultError && fallbackError instanceof EmptyResultError) {
+    return new EmptyResultError(operation, hint);
+  }
+  return new CommandExecutionError(
+    'Weixin article index and Sogou fallback both failed',
+    hint,
+  );
+}

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

@@ -0,0 +1,177 @@
+import { AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { buildSecretSet, redactText } from './redact.js';
+
+const DOMAIN = 'mp.weixin.qq.com';
+const ENDPOINT = `https://${DOMAIN}/cgi-bin/appmsgpublish`;
+
+function commandError(message, hint) {
+  return new CommandExecutionError(`WeChat appmsgpublish ${message}`, hint);
+}
+
+function parseNestedJson(value, field) {
+  if (typeof value !== 'string') return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw commandError(`returned invalid ${field} JSON`);
+  }
+}
+
+function requireRecord(value, field) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw commandError(`returned invalid ${field}`);
+  }
+  return value;
+}
+
+export function mapArticleIndexPayload(payload) {
+  const response = requireRecord(payload, 'response');
+  const baseResponse = requireRecord(response.base_resp, 'base_resp');
+  const ret = baseResponse.ret;
+  const normalizedMessage = typeof baseResponse.err_msg === 'string'
+    ? baseResponse.err_msg.trim().toLowerCase().replace(/\s+/g, ' ') : '';
+  if (ret === 200013 && normalizedMessage === 'invalid credential') {
+    throw new AuthRequiredError(DOMAIN, 'WeChat article-index credentials have expired');
+  }
+  if (ret === 200013 && normalizedMessage === 'freq control') {
+    throw commandError(
+      'was rate limited (ret=200013)',
+      'Wait before retrying the WeChat article-index request; repeated retries may extend frequency control.',
+    );
+  }
+  if (!Number.isInteger(ret) || ret !== 0) {
+    throw commandError(`failed (ret=${String(ret ?? 'unknown')})`);
+  }
+  if (response.publish_page === undefined || response.publish_page === null
+    || response.publish_page === '') {
+    return { total: 0, publishItemCount: 0, articles: [] };
+  }
+
+  const page = requireRecord(parseNestedJson(response.publish_page, 'publish_page'), 'publish_page');
+  if (!Number.isInteger(page.total_count) || page.total_count < 0) {
+    throw commandError('returned invalid total_count');
+  }
+  if (!Array.isArray(page.publish_list)) {
+    throw commandError('returned invalid publish_list');
+  }
+
+  const articles = [];
+  for (const [publishIndex, rawItem] of page.publish_list.entries()) {
+    const item = requireRecord(rawItem, `publish_list[${publishIndex}]`);
+    if (!Object.prototype.hasOwnProperty.call(item, 'publish_info')) {
+      throw commandError(`returned missing publish_info at index ${publishIndex}`);
+    }
+    const info = requireRecord(
+      parseNestedJson(item.publish_info, `publish_info at index ${publishIndex}`),
+      `publish_info at index ${publishIndex}`,
+    );
+    if (!Array.isArray(info.appmsg_info)) {
+      throw commandError(`returned invalid appmsg_info at index ${publishIndex}`);
+    }
+    if (info.sent_info !== undefined) requireRecord(info.sent_info, `sent_info at index ${publishIndex}`);
+    if (info.publish_info !== undefined) requireRecord(info.publish_info, `publish metadata at index ${publishIndex}`);
+    const timestamp = info.sent_info?.time ?? info.publish_info?.create_time ?? 0;
+    if (!Number.isInteger(timestamp) || timestamp < 0) {
+      throw commandError(`returned invalid timestamp at index ${publishIndex}`);
+    }
+
+    for (const [articleIndex, rawArticle] of info.appmsg_info.entries()) {
+      const article = requireRecord(rawArticle, `appmsg_info[${articleIndex}]`);
+      for (const field of ['title', 'content_url', 'digest', 'author']) {
+        if (article[field] !== undefined && typeof article[field] !== 'string') {
+          throw commandError(`returned invalid ${field} at article index ${articleIndex}`);
+        }
+      }
+      articles.push({
+        title: article.title || '',
+        url: article.content_url || '',
+        isDeleted: article.is_deleted === true,
+        timestamp,
+        publishedAt: timestamp > 0 ? new Date(timestamp * 1000).toISOString() : null,
+        digest: article.digest || '',
+        author: article.author || '',
+      });
+    }
+  }
+
+  return { total: page.total_count, publishItemCount: page.publish_list.length, articles };
+}
+
+function buildReferer(token) {
+  const params = new URLSearchParams({
+    t: 'media/appmsg_edit_v2', action: 'edit', isNew: '1', type: '10',
+    token, lang: 'zh_CN',
+  });
+  return `https://${DOMAIN}/cgi-bin/appmsg?${params}`;
+}
+
+function isWechatVerificationResponse(message, hint) {
+  const text = `${message}\n${hint ?? ''}`;
+  return /mp\/wappoc_appmsgcaptcha/i.test(text)
+    || /secitptpage\/verify\.html/i.test(text)
+    || /id=["']js_verify["']/i.test(text)
+    || (/环境异常/.test(text) && /(完成验证后即可继续访问|去验证)/.test(text));
+}
+
+function transportError(error, credentials) {
+  const secrets = buildSecretSet(credentials);
+  const message = error instanceof Error ? error.message : String(error);
+  const hint = error && typeof error === 'object' && 'hint' in error
+    && typeof error.hint === 'string' ? error.hint : undefined;
+  const redactedMessage = redactText(message, secrets);
+  const redactedHint = hint ? redactText(hint, secrets) : undefined;
+  if (error instanceof AuthRequiredError && error.domain === DOMAIN
+    && redactedMessage === message && redactedHint === hint) return error;
+  if (isWechatVerificationResponse(redactedMessage, redactedHint)) {
+    return new AuthRequiredError(
+      DOMAIN,
+      'WeChat article index requires environment verification. Complete it in the open browser tab and run the command again.',
+    );
+  }
+  return new CommandExecutionError(
+    `WeChat appmsgpublish request failed: ${redactedMessage}`,
+    redactedHint,
+  );
+}
+
+export function createArticleIndexFetcher({
+  page,
+  source,
+  credentials,
+  fetchImpl = fetch,
+  timeoutMs = 30_000,
+}) {
+  return async function fetchPage({ fakeid, begin = 0, count = 10 }) {
+    const params = new URLSearchParams({
+      sub: 'list', begin: String(begin), count: String(count), fakeid,
+      token: credentials.token, lang: 'zh_CN', f: 'json', ajax: '1',
+    });
+    const url = `${ENDPOINT}?${params}`;
+    const headers = {
+      Referer: buildReferer(credentials.token),
+      'X-Requested-With': 'XMLHttpRequest',
+    };
+
+    try {
+      let payload;
+      if (source === 'browser') {
+        if (!page || typeof page.fetchJson !== 'function') {
+          throw new CommandExecutionError('Browser page.fetchJson is unavailable');
+        }
+        payload = await page.fetchJson(url, { headers });
+      } else {
+        const response = await fetchImpl(url, {
+          headers: { ...headers, Cookie: credentials.cookie },
+          signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) {
+          throw new CommandExecutionError(`HTTP ${String(response.status ?? 'unknown')}`);
+        }
+        payload = await response.json();
+      }
+      return mapArticleIndexPayload(payload);
+    } catch (error) {
+      throw transportError(error, credentials);
+    }
+  };
+}

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

@@ -0,0 +1,88 @@
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
+
+export function normalizeWechatUrl(raw) {
+  let value = String(raw ?? '').trim();
+  if (!value) return value;
+  if ((value.startsWith('"') && value.endsWith('"'))
+      || (value.startsWith("'") && value.endsWith("'"))) {
+    value = value.slice(1, -1).trim();
+  }
+  if (value.startsWith('<') && value.endsWith('>')) {
+    value = value.slice(1, -1).trim();
+  }
+  value = value.replace(/\\+([:/&?=#%])/g, '$1');
+  value = value.replace(/&amp;/g, '&').replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>').replace(/&quot;/g, '"');
+  if (value.startsWith('mp.weixin.qq.com/') || value.startsWith('//mp.weixin.qq.com/')) {
+    value = `https://${value.replace(/^\/+/, '')}`;
+  }
+  try {
+    const parsed = new URL(value);
+    if (['http:', 'https:'].includes(parsed.protocol)
+        && parsed.hostname.toLowerCase() === 'mp.weixin.qq.com') {
+      parsed.protocol = 'https:';
+      value = parsed.toString();
+    }
+  } catch {
+    // Trust validation below reports malformed URLs.
+  }
+  return value;
+}
+
+function isStrictHttpsUrl(raw, hostname, pathname) {
+  try {
+    const url = new URL(raw);
+    return url.protocol === 'https:' && url.hostname === hostname
+      && url.port === '' && url.username === '' && url.password === ''
+      && pathname(url.pathname);
+  } catch {
+    return false;
+  }
+}
+
+export function isTrustedWechatArticleUrl(raw) {
+  return isStrictHttpsUrl(raw, 'mp.weixin.qq.com', path => path === '/s' || path.startsWith('/s/'));
+}
+
+export function isTrustedSogouRedirectUrl(raw) {
+  return isStrictHttpsUrl(raw, 'weixin.sogou.com', path => path === '/link');
+}
+
+export async function resolveWechatArticleUrl(page, rawUrl) {
+  const sourceUrl = normalizeWechatUrl(rawUrl);
+  if (isTrustedWechatArticleUrl(sourceUrl)) {
+    return { sourceUrl, resolvedUrl: sourceUrl, alreadyNavigated: false };
+  }
+  if (!isTrustedSogouRedirectUrl(sourceUrl)) {
+    throw new ArgumentError(
+      'A trusted WeChat article or Sogou Weixin result URL is required.',
+      'Pass an https://mp.weixin.qq.com/s/... or https://weixin.sogou.com/link?... URL.',
+    );
+  }
+  try {
+    await page.goto(sourceUrl);
+    await page.wait(2);
+    const result = await page.evaluate(`(() => ({
+      finalUrl: window.location.href,
+      pageText: document.body ? document.body.innerText : '',
+      html: document.documentElement ? document.documentElement.innerHTML : '',
+    }))()`);
+    const text = `${result?.pageText || ''} ${result?.html || ''}`;
+    if (/验证码|安全验证|异常访问|访问过于频繁|请输入验证码/.test(text)) {
+      throw new AuthRequiredError(
+        'weixin.sogou.com',
+        'Sogou Weixin requires verification. Complete it in the open browser tab and run the command again.',
+      );
+    }
+    if (!isTrustedWechatArticleUrl(result?.finalUrl)) {
+      throw new CommandExecutionError(
+        'Sogou Weixin did not resolve to a trusted WeChat article URL',
+        'Open the search result in a browser and confirm it redirects to mp.weixin.qq.com/s/... before retrying.',
+      );
+    }
+    return { sourceUrl, resolvedUrl: new URL(result.finalUrl).href, alreadyNavigated: true };
+  } catch (error) {
+    if (error instanceof AuthRequiredError || error instanceof CommandExecutionError) throw error;
+    throw new CommandExecutionError('Failed to resolve the Sogou Weixin result URL');
+  }
+}

package/clis/weixin/_wechat/auth-session.js

@@ -1,4 +1,4 @@
-import { AuthRequiredError, BrowserConnectError } from '@sovovs/bycli/errors';
+import { AuthRequiredError, BrowserConnectError, CommandExecutionError } from '@sovovs/bycli/errors';
 
 const DOMAIN = 'mp.weixin.qq.com';
 const LOGIN_URL = `https://${DOMAIN}/`;
@@ -46,6 +46,20 @@ export function isLoggedInPreflight(state) {
   }
 }
 
+/** @param {PreflightState} state @returns {boolean} */
+export function isLoggedInMiniProgramPreflight(state) {
+  if (state.url === null || state.hasLoginUi) return false;
+
+  try {
+    const url = new URL(state.url);
+    return url.origin === `https://${DOMAIN}`
+      && url.pathname.startsWith('/wxamp/')
+      && Boolean(url.searchParams.get('token')?.trim());
+  } catch {
+    return false;
+  }
+}
+
 /** @param {AuthPage} page @returns {Promise<PreflightState>} */
 async function readPreflight(page) {
   const result = await page.evaluate(() => {
@@ -100,6 +114,12 @@ export async function resolveBrowserCredentials(page, options = {}) {
     state = await readPreflight(page);
 
     if (!isLoggedInPreflight(state)) {
+      if (isLoggedInMiniProgramPreflight(state)) {
+        throw new CommandExecutionError(
+          'The connected WeChat session is authenticated as a Mini Program account',
+          'Switch to a WeChat Official Account in the same browser profile before running bycli weixin commands.',
+        );
+      }
       if (!page.focusWindow) {
         throw new BrowserConnectError(
           'The connected browser cannot be focused for WeChat login',

package/clis/weixin/_wechat/publish-records.js

@@ -69,6 +69,7 @@ function routePart(value) {
 
 function decodePublishInfo(value) {
   const decoded = parseJson(value, 'publish_info');
+  if (Array.isArray(decoded.appmsg_info)) return decoded;
   if (!Object.prototype.hasOwnProperty.call(decoded, 'publish_info')) return decoded;
   const nested = decoded.publish_info;
   if (typeof nested === 'string') return parseJson(nested, 'nested publish_info');
@@ -86,7 +87,7 @@ function parseEntry(info, article) {
   if (msgid === null || itemIdx === null) {
     throw commandError('returned an article without a detail route');
   }
-  const publishedAt = dateInShanghai(info?.sent_info?.time);
+  const publishedAt = dateInShanghai(info?.sent_info?.time ?? info?.publish_info?.create_time);
   return {
     title,
     publishedAt,
@@ -249,6 +250,18 @@ function normalizeArticleUrl(value) {
   return url.href;
 }
 
+export function validatePublishedQuery(value) {
+  const text = normalizeTitle(value);
+  if (!text) throw new ArgumentError('query must not be empty');
+  const parsed = parseAbsoluteUrl(text);
+  if (!parsed) return text;
+  const trustedPath = parsed.pathname === '/s' || parsed.pathname.startsWith('/s/');
+  if (!normalizeArticleUrl(text) || !trustedPath) {
+    throw new ArgumentError('query URL must be a trusted WeChat article URL');
+  }
+  return text;
+}
+
 function ambiguityError(matches) {
   const choices = matches.slice(0, 5)
     .map(record => `${record.publishedAt ?? record.publishDate} ${record.title} ${record.url}`)
@@ -280,8 +293,6 @@ export function matchPublishedRecord(records, query, date) {
   } else {
     const exact = uniqueMatch(candidates.filter(record => normalizeTitle(record.title) === text));
     if (exact) return exact;
-    const substring = uniqueMatch(candidates.filter(record => normalizeTitle(record.title).includes(text)));
-    if (substring) return substring;
   }
 
   throw new EmptyResultError(