@sovovs/bycli 2.1.0 → 2.1.1

package/cli-manifest.json

@@ -27804,6 +27804,109 @@
     "sourceFile": "weibo/user-posts.js",
     "navigateBefore": "https://weibo.com"
   },
+  {
+    "site": "weixin",
+    "name": "accounts",
+    "description": "Search WeChat official accounts and return their fakeids",
+    "access": "read",
+    "domain": "mp.weixin.qq.com",
+    "strategy": "intercept",
+    "browser": "conditional",
+    "args": [
+      {
+        "name": "query",
+        "type": "str",
+        "required": true,
+        "positional": true,
+        "help": "Official-account name to search for"
+      },
+      {
+        "name": "limit",
+        "type": "int",
+        "default": 10,
+        "required": false,
+        "help": "Maximum number of matching accounts to return"
+      },
+      {
+        "name": "auth-source",
+        "type": "str",
+        "default": "browser",
+        "required": false,
+        "help": "Credential source: browser session or environment variables",
+        "choices": [
+          "browser",
+          "env"
+        ]
+      }
+    ],
+    "columns": [
+      "nickname",
+      "fakeid",
+      "alias"
+    ],
+    "type": "js",
+    "modulePath": "weixin/accounts.js",
+    "sourceFile": "weixin/accounts.js",
+    "navigateBefore": true
+  },
+  {
+    "site": "weixin",
+    "name": "articles",
+    "description": "List published articles from a WeChat official account",
+    "access": "read",
+    "domain": "mp.weixin.qq.com",
+    "strategy": "cookie",
+    "browser": "conditional",
+    "args": [
+      {
+        "name": "fakeid",
+        "type": "str",
+        "required": true,
+        "positional": true,
+        "help": "Official-account fakeid returned by weixin accounts"
+      },
+      {
+        "name": "name",
+        "type": "str",
+        "required": false,
+        "help": "Optional official-account name for display context"
+      },
+      {
+        "name": "limit",
+        "type": "int",
+        "required": false,
+        "help": "Maximum number of articles to return"
+      },
+      {
+        "name": "max-pages",
+        "type": "int",
+        "required": false,
+        "help": "Maximum number of history pages to scan"
+      },
+      {
+        "name": "auth-source",
+        "type": "str",
+        "default": "browser",
+        "required": false,
+        "help": "Credential source: browser session or environment variables",
+        "choices": [
+          "browser",
+          "env"
+        ]
+      }
+    ],
+    "columns": [
+      "title",
+      "author",
+      "digest",
+      "publishedAt",
+      "url"
+    ],
+    "type": "js",
+    "modulePath": "weixin/articles.js",
+    "sourceFile": "weixin/articles.js",
+    "navigateBefore": "https://mp.weixin.qq.com"
+  },
   {
     "site": "weixin",
     "name": "create-draft",
@@ -27938,6 +28041,72 @@
     "sourceFile": "weixin/drafts.js",
     "navigateBefore": false
   },
+  {
+    "site": "weixin",
+    "name": "save-articles",
+    "description": "Download WeChat official-account articles as Markdown files",
+    "access": "write",
+    "domain": "mp.weixin.qq.com",
+    "strategy": "cookie",
+    "browser": "conditional",
+    "args": [
+      {
+        "name": "fakeid",
+        "type": "str",
+        "required": true,
+        "positional": true,
+        "help": "Official-account fakeid returned by weixin accounts"
+      },
+      {
+        "name": "name",
+        "type": "str",
+        "required": false,
+        "help": "Official-account name used in Markdown metadata"
+      },
+      {
+        "name": "output",
+        "type": "str",
+        "default": "./weixin-articles",
+        "required": false,
+        "help": "Directory for saved Markdown files"
+      },
+      {
+        "name": "limit",
+        "type": "int",
+        "required": false,
+        "help": "Maximum number of articles to save"
+      },
+      {
+        "name": "max-pages",
+        "type": "int",
+        "required": false,
+        "help": "Maximum number of history pages to scan"
+      },
+      {
+        "name": "auth-source",
+        "type": "str",
+        "default": "browser",
+        "required": false,
+        "help": "Credential source: browser session or environment variables",
+        "choices": [
+          "browser",
+          "env"
+        ]
+      }
+    ],
+    "columns": [
+      "title",
+      "status",
+      "stage",
+      "path",
+      "error",
+      "url"
+    ],
+    "type": "js",
+    "modulePath": "weixin/save-articles.js",
+    "sourceFile": "weixin/save-articles.js",
+    "navigateBefore": "https://mp.weixin.qq.com"
+  },
   {
     "site": "weixin",
     "name": "search",

package/clis/weixin/_wechat/args.js

@@ -0,0 +1,48 @@
+import { ArgumentError } from '@sovovs/bycli/errors';
+
+/**
+ * @param {Record<string, unknown>} args
+ * @returns {'browser' | 'env'}
+ */
+export function readAuthSource(args) {
+  const value = args['auth-source'] ?? 'browser';
+  if (value === 'browser' || value === 'env') return value;
+  throw new ArgumentError('--auth-source must be one of: browser, env');
+}
+
+/**
+ * @param {Record<string, unknown>} args
+ * @param {string} key
+ * @param {number} [fallback]
+ * @returns {number | undefined}
+ */
+export function readPositiveInteger(args, key, fallback) {
+  const raw = args[key] ?? fallback;
+  if (raw === undefined) return undefined;
+
+  if (typeof raw !== 'number' && typeof raw !== 'string') {
+    throw new ArgumentError(`--${key} must be a positive integer`);
+  }
+  if (typeof raw === 'string' && raw.trim() === '') {
+    throw new ArgumentError(`--${key} must be a positive integer`);
+  }
+
+  const value = Number(raw);
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+    throw new ArgumentError(`--${key} must be a positive integer`);
+  }
+  return value;
+}
+
+/**
+ * @param {Record<string, unknown>} args
+ * @param {string} key
+ * @returns {string}
+ */
+export function readRequiredString(args, key) {
+  const value = args[key];
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new ArgumentError(`--${key} is required`);
+  }
+  return value.trim();
+}

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

@@ -0,0 +1,53 @@
+/**
+ * Extract the mutable WeChat article body. This function is deliberately
+ * self-contained so download.js can serialize the exact same implementation
+ * into page.evaluate().
+ */
+export function extractWechatArticleContent(document) {
+  const result = { contentHtml: '', codeBlocks: [], imageUrls: [] };
+  const contentEl = document.querySelector('#js_content');
+  if (!contentEl) return result;
+
+  contentEl.querySelectorAll('img').forEach(img => {
+    const dataSrc = img.getAttribute('data-src');
+    if (dataSrc) img.setAttribute('src', dataSrc);
+  });
+  contentEl.querySelectorAll('[href], [src], [poster], [data-src]').forEach(el => {
+    ['href', 'src', 'poster', 'data-src'].forEach(name => {
+      if (!el.hasAttribute(name)) return;
+      const raw = (el.getAttribute(name) || '').trim();
+      const normalized = raw.startsWith('//') ? `https:${raw}` : raw;
+      try {
+        const url = new URL(normalized);
+        if (!['http:', 'https:'].includes(url.protocol)) el.removeAttribute(name);
+        else el.setAttribute(name, url.href);
+      } catch {
+        el.removeAttribute(name);
+      }
+    });
+  });
+  contentEl.querySelectorAll('.code-snippet__line-index').forEach(node => node.remove());
+  ['script', 'style', '.qr_code_pc', '.reward_area'].forEach(selector => {
+    contentEl.querySelectorAll(selector).forEach(node => node.remove());
+  });
+  const seen = new Set();
+  contentEl.querySelectorAll('img[src]').forEach(img => {
+    const src = img.getAttribute('src');
+    if (src && !seen.has(src)) {
+      seen.add(src);
+      result.imageUrls.push(src);
+    }
+  });
+  result.contentHtml = contentEl.innerHTML;
+  return result;
+}
+
+export function buildExtractWechatArticleContentJs() {
+  return `(${extractWechatArticleContent.toString()})`;
+}
+
+/** Node-side HTML counterpart used by history saving; owns all body cleanup. */
+export function extractWechatArticleContentFromHtml(htmlInput) {
+  return { ...extractWechatArticleHtml(String(htmlInput || '')), codeBlocks: [] };
+}
+import { extractWechatArticleHtml } from '@sovovs/bycli/download/article-download';

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

@@ -0,0 +1,124 @@
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+
+export const MAX_PAGES = 100;
+export const MAX_PAGE_SIZE = 10;
+export const MAX_ARTICLES = 1000;
+
+export function isTrustedWechatArticleUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === 'https:'
+      && url.hostname === 'mp.weixin.qq.com'
+      && url.port === ''
+      && url.username === ''
+      && url.password === ''
+      && (url.pathname === '/s' || url.pathname.startsWith('/s/'));
+  } catch {
+    return false;
+  }
+}
+
+/** @param {any} article */
+export function isUsableArticle(article) {
+  return Boolean(article)
+    && article.isDeleted !== true
+    && typeof article.url === 'string'
+    && isTrustedWechatArticleUrl(article.url)
+    && !article.url.includes('tempkey=');
+}
+
+function canonicalUrl(value) {
+  try {
+    const url = new URL(value);
+    url.hash = '';
+    return url.href;
+  } catch {
+    return value;
+  }
+}
+
+function publicArticle(article) {
+  return {
+    title: typeof article.title === 'string' ? article.title : '',
+    url: article.url,
+    publishedAt: typeof article.publishedAt === 'string' ? article.publishedAt : null,
+    digest: typeof article.digest === 'string' ? article.digest : '',
+    author: typeof article.author === 'string' ? article.author : '',
+  };
+}
+
+/**
+ * @param {{fakeid:string,fetchPage:(input:{fakeid:string,begin:number,count:number})=>Promise<any>,limit?:number,maxPages?:number,pageSize?:number}} options
+ */
+export async function collectArticles({ fakeid, fetchPage, limit, maxPages, pageSize = 10 }) {
+  for (const [name, value, maximum] of [
+    ['pageSize', pageSize, MAX_PAGE_SIZE],
+    ['limit', limit, MAX_ARTICLES],
+    ['maxPages', maxPages, MAX_PAGES],
+  ]) {
+    if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {
+      throw new ArgumentError(`${name} must be a positive safe integer`);
+    }
+    if (value !== undefined && value > maximum) {
+      throw new ArgumentError(`${name} must not exceed ${maximum}`);
+    }
+  }
+  const pageLimit = maxPages ?? MAX_PAGES;
+  const articleLimit = limit ?? MAX_ARTICLES;
+  const articles = [];
+  const seen = new Set();
+  let totalFromApi = 0;
+  let scanned = 0;
+  let invalid = 0;
+  let duplicates = 0;
+  let pages = 0;
+  let begin = 0;
+
+  while (true) {
+    const page = await fetchPage({ fakeid, begin, count: pageSize });
+    pages += 1;
+    const pageTotal = page?.total === undefined ? 0 : page.total;
+    if (!Number.isSafeInteger(pageTotal) || pageTotal < 0) {
+      throw new CommandExecutionError('WeChat article history returned invalid total metadata');
+    }
+    if (pages === 1) totalFromApi = pageTotal;
+    const rawArticles = Array.isArray(page?.articles) ? page.articles : [];
+    const publishItemCount = page?.publishItemCount === undefined ? 0 : page.publishItemCount;
+    if (!Number.isSafeInteger(publishItemCount) || publishItemCount < 0) {
+      throw new CommandExecutionError('WeChat article history returned invalid publish-item metadata');
+    }
+
+    for (const article of rawArticles) {
+      scanned += 1;
+      if (!isUsableArticle(article)) {
+        invalid += 1;
+        continue;
+      }
+      const canonical = canonicalUrl(article.url);
+      if (seen.has(canonical)) {
+        duplicates += 1;
+        continue;
+      }
+      seen.add(canonical);
+      articles.push(publicArticle(article));
+      if (articles.length >= articleLimit) break;
+    }
+
+    const reachedLimit = articles.length >= articleLimit;
+    const reachedMaxPages = pages >= pageLimit;
+    const reachedEnd = publishItemCount === 0
+      || publishItemCount < pageSize
+      || (totalFromApi > 0 && begin + publishItemCount >= totalFromApi);
+    if (reachedLimit || reachedMaxPages || reachedEnd) break;
+    const nextBegin = begin + pageSize;
+    if (!Number.isSafeInteger(nextBegin) || nextBegin <= begin) {
+      throw new CommandExecutionError('WeChat article pagination could not advance safely');
+    }
+    begin = nextBegin;
+  }
+
+  return {
+    articles,
+    summary: { totalFromApi, scanned, valid: articles.length, invalid, duplicates, pages },
+  };
+}

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

@@ -0,0 +1,142 @@
+import { AuthRequiredError, BrowserConnectError, TimeoutError } from '@sovovs/bycli/errors';
+
+const DOMAIN = 'mp.weixin.qq.com';
+const LOGIN_URL = `https://${DOMAIN}/`;
+const DEFAULT_TIMEOUT_MS = 180_000;
+const POLL_INTERVAL_MS = 500;
+
+/**
+ * @typedef {{token: string, cookie: string, fingerprint?: string}} WechatCredentials
+ * @typedef {{url: string | null, hasLoginUi: boolean}} PreflightState
+ * @typedef {{timeoutMs?: number, now?: () => number}} ResolveBrowserCredentialsOptions
+ * @typedef {Pick<import('@sovovs/bycli/types').IPage, 'evaluate' | 'getCookies' | 'goto' | 'wait' | 'focusWindow'>} AuthPage
+ */
+
+/**
+ * @param {boolean} needsFingerprint
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {WechatCredentials}
+ */
+export function readEnvironmentCredentials(needsFingerprint, env = process.env) {
+  const token = env.WECHAT_TOKEN?.trim() ?? '';
+  const cookie = env.WECHAT_COOKIE?.trim() ?? '';
+  const fingerprint = env.WECHAT_FINGERPRINT?.trim() ?? '';
+
+  if (!token || !cookie || (needsFingerprint && !fingerprint)) {
+    throw new AuthRequiredError(
+      DOMAIN,
+      needsFingerprint
+        ? 'WECHAT_TOKEN, WECHAT_COOKIE, and WECHAT_FINGERPRINT are required for env search'
+        : 'WECHAT_TOKEN and WECHAT_COOKIE are required for env crawling',
+    );
+  }
+
+  return { token, cookie, ...(fingerprint ? { fingerprint } : {}) };
+}
+
+/** @param {PreflightState} state @returns {boolean} */
+export function isLoggedInPreflight(state) {
+  if (state.url === null || state.hasLoginUi) return false;
+
+  try {
+    const url = new URL(state.url);
+    return url.origin === `https://${DOMAIN}`
+      && url.pathname.startsWith('/cgi-bin/')
+      && Boolean(url.searchParams.get('token')?.trim());
+  } catch {
+    return false;
+  }
+}
+
+/** @param {AuthPage} page @returns {Promise<PreflightState>} */
+async function readPreflight(page) {
+  const result = await page.evaluate(() => {
+    const selectors = [
+      'form[action*="login"]',
+      'img[src*="qrcode"]',
+      'canvas[class*="qrcode"]',
+    ];
+    const isVisible = element => {
+      const style = window.getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      return style.display !== 'none'
+        && style.visibility !== 'hidden'
+        && Number(style.opacity) !== 0
+        && rect.width > 0
+        && rect.height > 0;
+    };
+    const hasVisibleSelector = selectors.some(selector =>
+      Array.from(document.querySelectorAll(selector)).some(isVisible));
+    const hasLoginText = /扫码登录|使用微信扫码/.test(document.body?.innerText ?? '');
+
+    return {
+      href: window.location.href,
+      hasLoginUi: hasVisibleSelector || hasLoginText,
+    };
+  });
+
+  return { url: result.href, hasLoginUi: result.hasLoginUi };
+}
+
+/** @param {string} cookieDomain @returns {boolean} */
+function matchesDomain(cookieDomain) {
+  const normalized = cookieDomain.toLowerCase().replace(/^\./, '');
+  return normalized === DOMAIN || normalized.endsWith(`.${DOMAIN}`);
+}
+
+/**
+ * @param {AuthPage | null} page
+ * @param {ResolveBrowserCredentialsOptions} [options]
+ * @returns {Promise<WechatCredentials>}
+ */
+export async function resolveBrowserCredentials(page, options = {}) {
+  if (page === null) {
+    throw new BrowserConnectError('No browser page is connected for WeChat authentication');
+  }
+
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const now = options.now ?? Date.now;
+  const startedAt = now();
+  let state = await readPreflight(page);
+
+  if (!isLoggedInPreflight(state)) {
+    if (!page.focusWindow) {
+      throw new BrowserConnectError(
+        'The connected browser cannot be focused for WeChat login',
+        'Upgrade to byCLI 2.1 or newer to support interactive browser login',
+      );
+    }
+
+    await page.goto(LOGIN_URL);
+    await page.focusWindow();
+
+    while (!isLoggedInPreflight(state)) {
+      const remainingMs = timeoutMs - (now() - startedAt);
+      if (remainingMs <= 0) {
+        throw new TimeoutError('WeChat login', timeoutMs / 1000);
+      }
+      await page.wait(Math.min(POLL_INTERVAL_MS, remainingMs) / 1000);
+      state = await readPreflight(page);
+    }
+  }
+
+  const finalUrl = state.url;
+  const token = finalUrl === null ? '' : new URL(finalUrl).searchParams.get('token')?.trim() ?? '';
+  const cookies = await page.getCookies({ url: LOGIN_URL });
+  const nowSeconds = now() / 1000;
+  const cookie = cookies
+    .filter(item => matchesDomain(item.domain))
+    .filter(item => item.expirationDate === undefined || item.expirationDate > nowSeconds)
+    .map(item => `${item.name}=${item.value}`)
+    .join('; ');
+
+  if (!token || !cookie) {
+    throw new AuthRequiredError(DOMAIN, 'A logged-in WeChat session with a token and cookies is required');
+  }
+
+  await page.goto(
+    `https://${DOMAIN}/cgi-bin/appmsg?t=media/appmsg_edit_v2&action=edit&isNew=1&type=10&token=${encodeURIComponent(token)}&lang=zh_CN`,
+  );
+
+  return { token, cookie };
+}