@sovovs/bycli 2.1.46 → 2.1.47

package/cli-manifest.json

@@ -29020,6 +29020,13 @@
         "required": false,
         "help": "浏览器模式：填充并验证正文后停止，不会保存草稿"
       },
+      {
+        "name": "allow-private-image-hosts",
+        "type": "boolean",
+        "default": false,
+        "required": false,
+        "help": "允许下载 localhost/内网 HTTP(S) 正文图片；云元数据地址始终禁止"
+      },
       {
         "name": "timeout",
         "type": "int",

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

@@ -2,6 +2,7 @@ import * as nodeFs from 'node:fs/promises';
 import * as nodePath from 'node:path';
 import { CommandExecutionError } from '@sovovs/bycli/errors';
 import { prepareHtmlContent } from './draft-content.js';
+import { stageDraftHtmlImages } from './draft-image-stage.js';
 
 const API_BASE = 'https://api.weixin.qq.com/cgi-bin';
 
@@ -55,6 +56,18 @@ async function uploadImage(filePath, token, fetchImpl) {
   return payload;
 }
 
+async function uploadContentImage(filePath, token, fetchImpl) {
+  const data = await nodeFs.readFile(filePath);
+  const form = new FormData();
+  form.append('media', new Blob([data], { type: mimeType(filePath) }), nodePath.basename(filePath));
+  const url = new URL(`${API_BASE}/media/uploadimg`);
+  url.searchParams.set('access_token', token);
+  const response = await fetchImpl(url.toString(), { method: 'POST', body: form });
+  const payload = await readJsonResponse(response, '上传正文图片');
+  if (!payload.url) throw new CommandExecutionError('上传正文图片 failed: response did not contain url');
+  return payload.url;
+}
+
 function removeCoverImage(html) {
   return String(html ?? '').replace(/<img\b[^>]*(?:alt|title)=["'][^"']*封面[^"']*["'][^>]*>\s*/giu, '');
 }
@@ -69,6 +82,9 @@ export async function createDraftViaApi({
   html,
   baseDir = process.cwd(),
   fetchImpl = globalThis.fetch,
+  imageFetchImpl = globalThis.fetch,
+  lookupImpl,
+  allowPrivateImageHosts = false,
 } = {}) {
   if (!String(appid ?? '').trim() || !String(appsecret ?? '').trim()) {
     throw new CommandExecutionError('API mode requires both appid and appsecret');
@@ -76,39 +92,48 @@ export async function createDraftViaApi({
   if (typeof fetchImpl !== 'function') throw new CommandExecutionError('API mode requires fetch support');
   if (!coverImage) throw new CommandExecutionError('API mode requires cover-image');
 
-  const token = await getAccessToken(String(appid).trim(), String(appsecret).trim(), fetchImpl);
-  const cover = await uploadImage(nodePath.resolve(coverImage), token, fetchImpl);
-  const prepared = await prepareHtmlContent(removeCoverImage(html), {
+  const bodyHtml = removeCoverImage(html);
+  const staged = await stageDraftHtmlImages(bodyHtml, {
     baseDir,
-    resolveImage: async imagePath => {
-      const uploaded = await uploadImage(imagePath, token, fetchImpl);
-      return uploaded.url || uploaded.media_id;
-    },
+    allowPrivateHosts: allowPrivateImageHosts,
+    fetchImpl: imageFetchImpl,
+    ...(lookupImpl ? { lookupImpl } : {}),
   });
+  try {
+    const token = await getAccessToken(String(appid).trim(), String(appsecret).trim(), fetchImpl);
+    const cover = await uploadImage(nodePath.resolve(coverImage), token, fetchImpl);
+    const prepared = await prepareHtmlContent(staged.html, {
+      baseDir,
+      allowRemoteImages: false,
+      resolveImage: imagePath => uploadContentImage(imagePath, token, fetchImpl),
+    });
 
-  const url = new URL(`${API_BASE}/draft/add`);
-  url.searchParams.set('access_token', token);
-  const body = {
-    articles: [{
-      title: String(title ?? ''),
-      author: String(author ?? ''),
-      digest: String(digest || title || ''),
-      content: prepared.html,
-      content_source_url: '',
-      thumb_media_id: cover.media_id,
-      show_cover_pic: 1,
-      need_open_comment: 0,
-      only_fans_can_comment: 0,
-    }],
-  };
-  const response = await fetchImpl(url.toString(), {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json; charset=utf-8' },
-    body: JSON.stringify(body),
-  });
-  const payload = await readJsonResponse(response, '创建草稿');
-  if (!payload.media_id) throw new CommandExecutionError('创建草稿 failed: response did not contain media_id');
-  return { mediaId: payload.media_id };
+    const url = new URL(`${API_BASE}/draft/add`);
+    url.searchParams.set('access_token', token);
+    const body = {
+      articles: [{
+        title: String(title ?? ''),
+        author: String(author ?? ''),
+        digest: String(digest || title || ''),
+        content: prepared.html,
+        content_source_url: '',
+        thumb_media_id: cover.media_id,
+        show_cover_pic: 1,
+        need_open_comment: 0,
+        only_fans_can_comment: 0,
+      }],
+    };
+    const response = await fetchImpl(url.toString(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json; charset=utf-8' },
+      body: JSON.stringify(body),
+    });
+    const payload = await readJsonResponse(response, '创建草稿');
+    if (!payload.media_id) throw new CommandExecutionError('创建草稿 failed: response did not contain media_id');
+    return { mediaId: payload.media_id };
+  } finally {
+    await staged.cleanup();
+  }
 }
 
 export { removeCoverImage };

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

@@ -101,6 +101,31 @@ function safeUrl(value, { image = false } = {}) {
   return raw;
 }
 
+function validatedImageSource(node, { allowRemoteImages = false } = {}) {
+  const source = attributes(node).find(attr => attr.name === 'src')?.value;
+  const url = safeUrl(source, { image: true });
+  if (!url) throw new CommandExecutionError('HTML contains an unsupported image source');
+  const isHttpsRemote = /^https:\/\//iu.test(url);
+  const isHttpRemote = /^http:\/\//iu.test(url);
+  const isRemote = isHttpsRemote || isHttpRemote;
+  if (isRemote && !allowRemoteImages) {
+    throw new CommandExecutionError('API mode requires HTML images to be local files');
+  }
+  return { url, isRemote };
+}
+
+function validateImageSources(node, options) {
+  if (!node || typeof node !== 'object') return;
+  const tag = String(node.tagName ?? node.nodeName ?? '').toLowerCase();
+  if (tag === 'img') validatedImageSource(node, options);
+  for (const child of node.childNodes ?? []) validateImageSources(child, options);
+}
+
+export function validateHtmlImageSources(html, { allowRemoteImages = false } = {}) {
+  const fragment = parseWechatHtmlFragment(String(html ?? ''));
+  for (const node of fragment.childNodes ?? []) validateImageSources(node, { allowRemoteImages });
+}
+
 function sanitizeAttributes(node) {
   for (const attr of [...attributes(node)]) {
     const name = attr.name.toLowerCase();
@@ -157,11 +182,8 @@ async function sanitizeNode(node, options) {
   convertBackgroundSection(node);
 
   if (tag === 'img') {
-    const source = attributes(node).find(attr => attr.name === 'src')?.value;
-    const url = safeUrl(source, { image: true });
-    if (!url) throw new CommandExecutionError('HTML contains an unsupported image source');
-    const isRemote = /^https?:\/\//iu.test(url);
-    const resolved = isRemote ? url : await options.resolveImage(url);
+    const { url } = validatedImageSource(node, options);
+    const resolved = await options.resolveImage(url);
     if (!resolved) throw new CommandExecutionError(`Could not upload HTML image: ${url}`);
     setAttribute(node, 'src', resolved);
   }
@@ -196,13 +218,23 @@ export function loadDraftContent({ content, contentFile, contentFormat = 'text'
   };
 }
 
-export async function prepareHtmlContent(html, { baseDir = process.cwd(), resolveImage } = {}) {
+export async function prepareHtmlContent(html, {
+  baseDir = process.cwd(),
+  resolveImage,
+  allowRemoteImages = false,
+} = {}) {
   if (typeof resolveImage !== 'function') throw new ArgumentError('resolveImage is required for HTML content');
   const fragment = parseWechatHtmlFragment(String(html ?? ''));
+  for (const node of fragment.childNodes ?? []) validateImageSources(node, { allowRemoteImages });
   const imageResolver = async source => {
     const absolute = /^https?:\/\//iu.test(source) ? source : nodePath.resolve(baseDir, source);
     return resolveImage(absolute);
   };
-  await Promise.all((fragment.childNodes ?? []).map(node => sanitizeNode(node, { resolveImage: imageResolver })));
+  for (const node of fragment.childNodes ?? []) {
+    await sanitizeNode(node, {
+      resolveImage: imageResolver,
+      allowRemoteImages,
+    });
+  }
   return { html: serializeWechatHtml(fragment) };
 }

package/clis/weixin/_wechat/draft-image-stage.js

@@ -0,0 +1,51 @@
+import { prepareHtmlContent } from './draft-content.js';
+import { downloadRemoteImage } from './remote-image.js';
+import { CommandExecutionError } from '@sovovs/bycli/errors';
+
+function isRemoteImageSource(source) {
+  return /^https?:\/\//iu.test(String(source || ''));
+}
+
+export async function stageDraftHtmlImages(html, {
+  baseDir = process.cwd(),
+  allowPrivateHosts = false,
+  fetchImpl = globalThis.fetch,
+  lookupImpl,
+  downloadImpl = downloadRemoteImage,
+} = {}) {
+  const downloads = [];
+  let cleaned = false;
+  const cleanup = async () => {
+    if (cleaned) return;
+    cleaned = true;
+    const results = await Promise.allSettled(downloads.map(downloaded => downloaded.cleanup()));
+    const failure = results.find(result => result.status === 'rejected');
+    if (failure) {
+      throw new CommandExecutionError(`Failed to clean up a temporary Weixin image: ${failure.reason?.message ?? failure.reason}`);
+    }
+  };
+  try {
+    const prepared = await prepareHtmlContent(html, {
+      baseDir,
+      allowRemoteImages: true,
+      resolveImage: async source => {
+        if (!isRemoteImageSource(source)) return source;
+        const downloaded = await downloadImpl(source, {
+          allowPrivateHosts,
+          fetchImpl,
+          ...(lookupImpl ? { lookupImpl } : {}),
+        });
+        downloads.push(downloaded);
+        return downloaded.path;
+      },
+    });
+    return { html: prepared.html, cleanup };
+  } catch (error) {
+    try {
+      await cleanup();
+    } catch (cleanupError) {
+      throw new CommandExecutionError(`${error?.message ?? error}; ${cleanupError.message}`);
+    }
+    throw error;
+  }
+}

package/clis/weixin/_wechat/remote-image.js

@@ -0,0 +1,369 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { lookup as dnsLookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ArgumentError } from '@sovovs/bycli/errors';
+import { createPinnedDispatcher } from '@sovovs/bycli/node-network';
+
+const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+const DEFAULT_TIMEOUT_MS = 20_000;
+const DEFAULT_MAX_REDIRECTS = 5;
+const CLOUD_METADATA_HOSTS = new Set([
+  'instance-data.ec2.internal',
+  'metadata.google.internal',
+  'metadata.goog',
+]);
+const CLOUD_METADATA_ADDRESSES = new Set([
+  '100.100.100.200',
+  '169.254.169.254',
+  '169.254.170.2',
+  '169.254.170.23',
+  'fd00:ec2::254',
+  'fd00:ec2::23',
+]);
+const IMAGE_FORMATS = new Map([
+  ['image/jpeg', { extension: '.jpg', matches: bytes => bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff }],
+  ['image/png', { extension: '.png', matches: bytes => isPng(bytes) }],
+  ['image/gif', { extension: '.gif', matches: bytes => {
+    const header = String.fromCharCode(...bytes.slice(0, 6));
+    return header === 'GIF87a' || header === 'GIF89a';
+  } }],
+  ['image/webp', { extension: '.webp', matches: bytes => {
+    const riff = String.fromCharCode(...bytes.slice(0, 4));
+    const webp = String.fromCharCode(...bytes.slice(8, 12));
+    return riff === 'RIFF' && webp === 'WEBP';
+  } }],
+]);
+
+function isPng(bytes) {
+  const signature = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+  return signature.every((value, index) => bytes[index] === value);
+}
+
+function normalizeHostname(value) {
+  return String(value || '').replace(/^\[|\]$/gu, '').replace(/\.$/u, '').toLowerCase();
+}
+
+function parseIpv4(address) {
+  const parts = String(address).split('.');
+  if (parts.length !== 4 || parts.some(part => !/^\d{1,3}$/u.test(part))) return null;
+  const numbers = parts.map(Number);
+  return numbers.some(value => value > 255) ? null : numbers;
+}
+
+function isPrivateIpv4(address) {
+  const parts = parseIpv4(address);
+  if (!parts) return false;
+  const [a, b, c] = parts;
+  return a === 0
+    || a === 10
+    || a === 127
+    || (a === 100 && b >= 64 && b <= 127)
+    || (a === 169 && b === 254)
+    || (a === 172 && b >= 16 && b <= 31)
+    || (a === 192 && ((b === 0 && (c === 0 || c === 2)) || (b === 88 && c === 99) || b === 168))
+    || (a === 198 && (b === 18 || b === 19 || (b === 51 && c === 100)))
+    || (a === 203 && b === 0 && c === 113)
+    || a >= 224;
+}
+
+function parseIpv6Groups(address) {
+  let normalized = normalizeHostname(address).split('%')[0];
+  if (normalized.includes('.')) {
+    const lastColon = normalized.lastIndexOf(':');
+    const ipv4 = parseIpv4(normalized.slice(lastColon + 1));
+    if (!ipv4) return null;
+    normalized = `${normalized.slice(0, lastColon)}:${((ipv4[0] << 8) | ipv4[1]).toString(16)}:${((ipv4[2] << 8) | ipv4[3]).toString(16)}`;
+  }
+  const halves = normalized.split('::');
+  if (halves.length > 2) return null;
+  const parseHalf = half => half
+    ? half.split(':').map(part => (/^[0-9a-f]{1,4}$/u.test(part) ? Number.parseInt(part, 16) : NaN))
+    : [];
+  const left = parseHalf(halves[0]);
+  const right = parseHalf(halves[1] ?? '');
+  if ([...left, ...right].some(Number.isNaN)) return null;
+  const omitted = 8 - left.length - right.length;
+  if ((halves.length === 1 && omitted !== 0) || omitted < 0) return null;
+  return [...left, ...Array.from({ length: omitted }, () => 0), ...right];
+}
+
+function mappedIpv4Address(address) {
+  const groups = parseIpv6Groups(address);
+  if (!groups || groups.length !== 8) return null;
+  if (!groups.slice(0, 5).every(group => group === 0) || groups[5] !== 0xffff) return null;
+  return [groups[6] >> 8, groups[6] & 0xff, groups[7] >> 8, groups[7] & 0xff].join('.');
+}
+
+function translatedIpv4Address(address) {
+  const groups = parseIpv6Groups(address);
+  if (!groups || groups.length !== 8) return null;
+  const isWellKnownNat64 = groups[0] === 0x0064
+    && groups[1] === 0xff9b
+    && groups.slice(2, 6).every(group => group === 0);
+  const isSixToFour = groups[0] === 0x2002;
+  if (!isWellKnownNat64 && !isSixToFour) return null;
+  const high = isSixToFour ? groups[1] : groups[6];
+  const low = isSixToFour ? groups[2] : groups[7];
+  return [high >> 8, high & 0xff, low >> 8, low & 0xff].join('.');
+}
+
+function isPrivateIpv6(address) {
+  const normalized = normalizeHostname(address).split('%')[0];
+  const mappedIpv4 = mappedIpv4Address(normalized);
+  if (mappedIpv4) return isPrivateIpv4(mappedIpv4);
+  const translatedIpv4 = translatedIpv4Address(normalized);
+  if (translatedIpv4 && isPrivateIpv4(translatedIpv4)) return true;
+  const groups = parseIpv6Groups(normalized);
+  if (!groups) return true;
+  const [a, b, c, d] = groups;
+  const protocolAssignments = a === 0x2001 && b <= 0x01ff;
+  const globallyReachableProtocolAssignment = (b === 0x0001
+      && groups.slice(2, 7).every(group => group === 0)
+      && [1, 2, 3].includes(groups[7]))
+    || b === 0x0003
+    || (b === 0x0004 && c === 0x0112)
+    || (b & 0xfff0) === 0x0020
+    || (b & 0xfff0) === 0x0030;
+  return groups.slice(0, 6).every(group => group === 0)
+    || (a & 0xfe00) === 0xfc00
+    || (a & 0xffc0) === 0xfe80
+    || (a & 0xffc0) === 0xfec0
+    || (a & 0xff00) === 0xff00
+    || (a === 0x0064 && b === 0xff9b && c === 0x0001)
+    || (a === 0x0100 && b === 0 && c === 0 && (d === 0 || d === 1))
+    || (protocolAssignments && !globallyReachableProtocolAssignment)
+    || (a === 0x2001 && b === 0x0db8)
+    || a === 0x2002
+    || (a === 0x3fff && (b & 0xf000) === 0)
+    || a === 0x5f00;
+}
+
+function isPrivateAddress(address) {
+  const normalized = normalizeHostname(address);
+  if (isIP(normalized) === 4) return isPrivateIpv4(normalized);
+  if (isIP(normalized) === 6) return isPrivateIpv6(normalized);
+  return false;
+}
+
+function isCloudMetadataAddress(address) {
+  const normalized = normalizeHostname(address);
+  const mappedIpv4 = mappedIpv4Address(normalized);
+  const translatedIpv4 = translatedIpv4Address(normalized);
+  return CLOUD_METADATA_ADDRESSES.has(normalized)
+    || Boolean(mappedIpv4 && CLOUD_METADATA_ADDRESSES.has(mappedIpv4))
+    || Boolean(translatedIpv4 && CLOUD_METADATA_ADDRESSES.has(translatedIpv4));
+}
+
+async function defaultLookup(hostname) {
+  return dnsLookup(hostname, { all: true, verbatim: true });
+}
+
+function remainingTime(deadline) {
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) throw new ArgumentError('Remote image download timed out');
+  return remaining;
+}
+
+async function lookupBeforeDeadline(lookupImpl, hostname, deadline) {
+  const remaining = remainingTime(deadline);
+  let timer;
+  try {
+    return await Promise.race([
+      lookupImpl(hostname),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new ArgumentError('Remote image download timed out')), remaining);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function assertAllowedTarget(url, { allowPrivateHosts, lookupImpl, deadline }) {
+  const hostname = normalizeHostname(url.hostname);
+  if (CLOUD_METADATA_HOSTS.has(hostname) || isCloudMetadataAddress(hostname)) {
+    throw new ArgumentError('Cloud metadata addresses are not allowed');
+  }
+  let addresses;
+  if (isIP(hostname)) {
+    addresses = [{ address: hostname, family: isIP(hostname) }];
+  } else if (hostname === 'localhost' || hostname.endsWith('.localhost')) {
+    addresses = [{ address: '127.0.0.1', family: 4 }];
+  } else {
+    try {
+      addresses = await lookupBeforeDeadline(lookupImpl, hostname, deadline);
+    } catch (error) {
+      if (error instanceof ArgumentError && error.message.includes('timed out')) throw error;
+      throw new ArgumentError(`Remote image host lookup failed: ${error?.message ?? error}`);
+    }
+  }
+  if (!Array.isArray(addresses) || addresses.length === 0) {
+    throw new ArgumentError('Remote image host did not resolve to an address');
+  }
+  if (addresses.some(item => !item || !isIP(normalizeHostname(item.address)))) {
+    throw new ArgumentError('Remote image host resolved to an invalid address');
+  }
+  if (addresses.some(item => isCloudMetadataAddress(item.address))) {
+    throw new ArgumentError('Cloud metadata addresses are not allowed');
+  }
+  if (!allowPrivateHosts && addresses.some(item => isPrivateAddress(item.address))) {
+    throw new ArgumentError('Private remote image hosts require --allow-private-image-hosts true');
+  }
+  return addresses.map(item => ({ address: normalizeHostname(item.address), family: isIP(normalizeHostname(item.address)) }));
+}
+
+async function startTimedFetch(fetchImpl, url, timeoutMs, addresses) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const dispatcher = createPinnedDispatcher(addresses);
+  try {
+    const response = await fetchImpl(url, {
+      redirect: 'manual',
+      signal: controller.signal,
+      dispatcher,
+    });
+    let disposed = false;
+    return {
+      response,
+      signal: controller.signal,
+      dispose: async () => {
+        if (disposed) return;
+        disposed = true;
+        clearTimeout(timer);
+        await dispatcher.close();
+      },
+    };
+  } catch (error) {
+    clearTimeout(timer);
+    await dispatcher.close();
+    if (controller.signal.aborted) throw new ArgumentError('Remote image download timed out');
+    throw new ArgumentError(`Remote image download failed: ${error?.message ?? error}`);
+  }
+}
+
+async function readWithAbort(reader, signal) {
+  if (signal.aborted) throw new ArgumentError('Remote image download timed out');
+  let onAbort;
+  const aborted = new Promise((_, reject) => {
+    onAbort = () => reject(new ArgumentError('Remote image download timed out'));
+    signal.addEventListener('abort', onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([reader.read(), aborted]);
+  } finally {
+    signal.removeEventListener('abort', onAbort);
+  }
+}
+
+async function readBoundedBody(response, maxBytes, signal) {
+  if (!response.body || typeof response.body.getReader !== 'function') {
+    throw new ArgumentError('Remote image response body was empty');
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (;;) {
+      const { done, value } = await readWithAbort(reader, signal);
+      if (done) break;
+      const chunk = value instanceof Uint8Array ? value : new Uint8Array(value);
+      size += chunk.byteLength;
+      if (size > maxBytes) {
+        throw new ArgumentError(`Remote image exceeds ${maxBytes} bytes`);
+      }
+      chunks.push(chunk);
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {});
+    throw error;
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+
+export async function downloadRemoteImage(sourceUrl, {
+  allowPrivateHosts = false,
+  fetchImpl = globalThis.fetch,
+  lookupImpl = defaultLookup,
+  maxBytes = DEFAULT_MAX_BYTES,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  maxRedirects = DEFAULT_MAX_REDIRECTS,
+  mkdtempImpl = mkdtemp,
+  writeFileImpl = writeFile,
+  rmImpl = rm,
+} = {}) {
+  let url;
+  try {
+    url = new URL(sourceUrl);
+  } catch {
+    throw new ArgumentError(`Invalid remote image URL: ${sourceUrl}`);
+  }
+  if (!['http:', 'https:'].includes(url.protocol)) {
+    throw new ArgumentError(`Unsupported remote image protocol: ${url.protocol}`);
+  }
+  const deadline = Date.now() + timeoutMs;
+  let timedFetch;
+  for (let redirects = 0; ; redirects += 1) {
+    const addresses = await assertAllowedTarget(url, {
+      allowPrivateHosts,
+      lookupImpl,
+      deadline,
+    });
+    timedFetch = await startTimedFetch(fetchImpl, url.href, remainingTime(deadline), addresses);
+    const { response } = timedFetch;
+    if (response.status < 300 || response.status >= 400) break;
+    await response.body?.cancel().catch(() => {});
+    await timedFetch.dispose();
+    if (redirects >= maxRedirects) throw new ArgumentError(`Remote image exceeded ${maxRedirects} redirects`);
+    const location = response.headers.get('location');
+    if (!location) throw new ArgumentError('Remote image redirect was missing a destination');
+    try {
+      url = new URL(location, url);
+    } catch {
+      throw new ArgumentError('Remote image redirect destination was invalid');
+    }
+    if (!['http:', 'https:'].includes(url.protocol)) {
+      throw new ArgumentError(`Unsupported remote image protocol: ${url.protocol}`);
+    }
+  }
+  try {
+    const { response, signal } = timedFetch;
+    if (!response.ok) throw new ArgumentError(`Remote image download failed: HTTP ${response.status}`);
+    const contentType = String(response.headers.get('content-type') || '').split(';')[0].trim().toLowerCase();
+    const format = IMAGE_FORMATS.get(contentType === 'image/jpg' ? 'image/jpeg' : contentType);
+    if (!format) throw new ArgumentError(`Unsupported remote image content type: ${contentType || 'missing'}`);
+    const contentLength = Number(response.headers.get('content-length') || 0);
+    if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+      throw new ArgumentError(`Remote image exceeds ${maxBytes} bytes`);
+    }
+    const bytes = await readBoundedBody(response, maxBytes, signal);
+    if (!format.matches(bytes)) throw new ArgumentError(`Remote image content does not match ${contentType}`);
+    const directory = await mkdtempImpl(join(tmpdir(), 'bycli-weixin-image-'));
+    const path = join(directory, `image${format.extension}`);
+    try {
+      await writeFileImpl(path, bytes, { mode: 0o600 });
+      return {
+        path,
+        extension: format.extension,
+        size: bytes.byteLength,
+        resolvedUrl: url.href,
+        cleanup: () => rmImpl(directory, { recursive: true, force: true }),
+      };
+    } catch (error) {
+      await rmImpl(directory, { recursive: true, force: true });
+      throw error;
+    }
+  } catch (error) {
+    await timedFetch.response.body?.cancel().catch(() => {});
+    throw error;
+  } finally {
+    await timedFetch.dispose();
+  }
+}

package/clis/weixin/create-draft.js

@@ -5,6 +5,7 @@ import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@sovovs
 import { loadDraftContent, prepareHtmlContent } from './_wechat/draft-content.js';
 import { pasteHtmlThroughClipboard } from './_wechat/html-clipboard.js';
 import { createDraftViaApi } from './_wechat/api-draft.js';
+import { stageDraftHtmlImages } from './_wechat/draft-image-stage.js';
 
 const WEIXIN_DOMAIN = 'mp.weixin.qq.com';
 const WEIXIN_HOME = 'https://mp.weixin.qq.com/';
@@ -52,6 +53,7 @@ function readApiCredentials(kwargs) {
 
 function requiresBrowser(kwargs) {
     const { appid, appsecret } = readApiCredentials(kwargs);
+    if (kwargs['dry-run'] === true) return true;
     return !(appid && appsecret);
 }
 
@@ -77,6 +79,7 @@ function normalizeCreateDraftArgs(kwargs) {
         summary: kwargs.summary == null ? null : String(kwargs.summary).trim(),
         coverImage: validateCoverImage(kwargs['cover-image']),
         dryRun: kwargs['dry-run'] === true,
+        allowPrivateImageHosts: kwargs['allow-private-image-hosts'] === true,
         appid,
         appsecret,
     };
@@ -254,7 +257,7 @@ async function uploadContentImage(page, imagePath) {
             var editors = document.querySelectorAll('#ueditor_0, div[contenteditable="true"]');
             var sources = [];
             editors.forEach(function(editor) {
-                editor.querySelectorAll('img[src*="mmbiz"], img[data-src*="mmbiz"]').forEach(function(image) {
+                editor.querySelectorAll('img[src*=".qpic.cn"], img[data-src*=".qpic.cn"]').forEach(function(image) {
                     var src = image.getAttribute('src') || image.getAttribute('data-src') || '';
                     if (src && !sources.includes(src)) sources.push(src);
                 });
@@ -328,10 +331,10 @@ async function selectCoverFromContent(page) {
             var areas = document.querySelectorAll('#js_cover_area, #js_cover_description_area, #appmsgItem');
             var found = false;
             areas.forEach(function(area) {
-                if (area.querySelector('img[src*="mmbiz"], img[data-src*="mmbiz"]')) found = true;
+                if (area.querySelector('img[src*=".qpic.cn"], img[data-src*=".qpic.cn"]')) found = true;
                 [area].concat(Array.from(area.querySelectorAll('*'))).forEach(function(el) {
                     var bg = window.getComputedStyle(el).backgroundImage;
-                    if (bg && bg.includes('mmbiz')) found = true;
+                    if (bg && bg.includes('.qpic.cn')) found = true;
                 });
             });
             return found;
@@ -384,13 +387,14 @@ export const createDraftCommand = cli({
         { name: 'appid', help: '公众号 AppID；与 --appsecret 同传时走官方 API，不打开浏览器' },
         { name: 'appsecret', help: '公众号 AppSecret；请勿提交到 shell 历史或日志' },
         { name: 'dry-run', type: 'boolean', default: false, help: '浏览器模式：填充并验证正文后停止，不会保存草稿' },
+        { name: 'allow-private-image-hosts', type: 'boolean', default: false, help: '允许下载 localhost/内网 HTTP(S) 正文图片；云元数据地址始终禁止' },
         { name: 'timeout', type: 'int', required: false, default: 180, help: '命令总超时时间（秒，默认 180）' },
     ],
     columns: ['status', 'detail'],
 
     func: async (page, kwargs) => {
         const args = normalizeCreateDraftArgs(kwargs);
-        if (args.appid && args.appsecret) {
+        if (!args.dryRun && args.appid && args.appsecret) {
             const baseDir = args.filePath ? nodePath.dirname(args.filePath) : process.cwd();
             const result = await createDraftViaApi({
                 appid: args.appid,
@@ -401,68 +405,80 @@ export const createDraftCommand = cli({
                 coverImage: args.coverImage,
                 html: args.content,
                 baseDir,
+                allowPrivateImageHosts: args.allowPrivateImageHosts,
             });
             return [{
                 status: 'draft created',
                 detail: `"${args.title}" (media_id: ${result.mediaId})`,
             }];
         }
-        await navigateToEditor(page);
-
+        const baseDir = args.filePath ? nodePath.dirname(args.filePath) : process.cwd();
+        const staged = args.format === 'html'
+            ? await stageDraftHtmlImages(args.content, {
+                baseDir,
+                allowPrivateHosts: args.allowPrivateImageHosts,
+            })
+            : null;
+        try {
+            await navigateToEditor(page);
 
-        const titleResult = await fillField(page, 'textarea#title', args.title);
-        requirePageResult(titleResult, 'title');
 
-        if (args.author) {
-            const authorResult = await fillField(page, 'input#author', args.author);
-            requirePageResult(authorResult, 'author');
-        }
+            const titleResult = await fillField(page, 'textarea#title', args.title);
+            requirePageResult(titleResult, 'title');
 
-        await page.wait(10);
+            if (args.author) {
+                const authorResult = await fillField(page, 'input#author', args.author);
+                requirePageResult(authorResult, 'author');
+            }
 
-        let content = args.content;
-        if (args.format === 'html') {
-            const baseDir = args.filePath ? nodePath.dirname(args.filePath) : process.cwd();
-            const prepared = await prepareHtmlContent(content, {
-                baseDir,
-                resolveImage: async imagePath => {
-                    const uploaded = await uploadContentImage(page, imagePath);
-                    await removeTemporaryInsertedImage(page);
-                    return uploaded;
-                },
-            });
-            await pasteHtmlThroughClipboard(page, prepared.html, { origin: `https://${WEIXIN_DOMAIN}` });
-        } else {
-            const contentResult = await fillContent(page, content);
-            requirePageResult(contentResult, 'content');
-        }
+            await page.wait(10);
+
+            const content = staged?.html ?? args.content;
+            if (args.format === 'html') {
+                const prepared = await prepareHtmlContent(content, {
+                    baseDir,
+                    allowRemoteImages: false,
+                    resolveImage: async imagePath => {
+                        const uploaded = await uploadContentImage(page, imagePath);
+                        await removeTemporaryInsertedImage(page);
+                        return uploaded;
+                    },
+                });
+                await pasteHtmlThroughClipboard(page, prepared.html, { origin: `https://${WEIXIN_DOMAIN}` });
+            } else {
+                const contentResult = await fillContent(page, content);
+                requirePageResult(contentResult, 'content');
+            }
 
-        if (args.dryRun) {
-            return [{
-                status: 'draft ready',
-                detail: `"${args.title}" (dry-run)`,
-            }];
-        }
+            if (args.dryRun) {
+                return [{
+                    status: 'draft ready',
+                    detail: `"${args.title}" (dry-run)`,
+                }];
+            }
 
-        if (args.coverImage) {
-            await uploadContentImage(page, args.coverImage);
-            const coverSet = await selectCoverFromContent(page);
-            if (!coverSet) {
-                throw new CommandExecutionError('Failed to set the requested cover image');
+            if (args.coverImage) {
+                await uploadContentImage(page, args.coverImage);
+                const coverSet = await selectCoverFromContent(page);
+                if (!coverSet) {
+                    throw new CommandExecutionError('Failed to set the requested cover image');
+                }
             }
-        }
 
-        if (args.summary) {
-            const summaryResult = await fillField(page, 'textarea#js_description', args.summary);
-            requirePageResult(summaryResult, 'summary');
-        }
+            if (args.summary) {
+                const summaryResult = await fillField(page, 'textarea#js_description', args.summary);
+                requirePageResult(summaryResult, 'summary');
+            }
 
-        await page.wait(1);
-        await clickSaveDraft(page);
+            await page.wait(1);
+            await clickSaveDraft(page);
 
-        return [{
-            status: 'draft saved',
-            detail: `"${args.title}"${args.author ? ` by ${args.author}` : ''}${args.coverImage ? ' (with cover)' : ''}`,
-        }];
+            return [{
+                status: 'draft saved',
+                detail: `"${args.title}"${args.author ? ` by ${args.author}` : ''}${args.coverImage ? ' (with cover)' : ''}`,
+            }];
+        } finally {
+            await staged?.cleanup();
+        }
     },
 });

package/dist/src/node-network.d.ts

@@ -3,8 +3,13 @@ export interface ProxyDecision {
     mode: 'direct' | 'proxy';
     proxyUrl?: string;
 }
+export interface PinnedNetworkAddress {
+    address: string;
+    family: 4 | 6;
+}
 export declare function hasProxyEnv(env?: NodeJS.ProcessEnv): boolean;
 export declare function decideProxy(url: URL, env?: NodeJS.ProcessEnv): ProxyDecision;
 export declare function getDispatcherForUrl(url: URL, env?: NodeJS.ProcessEnv): Dispatcher;
+export declare function createPinnedDispatcher(addresses: PinnedNetworkAddress[]): Dispatcher;
 export declare function fetchWithNodeNetwork(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 export declare function installNodeNetwork(): void;

package/dist/src/node-network.js

@@ -156,7 +156,36 @@ export function getDispatcherForUrl(url, env = process.env) {
         return directDispatcher;
     return createProxyDispatcher(config);
 }
+export function createPinnedDispatcher(addresses) {
+    if (addresses.length === 0)
+        throw new Error('At least one pinned network address is required');
+    return new Agent({
+        connect: {
+            lookup(_hostname, options, callback) {
+                const requestedFamily = Number(options?.family) || 0;
+                const candidates = requestedFamily
+                    ? addresses.filter(item => item.family === requestedFamily)
+                    : addresses;
+                if (candidates.length === 0) {
+                    callback(new Error(`No pinned address for IPv${requestedFamily}`), []);
+                    return;
+                }
+                if (options?.all)
+                    callback(null, candidates);
+                else
+                    callback(null, candidates[0].address, candidates[0].family);
+            },
+        },
+    });
+}
 export async function fetchWithNodeNetwork(input, init = {}) {
+    const explicitDispatcher = init.dispatcher;
+    if (explicitDispatcher) {
+        return (await undiciFetch(input, {
+            ...init,
+            dispatcher: explicitDispatcher,
+        }));
+    }
     const url = resolveUrl(input);
     if (!url || !hasProxyEnv()) {
         return nativeFetch(input, init);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sovovs/bycli",
-  "version": "2.1.46",
+  "version": "2.1.47",
   "publishConfig": {
     "access": "public"
   },
@@ -24,6 +24,7 @@
     "./types": "./dist/src/types.js",
     "./utils": "./dist/src/utils.js",
     "./logger": "./dist/src/logger.js",
+    "./node-network": "./dist/src/node-network.js",
     "./launcher": "./dist/src/launcher.js",
     "./browser/cdp": "./dist/src/browser/cdp.js",
     "./browser/page": "./dist/src/browser/page.js",