1import path from "node:path";
2import { mkdir, writeFile } from "node:fs/promises";
3 
4type MediaKind = "image" | "video";
5type MediaHint = "image" | "unknown";
6 
7type MarkdownLinkCandidate = {
8  url: string;
9  hint: MediaHint;
10};
11 
12export type LocalizeMarkdownMediaOptions = {
13  markdownPath: string;
14  log?: (message: string) => void;
15};
16 
17export type LocalizeMarkdownMediaResult = {
18  markdown: string;
19  downloadedImages: number;
20  downloadedVideos: number;
21  imageDir: string | null;
22  videoDir: string | null;
23};
24 
25const MARKDOWN_LINK_RE = /(!?\[[^\]\n]*\])\((<)?(https?:\/\/[^)\s>]+)(>)?\)/g;
26 
27const IMAGE_EXTENSIONS = new Set([
28  "jpg",
29  "jpeg",
30  "png",
31  "webp",
32  "gif",
33  "bmp",
34  "avif",
35  "heic",
36  "heif",
37  "svg",
38]);
39 
40const VIDEO_EXTENSIONS = new Set(["mp4", "m4v", "mov", "webm", "mkv"]);
41 
42const MIME_EXTENSION_MAP: Record<string, string> = {
43  "image/jpeg": "jpg",
44  "image/jpg": "jpg",
45  "image/png": "png",
46  "image/webp": "webp",
47  "image/gif": "gif",
48  "image/bmp": "bmp",
49  "image/avif": "avif",
50  "image/heic": "heic",
51  "image/heif": "heif",
52  "image/svg+xml": "svg",
53  "video/mp4": "mp4",
54  "video/webm": "webm",
55  "video/quicktime": "mov",
56  "video/x-m4v": "m4v",
57};
58 
59const DOWNLOAD_USER_AGENT =
60  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36";
61 
62function normalizeContentType(raw: string | null): string {
63  return raw?.split(";")[0]?.trim().toLowerCase() ?? "";
64}
65 
66function normalizeExtension(raw: string | undefined | null): string | undefined {
67  if (!raw) return undefined;
68  const trimmed = raw.replace(/^\./, "").trim().toLowerCase();
69  if (!trimmed) return undefined;
70  if (trimmed === "jpeg") return "jpg";
71  if (trimmed === "jpg") return "jpg";
72  return trimmed;
73}
74 
75function resolveExtensionFromUrl(rawUrl: string): string | undefined {
76  try {
77    const parsed = new URL(rawUrl);
78    const extFromPath = normalizeExtension(path.posix.extname(parsed.pathname));
79    if (extFromPath) return extFromPath;
80    const extFromFormat = normalizeExtension(parsed.searchParams.get("format"));
81    if (extFromFormat) return extFromFormat;
82  } catch {
83    return undefined;
84  }
85  return undefined;
86}
87 
88function resolveKindFromContentType(contentType: string): MediaKind | undefined {
89  if (!contentType) return undefined;
90  if (contentType.startsWith("image/")) return "image";
91  if (contentType.startsWith("video/")) return "video";
92  return undefined;
93}
94 
95function resolveKindFromExtension(ext: string | undefined): MediaKind | undefined {
96  if (!ext) return undefined;
97  if (IMAGE_EXTENSIONS.has(ext)) return "image";
98  if (VIDEO_EXTENSIONS.has(ext)) return "video";
99  return undefined;
100}
101 
102function resolveKindFromHostname(rawUrl: string): MediaKind | undefined {
103  try {
104    const hostname = new URL(rawUrl).hostname.toLowerCase();
105    if (hostname.includes("video.twimg.com")) return "video";
106    if (hostname.includes("pbs.twimg.com")) return "image";
107  } catch {
108    return undefined;
109  }
110  return undefined;
111}
112 
113function resolveMediaKind(
114  rawUrl: string,
115  contentType: string,
116  extension: string | undefined,
117  hint: MediaHint
118): MediaKind | undefined {
119  const kindFromType = resolveKindFromContentType(contentType);
120  if (kindFromType) return kindFromType;
121 
122  const kindFromExtension = resolveKindFromExtension(extension);
123  if (kindFromExtension) return kindFromExtension;
124 
125  const kindFromHost = resolveKindFromHostname(rawUrl);
126  if (kindFromHost) return kindFromHost;
127 
128  if (contentType && contentType !== "application/octet-stream") {
129    return undefined;
130  }
131 
132  return hint === "image" ? "image" : undefined;
133}
134 
135function resolveOutputExtension(
136  contentType: string,
137  extension: string | undefined,
138  kind: MediaKind
139): string {
140  const extFromMime = normalizeExtension(MIME_EXTENSION_MAP[contentType]);
141  if (extFromMime) return extFromMime;
142 
143  const normalizedExt = normalizeExtension(extension);
144  if (normalizedExt) return normalizedExt;
145 
146  return kind === "video" ? "mp4" : "jpg";
147}
148 
149function safeDecodeURIComponent(value: string): string {
150  try {
151    return decodeURIComponent(value);
152  } catch {
153    return value;
154  }
155}
156 
157function sanitizeFileSegment(input: string): string {
158  return input
159    .replace(/[^a-zA-Z0-9_-]+/g, "-")
160    .replace(/-+/g, "-")
161    .replace(/^[-_]+|[-_]+$/g, "")
162    .slice(0, 48);
163}
164 
165function resolveFileStem(rawUrl: string, extension: string): string {
166  try {
167    const parsed = new URL(rawUrl);
168    const base = path.posix.basename(parsed.pathname);
169    if (!base) return "";
170    const decodedBase = safeDecodeURIComponent(base);
171    const normalizedExt = normalizeExtension(extension);
172    const stripExt = normalizedExt ? new RegExp(`\\.${normalizedExt}$`, "i") : null;
173    const rawStem = stripExt ? decodedBase.replace(stripExt, "") : decodedBase;
174    return sanitizeFileSegment(rawStem);
175  } catch {
176    return "";
177  }
178}
179 
180function buildFileName(kind: MediaKind, index: number, sourceUrl: string, extension: string): string {
181  const stem = resolveFileStem(sourceUrl, extension);
182  const prefix = kind === "image" ? "img" : "video";
183  const serial = String(index).padStart(3, "0");
184  const suffix = stem ? `-${stem}` : "";
185  return `${prefix}-${serial}${suffix}.${extension}`;
186}
187 
188const FRONTMATTER_COVER_RE = /^(coverImage:\s*")(https?:\/\/[^"]+)(")/m;
189 
190function toHighResUrl(rawUrl: string): string {
191  try {
192    const parsed = new URL(rawUrl);
193    if (parsed.hostname !== "pbs.twimg.com") return rawUrl;
194    const ext = path.posix.extname(parsed.pathname).replace(/^\./, "").toLowerCase();
195    if (!ext || !IMAGE_EXTENSIONS.has(ext)) return rawUrl;
196    parsed.pathname = parsed.pathname.replace(new RegExp(`\\.${ext}$`), "");
197    parsed.searchParams.set("format", ext === "jpeg" ? "jpg" : ext);
198    parsed.searchParams.set("name", "4096x4096");
199    return parsed.toString();
200  } catch {
201    return rawUrl;
202  }
203}
204 
205function isPlausibleMediaUrl(rawUrl: string): boolean {
206  const ext = resolveExtensionFromUrl(rawUrl);
207  if (ext && (IMAGE_EXTENSIONS.has(ext) || VIDEO_EXTENSIONS.has(ext))) return true;
208  if (resolveKindFromHostname(rawUrl) !== undefined) return true;
209  return false;
210}
211 
212function collectMarkdownLinkCandidates(markdown: string): MarkdownLinkCandidate[] {
213  const candidates: MarkdownLinkCandidate[] = [];
214  const seen = new Set<string>();
215 
216  const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---/);
217  if (fmMatch) {
218    const coverMatch = fmMatch[1]?.match(FRONTMATTER_COVER_RE);
219    if (coverMatch?.[2] && !seen.has(coverMatch[2])) {
220      seen.add(coverMatch[2]);
221      candidates.push({ url: coverMatch[2], hint: "image" });
222    }
223  }
224 
225  MARKDOWN_LINK_RE.lastIndex = 0;
226  let match: RegExpExecArray | null;
227  while ((match = MARKDOWN_LINK_RE.exec(markdown))) {
228    const label = match[1] ?? "";
229    const rawUrl = match[3] ?? "";
230    if (!rawUrl || seen.has(rawUrl)) continue;
231    const isImage = label.startsWith("![");
232    if (!isImage && !isPlausibleMediaUrl(rawUrl)) continue;
233    seen.add(rawUrl);
234    candidates.push({
235      url: rawUrl,
236      hint: isImage ? "image" : "unknown",
237    });
238  }
239 
240  return candidates;
241}
242 
243function rewriteMarkdownMediaLinks(markdown: string, replacements: Map<string, string>): string {
244  if (replacements.size === 0) return markdown;
245  MARKDOWN_LINK_RE.lastIndex = 0;
246 
247  let result = markdown.replace(MARKDOWN_LINK_RE, (full, label, _openAngle, rawUrl) => {
248    const localPath = replacements.get(rawUrl);
249    if (!localPath) return full;
250    return `${label}(${localPath})`;
251  });
252 
253  result = result.replace(FRONTMATTER_COVER_RE, (full, prefix, rawUrl, suffix) => {
254    const localPath = replacements.get(rawUrl);
255    if (!localPath) return full;
256    return `${prefix}${localPath}${suffix}`;
257  });
258 
259  return result;
260}
261 
262export async function localizeMarkdownMedia(
263  markdown: string,
264  options: LocalizeMarkdownMediaOptions
265): Promise<LocalizeMarkdownMediaResult> {
266  const log = options.log ?? (() => {});
267  const markdownDir = path.dirname(options.markdownPath);
268  const candidates = collectMarkdownLinkCandidates(markdown);
269 
270  if (candidates.length === 0) {
271    return {
272      markdown,
273      downloadedImages: 0,
274      downloadedVideos: 0,
275      imageDir: null,
276      videoDir: null,
277    };
278  }
279 
280  const replacements = new Map<string, string>();
281  let downloadedImages = 0;
282  let downloadedVideos = 0;
283 
284  for (const candidate of candidates) {
285    try {
286      const downloadUrl = toHighResUrl(candidate.url);
287      const response = await fetch(downloadUrl, {
288        method: "GET",
289        redirect: "follow",
290        headers: {
291          "user-agent": DOWNLOAD_USER_AGENT,
292        },
293      });
294 
295      if (!response.ok) {
296        log(`[x-to-markdown] Skip media (${response.status}): ${candidate.url}`);
297        continue;
298      }
299 
300      const sourceUrl = response.url || candidate.url;
301      const contentType = normalizeContentType(response.headers.get("content-type"));
302      const extension = resolveExtensionFromUrl(sourceUrl) ?? resolveExtensionFromUrl(candidate.url);
303      const kind = resolveMediaKind(sourceUrl, contentType, extension, candidate.hint);
304      if (!kind) {
305        continue;
306      }
307 
308      const outputExtension = resolveOutputExtension(contentType, extension, kind);
309      const nextIndex = kind === "image" ? downloadedImages + 1 : downloadedVideos + 1;
310      const dirName = kind === "image" ? "imgs" : "videos";
311      const targetDir = path.join(markdownDir, dirName);
312      await mkdir(targetDir, { recursive: true });
313 
314      const fileName = buildFileName(kind, nextIndex, sourceUrl, outputExtension);
315      const absolutePath = path.join(targetDir, fileName);
316      const relativePath = path.posix.join(dirName, fileName);
317      const bytes = Buffer.from(await response.arrayBuffer());
318      await writeFile(absolutePath, bytes);
319      replacements.set(candidate.url, relativePath);
320 
321      if (kind === "image") {
322        downloadedImages = nextIndex;
323      } else {
324        downloadedVideos = nextIndex;
325      }
326    } catch (error) {
327      const message = error instanceof Error ? error.message : String(error ?? "");
328      log(`[x-to-markdown] Failed to download media ${candidate.url}: ${message}`);
329    }
330  }
331 
332  return {
333    markdown: rewriteMarkdownMediaLinks(markdown, replacements),
334    downloadedImages,
335    downloadedVideos,
336    imageDir: downloadedImages > 0 ? path.join(markdownDir, "imgs") : null,
337    videoDir: downloadedVideos > 0 ? path.join(markdownDir, "videos") : null,
338  };
339}
340