1import fs from "node:fs";
2import path from "node:path";
3import { spawnSync } from "node:child_process";
4import { fileURLToPath } from "node:url";
5import { loadWechatExtendConfig, resolveAccount, loadCredentials } from "./wechat-extend-config.ts";
6import {
7  type WechatUploadAsset,
8  prepareWechatBodyImageUpload,
9  needsWechatBodyImageProcessing,
10  detectImageFormatFromBuffer,
11} from "./wechat-image-processor.ts";
12 
13interface AccessTokenResponse {
14  access_token?: string;
15  errcode?: number;
16  errmsg?: string;
17}
18 
19interface UploadResponse {
20  media_id: string;
21  url: string;
22  errcode?: number;
23  errmsg?: string;
24}
25 
26interface PublishResponse {
27  media_id?: string;
28  errcode?: number;
29  errmsg?: string;
30}
31 
32interface ImageInfo {
33  placeholder: string;
34  localPath: string;
35  originalPath: string;
36}
37 
38interface MarkdownRenderResult {
39  title: string;
40  author: string;
41  summary: string;
42  htmlPath: string;
43  contentImages: ImageInfo[];
44}
45 
46type ArticleType = "news" | "newspic";
47 
48interface ArticleOptions {
49  title: string;
50  author?: string;
51  digest?: string;
52  content: string;
53  thumbMediaId: string;
54  articleType: ArticleType;
55  imageMediaIds?: string[];
56  needOpenComment?: number;
57  onlyFansCanComment?: number;
58}
59 
60const TOKEN_URL = "https://api.weixin.qq.com/cgi-bin/token";
61const UPLOAD_BODY_IMG_URL = "https://api.weixin.qq.com/cgi-bin/media/uploadimg";
62const UPLOAD_MATERIAL_URL = "https://api.weixin.qq.com/cgi-bin/material/add_material";
63const DRAFT_URL = "https://api.weixin.qq.com/cgi-bin/draft/add";
64 
65async function fetchAccessToken(appId: string, appSecret: string): Promise<string> {
66  const url = `${TOKEN_URL}?grant_type=client_credential&appid=${appId}&secret=${appSecret}`;
67  const res = await fetch(url);
68  if (!res.ok) {
69    throw new Error(`Failed to fetch access token: ${res.status}`);
70  }
71  const data = await res.json() as AccessTokenResponse;
72  if (data.errcode) {
73    throw new Error(`Access token error ${data.errcode}: ${data.errmsg}`);
74  }
75  if (!data.access_token) {
76    throw new Error("No access_token in response");
77  }
78  return data.access_token;
79}
80 
81function toHttpsUrl(url: string | undefined): string {
82  if (!url) return "";
83  return url.startsWith("http://") ? url.replace(/^http:\/\//i, "https://") : url;
84}
85 
86async function loadUploadAsset(
87  imagePath: string,
88  baseDir?: string,
89): Promise<WechatUploadAsset> {
90  let fileBuffer: Buffer;
91  let filename: string;
92  let contentType: string;
93  let fileSize = 0;
94  let fileExt = "";
95 
96  if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
97    const response = await fetch(imagePath);
98    if (!response.ok) {
99      throw new Error(`Failed to download image: ${imagePath}`);
100    }
101    const buffer = await response.arrayBuffer();
102    if (buffer.byteLength === 0) {
103      throw new Error(`Remote image is empty: ${imagePath}`);
104    }
105    fileBuffer = Buffer.from(buffer);
106    fileSize = buffer.byteLength;
107    const urlPath = imagePath.split("?")[0];
108    filename = path.basename(urlPath) || "image.jpg";
109    fileExt = path.extname(filename).toLowerCase();
110    contentType = response.headers.get("content-type") || "image/jpeg";
111  } else {
112    const resolvedPath = path.isAbsolute(imagePath)
113      ? imagePath
114      : path.resolve(baseDir || process.cwd(), imagePath);
115 
116    if (!fs.existsSync(resolvedPath)) {
117      throw new Error(`Image not found: ${resolvedPath}`);
118    }
119    const stats = fs.statSync(resolvedPath);
120    if (stats.size === 0) {
121      throw new Error(`Local image is empty: ${resolvedPath}`);
122    }
123    fileSize = stats.size;
124    fileBuffer = fs.readFileSync(resolvedPath);
125    filename = path.basename(resolvedPath);
126    fileExt = path.extname(filename).toLowerCase();
127    const mimeTypes: Record<string, string> = {
128      ".jpg": "image/jpeg",
129      ".jpeg": "image/jpeg",
130      ".png": "image/png",
131      ".gif": "image/gif",
132      ".webp": "image/webp",
133      ".bmp": "image/bmp",
134      ".tiff": "image/tiff",
135      ".tif": "image/tiff",
136      ".svg": "image/svg+xml",
137      ".ico": "image/x-icon",
138    };
139    contentType = mimeTypes[fileExt] || "image/jpeg";
140  }
141 
142  // Detect actual format from magic bytes to fix extension/content-type mismatches
143  // (e.g. CDNs serving WebP for URLs with .png extension)
144  const detected = detectImageFormatFromBuffer(fileBuffer);
145  if (detected && detected.contentType !== contentType) {
146    console.error(`[wechat-api] Format mismatch: ${filename} declared as ${contentType}, actual ${detected.contentType}`);
147    contentType = detected.contentType;
148    fileExt = detected.fileExt;
149    filename = `${path.basename(filename, path.extname(filename))}${detected.fileExt}`;
150  }
151 
152  return {
153    buffer: fileBuffer,
154    filename,
155    contentType,
156    fileExt,
157    fileSize,
158  };
159}
160 
161async function uploadImage(
162  imagePath: string,
163  accessToken: string,
164  baseDir?: string,
165  uploadType: "body" | "material" = "body"
166): Promise<UploadResponse> {
167  const asset = await loadUploadAsset(imagePath, baseDir);
168  let uploadAsset = asset;
169 
170  if (uploadType === "body" && needsWechatBodyImageProcessing(asset)) {
171    const prepared = await prepareWechatBodyImageUpload(asset);
172    uploadAsset = {
173      ...asset,
174      buffer: prepared.buffer,
175      filename: prepared.filename,
176      contentType: prepared.contentType,
177      fileExt: path.extname(prepared.filename).toLowerCase(),
178      fileSize: prepared.buffer.length,
179    };
180    const note = prepared.processingNotes.join(", ");
181    console.error(`[wechat-api] Processed ${asset.filename} for body upload: ${note}`);
182  }
183 
184  const result = await uploadToWechat(
185    uploadAsset.buffer,
186    uploadAsset.filename,
187    uploadAsset.contentType,
188    accessToken,
189    uploadType,
190  );
191 
192  // media/uploadimg 接口只返回 URL，material/add_material 返回 media_id
193  if (uploadType === "body") {
194    return {
195      url: toHttpsUrl(result.url),
196      media_id: "",
197    } as UploadResponse;
198  } else {
199    result.url = toHttpsUrl(result.url);
200    return result;
201  }
202}
203 
204// 实际的微信上传函数
205async function uploadToWechat(
206  fileBuffer: Buffer,
207  filename: string,
208  contentType: string,
209  accessToken: string,
210  uploadType: "body" | "material"
211): Promise<UploadResponse> {
212  const boundary = `----WebKitFormBoundary${Date.now().toString(16)}`;
213  const header = [
214    `--${boundary}`,
215    `Content-Disposition: form-data; name="media"; filename="${filename}"`,
216    `Content-Type: ${contentType}`,
217    "",
218    "",
219  ].join("\r\n");
220  const footer = `\r\n--${boundary}--\r\n`;
221 
222  const headerBuffer = Buffer.from(header, "utf-8");
223  const footerBuffer = Buffer.from(footer, "utf-8");
224  const body = Buffer.concat([headerBuffer, fileBuffer, footerBuffer]);
225 
226  const uploadUrl = uploadType === "body" ? UPLOAD_BODY_IMG_URL : UPLOAD_MATERIAL_URL;
227  const url = `${uploadUrl}?type=image&access_token=${accessToken}`;
228  const res = await fetch(url, {
229    method: "POST",
230    headers: {
231      "Content-Type": `multipart/form-data; boundary=${boundary}`,
232    },
233    body,
234  });
235 
236  const data = await res.json() as UploadResponse;
237  if (data.errcode && data.errcode !== 0) {
238    throw new Error(`Upload failed ${data.errcode}: ${data.errmsg}`);
239  }
240 
241  return data;
242}
243 
244async function uploadImagesInHtml(
245  html: string,
246  accessToken: string,
247  baseDir: string,
248  contentImages: ImageInfo[] = [],
249  articleType: ArticleType = "news",
250  collectNewsCoverFallback: boolean = false,
251): Promise<{ html: string; firstCoverMediaId: string; imageMediaIds: string[] }> {
252  const imgRegex = /<img[^>]*\ssrc=["']([^"']+)["'][^>]*>/gi;
253  const matches = [...html.matchAll(imgRegex)];
254 
255  if (matches.length === 0 && contentImages.length === 0) {
256    return { html, firstCoverMediaId: "", imageMediaIds: [] };
257  }
258 
259  let firstCoverMediaId = "";
260  let updatedHtml = html;
261  const imageMediaIds: string[] = [];
262  const uploadedBySource = new Map<string, UploadResponse>();
263 
264  for (const match of matches) {
265    const [fullTag, src] = match;
266    if (!src) continue;
267 
268    if (src.startsWith("https://mmbiz.qpic.cn")) {
269      if (collectNewsCoverFallback && !firstCoverMediaId) {
270        try {
271          const coverResp = await uploadImage(src, accessToken, baseDir, "material");
272          firstCoverMediaId = coverResp.media_id;
273        } catch (err) {
274          console.error(`[wechat-api] Failed to reuse existing WeChat image as cover: ${src}`, err);
275        }
276      }
277      continue;
278    }
279 
280    const localPathMatch = fullTag.match(/data-local-path=["']([^"']+)["']/);
281    const imagePath = localPathMatch ? localPathMatch[1]! : src;
282 
283    console.error(`[wechat-api] Uploading body image: ${imagePath}`);
284    try {
285      let resp = uploadedBySource.get(imagePath);
286      if (!resp) {
287        // 正文图片使用 media/uploadimg 接口获取 URL
288        resp = await uploadImage(imagePath, accessToken, baseDir, "body");
289        uploadedBySource.set(imagePath, resp);
290      }
291      const newTag = fullTag
292        .replace(/\ssrc=["'][^"']+["']/, ` src="${resp.url}"`)
293        .replace(/\sdata-local-path=["'][^"']+["']/, "");
294      updatedHtml = updatedHtml.replace(fullTag, newTag);
295      const shouldUploadMaterial = articleType === "newspic" || (collectNewsCoverFallback && !firstCoverMediaId);
296      if (shouldUploadMaterial) {
297        let materialResp = uploadedBySource.get(`${imagePath}:material`);
298        if (!materialResp) {
299          materialResp = await uploadImage(imagePath, accessToken, baseDir, "material");
300          uploadedBySource.set(`${imagePath}:material`, materialResp);
301        }
302        if (articleType === "newspic" && materialResp.media_id) {
303          imageMediaIds.push(materialResp.media_id);
304        }
305        if (collectNewsCoverFallback && !firstCoverMediaId && materialResp.media_id) {
306          firstCoverMediaId = materialResp.media_id;
307        }
308      }
309    } catch (err) {
310      console.error(`[wechat-api] Failed to upload ${imagePath}:`, err);
311    }
312  }
313 
314  for (const image of contentImages) {
315    if (!updatedHtml.includes(image.placeholder)) continue;
316 
317    const imagePath = image.localPath || image.originalPath;
318    console.error(`[wechat-api] Uploading body image: ${imagePath}`);
319 
320    try {
321      let resp = uploadedBySource.get(imagePath);
322      if (!resp) {
323        // 正文图片使用 media/uploadimg 接口获取 URL
324        resp = await uploadImage(imagePath, accessToken, baseDir, "body");
325        uploadedBySource.set(imagePath, resp);
326      }
327 
328      const replacementTag = `<img src="${resp.url}" style="display: block; width: 100%; margin: 1.5em auto;">`;
329      updatedHtml = replaceAllPlaceholders(updatedHtml, image.placeholder, replacementTag);
330      const shouldUploadMaterial = articleType === "newspic" || (collectNewsCoverFallback && !firstCoverMediaId);
331      if (shouldUploadMaterial) {
332        let materialResp = uploadedBySource.get(`${imagePath}:material`);
333        if (!materialResp) {
334          materialResp = await uploadImage(imagePath, accessToken, baseDir, "material");
335          uploadedBySource.set(`${imagePath}:material`, materialResp);
336        }
337        if (articleType === "newspic" && materialResp.media_id) {
338          imageMediaIds.push(materialResp.media_id);
339        }
340        if (collectNewsCoverFallback && !firstCoverMediaId && materialResp.media_id) {
341          firstCoverMediaId = materialResp.media_id;
342        }
343      }
344    } catch (err) {
345      console.error(`[wechat-api] Failed to upload placeholder ${image.placeholder}:`, err);
346    }
347  }
348 
349  return { html: updatedHtml, firstCoverMediaId, imageMediaIds };
350}
351 
352async function publishToDraft(
353  options: ArticleOptions,
354  accessToken: string
355): Promise<PublishResponse> {
356  const url = `${DRAFT_URL}?access_token=${accessToken}`;
357 
358  let article: Record<string, unknown>;
359 
360  const noc = options.needOpenComment ?? 1;
361  const ofcc = options.onlyFansCanComment ?? 0;
362 
363  if (options.articleType === "newspic") {
364    if (!options.imageMediaIds || options.imageMediaIds.length === 0) {
365      throw new Error("newspic requires at least one image");
366    }
367    article = {
368      article_type: "newspic",
369      title: options.title,
370      content: options.content,
371      need_open_comment: noc,
372      only_fans_can_comment: ofcc,
373      image_info: {
374        image_list: options.imageMediaIds.map(id => ({ image_media_id: id })),
375      },
376    };
377    if (options.author) article.author = options.author;
378  } else {
379    article = {
380      article_type: "news",
381      title: options.title,
382      content: options.content,
383      thumb_media_id: options.thumbMediaId,
384      need_open_comment: noc,
385      only_fans_can_comment: ofcc,
386    };
387    if (options.author) article.author = options.author;
388    if (options.digest) article.digest = options.digest;
389  }
390 
391  const res = await fetch(url, {
392    method: "POST",
393    headers: {
394      "Content-Type": "application/json",
395    },
396    body: JSON.stringify({ articles: [article] }),
397  });
398 
399  const data = await res.json() as PublishResponse;
400  if (data.errcode && data.errcode !== 0) {
401    throw new Error(`Publish failed ${data.errcode}: ${data.errmsg}`);
402  }
403 
404  return data;
405}
406 
407function parseFrontmatter(content: string): { frontmatter: Record<string, string>; body: string } {
408  const match = content.match(/^\s*---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
409  if (!match) return { frontmatter: {}, body: content };
410 
411  const frontmatter: Record<string, string> = {};
412  const lines = match[1]!.split("\n");
413  for (const line of lines) {
414    const colonIdx = line.indexOf(":");
415    if (colonIdx > 0) {
416      const key = line.slice(0, colonIdx).trim();
417      let value = line.slice(colonIdx + 1).trim();
418      if ((value.startsWith('"') && value.endsWith('"')) ||
419          (value.startsWith("'") && value.endsWith("'"))) {
420        value = value.slice(1, -1);
421      }
422      frontmatter[key] = value;
423    }
424  }
425 
426  return { frontmatter, body: match[2]! };
427}
428 
429function renderMarkdownWithPlaceholders(
430  markdownPath: string,
431  theme: string = "default",
432  color?: string,
433  citeStatus: boolean = true,
434  title?: string,
435): MarkdownRenderResult {
436  const __filename = fileURLToPath(import.meta.url);
437  const __dirname = path.dirname(__filename);
438  const mdToWechatScript = path.join(__dirname, "md-to-wechat.ts");
439  const baseDir = path.dirname(markdownPath);
440 
441  const args = ["-y", "bun", mdToWechatScript, markdownPath];
442  if (title) args.push("--title", title);
443  if (theme) args.push("--theme", theme);
444  if (color) args.push("--color", color);
445  if (!citeStatus) args.push("--no-cite");
446 
447  console.error(`[wechat-api] Rendering markdown with placeholders via md-to-wechat: ${theme}${color ? `, color: ${color}` : ""}, citeStatus: ${citeStatus}`);
448  const result = spawnSync("npx", args, {
449    stdio: ["inherit", "pipe", "pipe"],
450    cwd: baseDir,
451  });
452 
453  if (result.status !== 0) {
454    const stderr = result.stderr?.toString() || "";
455    throw new Error(`Markdown placeholder render failed: ${stderr}`);
456  }
457 
458  const stdout = result.stdout?.toString() || "";
459  return JSON.parse(stdout) as MarkdownRenderResult;
460}
461 
462function replaceAllPlaceholders(html: string, placeholder: string, replacement: string): string {
463  const escapedPlaceholder = placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
464  return html.replace(new RegExp(escapedPlaceholder + "(?!\\d)", "g"), replacement);
465}
466 
467function extractHtmlContent(htmlPath: string): string {
468  const html = fs.readFileSync(htmlPath, "utf-8");
469  const match = html.match(/<div id="output">([\s\S]*?)<\/div>\s*<\/body>/);
470  if (match) {
471    return match[1]!.trim();
472  }
473  const bodyMatch = html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
474  return bodyMatch ? bodyMatch[1]!.trim() : html;
475}
476 
477function printUsage(): never {
478  console.log(`Publish article to WeChat Official Account draft using API
479 
480Usage:
481  npx -y bun wechat-api.ts <file> [options]
482 
483Arguments:
484  file                Markdown (.md) or HTML (.html) file
485 
486Options:
487  --type <type>       Article type: news (文章, default) or newspic (图文)
488  --title <title>     Override title
489  --author <name>     Author name (max 16 chars)
490  --summary <text>    Article summary/digest (max 128 chars)
491  --theme <name>      Theme name for markdown (default, grace, simple, modern). Default: default
492  --color <name|hex>  Primary color (blue, green, vermilion, etc. or hex)
493  --cover <path>      Cover image path (local or URL)
494  --account <alias>   Select account by alias (for multi-account setups)
495  --no-cite           Disable bottom citations for ordinary external links in markdown mode
496  --dry-run           Parse and render only, don't publish
497  --help              Show this help
498 
499Frontmatter Fields (markdown):
500  title               Article title
501  author              Author name
502  digest/summary      Article summary
503  coverImage/featureImage/cover/image   Cover image path
504 
505Comments:
506  Comments are enabled by default, open to all users.
507 
508Environment Variables:
509  WECHAT_APP_ID       WeChat App ID
510  WECHAT_APP_SECRET   WeChat App Secret
511 
512Config File Locations (in priority order):
513  1. Environment variables
514  2. <cwd>/.baoyu-skills/.env
515  3. ~/.baoyu-skills/.env
516 
517Example:
518  npx -y bun wechat-api.ts article.md
519  npx -y bun wechat-api.ts article.md --theme grace --cover cover.png
520  npx -y bun wechat-api.ts article.md --author "Author Name" --summary "Brief intro"
521  npx -y bun wechat-api.ts article.html --title "My Article"
522  npx -y bun wechat-api.ts images/ --type newspic --title "Photo Album"
523  npx -y bun wechat-api.ts article.md --dry-run
524  npx -y bun wechat-api.ts article.md --no-cite
525`);
526  process.exit(0);
527}
528 
529interface CliArgs {
530  filePath: string;
531  isHtml: boolean;
532  articleType: ArticleType;
533  title?: string;
534  author?: string;
535  summary?: string;
536  theme: string;
537  color?: string;
538  cover?: string;
539  account?: string;
540  citeStatus: boolean;
541  dryRun: boolean;
542}
543 
544function parseArgs(argv: string[]): CliArgs {
545  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
546    printUsage();
547  }
548 
549  const args: CliArgs = {
550    filePath: "",
551    isHtml: false,
552    articleType: "news",
553    theme: "default",
554    citeStatus: true,
555    dryRun: false,
556  };
557 
558  for (let i = 0; i < argv.length; i++) {
559    const arg = argv[i]!;
560    if (arg === "--type" && argv[i + 1]) {
561      const t = argv[++i]!.toLowerCase();
562      if (t === "news" || t === "newspic") {
563        args.articleType = t;
564      }
565    } else if (arg === "--title" && argv[i + 1]) {
566      args.title = argv[++i];
567    } else if (arg === "--author" && argv[i + 1]) {
568      args.author = argv[++i];
569    } else if (arg === "--summary" && argv[i + 1]) {
570      args.summary = argv[++i];
571    } else if (arg === "--theme" && argv[i + 1]) {
572      args.theme = argv[++i]!;
573    } else if (arg === "--color" && argv[i + 1]) {
574      args.color = argv[++i];
575    } else if (arg === "--cover" && argv[i + 1]) {
576      args.cover = argv[++i];
577    } else if (arg === "--account" && argv[i + 1]) {
578      args.account = argv[++i];
579    } else if (arg === "--cite") {
580      args.citeStatus = true;
581    } else if (arg === "--no-cite") {
582      args.citeStatus = false;
583    } else if (arg === "--dry-run") {
584      args.dryRun = true;
585    } else if (arg.startsWith("--") && argv[i + 1] && !argv[i + 1]!.startsWith("-")) {
586      i++;
587    } else if (!arg.startsWith("-")) {
588      args.filePath = arg;
589    }
590  }
591 
592  if (!args.filePath) {
593    console.error("Error: File path required");
594    process.exit(1);
595  }
596 
597  args.isHtml = args.filePath.toLowerCase().endsWith(".html");
598 
599  return args;
600}
601 
602function extractHtmlTitle(html: string): string {
603  const titleMatch = html.match(/<title>([^<]+)<\/title>/i);
604  if (titleMatch) return titleMatch[1]!;
605  const h1Match = html.match(/<h1[^>]*>([^<]+)<\/h1>/i);
606  if (h1Match) return h1Match[1]!.replace(/<[^>]+>/g, "").trim();
607  return "";
608}
609 
610async function main(): Promise<void> {
611  const args = parseArgs(process.argv.slice(2));
612 
613  const filePath = path.resolve(args.filePath);
614  if (!fs.existsSync(filePath)) {
615    console.error(`Error: File not found: ${filePath}`);
616    process.exit(1);
617  }
618 
619  const baseDir = path.dirname(filePath);
620  let title = args.title || "";
621  let author = args.author || "";
622  let digest = args.summary || "";
623  let htmlPath: string;
624  let htmlContent: string;
625  let frontmatter: Record<string, string> = {};
626  let contentImages: ImageInfo[] = [];
627 
628  if (args.isHtml) {
629    htmlPath = filePath;
630    htmlContent = extractHtmlContent(htmlPath);
631    const mdPath = filePath.replace(/\.html$/i, ".md");
632    if (fs.existsSync(mdPath)) {
633      const mdContent = fs.readFileSync(mdPath, "utf-8");
634      const parsed = parseFrontmatter(mdContent);
635      frontmatter = parsed.frontmatter;
636      if (!title && frontmatter.title) title = frontmatter.title;
637      if (!author) author = frontmatter.author || "";
638      if (!digest) digest = frontmatter.digest || frontmatter.summary || frontmatter.description || "";
639    }
640    if (!title) {
641      title = extractHtmlTitle(fs.readFileSync(htmlPath, "utf-8"));
642    }
643    console.error(`[wechat-api] Using HTML file: ${htmlPath}`);
644  } else {
645    const content = fs.readFileSync(filePath, "utf-8");
646    const parsed = parseFrontmatter(content);
647    frontmatter = parsed.frontmatter;
648    const body = parsed.body;
649 
650    title = title || frontmatter.title || "";
651    if (!title) {
652      const h1Match = body.match(/^#\s+(.+)$/m);
653      if (h1Match) title = h1Match[1]!;
654    }
655    if (!author) author = frontmatter.author || "";
656    if (!digest) digest = frontmatter.digest || frontmatter.summary || frontmatter.description || "";
657 
658    console.error(`[wechat-api] Theme: ${args.theme}${args.color ? `, color: ${args.color}` : ""}, citeStatus: ${args.citeStatus}`);
659    const rendered = renderMarkdownWithPlaceholders(filePath, args.theme, args.color, args.citeStatus, args.title);
660    htmlPath = rendered.htmlPath;
661    contentImages = rendered.contentImages;
662    if (!title) title = rendered.title;
663    if (!author) author = rendered.author;
664    if (!digest) digest = rendered.summary;
665    console.error(`[wechat-api] HTML generated: ${htmlPath}`);
666    console.error(`[wechat-api] Placeholder images: ${contentImages.length}`);
667    htmlContent = extractHtmlContent(htmlPath);
668  }
669 
670  if (!title) {
671    console.error("Error: No title found. Provide via --title, frontmatter, or <title> tag.");
672    process.exit(1);
673  }
674 
675  if (digest && digest.length > 120) {
676    const truncated = digest.slice(0, 117);
677    const lastPunct = Math.max(truncated.lastIndexOf("。"), truncated.lastIndexOf("，"), truncated.lastIndexOf("；"), truncated.lastIndexOf("、"));
678    digest = lastPunct > 80 ? truncated.slice(0, lastPunct + 1) : truncated + "...";
679    console.error(`[wechat-api] Digest truncated to ${digest.length} chars`);
680  }
681 
682  console.error(`[wechat-api] Title: ${title}`);
683  if (author) console.error(`[wechat-api] Author: ${author}`);
684  if (digest) console.error(`[wechat-api] Digest: ${digest.slice(0, 50)}...`);
685  console.error(`[wechat-api] Type: ${args.articleType}`);
686 
687  const extConfig = loadWechatExtendConfig();
688  const resolved = resolveAccount(extConfig, args.account);
689  if (resolved.name) console.error(`[wechat-api] Account: ${resolved.name} (${resolved.alias})`);
690 
691  if (!author && resolved.default_author) author = resolved.default_author;
692 
693  if (args.dryRun) {
694    console.log(JSON.stringify({
695      articleType: args.articleType,
696      title,
697      author: author || undefined,
698      digest: digest || undefined,
699      htmlPath,
700      contentLength: htmlContent.length,
701      placeholderImageCount: contentImages.length || undefined,
702      account: resolved.alias || undefined,
703    }, null, 2));
704    return;
705  }
706 
707  const creds = loadCredentials(resolved);
708  for (const skippedSource of creds.skippedSources) {
709    console.error(`[wechat-api] Skipped incomplete credential source: ${skippedSource}`);
710  }
711  console.error(`[wechat-api] Credentials source: ${creds.source}`);
712  console.error("[wechat-api] Fetching access token...");
713  const accessToken = await fetchAccessToken(creds.appId, creds.appSecret);
714 
715  const rawCoverPath = args.cover ||
716    frontmatter.coverImage ||
717    frontmatter.featureImage ||
718    frontmatter.cover ||
719    frontmatter.image;
720  const coverPath = rawCoverPath && !path.isAbsolute(rawCoverPath) && args.cover
721    ? path.resolve(process.cwd(), rawCoverPath)
722    : rawCoverPath;
723  const needNewsCoverFallback = args.articleType === "news" && !coverPath;
724 
725  console.error("[wechat-api] Uploading body images...");
726  const { html: processedHtml, firstCoverMediaId, imageMediaIds } = await uploadImagesInHtml(
727    htmlContent,
728    accessToken,
729    baseDir,
730    contentImages,
731    args.articleType,
732    needNewsCoverFallback,
733  );
734  htmlContent = processedHtml;
735 
736  let thumbMediaId = "";
737 
738  if (coverPath) {
739    console.error(`[wechat-api] Uploading cover: ${coverPath}`);
740    // 封面图片使用 material/add_material 接口
741    const coverResp = await uploadImage(coverPath, accessToken, baseDir, "material");
742    thumbMediaId = coverResp.media_id;
743    console.error(`[wechat-api] Cover uploaded successfully, media_id: ${thumbMediaId}`);
744  } else if (firstCoverMediaId && args.articleType === "news") {
745    // news 类型没有封面时，使用第一张正文图的 media_id 作为封面（兜底逻辑）
746    thumbMediaId = firstCoverMediaId;
747    console.error(`[wechat-api] Using first body image as cover (fallback), media_id: ${thumbMediaId}`);
748  }
749 
750  if (args.articleType === "news" && !thumbMediaId) {
751    console.error("Error: No cover image. Provide via --cover, frontmatter.coverImage, or include an image in content.");
752    process.exit(1);
753  }
754 
755  if (args.articleType === "newspic" && imageMediaIds.length === 0) {
756    console.error("Error: newspic requires at least one image in content.");
757    process.exit(1);
758  }
759 
760  console.error("[wechat-api] Publishing to draft...");
761  const result = await publishToDraft({
762    title,
763    author: author || undefined,
764    digest: digest || undefined,
765    content: htmlContent,
766    thumbMediaId,
767    articleType: args.articleType,
768    imageMediaIds: args.articleType === "newspic" ? imageMediaIds : undefined,
769    needOpenComment: resolved.need_open_comment,
770    onlyFansCanComment: resolved.only_fans_can_comment,
771  }, accessToken);
772 
773  console.log(JSON.stringify({
774    success: true,
775    media_id: result.media_id,
776    title,
777    articleType: args.articleType,
778  }, null, 2));
779 
780  console.error(`[wechat-api] Published successfully! media_id: ${result.media_id}`);
781}
782 
783await main().catch((err) => {
784  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
785  process.exit(1);
786});
787