@sovovs/bycli 2.1.0 → 2.1.1

package/clis/weixin/_wechat/wechat-api.js

@@ -0,0 +1,133 @@
+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 normalizedMessage(value) {
+  return String(value ?? '').trim().toLowerCase().replace(/\s+/g, ' ');
+}
+
+function commandError(message) {
+  return new CommandExecutionError(redactText(message, []));
+}
+
+function parseNestedJson(value, label) {
+  if (typeof value !== 'string') return value;
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw commandError(`WeChat ${label} is malformed: ${detail}`);
+  }
+}
+
+/** @param {unknown} data */
+export function parsePublishData(data) {
+  if (!data || typeof data !== 'object') {
+    throw new CommandExecutionError('WeChat article history returned an unreadable response');
+  }
+  const response = /** @type {Record<string, any>} */ (data);
+  const ret = response.base_resp?.ret;
+  const message = response.base_resp?.err_msg ?? response.base_resp?.err_msg_en ?? '';
+  if (ret === 200013 && normalizedMessage(message) === 'invalid credential') {
+    throw new AuthRequiredError(DOMAIN, 'WeChat article-history credentials have expired');
+  }
+  if (ret !== undefined && ret !== 0) {
+    throw new CommandExecutionError(`WeChat article history failed (ret=${String(ret)})`);
+  }
+  if (response.publish_page === undefined || response.publish_page === null || response.publish_page === '') {
+    return { total: 0, publishItemCount: 0, articles: [] };
+  }
+  const page = parseNestedJson(response.publish_page, 'publish_page');
+  if (!page || typeof page !== 'object' || !Array.isArray(page.publish_list)) {
+    throw new CommandExecutionError('WeChat article history returned an invalid publish page');
+  }
+  const total = page.total_count === undefined ? 0 : page.total_count;
+  if (!Number.isSafeInteger(total) || total < 0) {
+    throw new CommandExecutionError('WeChat article history returned invalid total metadata');
+  }
+  const articles = [];
+  for (const item of page.publish_list) {
+    const info = parseNestedJson(item?.publish_info ?? {}, 'publish_info');
+    if (!info || typeof info !== 'object' || !Array.isArray(info.appmsg_info)) {
+      throw new CommandExecutionError('WeChat article history returned invalid publish information');
+    }
+    const timestamp = info.sent_info?.time ?? info.publish_info?.create_time ?? 0;
+    let publishedAt = null;
+    if (timestamp !== 0) {
+      if (typeof timestamp !== 'number' || !Number.isFinite(timestamp) || timestamp <= 0) {
+        throw new CommandExecutionError('WeChat article history returned an invalid publish timestamp');
+      }
+      const date = new Date(timestamp * 1000);
+      if (!Number.isFinite(date.getTime())) {
+        throw new CommandExecutionError('WeChat article history returned an invalid publish timestamp');
+      }
+      publishedAt = date.toISOString();
+    }
+    for (const messageItem of info.appmsg_info) {
+      const article = messageItem && typeof messageItem === 'object' ? messageItem : {};
+      articles.push({
+        title: typeof article.title === 'string' ? article.title : '',
+        url: typeof article.content_url === 'string' ? article.content_url : '',
+        isDeleted: article.is_deleted === true,
+        timestamp,
+        publishedAt,
+        digest: typeof article.digest === 'string' ? article.digest : '',
+        author: typeof article.author === 'string' ? article.author : '',
+      });
+    }
+  }
+  return {
+    total,
+    publishItemCount: page.publish_list.length,
+    articles,
+  };
+}
+
+export function requestHeaders(cookie, token) {
+  return {
+    Accept: 'application/json, text/javascript, */*; q=0.01',
+    Cookie: cookie,
+    Origin: `https://${DOMAIN}`,
+    Referer: `https://${DOMAIN}/cgi-bin/appmsg?t=media/appmsg_edit_v2&action=edit&isNew=1&type=10&token=${encodeURIComponent(token)}&lang=zh_CN`,
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/143 Safari/537.36',
+    'X-Requested-With': 'XMLHttpRequest',
+  };
+}
+
+/**
+ * @param {{token:string,cookie:string,timeoutMs?:number,fetchImpl?:typeof fetch}} options
+ */
+export function createWechatApi({ token, cookie, timeoutMs = 30_000, fetchImpl = fetch }) {
+  const headers = requestHeaders(cookie, token);
+  const secrets = buildSecretSet({ token, cookie });
+
+  return {
+    async fetchPage({ fakeid, begin = 0, count = 10 }) {
+      const query = new URLSearchParams({
+        sub: 'list', begin: String(begin), count: String(count), fakeid, token,
+        lang: 'zh_CN', f: 'json', ajax: '1',
+      });
+      try {
+        const response = await fetchImpl(`${ENDPOINT}?${query}`, {
+          headers,
+          signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) {
+          throw new CommandExecutionError(`WeChat article history request failed: HTTP ${response.status} ${response.statusText ?? ''}`.trim());
+        }
+        return parsePublishData(await response.json());
+      } catch (error) {
+        if (error instanceof AuthRequiredError && error.domain === DOMAIN) throw error;
+        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;
+        throw new CommandExecutionError(
+          `WeChat article history request failed: ${redactText(message, secrets)}`,
+          hint ? redactText(hint, secrets) : undefined,
+        );
+      }
+    },
+  };
+}

package/clis/weixin/accounts.js

@@ -0,0 +1,38 @@
+import { ArgumentError, EmptyResultError } from '@sovovs/bycli/errors';
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { readEnvironmentCredentials, resolveBrowserCredentials } from './_wechat/auth-session.js';
+import { captureSearchBizFingerprint } from './_wechat/fingerprint.js';
+import { executeSearchBiz } from './_wechat/search-biz.js';
+import { readAuthSource } from './_wechat/args.js';
+
+const DOMAIN = 'mp.weixin.qq.com';
+const browserRequired = args => readAuthSource(args) === 'browser';
+
+export const accountsCommand = cli({
+  site: 'weixin', name: 'accounts', access: 'read', domain: DOMAIN,
+  description: 'Search WeChat official accounts and return their fakeids',
+  strategy: Strategy.INTERCEPT, browser: browserRequired,
+  args: [
+    { name: 'query', positional: true, required: true, help: 'Official-account name to search for' },
+    { name: 'limit', type: 'int', default: 10, help: 'Maximum number of matching accounts to return' },
+    { name: 'auth-source', default: 'browser', choices: ['browser', 'env'], help: 'Credential source: browser session or environment variables' },
+  ],
+  columns: ['nickname', 'fakeid', 'alias'],
+  func: async (page, args) => {
+    const query = String(args.query ?? '').trim();
+    if (!query) throw new ArgumentError('query is required');
+    const limit = args.limit ?? 10;
+    if (!Number.isSafeInteger(limit) || limit <= 0) throw new ArgumentError('limit must be a positive safe integer');
+    const authSource = readAuthSource(args);
+    let credentials;
+    if (authSource === 'env') {
+      credentials = readEnvironmentCredentials(true);
+    } else {
+      credentials = await resolveBrowserCredentials(page);
+      credentials = { ...credentials, fingerprint: await captureSearchBizFingerprint(page, query) };
+    }
+    const rows = await executeSearchBiz({ page, source: authSource, credentials, query, limit });
+    if (rows.length === 0) throw new EmptyResultError('weixin accounts', `No official accounts matched "${query}".`);
+    return rows.map(row => ({ nickname: row.nickname, fakeid: row.fakeid, alias: row.alias || null }));
+  },
+});

package/clis/weixin/articles.js

@@ -0,0 +1,35 @@
+import { ArgumentError, EmptyResultError } from '@sovovs/bycli/errors';
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { readEnvironmentCredentials, resolveBrowserCredentials } from './_wechat/auth-session.js';
+import { collectArticles } from './_wechat/article-service.js';
+import { createWechatApi } from './_wechat/wechat-api.js';
+import { readAuthSource } from './_wechat/args.js';
+
+const DOMAIN = 'mp.weixin.qq.com';
+const browserRequired = args => readAuthSource(args) === 'browser';
+
+export const articlesCommand = cli({
+  site: 'weixin', name: 'articles', access: 'read', domain: DOMAIN,
+  description: 'List published articles from a WeChat official account',
+  strategy: Strategy.COOKIE, browser: browserRequired,
+  args: [
+    { name: 'fakeid', positional: true, required: true, help: 'Official-account fakeid returned by weixin accounts' },
+    { name: 'name', help: 'Optional official-account name for display context' }, { name: 'limit', type: 'int', help: 'Maximum number of articles to return' }, { name: 'max-pages', type: 'int', help: 'Maximum number of history pages to scan' },
+    { name: 'auth-source', default: 'browser', choices: ['browser', 'env'], help: 'Credential source: browser session or environment variables' },
+  ],
+  columns: ['title', 'author', 'digest', 'publishedAt', 'url'],
+  func: async (page, args) => {
+    const fakeid = String(args.fakeid ?? '').trim();
+    if (!fakeid) throw new ArgumentError('fakeid is required');
+    const authSource = readAuthSource(args);
+    const credentials = authSource === 'env'
+      ? readEnvironmentCredentials(false) : await resolveBrowserCredentials(page);
+    const { fetchPage } = createWechatApi(credentials);
+    const { articles } = await collectArticles({ fakeid, fetchPage, limit: args.limit, maxPages: args['max-pages'] });
+    if (articles.length === 0) throw new EmptyResultError('weixin articles', `No published articles were found for ${fakeid}.`);
+    return articles.map(article => ({
+      title: article.title, author: article.author || null, digest: article.digest || null,
+      publishedAt: article.publishedAt || null, url: article.url,
+    }));
+  },
+});

package/clis/weixin/download.js

@@ -8,6 +8,8 @@
  */
 import { cli, Strategy } from '@sovovs/bycli/registry';
 import { downloadArticle } from '@sovovs/bycli/download/article-download';
+import { buildExtractWechatArticleContentJs } from './_wechat/article-content.js';
+export { extractWechatArticleContent } from './_wechat/article-content.js';
 // ============================================================
 // URL Normalization
 // ============================================================
@@ -241,53 +243,8 @@ cli({
         );
         if (result.errorHint) return result;
 
-        // Content processing
-        const contentEl = document.querySelector('#js_content');
-        if (!contentEl) return result;
-
-        // Fix lazy-loaded images: data-src -> src
-        contentEl.querySelectorAll('img').forEach(img => {
-          const dataSrc = img.getAttribute('data-src');
-          if (dataSrc) img.setAttribute('src', dataSrc);
-        });
-
-        // Extract code blocks with placeholder replacement
-        const codeBlocks = [];
-        contentEl.querySelectorAll('.code-snippet__fix').forEach(el => {
-          el.querySelectorAll('.code-snippet__line-index').forEach(li => li.remove());
-          const pre = el.querySelector('pre[data-lang]');
-          const lang = pre ? (pre.getAttribute('data-lang') || '') : '';
-          const lines = [];
-          el.querySelectorAll('code').forEach(codeTag => {
-            const text = codeTag.textContent;
-            if (/^[ce]?ounter\\(line/.test(text)) return;
-            lines.push(text);
-          });
-          if (lines.length === 0) lines.push(el.textContent);
-          const placeholder = 'CODEBLOCK-PLACEHOLDER-' + codeBlocks.length;
-          codeBlocks.push({ lang, code: lines.join('\\n') });
-          const p = document.createElement('p');
-          p.textContent = placeholder;
-          el.replaceWith(p);
-        });
-        result.codeBlocks = codeBlocks;
-
-        // Remove noise elements
-        ['script', 'style', '.qr_code_pc', '.reward_area'].forEach(sel => {
-          contentEl.querySelectorAll(sel).forEach(tag => tag.remove());
-        });
-
-        // Collect image URLs (deduplicated)
-        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;
+        const extractWechatArticleContent = ${buildExtractWechatArticleContentJs()};
+        Object.assign(result, extractWechatArticleContent(document));
         return result;
       })()
     `);
@@ -318,6 +275,7 @@ cli({
                 const m = url.match(/wx_fmt=(\w+)/) || url.match(/\.(\w{3,4})(?:\?|$)/);
                 return m ? m[1] : 'png';
             },
+            secureMarkdown: true,
         });
     },
 });

package/clis/weixin/save-articles.js

@@ -0,0 +1,175 @@
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { MAX_WECHAT_HTML_BYTES } from '@sovovs/bycli/download/wechat-article';
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { readEnvironmentCredentials, resolveBrowserCredentials } from './_wechat/auth-session.js';
+import { collectArticles, isTrustedWechatArticleUrl } from './_wechat/article-service.js';
+import { saveArticles } from './_wechat/save-service.js';
+import { createWechatApi } from './_wechat/wechat-api.js';
+import { readAuthSource } from './_wechat/args.js';
+
+const DOMAIN = 'mp.weixin.qq.com';
+const browserRequired = args => readAuthSource(args) === 'browser';
+
+const MAX_REDIRECTS = 5;
+
+async function readBoundedHtml(response) {
+  const lengthValue = response.headers?.get?.('content-length');
+  if (lengthValue !== null && lengthValue !== undefined && lengthValue !== '') {
+    const length = Number(lengthValue);
+    if (!Number.isSafeInteger(length) || length < 0 || length > MAX_WECHAT_HTML_BYTES) {
+      throw new CommandExecutionError('Article response exceeds the allowed size');
+    }
+  }
+  if (!response.body?.getReader) {
+    if (typeof response.text !== 'function') throw new CommandExecutionError('Article response has no readable body');
+    const text = await response.text();
+    if (new TextEncoder().encode(text).byteLength > MAX_WECHAT_HTML_BYTES) {
+      throw new CommandExecutionError('Article response exceeds the allowed size');
+    }
+    return text;
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!(value instanceof Uint8Array)) throw new CommandExecutionError('Article response returned invalid body data');
+    total += value.byteLength;
+    if (total > MAX_WECHAT_HTML_BYTES) {
+      try { await reader.cancel(); } catch { /* best-effort stream cleanup */ }
+      throw new CommandExecutionError('Article response exceeds the allowed size');
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
+  return new TextDecoder().decode(bytes);
+}
+
+export async function fetchArticleHtml(article, { fetchImpl = fetch, timeoutMs = 30_000 } = {}) {
+  try {
+    if (!isTrustedWechatArticleUrl(article?.url)) throw new CommandExecutionError('Article request rejected an untrusted URL');
+    let current = new URL(article.url).href;
+    const seen = new Set([current]);
+    for (let redirects = 0; ; redirects += 1) {
+      const response = await fetchImpl(current, {
+        signal: AbortSignal.timeout(timeoutMs), redirect: 'manual',
+      });
+      if (response.status >= 300 && response.status < 400) {
+        if (redirects >= MAX_REDIRECTS) throw new CommandExecutionError('Article request exceeded the redirect limit');
+        const location = response.headers?.get?.('location');
+        if (!location) throw new CommandExecutionError('Article redirect was missing a destination');
+        let next;
+        try { next = new URL(location, current).href; } catch { throw new CommandExecutionError('Article redirect was invalid'); }
+        if (!isTrustedWechatArticleUrl(next)) throw new CommandExecutionError('Article redirect was rejected');
+        if (seen.has(next)) throw new CommandExecutionError('Article redirect loop was rejected');
+        seen.add(next);
+        current = next;
+        continue;
+      }
+      if (!response.ok) throw new CommandExecutionError(`Article request failed: HTTP ${response.status}`);
+      return await readBoundedHtml(response);
+    }
+  } catch (error) {
+    if (error instanceof CommandExecutionError) throw error;
+    throw new CommandExecutionError('Article request failed');
+  }
+}
+
+export async function fetchArticleHtmlInBrowser(article, page) {
+  try {
+    if (!isTrustedWechatArticleUrl(article?.url)) {
+      throw new CommandExecutionError('Article browser request rejected an untrusted URL');
+    }
+    if (!page || typeof page.goto !== 'function' || typeof page.evaluate !== 'function') {
+      throw new CommandExecutionError('Article browser fallback is unavailable');
+    }
+    await page.goto(article.url);
+    await page.wait(5);
+    const result = await page.evaluate(({ maxBytes }) => {
+      const html = document.documentElement?.outerHTML ?? '';
+      const pageText = document.body?.innerText?.replace(/\s+/g, ' ').trim() ?? '';
+      const finalUrl = window.location.href;
+      const pathname = window.location.pathname;
+      const accessIssue = pathname.includes('/mp/wappoc_appmsgcaptcha')
+        || (/环境异常/.test(pageText) && /(完成验证后即可继续访问|去验证)/.test(pageText))
+        || /secitptpage\/verify\.html/.test(html)
+        || /id=["']js_verify["']/.test(html)
+        ? 'environment verification required' : '';
+      const byteLength = new TextEncoder().encode(html).byteLength;
+      return {
+        finalUrl,
+        accessIssue,
+        byteLength,
+        tooLarge: byteLength > maxBytes,
+        html: byteLength > maxBytes ? '' : html,
+      };
+    }, { maxBytes: MAX_WECHAT_HTML_BYTES });
+    if (result?.accessIssue) throw new CommandExecutionError('Article browser page requires environment verification');
+    if (!isTrustedWechatArticleUrl(result?.finalUrl)) {
+      throw new CommandExecutionError('Article browser navigation left the trusted article path');
+    }
+    if (result?.tooLarge || !Number.isSafeInteger(result?.byteLength)
+        || result.byteLength < 0 || result.byteLength > MAX_WECHAT_HTML_BYTES) {
+      throw new CommandExecutionError('Article response exceeds the allowed size');
+    }
+    if (typeof result?.html !== 'string' || result.html.length === 0) {
+      throw new CommandExecutionError('Article browser page returned no HTML');
+    }
+    if (new TextEncoder().encode(result.html).byteLength > MAX_WECHAT_HTML_BYTES) {
+      throw new CommandExecutionError('Article response exceeds the allowed size');
+    }
+    return result.html;
+  } catch (error) {
+    if (error instanceof CommandExecutionError) throw error;
+    throw new CommandExecutionError('Article browser request failed');
+  }
+}
+
+export function createArticleHtmlDownloader({
+  authSource,
+  page,
+  nodeFetcher = fetchArticleHtml,
+  browserFetcher = fetchArticleHtmlInBrowser,
+}) {
+  return async article => {
+    try {
+      return await nodeFetcher(article);
+    } catch (error) {
+      if (authSource !== 'browser') throw error;
+      return browserFetcher(article, page);
+    }
+  };
+}
+
+export const saveArticlesCommand = cli({
+  site: 'weixin', name: 'save-articles', access: 'write', domain: DOMAIN,
+  description: 'Download WeChat official-account articles as Markdown files',
+  strategy: Strategy.COOKIE, browser: browserRequired,
+  args: [
+    { name: 'fakeid', positional: true, required: true, help: 'Official-account fakeid returned by weixin accounts' }, { name: 'name', help: 'Official-account name used in Markdown metadata' },
+    { name: 'output', default: './weixin-articles', help: 'Directory for saved Markdown files' }, { name: 'limit', type: 'int', help: 'Maximum number of articles to save' },
+    { name: 'max-pages', type: 'int', help: 'Maximum number of history pages to scan' }, { name: 'auth-source', default: 'browser', choices: ['browser', 'env'], help: 'Credential source: browser session or environment variables' },
+  ],
+  columns: ['title', 'status', 'stage', 'path', 'error', 'url'],
+  func: async (page, args) => {
+    const fakeid = String(args.fakeid ?? '').trim();
+    if (!fakeid) throw new ArgumentError('fakeid is required');
+    const authSource = readAuthSource(args);
+    const credentials = authSource === 'env'
+      ? readEnvironmentCredentials(false) : await resolveBrowserCredentials(page);
+    const { fetchPage } = createWechatApi(credentials);
+    const { articles } = await collectArticles({ fakeid, fetchPage, limit: args.limit, maxPages: args['max-pages'] });
+    const articleHtmlDownloader = createArticleHtmlDownloader({ authSource, page });
+    const rows = await saveArticles({
+      articles, accountName: String(args.name ?? '').trim(),
+      outputDir: args.output ?? './weixin-articles', fetchArticleHtml: articleHtmlDownloader,
+    });
+    return rows.map(row => ({
+      title: row.title, status: row.status, stage: row.stage || null, path: row.saved || null,
+      error: row.error || null, url: row.url,
+    }));
+  },
+});

package/dist/src/download/article-download.d.ts

@@ -6,6 +6,7 @@
  * Flow: ArticleData → TurndownService → image download → frontmatter → .md file
  */
 import TurndownService from 'turndown';
+export { extractWechatArticleHtml } from './wechat-article.js';
 export interface ArticleData {
     title: string;
     author?: string;
@@ -49,6 +50,8 @@ export interface ArticleDownloadOptions {
      * as-is so the output is self-contained when piped.
      */
     stdout?: boolean;
+    /** Opt-in hardened Markdown rules used by HTML-focused adapters. */
+    secureMarkdown?: boolean;
 }
 export interface ArticleDownloadResult {
     title: string;
@@ -58,6 +61,9 @@ export interface ArticleDownloadResult {
     size: string;
     saved: string;
 }
+export declare function convertArticleHtmlToMarkdown(contentHtml: string, options?: {
+    safeFencedCodeBlocks?: boolean;
+}): string;
 /**
  * Download an article to Markdown with optional image localization.
  *

package/dist/src/download/article-download.js

@@ -11,12 +11,29 @@ import TurndownService from 'turndown';
 import { gfm } from 'turndown-plugin-gfm';
 import { httpDownload, sanitizeFilename } from './index.js';
 import { formatBytes } from './progress.js';
+export { extractWechatArticleHtml } from './wechat-article.js';
 const IMAGE_CONCURRENCY = 5;
 const DEFAULT_LABELS = {
     author: '作者',
     publishTime: '发布时间',
     sourceUrl: '原文链接',
 };
+function escapeMarkdownText(value) {
+    return value.replace(/\s+/g, ' ').trim()
+        .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;').replace(/'/g, '&#39;')
+        .replace(/([\\`*_[\]{}()#+.!|>~-])/g, '\\$1');
+}
+function safeHttpUrl(value) {
+    const normalized = value.trim().startsWith('//') ? `https:${value.trim()}` : value.trim();
+    try {
+        const url = new URL(normalized);
+        return url.protocol === 'http:' || url.protocol === 'https:' ? url.href : '';
+    }
+    catch {
+        return '';
+    }
+}
 // ============================================================
 // Markdown Conversion
 // ============================================================
@@ -36,13 +53,48 @@ const STRIPPED_TAGS = [
     'form', 'button', 'dialog',
     'header', 'footer', 'nav', 'aside',
 ];
-function createTurndown(configure, cleanSelectors) {
+function createTurndown(configure, cleanSelectors, secureMarkdown = false) {
     const td = new TurndownService({
         headingStyle: 'atx',
         codeBlockStyle: 'fenced',
         bulletListMarker: '-',
     });
     td.use(gfm);
+    if (secureMarkdown) {
+        const escapeDestination = (value) => value.replace(/([\\()])/g, '\\$1');
+        td.addRule('safeFencedCodeBlock', {
+            filter: 'pre',
+            replacement: (_content, node) => {
+                const element = node;
+                const code = element.textContent || '';
+                const longest = Math.max(0, ...[...code.matchAll(/`+/g)].map(match => match[0].length));
+                const fence = '`'.repeat(Math.max(3, longest + 1));
+                const className = element.querySelector('code')?.getAttribute('class') || '';
+                const language = element.getAttribute('data-lang')
+                    || /(?:^|\s)language-([^\s]+)/.exec(className)?.[1]
+                    || '';
+                return `\n${fence}${language}\n${code.replace(/\n$/, '')}\n${fence}\n`;
+            },
+        });
+        td.addRule('safeImage', {
+            filter: 'img',
+            replacement: (_content, node) => {
+                const element = node;
+                const alt = escapeMarkdownText(element.getAttribute('alt') || '');
+                const src = element.getAttribute('src') || '';
+                return src ? `![${alt}](${escapeDestination(src)})` : alt;
+            },
+        });
+        td.addRule('safeLink', {
+            filter: 'a',
+            replacement: (_content, node) => {
+                const element = node;
+                const label = escapeMarkdownText(element.textContent || '');
+                const href = element.getAttribute('href') || '';
+                return href ? `[${label}](${escapeDestination(href)})` : label;
+            },
+        });
+    }
     td.remove(STRIPPED_TAGS);
     // turndown-plugin-gfm@1.0.2 emits single-tilde strikethrough (`~x~`), which
     // is not the canonical GFM form. Override it so exported markdown is
@@ -104,11 +156,14 @@ function createTurndown(configure, cleanSelectors) {
         filter: (node) => node.nodeName === 'IFRAME',
         replacement: (_content, node) => {
             const el = node;
-            const src = el.getAttribute('src') || '';
+            const rawSrc = el.getAttribute('src') || '';
+            const src = secureMarkdown ? safeHttpUrl(rawSrc) : rawSrc;
             if (!src)
                 return '';
-            const title = el.getAttribute('title') || 'Embedded content';
-            return `\n[${title}](${src})\n`;
+            const rawTitle = el.getAttribute('title') || 'Embedded content';
+            const title = secureMarkdown ? escapeMarkdownText(rawTitle) : rawTitle;
+            const destination = secureMarkdown ? src.replace(/([\\()])/g, '\\$1') : src;
+            return `\n[${title}](${destination})\n`;
         },
     });
     // Per-adapter dirty-node removal. Adapters know their site's specific noise
@@ -139,14 +194,16 @@ function createTurndown(configure, cleanSelectors) {
         configure(td);
     return td;
 }
-function convertToMarkdown(contentHtml, codeBlocks, configure, cleanSelectors) {
-    const td = createTurndown(configure, cleanSelectors);
+function convertToMarkdown(contentHtml, codeBlocks, configure, cleanSelectors, secureMarkdown = false) {
+    const td = createTurndown(configure, cleanSelectors, secureMarkdown);
     let md = td.turndown(contentHtml);
-    // Restore code block placeholders
-    codeBlocks.forEach((block, i) => {
-        const placeholder = `CODEBLOCK-PLACEHOLDER-${i}`;
-        const fenced = `\n\`\`\`${block.lang}\n${block.code}\n\`\`\`\n`;
-        md = md.replace(placeholder, fenced);
+    // Legacy callers may still supply extracted blocks. New callers preserve
+    // real <pre>/<code> nodes so Turndown owns fencing without collision-prone
+    // magic text; legacy blocks are appended with safe dynamic fences.
+    codeBlocks.forEach((block) => {
+        const longest = Math.max(0, ...[...block.code.matchAll(/`+/g)].map(match => match[0].length));
+        const fence = '`'.repeat(Math.max(3, longest + 1));
+        md += `\n\n${fence}${block.lang}\n${block.code}\n${fence}`;
     });
     // Clean up
     md = md.replace(/\u00a0/g, ' ');
@@ -158,6 +215,9 @@ function convertToMarkdown(contentHtml, codeBlocks, configure, cleanSelectors) {
     md = md.replace(/\n{3,}/g, '\n\n');
     return md;
 }
+export function convertArticleHtmlToMarkdown(contentHtml, options = {}) {
+    return convertToMarkdown(contentHtml, [], undefined, undefined, options.safeFencedCodeBlocks === true);
+}
 function replaceImageUrls(md, urlMap) {
     return md.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (match, alt, imgUrl) => {
         const local = urlMap[imgUrl];
@@ -230,7 +290,7 @@ async function downloadImages(imgUrls, imgDir, headers, detectExt) {
  * 6. File write
  */
 export async function downloadArticle(data, options) {
-    const { output, downloadImages: shouldDownloadImages = true, imageHeaders, maxTitleLength = 80, configureTurndown, detectImageExt, frontmatterLabels, cleanSelectors, stdout = false, } = options;
+    const { output, downloadImages: shouldDownloadImages = true, imageHeaders, maxTitleLength = 80, configureTurndown, detectImageExt, frontmatterLabels, cleanSelectors, stdout = false, secureMarkdown = false, } = options;
     const labels = { ...DEFAULT_LABELS, ...frontmatterLabels };
     if (!data.title) {
         return [{
@@ -253,7 +313,7 @@ export async function downloadArticle(data, options) {
             }];
     }
     // Convert HTML to Markdown
-    let markdown = convertToMarkdown(data.contentHtml, data.codeBlocks || [], configureTurndown, cleanSelectors);
+    let markdown = convertToMarkdown(data.contentHtml, data.codeBlocks || [], configureTurndown, cleanSelectors, secureMarkdown);
     const safeTitle = sanitizeFilename(data.title, maxTitleLength);
     // Download images only when writing to disk. In stdout mode remote URLs
     // stay intact so the piped output is self-contained.
@@ -268,13 +328,14 @@ export async function downloadArticle(data, options) {
     // Build frontmatter with customizable labels.
     // Shape: `# Title\n[> meta\n...]\n---\n\n<markdown>` — exactly one blank
     // line separates every section, so we never produce ≥3 consecutive newlines.
-    const headerLines = [`# ${data.title}`];
+    const headerValue = (value) => secureMarkdown ? escapeMarkdownText(value) : value;
+    const headerLines = [`# ${headerValue(data.title)}`];
     if (data.author)
-        headerLines.push(`> ${labels.author}: ${data.author}`);
+        headerLines.push(`> ${labels.author}: ${headerValue(data.author)}`);
     if (data.publishTime)
-        headerLines.push(`> ${labels.publishTime}: ${data.publishTime}`);
+        headerLines.push(`> ${labels.publishTime}: ${headerValue(data.publishTime)}`);
     if (data.sourceUrl)
-        headerLines.push(`> ${labels.sourceUrl}: ${data.sourceUrl}`);
+        headerLines.push(`> ${labels.sourceUrl}: ${headerValue(data.sourceUrl)}`);
     const frontmatter = headerLines.join('\n') + '\n\n---\n\n';
     const fullContent = frontmatter + markdown;
     const size = Buffer.byteLength(fullContent, 'utf-8');

package/dist/src/download/wechat-article.d.ts

@@ -0,0 +1,8 @@
+export declare const MAX_WECHAT_HTML_BYTES: number;
+export declare const MAX_WECHAT_NODES = 100000;
+export declare const MAX_WECHAT_CODE_BLOCKS = 1000;
+export interface ExtractedWechatArticle {
+    contentHtml: string;
+    imageUrls: string[];
+}
+export declare function extractWechatArticleHtml(html: string): ExtractedWechatArticle;