1import fs from 'node:fs';
2import { mkdir, writeFile } from 'node:fs/promises';
3import https from 'node:https';
4import os from 'node:os';
5import path from 'node:path';
6import process from 'node:process';
7import { createHash } from 'node:crypto';
8import { pathToFileURL } from 'node:url';
9 
10import frontMatter from 'front-matter';
11import hljs from 'highlight.js/lib/common';
12import { Lexer, Marked, type RendererObject, type Tokens } from 'marked';
13import { unified } from 'unified';
14import remarkCjkFriendly from 'remark-cjk-friendly';
15import remarkParse from 'remark-parse';
16import remarkStringify from 'remark-stringify';
17 
18interface ImageInfo {
19  placeholder: string;
20  localPath: string;
21  originalPath: string;
22  blockIndex: number;
23}
24 
25interface ParsedMarkdown {
26  title: string;
27  coverImage: string | null;
28  contentImages: ImageInfo[];
29  html: string;
30  totalBlocks: number;
31}
32 
33type FrontmatterFields = Record<string, unknown>;
34 
35function parseFrontmatter(content: string): { frontmatter: FrontmatterFields; body: string } {
36  try {
37    const parsed = frontMatter<FrontmatterFields>(content);
38    return {
39      frontmatter: parsed.attributes ?? {},
40      body: parsed.body,
41    };
42  } catch {
43    return { frontmatter: {}, body: content };
44  }
45}
46 
47function stripWrappingQuotes(value: string): string {
48  if (!value) return value;
49  const doubleQuoted = value.startsWith('"') && value.endsWith('"');
50  const singleQuoted = value.startsWith("'") && value.endsWith("'");
51  const cjkDoubleQuoted = value.startsWith('\u201c') && value.endsWith('\u201d');
52  const cjkSingleQuoted = value.startsWith('\u2018') && value.endsWith('\u2019');
53  if (doubleQuoted || singleQuoted || cjkDoubleQuoted || cjkSingleQuoted) {
54    return value.slice(1, -1).trim();
55  }
56  return value.trim();
57}
58 
59function toFrontmatterString(value: unknown): string | undefined {
60  if (typeof value === 'string') {
61    return stripWrappingQuotes(value);
62  }
63  if (typeof value === 'number' || typeof value === 'boolean') {
64    return String(value);
65  }
66  return undefined;
67}
68 
69function pickFirstString(frontmatter: FrontmatterFields, keys: string[]): string | undefined {
70  for (const key of keys) {
71    const value = toFrontmatterString(frontmatter[key]);
72    if (value) return value;
73  }
74  return undefined;
75}
76 
77function findCoverImageNearMarkdown(baseDir: string): string | null {
78  const candidateDirs = [baseDir, path.join(baseDir, 'imgs')];
79  const coverPattern = /^cover\.(png|jpe?g|webp)$/i;
80 
81  for (const dir of candidateDirs) {
82    try {
83      if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
84        continue;
85      }
86 
87      const match = fs.readdirSync(dir).find((entry) => coverPattern.test(entry));
88      if (match) {
89        return path.join(dir, match);
90      }
91    } catch {
92      continue;
93    }
94  }
95 
96  return null;
97}
98 
99function extractTitleFromMarkdown(markdown: string): string {
100  const tokens = Lexer.lex(markdown, { gfm: true, breaks: true });
101  for (const token of tokens) {
102    if (token.type === 'heading' && token.depth === 1) {
103      return stripWrappingQuotes(token.text);
104    }
105  }
106  return '';
107}
108 
109function downloadFile(url: string, destPath: string, maxRedirects = 5): Promise<void> {
110  return new Promise((resolve, reject) => {
111    if (!url.startsWith('https://')) {
112      reject(new Error(`Refusing non-HTTPS download: ${url}`));
113      return;
114    }
115    if (maxRedirects <= 0) {
116      reject(new Error('Too many redirects'));
117      return;
118    }
119    const file = fs.createWriteStream(destPath);
120 
121    const request = https.get(url, { headers: { 'User-Agent': 'Mozilla/5.0' } }, (response) => {
122      if (response.statusCode === 301 || response.statusCode === 302) {
123        const redirectUrl = response.headers.location;
124        if (redirectUrl) {
125          file.close();
126          fs.unlinkSync(destPath);
127          downloadFile(redirectUrl, destPath, maxRedirects - 1).then(resolve).catch(reject);
128          return;
129        }
130      }
131 
132      if (response.statusCode !== 200) {
133        file.close();
134        fs.unlinkSync(destPath);
135        reject(new Error(`Failed to download: ${response.statusCode}`));
136        return;
137      }
138 
139      response.pipe(file);
140      file.on('finish', () => {
141        file.close();
142        resolve();
143      });
144    });
145 
146    request.on('error', (err) => {
147      file.close();
148      fs.unlink(destPath, () => {});
149      reject(err);
150    });
151 
152    request.setTimeout(30000, () => {
153      request.destroy();
154      reject(new Error('Download timeout'));
155    });
156  });
157}
158 
159function getImageExtension(urlOrPath: string): string {
160  const match = urlOrPath.match(/\.(jpg|jpeg|png|gif|webp)(\?|$)/i);
161  return match ? match[1]!.toLowerCase() : 'png';
162}
163 
164async function resolveImagePath(imagePath: string, baseDir: string, tempDir: string): Promise<string> {
165  if (imagePath.startsWith('http://')) {
166    console.error(`[md-to-html] Skipping non-HTTPS image: ${imagePath}`);
167    return '';
168  }
169  if (imagePath.startsWith('https://')) {
170    const hash = createHash('md5').update(imagePath).digest('hex').slice(0, 8);
171    const ext = getImageExtension(imagePath);
172    const localPath = path.join(tempDir, `remote_${hash}.${ext}`);
173 
174    if (!fs.existsSync(localPath)) {
175      console.error(`[md-to-html] Downloading: ${imagePath}`);
176      await downloadFile(imagePath, localPath);
177    }
178    return localPath;
179  }
180 
181  if (path.isAbsolute(imagePath)) {
182    return imagePath;
183  }
184 
185  return path.resolve(baseDir, imagePath);
186}
187 
188function escapeHtml(text: string): string {
189  return text
190    .replace(/&/g, '&amp;')
191    .replace(/</g, '&lt;')
192    .replace(/>/g, '&gt;')
193    .replace(/"/g, '&quot;')
194    .replace(/'/g, '&#39;');
195}
196 
197function highlightCode(code: string, lang: string): string {
198  try {
199    if (lang && hljs.getLanguage(lang)) {
200      return hljs.highlight(code, { language: lang, ignoreIllegals: true }).value;
201    }
202    return hljs.highlightAuto(code).value;
203  } catch {
204    return escapeHtml(code);
205  }
206}
207 
208function preprocessCjkMarkdown(markdown: string): string {
209  try {
210    const processor = unified()
211      .use(remarkParse)
212      .use(remarkCjkFriendly)
213      .use(remarkStringify);
214 
215    const result = String(processor.processSync(markdown));
216    return result.replace(/&#x([0-9A-Fa-f]+);/g, (_, hex: string) => String.fromCodePoint(parseInt(hex, 16)));
217  } catch {
218    return markdown;
219  }
220}
221 
222function convertMarkdownToHtml(markdown: string, imageCallback: (src: string, alt: string) => string): { html: string; totalBlocks: number } {
223  const preprocessedMarkdown = preprocessCjkMarkdown(markdown);
224  const blockTokens = Lexer.lex(preprocessedMarkdown, { gfm: true, breaks: true });
225 
226  const renderer: RendererObject = {
227    heading({ depth, tokens }: Tokens.Heading): string {
228      if (depth === 1) {
229        return '';
230      }
231      return `<h2>${this.parser.parseInline(tokens)}</h2>`;
232    },
233 
234    paragraph({ tokens }: Tokens.Paragraph): string {
235      const text = this.parser.parseInline(tokens).trim();
236      if (!text) return '';
237      return `<p>${text}</p>`;
238    },
239 
240    blockquote({ tokens }: Tokens.Blockquote): string {
241      return `<blockquote>${this.parser.parse(tokens)}</blockquote>`;
242    },
243 
244    code({ text, lang = '' }: Tokens.Code): string {
245      const language = lang.split(/\s+/)[0]!.toLowerCase();
246      const source = text.replace(/\n$/, '');
247      const highlighted = highlightCode(source, language).replace(/\n/g, '<br>');
248      const label = language ? `<strong>[${escapeHtml(language)}]</strong><br>` : '';
249      return `<blockquote>${label}${highlighted}</blockquote>`;
250    },
251 
252    image({ href, text }: Tokens.Image): string {
253      if (!href) return '';
254      return imageCallback(href, text ?? '');
255    },
256 
257    link({ href, title, tokens, text }: Tokens.Link): string {
258      const label = tokens?.length ? this.parser.parseInline(tokens) : escapeHtml(text || href || '');
259      if (!href) return label;
260 
261      const titleAttr = title ? ` title="${escapeHtml(title)}"` : '';
262      return `<a href="${escapeHtml(href)}"${titleAttr} rel="noopener noreferrer nofollow">${label}</a>`;
263    },
264  };
265 
266  const parser = new Marked({
267    gfm: true,
268    breaks: true,
269  });
270  parser.use({ renderer });
271 
272  const rendered = parser.parse(preprocessedMarkdown);
273  if (typeof rendered !== 'string') {
274    throw new Error('Unexpected async markdown parse result');
275  }
276 
277  const totalBlocks = blockTokens.filter((token) => {
278    if (token.type === 'space') return false;
279    if (token.type === 'heading' && token.depth === 1) return false;
280    return true;
281  }).length;
282 
283  return {
284    html: rendered,
285    totalBlocks,
286  };
287}
288 
289export async function parseMarkdown(
290  markdownPath: string,
291  options?: { coverImage?: string; title?: string; tempDir?: string },
292): Promise<ParsedMarkdown> {
293  const content = fs.readFileSync(markdownPath, 'utf-8');
294  const baseDir = path.dirname(markdownPath);
295  const tempDir = options?.tempDir ?? path.join(os.tmpdir(), 'x-article-images');
296 
297  await mkdir(tempDir, { recursive: true });
298 
299  const { frontmatter, body } = parseFrontmatter(content);
300 
301  let title = stripWrappingQuotes(options?.title ?? '') || pickFirstString(frontmatter, ['title']) || '';
302  if (!title) {
303    title = extractTitleFromMarkdown(body);
304  }
305  if (!title) {
306    title = path.basename(markdownPath, path.extname(markdownPath));
307  }
308 
309  let coverImagePath = stripWrappingQuotes(options?.coverImage ?? '') || pickFirstString(frontmatter, [
310    'cover_image',
311    'coverImage',
312    'cover',
313    'image',
314    'featureImage',
315    'feature_image',
316  ]) || null;
317  if (!coverImagePath) {
318    coverImagePath = findCoverImageNearMarkdown(baseDir);
319  }
320 
321  const images: Array<{ src: string; alt: string; blockIndex: number }> = [];
322  let imageCounter = 0;
323 
324  const { html, totalBlocks } = convertMarkdownToHtml(body, (src, alt) => {
325    const placeholder = `XIMGPH_${++imageCounter}`;
326    images.push({ src, alt, blockIndex: -1 });
327    return placeholder;
328  });
329 
330  const htmlLines = html.split('\n');
331  for (let i = 0; i < images.length; i++) {
332    const placeholder = `XIMGPH_${i + 1}`;
333    for (let lineIndex = 0; lineIndex < htmlLines.length; lineIndex++) {
334      const regex = new RegExp(`\\b${placeholder}\\b`);
335      if (regex.test(htmlLines[lineIndex]!)) {
336        images[i]!.blockIndex = lineIndex;
337        break;
338      }
339    }
340  }
341 
342  const contentImages: ImageInfo[] = [];
343  let firstImageAsCover: string | null = null;
344 
345  for (let i = 0; i < images.length; i++) {
346    const img = images[i]!;
347    const localPath = await resolveImagePath(img.src, baseDir, tempDir);
348 
349    if (i === 0 && !coverImagePath) {
350      firstImageAsCover = localPath;
351    }
352 
353    contentImages.push({
354      placeholder: `XIMGPH_${i + 1}`,
355      localPath,
356      originalPath: img.src,
357      blockIndex: img.blockIndex,
358    });
359  }
360 
361  const finalHtml = html.replace(/\n{3,}/g, '\n\n').trim();
362 
363  let resolvedCoverImage: string | null = null;
364  if (coverImagePath) {
365    resolvedCoverImage = await resolveImagePath(coverImagePath, baseDir, tempDir);
366  } else if (firstImageAsCover) {
367    resolvedCoverImage = firstImageAsCover;
368  }
369 
370  return {
371    title,
372    coverImage: resolvedCoverImage,
373    contentImages,
374    html: finalHtml,
375    totalBlocks,
376  };
377}
378 
379function printUsage(): never {
380  console.log(`Convert Markdown to HTML for X Article publishing
381 
382Usage:
383  npx -y bun md-to-html.ts <markdown_file> [options]
384 
385Options:
386  --title <title>       Override title from frontmatter
387  --cover <image>       Override cover image from frontmatter
388  --output <json|html>  Output format (default: json)
389  --html-only           Output only the HTML content
390  --save-html <path>    Save HTML to file
391 
392Frontmatter fields:
393  title: Article title (or use first H1)
394  cover_image: Cover image path or URL
395  cover: Alias for cover_image
396  image: Alias for cover_image
397 
398Example:
399  npx -y bun md-to-html.ts article.md --output json
400  npx -y bun md-to-html.ts article.md --html-only > /tmp/article.html
401  npx -y bun md-to-html.ts article.md --save-html /tmp/article.html
402`);
403  process.exit(0);
404}
405 
406async function main(): Promise<void> {
407  const args = process.argv.slice(2);
408  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
409    printUsage();
410  }
411 
412  let markdownPath: string | undefined;
413  let title: string | undefined;
414  let coverImage: string | undefined;
415  let outputFormat: 'json' | 'html' = 'json';
416  let htmlOnly = false;
417  let saveHtmlPath: string | undefined;
418 
419  for (let i = 0; i < args.length; i++) {
420    const arg = args[i]!;
421    if (arg === '--title' && args[i + 1]) {
422      title = args[++i];
423    } else if (arg === '--cover' && args[i + 1]) {
424      coverImage = args[++i];
425    } else if (arg === '--output' && args[i + 1]) {
426      outputFormat = args[++i] as 'json' | 'html';
427    } else if (arg === '--html-only') {
428      htmlOnly = true;
429    } else if (arg === '--save-html' && args[i + 1]) {
430      saveHtmlPath = args[++i];
431    } else if (!arg.startsWith('-')) {
432      markdownPath = arg;
433    }
434  }
435 
436  if (!markdownPath) {
437    console.error('Error: Markdown file path required');
438    process.exit(1);
439  }
440 
441  if (!fs.existsSync(markdownPath)) {
442    console.error(`Error: File not found: ${markdownPath}`);
443    process.exit(1);
444  }
445 
446  const result = await parseMarkdown(markdownPath, { title, coverImage });
447 
448  if (saveHtmlPath) {
449    await writeFile(saveHtmlPath, result.html, 'utf-8');
450    console.error(`[md-to-html] HTML saved to: ${saveHtmlPath}`);
451  }
452 
453  if (htmlOnly) {
454    console.log(result.html);
455  } else if (outputFormat === 'html') {
456    console.log(result.html);
457  } else {
458    console.log(JSON.stringify(result, null, 2));
459  }
460}
461 
462if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
463  await main().catch((err) => {
464    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
465    process.exit(1);
466  });
467}
468