1import fs from "node:fs";
2import os from "node:os";
3import path from "node:path";
4import process from "node:process";
5 
6import {
7  extractSummaryFromBody,
8  extractTitleFromMarkdown,
9  parseFrontmatter,
10  pickFirstString,
11  preprocessMermaidInMarkdown,
12  renderMarkdownDocument,
13  replaceMarkdownImagesWithPlaceholders,
14  resolveColorToken,
15  resolveContentImages,
16  resolveImagePath,
17  serializeFrontmatter,
18  stripWrappingQuotes,
19} from "baoyu-md";
20import { closeRenderer, renderMermaidToPng } from "baoyu-chrome-cdp/mermaid";
21 
22interface ImageInfo {
23  placeholder: string;
24  localPath: string;
25  originalPath: string;
26  alt?: string;
27}
28 
29interface ParsedMarkdown {
30  title: string;
31  summary: string;
32  shortSummary: string;
33  coverImage: string | null;
34  contentImages: ImageInfo[];
35  html: string;
36}
37 
38export async function parseMarkdown(
39  markdownPath: string,
40  options?: {
41    coverImage?: string;
42    title?: string;
43    tempDir?: string;
44    theme?: string;
45    color?: string;
46    citeStatus?: boolean;
47  },
48): Promise<ParsedMarkdown> {
49  const content = fs.readFileSync(markdownPath, "utf-8");
50  const baseDir = path.dirname(markdownPath);
51  const tempDir = options?.tempDir ?? fs.mkdtempSync(path.join(os.tmpdir(), "weibo-article-images-"));
52 
53  const { frontmatter, body } = parseFrontmatter(content);
54 
55  let title = stripWrappingQuotes(options?.title ?? "")
56    || stripWrappingQuotes(frontmatter.title ?? "")
57    || extractTitleFromMarkdown(body);
58  if (!title) {
59    title = path.basename(markdownPath, path.extname(markdownPath));
60  }
61 
62  let summary = stripWrappingQuotes(frontmatter.summary ?? "")
63    || stripWrappingQuotes(frontmatter.description ?? "")
64    || stripWrappingQuotes(frontmatter.excerpt ?? "");
65  if (!summary) {
66    summary = extractSummaryFromBody(body, 44);
67  }
68  const shortSummary = extractSummaryFromBody(body, 44);
69 
70  const coverImagePath = stripWrappingQuotes(options?.coverImage ?? "")
71    || pickFirstString(frontmatter, ["featureImage", "cover_image", "coverImage", "cover", "image"])
72    || null;
73 
74  const { markdown: mermaidProcessedBody, images: mermaidImages } =
75    await preprocessMermaidInMarkdown(body, {
76      baseDir,
77      renderFn: renderMermaidToPng,
78      onError: (error, block) => {
79        const message = error instanceof Error ? error.message : String(error);
80        console.error(
81          `[md-to-html] mermaid render failed (${block.code.slice(0, 40).replace(/\s+/g, " ")}…): ${message}`,
82        );
83      },
84    });
85 
86  if (mermaidImages.length > 0) {
87    const fresh = mermaidImages.filter((image) => !image.cached).length;
88    console.error(
89      `[md-to-html] mermaid: ${mermaidImages.length} block(s), ${fresh} rendered, ${mermaidImages.length - fresh} cached`,
90    );
91  }
92 
93  const { images, markdown: rewrittenBody } = replaceMarkdownImagesWithPlaceholders(
94    mermaidProcessedBody,
95    "WBIMGPH_",
96  );
97  const rewrittenMarkdown = `${serializeFrontmatter(frontmatter)}${rewrittenBody}`;
98 
99  const { html } = await renderMarkdownDocument(rewrittenMarkdown, {
100    citeStatus: options?.citeStatus ?? false,
101    defaultTitle: title,
102    keepTitle: false,
103    primaryColor: resolveColorToken(options?.color),
104    theme: options?.theme,
105  });
106 
107  const contentImages = await resolveContentImages(images, baseDir, tempDir, "md-to-html");
108 
109  let resolvedCoverImage: string | null = null;
110  if (coverImagePath) {
111    resolvedCoverImage = await resolveImagePath(coverImagePath, baseDir, tempDir, "md-to-html");
112  }
113 
114  return {
115    title,
116    summary,
117    shortSummary,
118    coverImage: resolvedCoverImage,
119    contentImages,
120    html,
121  };
122}
123 
124async function main(): Promise<void> {
125  const args = process.argv.slice(2);
126  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
127    console.log(`Convert Markdown to HTML for Weibo article publishing
128 
129Usage:
130  npx -y bun md-to-html.ts <markdown_file> [options]
131 
132Options:
133  --title <title>       Override title
134  --cover <image>       Override cover image
135  --output <json|html>  Output format (default: json)
136  --html-only           Output only the HTML content
137  --save-html <path>    Save HTML to file
138  --help                Show this help
139`);
140    process.exit(0);
141  }
142 
143  let markdownPath: string | undefined;
144  let title: string | undefined;
145  let coverImage: string | undefined;
146  let outputFormat: "json" | "html" = "json";
147  let htmlOnly = false;
148  let saveHtmlPath: string | undefined;
149 
150  for (let i = 0; i < args.length; i++) {
151    const arg = args[i]!;
152    if (arg === "--title" && args[i + 1]) {
153      title = args[++i];
154    } else if (arg === "--cover" && args[i + 1]) {
155      coverImage = args[++i];
156    } else if (arg === "--output" && args[i + 1]) {
157      outputFormat = args[++i] as "json" | "html";
158    } else if (arg === "--html-only") {
159      htmlOnly = true;
160    } else if (arg === "--save-html" && args[i + 1]) {
161      saveHtmlPath = args[++i];
162    } else if (!arg.startsWith("-")) {
163      markdownPath = arg;
164    }
165  }
166 
167  if (!markdownPath || !fs.existsSync(markdownPath)) {
168    console.error("Error: Valid markdown file path required");
169    process.exit(1);
170  }
171 
172  const result = await parseMarkdown(markdownPath, { title, coverImage });
173 
174  if (saveHtmlPath) {
175    fs.writeFileSync(saveHtmlPath, result.html, "utf-8");
176    console.error(`[md-to-html] HTML saved to: ${saveHtmlPath}`);
177  }
178 
179  if (htmlOnly || outputFormat === "html") {
180    console.log(result.html);
181  } else {
182    console.log(JSON.stringify(result, null, 2));
183  }
184}
185 
186if (import.meta.main ?? (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(import.meta.filename ?? ""))) {
187  try {
188    await main();
189  } catch (error) {
190    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
191    process.exitCode = 1;
192  } finally {
193    await closeRenderer();
194  }
195}
196