1import fs from "node:fs";
2import path from "node:path";
3import { spawnSync } from "node:child_process";
4import { fileURLToPath } from "node:url";
5import {
6  loadWechatExtendConfig,
7  resolveAccount,
8  loadCredentials,
9  type ResolvedAccount,
10  type StrictHostKeyChecking,
11} from "./wechat-extend-config.ts";
12import {
13  type WechatUploadAsset,
14  prepareWechatBodyImageUpload,
15  needsWechatBodyImageProcessing,
16} from "./wechat-image-processor.ts";
17import { loadUploadAsset } from "./wechat-image-loader.ts";
18import { wechatHttp, buildMultipart, type WechatClient } from "./wechat-http.ts";
19import {
20  type RemotePublishConfig,
21  normalizeRemoteConfig,
22  withSshTunnel,
23} from "./wechat-remote-publish.ts";
24 
25interface AccessTokenResponse {
26  access_token?: string;
27  errcode?: number;
28  errmsg?: string;
29}
30 
31interface UploadResponse {
32  media_id: string;
33  url: string;
34  errcode?: number;
35  errmsg?: string;
36}
37 
38interface PublishResponse {
39  media_id?: string;
40  errcode?: number;
41  errmsg?: string;
42}
43 
44interface ImageInfo {
45  placeholder: string;
46  localPath: string;
47  originalPath: string;
48}
49 
50interface MarkdownRenderResult {
51  title: string;
52  author: string;
53  summary: string;
54  htmlPath: string;
55  contentImages: ImageInfo[];
56}
57 
58type ArticleType = "news" | "newspic";
59 
60interface ArticleOptions {
61  title: string;
62  author?: string;
63  digest?: string;
64  content: string;
65  thumbMediaId: string;
66  articleType: ArticleType;
67  contentSourceUrl?: string;
68  imageMediaIds?: string[];
69  needOpenComment?: number;
70  onlyFansCanComment?: number;
71}
72 
73const TOKEN_URL = "https://api.weixin.qq.com/cgi-bin/token";
74const UPLOAD_BODY_IMG_URL = "https://api.weixin.qq.com/cgi-bin/media/uploadimg";
75const UPLOAD_MATERIAL_URL = "https://api.weixin.qq.com/cgi-bin/material/add_material";
76const DRAFT_URL = "https://api.weixin.qq.com/cgi-bin/draft/add";
77 
78async function fetchAccessToken(
79  appId: string,
80  appSecret: string,
81  client: WechatClient = wechatHttp,
82): Promise<string> {
83  const url = `${TOKEN_URL}?grant_type=client_credential&appid=${appId}&secret=${appSecret}`;
84  const res = await client(url);
85  if (res.status < 200 || res.status >= 300) {
86    throw new Error(`Failed to fetch access token: ${res.status}`);
87  }
88  const data = await res.json<AccessTokenResponse>();
89  if (data.errcode) {
90    throw new Error(`Access token error ${data.errcode}: ${data.errmsg}`);
91  }
92  if (!data.access_token) {
93    throw new Error("No access_token in response");
94  }
95  return data.access_token;
96}
97 
98function toHttpsUrl(url: string | undefined): string {
99  if (!url) return "";
100  return url.startsWith("http://") ? url.replace(/^http:\/\//i, "https://") : url;
101}
102 
103function htmlToPlainText(html: string): string {
104  if (!html) return "";
105 
106  let text = html;
107 
108  // 1. 将 <br>, <br/>, <br /> 替换为换行符
109  text = text.replace(/<br\s*\/?>/gi, "\n");
110 
111  // 2. 将 </p>, </div>, </h1>, </h2>, </h3>, </h4>, </h5>, </h6>, </li> 替换为换行符
112  text = text.replace(/<\/(?:p|div|h[1-6]|li|tr|td|th)>/gi, "\n");
113 
114  // 3. 去掉所有剩余的 HTML 标签
115  text = text.replace(/<[^>]+>/g, "");
116 
117  // 4. 解码 HTML 实体
118  const entityMap: Record<string, string> = {
119    "&nbsp;": " ",
120    "&lt;": "<",
121    "&gt;": ">",
122    "&amp;": "&",
123    "&quot;": '"',
124    "&#39;": "'",
125    "&apos;": "'",
126    "&mdash;": "—",
127    "&ndash;": "–",
128    "&hellip;": "…",
129    "&ldquo;": "“",
130    "&rdquo;": "”",
131    "&lsquo;": "‘",
132    "&rsquo;": "’",
133  };
134  text = text.replace(/&(?:[a-zA-Z]+|#x[0-9a-fA-F]+|#\d+);/g, (entity) => {
135    if (entityMap[entity]) return entityMap[entity];
136    const hexMatch = entity.match(/^&#x([0-9a-fA-F]+);$/);
137    if (hexMatch) {
138      return String.fromCodePoint(Number.parseInt(hexMatch[1]!, 16));
139    }
140    const numMatch = entity.match(/^&#(\d+);$/);
141    if (numMatch) {
142      return String.fromCodePoint(Number.parseInt(numMatch[1]!, 10));
143    }
144    return entity;
145  });
146 
147  // 5. 合并多个连续空白字符（空格、制表符、换行）为一个空格
148  text = text.replace(/[ \t]+/g, " ");
149 
150  // 6. 合并多个连续换行为一个换行
151  text = text.replace(/\n{3,}/g, "\n\n");
152 
153  // 7. 去掉行首行尾空白
154  text = text.split("\n").map(line => line.trim()).join("\n");
155 
156  // 8. 最终 trim
157  return text.trim();
158}
159 
160async function uploadImage(
161  imagePath: string,
162  accessToken: string,
163  baseDir?: string,
164  uploadType: "body" | "material" = "body",
165  client: WechatClient = wechatHttp,
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    client,
191  );
192 
193  // media/uploadimg 接口只返回 URL，material/add_material 返回 media_id
194  if (uploadType === "body") {
195    return {
196      url: toHttpsUrl(result.url),
197      media_id: "",
198    } as UploadResponse;
199  } else {
200    result.url = toHttpsUrl(result.url);
201    return result;
202  }
203}
204 
205async function uploadToWechat(
206  fileBuffer: Buffer,
207  filename: string,
208  contentType: string,
209  accessToken: string,
210  uploadType: "body" | "material",
211  client: WechatClient = wechatHttp,
212): Promise<UploadResponse> {
213  const multipart = buildMultipart([
214    { name: "media", filename, contentType, data: fileBuffer },
215  ]);
216 
217  const uploadUrl = uploadType === "body" ? UPLOAD_BODY_IMG_URL : UPLOAD_MATERIAL_URL;
218  const url = `${uploadUrl}?type=image&access_token=${accessToken}`;
219  const res = await client(url, {
220    method: "POST",
221    headers: { "Content-Type": multipart.contentType },
222    body: multipart.body,
223  });
224 
225  const data = await res.json<UploadResponse>();
226  if (data.errcode && data.errcode !== 0) {
227    throw new Error(`Upload failed ${data.errcode}: ${data.errmsg}`);
228  }
229 
230  return data;
231}
232 
233async function uploadImagesInHtml(
234  html: string,
235  accessToken: string,
236  baseDir: string,
237  contentImages: ImageInfo[] = [],
238  articleType: ArticleType = "news",
239  collectNewsCoverFallback: boolean = false,
240  client: WechatClient = wechatHttp,
241): Promise<{ html: string; firstCoverMediaId: string; imageMediaIds: string[] }> {
242  const imgRegex = /<img[^>]*\ssrc=["']([^"']+)["'][^>]*>/gi;
243  const matches = [...html.matchAll(imgRegex)];
244 
245  if (matches.length === 0 && contentImages.length === 0) {
246    return { html, firstCoverMediaId: "", imageMediaIds: [] };
247  }
248 
249  let firstCoverMediaId = "";
250  let updatedHtml = html;
251  const imageMediaIds: string[] = [];
252  const uploadedBySource = new Map<string, UploadResponse>();
253 
254  for (const match of matches) {
255    const [fullTag, src] = match;
256    if (!src) continue;
257 
258    if (src.startsWith("https://mmbiz.qpic.cn")) {
259      if (collectNewsCoverFallback && !firstCoverMediaId) {
260        try {
261          const coverResp = await uploadImage(src, accessToken, baseDir, "material", client);
262          firstCoverMediaId = coverResp.media_id;
263        } catch (err) {
264          console.error(`[wechat-api] Failed to reuse existing WeChat image as cover: ${src}`, err);
265        }
266      }
267      continue;
268    }
269 
270    const localPathMatch = fullTag.match(/data-local-path=["']([^"']+)["']/);
271    const imagePath = localPathMatch ? localPathMatch[1]! : src;
272 
273    console.error(`[wechat-api] Uploading body image: ${imagePath}`);
274    try {
275      let resp = uploadedBySource.get(imagePath);
276      if (!resp) {
277        resp = await uploadImage(imagePath, accessToken, baseDir, "body", client);
278        uploadedBySource.set(imagePath, resp);
279      }
280      const newTag = fullTag
281        .replace(/\ssrc=["'][^"']+["']/, ` src="${resp.url}"`)
282        .replace(/\sdata-local-path=["'][^"']+["']/, "");
283      updatedHtml = updatedHtml.replace(fullTag, newTag);
284      const shouldUploadMaterial = articleType === "newspic" || (collectNewsCoverFallback && !firstCoverMediaId);
285      if (shouldUploadMaterial) {
286        let materialResp = uploadedBySource.get(`${imagePath}:material`);
287        if (!materialResp) {
288          materialResp = await uploadImage(imagePath, accessToken, baseDir, "material", client);
289          uploadedBySource.set(`${imagePath}:material`, materialResp);
290        }
291        if (articleType === "newspic" && materialResp.media_id) {
292          imageMediaIds.push(materialResp.media_id);
293        }
294        if (collectNewsCoverFallback && !firstCoverMediaId && materialResp.media_id) {
295          firstCoverMediaId = materialResp.media_id;
296        }
297      }
298    } catch (err) {
299      console.error(`[wechat-api] Failed to upload ${imagePath}:`, err);
300    }
301  }
302 
303  for (const image of contentImages) {
304    if (!updatedHtml.includes(image.placeholder)) continue;
305 
306    const imagePath = image.localPath || image.originalPath;
307    console.error(`[wechat-api] Uploading body image: ${imagePath}`);
308 
309    try {
310      let resp = uploadedBySource.get(imagePath);
311      if (!resp) {
312        resp = await uploadImage(imagePath, accessToken, baseDir, "body", client);
313        uploadedBySource.set(imagePath, resp);
314      }
315 
316      const replacementTag = `<img src="${resp.url}" style="display: block; width: 100%; margin: 1.5em auto;">`;
317      updatedHtml = replaceAllPlaceholders(updatedHtml, image.placeholder, replacementTag);
318      const shouldUploadMaterial = articleType === "newspic" || (collectNewsCoverFallback && !firstCoverMediaId);
319      if (shouldUploadMaterial) {
320        let materialResp = uploadedBySource.get(`${imagePath}:material`);
321        if (!materialResp) {
322          materialResp = await uploadImage(imagePath, accessToken, baseDir, "material", client);
323          uploadedBySource.set(`${imagePath}:material`, materialResp);
324        }
325        if (articleType === "newspic" && materialResp.media_id) {
326          imageMediaIds.push(materialResp.media_id);
327        }
328        if (collectNewsCoverFallback && !firstCoverMediaId && materialResp.media_id) {
329          firstCoverMediaId = materialResp.media_id;
330        }
331      }
332    } catch (err) {
333      console.error(`[wechat-api] Failed to upload placeholder ${image.placeholder}:`, err);
334    }
335  }
336 
337  return { html: updatedHtml, firstCoverMediaId, imageMediaIds };
338}
339 
340async function publishToDraft(
341  options: ArticleOptions,
342  accessToken: string,
343  client: WechatClient = wechatHttp,
344): Promise<PublishResponse> {
345  const url = `${DRAFT_URL}?access_token=${accessToken}`;
346 
347  let article: Record<string, unknown>;
348 
349  const noc = options.needOpenComment ?? 1;
350  const ofcc = options.onlyFansCanComment ?? 0;
351 
352  if (options.articleType === "newspic") {
353    if (!options.imageMediaIds || options.imageMediaIds.length === 0) {
354      throw new Error("newspic requires at least one image");
355    }
356    // newspic 的 content 应该是纯文本，需要：
357    // 1. 去掉 HTML 标签
358    // 2. 解码 HTML 实体（&nbsp;、&lt; 等）
359    // 3. 合并多余空白字符
360    const plainContent = htmlToPlainText(options.content);
361    article = {
362      article_type: "newspic",
363      title: options.title,
364      content: plainContent,
365      need_open_comment: noc,
366      only_fans_can_comment: ofcc,
367      image_info: {
368        image_list: options.imageMediaIds.map(id => ({ image_media_id: id })),
369      },
370    };
371    if (options.author) article.author = options.author;
372  } else {
373    article = {
374      article_type: "news",
375      title: options.title,
376      content: options.content,
377      thumb_media_id: options.thumbMediaId,
378      need_open_comment: noc,
379      only_fans_can_comment: ofcc,
380    };
381    if (options.author) article.author = options.author;
382    if (options.digest) article.digest = options.digest;
383    if (options.contentSourceUrl) article.content_source_url = options.contentSourceUrl;
384  }
385 
386  const res = await client(url, {
387    method: "POST",
388    headers: { "Content-Type": "application/json" },
389    body: JSON.stringify({ articles: [article] }),
390  });
391 
392  const data = await res.json<PublishResponse>();
393  if (data.errcode && data.errcode !== 0) {
394    throw new Error(`Publish failed ${data.errcode}: ${data.errmsg}`);
395  }
396 
397  return data;
398}
399 
400function parseFrontmatter(content: string): { frontmatter: Record<string, string>; body: string } {
401  const match = content.match(/^\s*---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
402  if (!match) return { frontmatter: {}, body: content };
403 
404  const frontmatter: Record<string, string> = {};
405  const lines = match[1]!.split("\n");
406  for (const line of lines) {
407    const colonIdx = line.indexOf(":");
408    if (colonIdx > 0) {
409      const key = line.slice(0, colonIdx).trim();
410      let value = line.slice(colonIdx + 1).trim();
411      if ((value.startsWith('"') && value.endsWith('"')) ||
412          (value.startsWith("'") && value.endsWith("'"))) {
413        value = value.slice(1, -1);
414      }
415      frontmatter[key] = value;
416    }
417  }
418 
419  return { frontmatter, body: match[2]! };
420}
421 
422function renderMarkdownWithPlaceholders(
423  markdownPath: string,
424  theme: string = "default",
425  color?: string,
426  citeStatus: boolean = true,
427  title?: string,
428): MarkdownRenderResult {
429  const __filename = fileURLToPath(import.meta.url);
430  const __dirname = path.dirname(__filename);
431  const mdToWechatScript = path.join(__dirname, "md-to-wechat.ts");
432  const baseDir = path.dirname(markdownPath);
433 
434  const args = ["-y", "bun", mdToWechatScript, markdownPath];
435  if (title) args.push("--title", title);
436  if (theme) args.push("--theme", theme);
437  if (color) args.push("--color", color);
438  if (!citeStatus) args.push("--no-cite");
439 
440  console.error(`[wechat-api] Rendering markdown with placeholders via md-to-wechat: ${theme}${color ? `, color: ${color}` : ""}, citeStatus: ${citeStatus}`);
441  const result = spawnSync("npx", args, {
442    stdio: ["inherit", "pipe", "pipe"],
443    cwd: baseDir,
444  });
445 
446  if (result.status !== 0) {
447    const stderr = result.stderr?.toString() || "";
448    throw new Error(`Markdown placeholder render failed: ${stderr}`);
449  }
450 
451  const stdout = result.stdout?.toString() || "";
452  return JSON.parse(stdout) as MarkdownRenderResult;
453}
454 
455function replaceAllPlaceholders(html: string, placeholder: string, replacement: string): string {
456  const escapedPlaceholder = placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
457  return html.replace(new RegExp(escapedPlaceholder + "(?!\\d)", "g"), replacement);
458}
459 
460function extractHtmlContent(htmlPath: string): string {
461  const html = fs.readFileSync(htmlPath, "utf-8");
462  const match = html.match(/<div id="output">([\s\S]*?)<\/div>\s*<\/body>/);
463  if (match) {
464    return match[1]!.trim();
465  }
466  const bodyMatch = html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
467  return bodyMatch ? bodyMatch[1]!.trim() : html;
468}
469 
470function printUsage(): never {
471  console.log(`Publish article to WeChat Official Account draft using API
472 
473Usage:
474  npx -y bun wechat-api.ts <file> [options]
475 
476Arguments:
477  file                Markdown (.md) or HTML (.html) file
478 
479Options:
480  --type <type>       Article type: news (文章, default) or newspic (图文)
481  --title <title>     Override title
482  --author <name>     Author name (max 16 chars)
483  --summary <text>    Article summary/digest (max 128 chars)
484  --source-url <url>  Original article URL ("阅读原文" link, max 1KB)
485  --theme <name>      Theme name for markdown (default, grace, simple, modern). Default: default
486  --color <name|hex>  Primary color (blue, green, vermilion, etc. or hex)
487  --cover <path>      Cover image path (local or URL)
488  --account <alias>   Select account by alias (for multi-account setups)
489  --no-cite           Disable bottom citations for ordinary external links in markdown mode
490  --dry-run           Parse and render only, don't publish
491  --remote            Route WeChat API calls via SSH SOCKS5 tunnel to a whitelisted server
492  --remote-host <h>   Remote server host (implies --remote)
493  --remote-user <u>   SSH user (default: root, implies --remote)
494  --remote-port <n>   SSH port (default: 22, implies --remote)
495  --remote-identity-file <p>           SSH private key path (implies --remote)
496  --remote-known-hosts-file <p>        SSH known_hosts file path (implies --remote)
497  --remote-strict-host-key-checking <yes|no|accept-new> (implies --remote)
498  --remote-connect-timeout <seconds>   SSH ConnectTimeout (implies --remote)
499  --remote-proxy-jump <spec>           SSH ProxyJump value (implies --remote)
500  --help              Show this help
501 
502Frontmatter Fields (markdown):
503  title               Article title
504  author              Author name
505  digest/summary      Article summary
506  sourceUrl/contentSourceUrl/content_source_url   Original article URL
507  coverImage/featureImage/cover/image   Cover image path
508 
509Comments:
510  Comments are enabled by default, open to all users.
511 
512Environment Variables:
513  WECHAT_APP_ID       WeChat App ID
514  WECHAT_APP_SECRET   WeChat App Secret
515 
516Config File Locations (in priority order):
517  1. Environment variables
518  2. <cwd>/.baoyu-skills/.env
519  3. ~/.baoyu-skills/.env
520 
521Example:
522  npx -y bun wechat-api.ts article.md
523  npx -y bun wechat-api.ts article.md --theme grace --cover cover.png
524  npx -y bun wechat-api.ts article.md --author "Author Name" --summary "Brief intro" --source-url "https://example.com/original"
525  npx -y bun wechat-api.ts article.html --title "My Article"
526  npx -y bun wechat-api.ts images/ --type newspic --title "Photo Album"
527  npx -y bun wechat-api.ts article.md --dry-run
528  npx -y bun wechat-api.ts article.md --no-cite
529`);
530  process.exit(0);
531}
532 
533interface CliArgs {
534  filePath: string;
535  isHtml: boolean;
536  articleType: ArticleType;
537  title?: string;
538  author?: string;
539  summary?: string;
540  sourceUrl?: string;
541  theme: string;
542  color?: string;
543  cover?: string;
544  account?: string;
545  citeStatus: boolean;
546  dryRun: boolean;
547  remote: boolean;
548  remoteHost?: string;
549  remoteUser?: string;
550  remotePort?: number;
551  remoteIdentityFile?: string;
552  remoteKnownHostsFile?: string;
553  remoteStrictHostKeyChecking?: StrictHostKeyChecking;
554  remoteConnectTimeout?: number;
555  remoteProxyJump?: string;
556}
557 
558function parseArgs(argv: string[]): CliArgs {
559  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
560    printUsage();
561  }
562 
563  const args: CliArgs = {
564    filePath: "",
565    isHtml: false,
566    articleType: "news",
567    theme: "default",
568    citeStatus: true,
569    dryRun: false,
570    remote: false,
571  };
572 
573  for (let i = 0; i < argv.length; i++) {
574    const arg = argv[i]!;
575    if (arg === "--type" && argv[i + 1]) {
576      const t = argv[++i]!.toLowerCase();
577      if (t === "news" || t === "newspic") {
578        args.articleType = t;
579      }
580    } else if (arg === "--title" && argv[i + 1]) {
581      args.title = argv[++i];
582    } else if (arg === "--author" && argv[i + 1]) {
583      args.author = argv[++i];
584    } else if (arg === "--summary" && argv[i + 1]) {
585      args.summary = argv[++i];
586    } else if (arg === "--source-url" && argv[i + 1]) {
587      args.sourceUrl = argv[++i];
588    } else if (arg === "--theme" && argv[i + 1]) {
589      args.theme = argv[++i]!;
590    } else if (arg === "--color" && argv[i + 1]) {
591      args.color = argv[++i];
592    } else if (arg === "--cover" && argv[i + 1]) {
593      args.cover = argv[++i];
594    } else if (arg === "--account" && argv[i + 1]) {
595      args.account = argv[++i];
596    } else if (arg === "--cite") {
597      args.citeStatus = true;
598    } else if (arg === "--no-cite") {
599      args.citeStatus = false;
600    } else if (arg === "--dry-run") {
601      args.dryRun = true;
602    } else if (arg === "--remote") {
603      args.remote = true;
604    } else if (arg === "--remote-host" && argv[i + 1]) {
605      args.remoteHost = argv[++i];
606      args.remote = true;
607    } else if (arg === "--remote-user" && argv[i + 1]) {
608      args.remoteUser = argv[++i];
609      args.remote = true;
610    } else if (arg === "--remote-port" && argv[i + 1]) {
611      const n = Number.parseInt(argv[++i]!, 10);
612      if (!Number.isInteger(n) || n < 1 || n > 65535) {
613        console.error(`Error: --remote-port must be 1-65535, got ${argv[i]}`);
614        process.exit(1);
615      }
616      args.remotePort = n;
617      args.remote = true;
618    } else if (arg === "--remote-identity-file" && argv[i + 1]) {
619      args.remoteIdentityFile = argv[++i];
620      args.remote = true;
621    } else if (arg === "--remote-known-hosts-file" && argv[i + 1]) {
622      args.remoteKnownHostsFile = argv[++i];
623      args.remote = true;
624    } else if (arg === "--remote-strict-host-key-checking" && argv[i + 1]) {
625      const v = argv[++i]!.toLowerCase();
626      if (v !== "yes" && v !== "no" && v !== "accept-new") {
627        console.error(`Error: --remote-strict-host-key-checking must be yes|no|accept-new, got ${argv[i]}`);
628        process.exit(1);
629      }
630      args.remoteStrictHostKeyChecking = v as StrictHostKeyChecking;
631      args.remote = true;
632    } else if (arg === "--remote-connect-timeout" && argv[i + 1]) {
633      const n = Number.parseInt(argv[++i]!, 10);
634      if (!Number.isInteger(n) || n <= 0) {
635        console.error(`Error: --remote-connect-timeout must be a positive integer, got ${argv[i]}`);
636        process.exit(1);
637      }
638      args.remoteConnectTimeout = n;
639      args.remote = true;
640    } else if (arg === "--remote-proxy-jump" && argv[i + 1]) {
641      args.remoteProxyJump = argv[++i];
642      args.remote = true;
643    } else if (arg.startsWith("--") && argv[i + 1] && !argv[i + 1]!.startsWith("-")) {
644      i++;
645    } else if (!arg.startsWith("-")) {
646      args.filePath = arg;
647    }
648  }
649 
650  if (!args.filePath) {
651    console.error("Error: File path required");
652    process.exit(1);
653  }
654 
655  args.isHtml = args.filePath.toLowerCase().endsWith(".html");
656 
657  return args;
658}
659 
660function extractHtmlTitle(html: string): string {
661  const titleMatch = html.match(/<title>([^<]+)<\/title>/i);
662  if (titleMatch) return titleMatch[1]!;
663  const h1Match = html.match(/<h1[^>]*>([^<]+)<\/h1>/i);
664  if (h1Match) return h1Match[1]!.replace(/<[^>]+>/g, "").trim();
665  return "";
666}
667 
668function buildRemoteConfig(args: CliArgs, resolved: ResolvedAccount): RemotePublishConfig {
669  const host = args.remoteHost ?? resolved.remote_publish_host;
670  if (!host) {
671    throw new Error(
672      "Remote publishing requires a host. Set --remote-host, EXTEND.md remote_publish_host, " +
673      "or an account-level remote_publish_host.",
674    );
675  }
676  return {
677    host,
678    user: args.remoteUser ?? resolved.remote_publish_user,
679    port: args.remotePort ?? resolved.remote_publish_port,
680    identityFile: args.remoteIdentityFile ?? resolved.remote_publish_identity_file,
681    knownHostsFile: args.remoteKnownHostsFile ?? resolved.remote_publish_known_hosts_file,
682    strictHostKeyChecking:
683      args.remoteStrictHostKeyChecking ?? resolved.remote_publish_strict_host_key_checking,
684    connectTimeout: args.remoteConnectTimeout ?? resolved.remote_publish_connect_timeout,
685    proxyJump: args.remoteProxyJump ?? resolved.remote_publish_proxy_jump,
686  };
687}
688 
689async function main(): Promise<void> {
690  const args = parseArgs(process.argv.slice(2));
691 
692  const filePath = path.resolve(args.filePath);
693  if (!fs.existsSync(filePath)) {
694    console.error(`Error: File not found: ${filePath}`);
695    process.exit(1);
696  }
697 
698  const baseDir = path.dirname(filePath);
699  let title = args.title || "";
700  let author = args.author || "";
701  let digest = args.summary || "";
702  let sourceUrl = args.sourceUrl || "";
703  let htmlPath: string;
704  let htmlContent: string;
705  let frontmatter: Record<string, string> = {};
706  let contentImages: ImageInfo[] = [];
707 
708  if (args.isHtml) {
709    htmlPath = filePath;
710    htmlContent = extractHtmlContent(htmlPath);
711    const mdPath = filePath.replace(/\.html$/i, ".md");
712    if (fs.existsSync(mdPath)) {
713      const mdContent = fs.readFileSync(mdPath, "utf-8");
714      const parsed = parseFrontmatter(mdContent);
715      frontmatter = parsed.frontmatter;
716      if (!title && frontmatter.title) title = frontmatter.title;
717      if (!author) author = frontmatter.author || "";
718      if (!digest) digest = frontmatter.digest || frontmatter.summary || frontmatter.description || "";
719      if (!sourceUrl) sourceUrl = frontmatter.sourceUrl || frontmatter.contentSourceUrl || frontmatter.content_source_url || "";
720    }
721    if (!title) {
722      title = extractHtmlTitle(fs.readFileSync(htmlPath, "utf-8"));
723    }
724    console.error(`[wechat-api] Using HTML file: ${htmlPath}`);
725  } else {
726    const content = fs.readFileSync(filePath, "utf-8");
727    const parsed = parseFrontmatter(content);
728    frontmatter = parsed.frontmatter;
729    const body = parsed.body;
730 
731    title = title || frontmatter.title || "";
732    if (!title) {
733      const h1Match = body.match(/^#\s+(.+)$/m);
734      if (h1Match) title = h1Match[1]!;
735    }
736    if (!author) author = frontmatter.author || "";
737    if (!digest) digest = frontmatter.digest || frontmatter.summary || frontmatter.description || "";
738    if (!sourceUrl) sourceUrl = frontmatter.sourceUrl || frontmatter.contentSourceUrl || frontmatter.content_source_url || "";
739 
740    console.error(`[wechat-api] Theme: ${args.theme}${args.color ? `, color: ${args.color}` : ""}, citeStatus: ${args.citeStatus}`);
741    const rendered = renderMarkdownWithPlaceholders(filePath, args.theme, args.color, args.citeStatus, args.title);
742    htmlPath = rendered.htmlPath;
743    contentImages = rendered.contentImages;
744    if (!title) title = rendered.title;
745    if (!author) author = rendered.author;
746    if (!digest) digest = rendered.summary;
747    console.error(`[wechat-api] HTML generated: ${htmlPath}`);
748    console.error(`[wechat-api] Placeholder images: ${contentImages.length}`);
749    htmlContent = extractHtmlContent(htmlPath);
750  }
751 
752  if (!title) {
753    console.error("Error: No title found. Provide via --title, frontmatter, or <title> tag.");
754    process.exit(1);
755  }
756 
757  if (digest && digest.length > 120) {
758    const truncated = digest.slice(0, 117);
759    const lastPunct = Math.max(truncated.lastIndexOf("。"), truncated.lastIndexOf("，"), truncated.lastIndexOf("；"), truncated.lastIndexOf("、"));
760    digest = lastPunct > 80 ? truncated.slice(0, lastPunct + 1) : truncated + "...";
761    console.error(`[wechat-api] Digest truncated to ${digest.length} chars`);
762  }
763 
764  console.error(`[wechat-api] Title: ${title}`);
765  if (author) console.error(`[wechat-api] Author: ${author}`);
766  if (digest) console.error(`[wechat-api] Digest: ${digest.slice(0, 50)}...`);
767  if (sourceUrl) console.error(`[wechat-api] Source URL: ${sourceUrl}`);
768  console.error(`[wechat-api] Type: ${args.articleType}`);
769 
770  const extConfig = loadWechatExtendConfig();
771  const resolved = resolveAccount(extConfig, args.account);
772  if (resolved.name) console.error(`[wechat-api] Account: ${resolved.name} (${resolved.alias})`);
773 
774  if (!author && resolved.default_author) author = resolved.default_author;
775 
776  if (args.dryRun) {
777    console.log(JSON.stringify({
778      articleType: args.articleType,
779      title,
780      author: author || undefined,
781      digest: digest || undefined,
782      sourceUrl: sourceUrl || undefined,
783      htmlPath,
784      contentLength: htmlContent.length,
785      placeholderImageCount: contentImages.length || undefined,
786      account: resolved.alias || undefined,
787    }, null, 2));
788    return;
789  }
790 
791  const creds = loadCredentials(resolved);
792  for (const skippedSource of creds.skippedSources) {
793    console.error(`[wechat-api] Skipped incomplete credential source: ${skippedSource}`);
794  }
795  console.error(`[wechat-api] Credentials source: ${creds.source}`);
796 
797  const rawCoverPath = args.cover ||
798    frontmatter.coverImage ||
799    frontmatter.featureImage ||
800    frontmatter.cover ||
801    frontmatter.image;
802  const coverPath = rawCoverPath && !path.isAbsolute(rawCoverPath) && args.cover
803    ? path.resolve(process.cwd(), rawCoverPath)
804    : rawCoverPath;
805  const needNewsCoverFallback = args.articleType === "news" && !coverPath;
806 
807  const useRemote = args.remote || resolved.default_publish_method === "remote-api";
808  const method = useRemote ? "remote-api" : "api";
809 
810  const publishWith = async (client: WechatClient): Promise<void> => {
811    console.error("[wechat-api] Fetching access token...");
812    const accessToken = await fetchAccessToken(creds.appId, creds.appSecret, client);
813 
814    console.error("[wechat-api] Uploading body images...");
815    const { html: processedHtml, firstCoverMediaId, imageMediaIds } = await uploadImagesInHtml(
816      htmlContent,
817      accessToken,
818      baseDir,
819      contentImages,
820      args.articleType,
821      needNewsCoverFallback,
822      client,
823    );
824    htmlContent = processedHtml;
825 
826    let thumbMediaId = "";
827 
828    if (coverPath) {
829      console.error(`[wechat-api] Uploading cover: ${coverPath}`);
830      const coverResp = await uploadImage(coverPath, accessToken, baseDir, "material", client);
831      thumbMediaId = coverResp.media_id;
832      console.error(`[wechat-api] Cover uploaded successfully, media_id: ${thumbMediaId}`);
833    } else if (firstCoverMediaId && args.articleType === "news") {
834      thumbMediaId = firstCoverMediaId;
835      console.error(`[wechat-api] Using first body image as cover (fallback), media_id: ${thumbMediaId}`);
836    }
837 
838    if (args.articleType === "news" && !thumbMediaId) {
839      throw new Error("No cover image. Provide via --cover, frontmatter.coverImage, or include an image in content.");
840    }
841 
842    if (args.articleType === "newspic" && imageMediaIds.length === 0) {
843      throw new Error("newspic requires at least one image in content.");
844    }
845 
846    console.error("[wechat-api] Publishing to draft...");
847    const result = await publishToDraft({
848      title,
849      author: author || undefined,
850      digest: digest || undefined,
851      content: htmlContent,
852      thumbMediaId,
853      articleType: args.articleType,
854      contentSourceUrl: sourceUrl || undefined,
855      imageMediaIds: args.articleType === "newspic" ? imageMediaIds : undefined,
856      needOpenComment: resolved.need_open_comment,
857      onlyFansCanComment: resolved.only_fans_can_comment,
858    }, accessToken, client);
859 
860    console.log(JSON.stringify({
861      success: true,
862      media_id: result.media_id,
863      title,
864      articleType: args.articleType,
865      method,
866    }, null, 2));
867 
868    console.error(`[wechat-api] Published successfully! media_id: ${result.media_id}`);
869  };
870 
871  if (useRemote) {
872    const remoteConfig = normalizeRemoteConfig(buildRemoteConfig(args, resolved));
873    console.error(
874      `[wechat-api] Remote publishing via ${remoteConfig.user}@${remoteConfig.host}:${remoteConfig.port}`,
875    );
876    await withSshTunnel(remoteConfig, async (client) => {
877      await publishWith(client);
878    });
879  } else {
880    await publishWith(wechatHttp);
881  }
882}
883 
884await main().catch((err) => {
885  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
886  process.exit(1);
887});
888