1import fs from 'node:fs';
2import path from 'node:path';
3import { spawnSync } from 'node:child_process';
4import process from 'node:process';
5import { fileURLToPath } from 'node:url';
6import { launchChrome, tryConnectExisting, findExistingChromeDebugPort, getPageSession, waitForNewTab, clickElement, typeText, evaluate, sleep, getAccountProfileDir, type ChromeSession, type CdpConnection } from './cdp.ts';
7import { loadWechatExtendConfig, resolveAccount } from './wechat-extend-config.ts';
8 
9const WECHAT_URL = 'https://mp.weixin.qq.com/';
10 
11interface ImageInfo {
12  placeholder: string;
13  localPath: string;
14  originalPath: string;
15}
16 
17interface ArticleOptions {
18  title: string;
19  content?: string;
20  htmlFile?: string;
21  markdownFile?: string;
22  theme?: string;
23  color?: string;
24  citeStatus?: boolean;
25  author?: string;
26  summary?: string;
27  images?: string[];
28  contentImages?: ImageInfo[];
29  submit?: boolean;
30  profileDir?: string;
31  cdpPort?: number;
32}
33 
34async function sendQrToTelegram(session: ChromeSession): Promise<void> {
35  const botToken = process.env.TELEGRAM_BOT_TOKEN;
36  const chatId = process.env.TELEGRAM_CHAT_ID;
37  if (!botToken || !chatId) return;
38 
39  // Wait for QR to render before extracting
40  await sleep(2000);
41 
42  try {
43    // Try to extract QR image from DOM first (avoids full-page screenshot noise)
44    const domResult = await session.cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
45      expression: `
46        (function() {
47          const selectors = [
48            '.login__type__container__scan img',
49            '.login_img img',
50            '#login_container img',
51            '.qrcode img',
52            'img[src*="qrcode"]',
53            'img[src*="login"]',
54          ];
55          for (const sel of selectors) {
56            const el = document.querySelector(sel);
57            if (el?.src && !el.src.startsWith('data:,')) return el.src.startsWith('data:') ? el.src : 'url:' + el.src;
58          }
59          const canvas = document.querySelector('canvas');
60          if (canvas) try { return canvas.toDataURL('image/png'); } catch {}
61          return '';
62        })()
63      `,
64      returnByValue: true,
65    }, { sessionId: session.sessionId });
66 
67    const raw = (domResult.result.value as string) ?? '';
68    let imgBuffer: Buffer;
69 
70    if (raw.startsWith('data:image')) {
71      imgBuffer = Buffer.from(raw.split(',')[1] ?? '', 'base64');
72    } else if (raw.startsWith('url:')) {
73      // Fetch inside Chrome to carry WeChat session cookies
74      const imgUrl = raw.slice(4);
75      const inBrowserFetch = await session.cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
76        expression: `
77          (async () => {
78            const resp = await fetch(${JSON.stringify(imgUrl)}, { credentials: 'include' });
79            const buf = await resp.arrayBuffer();
80            const bytes = new Uint8Array(buf);
81            let b = '';
82            for (let i = 0; i < bytes.length; i++) b += String.fromCharCode(bytes[i]);
83            return btoa(b);
84          })()
85        `,
86        returnByValue: true,
87        awaitPromise: true,
88      }, { sessionId: session.sessionId });
89      imgBuffer = Buffer.from((inBrowserFetch.result.value as string) ?? '', 'base64');
90    } else {
91      // Fallback: viewport screenshot (smaller than full-page; QR is usually in viewport)
92      const screenshotResp = await session.cdp.send<{ data: string }>(
93        'Page.captureScreenshot', { format: 'png', captureBeyondViewport: false }, { sessionId: session.sessionId }
94      );
95      imgBuffer = Buffer.from(screenshotResp.data ?? '', 'base64');
96    }
97 
98    const boundary = `tgboundary${Date.now()}`;
99    const parts: Buffer[] = [
100      Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="chat_id"\r\n\r\n${chatId}\r\n`),
101      Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="caption"\r\n\r\nWeChat QR code — please scan to log in\r\n`),
102      Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="photo"; filename="qr.png"\r\nContent-Type: image/png\r\n\r\n`),
103      imgBuffer,
104      Buffer.from(`\r\n--${boundary}--\r\n`),
105    ];
106    const tgResp = await fetch(`https://api.telegram.org/bot${botToken}/sendPhoto`, {
107      method: 'POST',
108      headers: { 'Content-Type': `multipart/form-data; boundary=${boundary}` },
109      body: Buffer.concat(parts),
110      signal: AbortSignal.timeout(10_000),
111    });
112    const tgJson = await tgResp.json() as { ok: boolean; description?: string };
113    if (tgJson.ok) {
114      console.log('[wechat] QR code sent to Telegram.');
115    } else {
116      console.error('[wechat] Telegram send failed:', tgJson.description);
117    }
118  } catch (err) {
119    console.error('[wechat] Failed to send QR to Telegram:', err);
120  }
121}
122 
123async function waitForLogin(session: ChromeSession, timeoutMs = 120_000): Promise<boolean> {
124  // Notify via Telegram if configured (no-op when env vars absent)
125  await sendQrToTelegram(session);
126  const start = Date.now();
127  while (Date.now() - start < timeoutMs) {
128    const url = await evaluate<string>(session, 'window.location.href');
129    if (url.includes('/cgi-bin/home')) return true;
130    await sleep(2000);
131  }
132  return false;
133}
134 
135async function waitForElement(session: ChromeSession, selector: string, timeoutMs = 10_000): Promise<boolean> {
136  const start = Date.now();
137  while (Date.now() - start < timeoutMs) {
138    const found = await evaluate<boolean>(session, `!!document.querySelector('${selector}')`);
139    if (found) return true;
140    await sleep(500);
141  }
142  return false;
143}
144 
145async function clickMenuByText(session: ChromeSession, text: string, maxRetries = 5): Promise<void> {
146  console.log(`[wechat] Clicking "${text}" menu...`);
147  for (let attempt = 1; attempt <= maxRetries; attempt++) {
148    const posResult = await session.cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
149      expression: `
150        (function() {
151          const items = document.querySelectorAll('.new-creation__menu .new-creation__menu-item');
152          for (const item of items) {
153            const title = item.querySelector('.new-creation__menu-title');
154            if (title && title.textContent?.trim() === '${text}') {
155              item.scrollIntoView({ block: 'center' });
156              const rect = item.getBoundingClientRect();
157              return JSON.stringify({ x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 });
158            }
159          }
160          return 'null';
161        })()
162      `,
163      returnByValue: true,
164    }, { sessionId: session.sessionId });
165 
166    if (posResult.result.value !== 'null') {
167      const pos = JSON.parse(posResult.result.value);
168      await session.cdp.send('Input.dispatchMouseEvent', { type: 'mousePressed', x: pos.x, y: pos.y, button: 'left', clickCount: 1 }, { sessionId: session.sessionId });
169      await sleep(100);
170      await session.cdp.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x: pos.x, y: pos.y, button: 'left', clickCount: 1 }, { sessionId: session.sessionId });
171      return;
172    }
173 
174    if (attempt < maxRetries) {
175      const delay = Math.min(1000 * attempt, 3000);
176      console.log(`[wechat] Menu "${text}" not found, retrying in ${delay}ms (${attempt}/${maxRetries})...`);
177      await sleep(delay);
178    }
179  }
180  throw new Error(`Menu "${text}" not found after ${maxRetries} attempts`);
181}
182 
183async function copyImageToClipboard(imagePath: string): Promise<void> {
184  const __filename = fileURLToPath(import.meta.url);
185  const __dirname = path.dirname(__filename);
186  const copyScript = path.join(__dirname, './copy-to-clipboard.ts');
187  const result = spawnSync('npx', ['-y', 'bun', copyScript, 'image', imagePath], { stdio: 'inherit' });
188  if (result.status !== 0) throw new Error(`Failed to copy image: ${imagePath}`);
189}
190 
191async function pasteInEditor(session: ChromeSession): Promise<void> {
192  const modifiers = process.platform === 'darwin' ? 4 : 2;
193  await session.cdp.send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'v', code: 'KeyV', modifiers, windowsVirtualKeyCode: 86 }, { sessionId: session.sessionId });
194  await sleep(50);
195  await session.cdp.send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'v', code: 'KeyV', modifiers, windowsVirtualKeyCode: 86 }, { sessionId: session.sessionId });
196}
197 
198async function sendCopy(cdp?: CdpConnection, sessionId?: string): Promise<void> {
199  if (process.platform === 'darwin') {
200    spawnSync('osascript', ['-e', 'tell application "System Events" to keystroke "c" using command down']);
201  } else if (process.platform === 'linux') {
202    spawnSync('xdotool', ['key', 'ctrl+c']);
203  } else if (cdp && sessionId) {
204    await cdp.send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'c', code: 'KeyC', modifiers: 2, windowsVirtualKeyCode: 67 }, { sessionId });
205    await sleep(50);
206    await cdp.send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'c', code: 'KeyC', modifiers: 2, windowsVirtualKeyCode: 67 }, { sessionId });
207  }
208}
209 
210async function sendPaste(cdp?: CdpConnection, sessionId?: string): Promise<void> {
211  if (process.platform === 'darwin') {
212    spawnSync('osascript', ['-e', 'tell application "System Events" to keystroke "v" using command down']);
213  } else if (process.platform === 'linux') {
214    spawnSync('xdotool', ['key', 'ctrl+v']);
215  } else if (cdp && sessionId) {
216    await cdp.send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'v', code: 'KeyV', modifiers: 2, windowsVirtualKeyCode: 86 }, { sessionId });
217    await sleep(50);
218    await cdp.send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'v', code: 'KeyV', modifiers: 2, windowsVirtualKeyCode: 86 }, { sessionId });
219  }
220}
221 
222async function copyHtmlFromBrowser(cdp: CdpConnection, htmlFilePath: string, contentImages: ImageInfo[] = []): Promise<void> {
223  const absolutePath = path.isAbsolute(htmlFilePath) ? htmlFilePath : path.resolve(process.cwd(), htmlFilePath);
224  const fileUrl = `file://${absolutePath}`;
225 
226  console.log(`[wechat] Opening HTML file in new tab: ${fileUrl}`);
227 
228  const { targetId } = await cdp.send<{ targetId: string }>('Target.createTarget', { url: fileUrl });
229  const { sessionId } = await cdp.send<{ sessionId: string }>('Target.attachToTarget', { targetId, flatten: true });
230 
231  await cdp.send('Page.enable', {}, { sessionId });
232  await cdp.send('Runtime.enable', {}, { sessionId });
233  await sleep(2000);
234 
235  if (contentImages.length > 0) {
236    console.log('[wechat] Replacing img tags with placeholders for browser paste...');
237    const replacements = contentImages.map(img => ({ placeholder: img.placeholder, localPath: img.localPath }));
238    await cdp.send<{ result: { value: unknown } }>('Runtime.evaluate', {
239      expression: `
240        (function() {
241          const replacements = ${JSON.stringify(replacements)};
242          for (const r of replacements) {
243            const imgs = document.querySelectorAll('img[src="' + r.placeholder + '"], img[data-local-path="' + r.localPath + '"]');
244            for (const img of imgs) {
245              const text = document.createTextNode(r.placeholder);
246              img.parentNode.replaceChild(text, img);
247            }
248          }
249          return true;
250        })()
251      `,
252      returnByValue: true,
253    }, { sessionId });
254    await sleep(500);
255  }
256 
257  console.log('[wechat] Selecting #output content...');
258  await cdp.send<{ result: { value: unknown } }>('Runtime.evaluate', {
259    expression: `
260      (function() {
261        const output = document.querySelector('#output') || document.body;
262        const range = document.createRange();
263        range.selectNodeContents(output);
264        const selection = window.getSelection();
265        selection.removeAllRanges();
266        selection.addRange(range);
267        return true;
268      })()
269    `,
270    returnByValue: true,
271  }, { sessionId });
272  await sleep(300);
273 
274  console.log('[wechat] Activating HTML tab for copy...');
275  await cdp.send('Target.activateTarget', { targetId });
276  await sleep(300);
277 
278  console.log('[wechat] Copying content...');
279  await sendCopy(cdp, sessionId);
280  await sleep(1000);
281 
282  console.log('[wechat] Closing HTML tab...');
283  await cdp.send('Target.closeTarget', { targetId });
284}
285 
286async function pasteFromClipboardInEditor(session: ChromeSession): Promise<void> {
287  console.log('[wechat] Activating editor tab for paste...');
288  if (session.targetId) {
289    await session.cdp.send('Target.activateTarget', { targetId: session.targetId });
290    await sleep(300);
291  }
292  console.log('[wechat] Pasting content...');
293  await sendPaste(session.cdp, session.sessionId);
294  await sleep(1000);
295}
296 
297async function prepareEditorPasteTarget(
298  session: ChromeSession,
299  context: string,
300  options: { clickEditor?: boolean } = {},
301): Promise<void> {
302  await session.cdp.send('Target.activateTarget', { targetId: session.targetId }).catch(() => {});
303  await sleep(100);
304 
305  if (options.clickEditor) {
306    await clickElement(session, '.ProseMirror');
307    await sleep(200);
308  }
309 
310  const ready = await evaluate<boolean>(session, `
311    (function() {
312      const editor = document.querySelector('.ProseMirror');
313      if (!editor) return false;
314 
315      const active = document.activeElement;
316      const selection = window.getSelection();
317      const selectionInEditor = !!selection && selection.rangeCount > 0 && !!selection.anchorNode && editor.contains(selection.anchorNode);
318      const focusInEditor = !!active && (active === editor || editor.contains(active));
319      if (selectionInEditor || focusInEditor) return true;
320 
321      if (${JSON.stringify(Boolean(options.clickEditor))}) {
322        editor.focus();
323        const nextActive = document.activeElement;
324        return nextActive === editor || editor.contains(nextActive);
325      }
326 
327      return false;
328    })()
329  `);
330 
331  if (ready) return;
332 
333  const activeElement = await evaluate<string>(session, `
334    (function() {
335      const el = document.activeElement;
336      if (!el) return '(none)';
337      const id = el.id ? '#' + el.id : '';
338      const className = typeof el.className === 'string' && el.className ? '.' + el.className.split(/\\s+/).join('.') : '';
339      return el.tagName.toLowerCase() + id + className;
340    })()
341  `);
342  throw new Error(`Body editor is not focused before ${context}; active element: ${activeElement}`);
343}
344 
345async function parseMarkdownWithPlaceholders(
346  markdownPath: string,
347  theme?: string,
348  color?: string,
349  citeStatus: boolean = true
350): Promise<{ title: string; author: string; summary: string; htmlPath: string; contentImages: ImageInfo[] }> {
351  const __filename = fileURLToPath(import.meta.url);
352  const __dirname = path.dirname(__filename);
353  const mdToWechatScript = path.join(__dirname, 'md-to-wechat.ts');
354  const args = ['-y', 'bun', mdToWechatScript, markdownPath];
355  if (theme) args.push('--theme', theme);
356  if (color) args.push('--color', color);
357  if (!citeStatus) args.push('--no-cite');
358 
359  const result = spawnSync('npx', args, { stdio: ['inherit', 'pipe', 'pipe'] });
360  if (result.status !== 0) {
361    const stderr = result.stderr?.toString() || '';
362    throw new Error(`Failed to parse markdown: ${stderr}`);
363  }
364 
365  const output = result.stdout.toString();
366  return JSON.parse(output);
367}
368 
369function parseHtmlMeta(htmlPath: string): { title: string; author: string; summary: string; contentImages: ImageInfo[] } {
370  const content = fs.readFileSync(htmlPath, 'utf-8');
371 
372  let title = '';
373  const titleMatch = content.match(/<title>([^<]+)<\/title>/i);
374  if (titleMatch) title = titleMatch[1]!;
375 
376  let author = '';
377  const authorMatch = content.match(/<meta\s+name=["']author["']\s+content=["']([^"']+)["']/i)
378    || content.match(/<meta\s+content=["']([^"']+)["']\s+name=["']author["']/i);
379  if (authorMatch) author = authorMatch[1]!;
380 
381  let summary = '';
382  const descMatch = content.match(/<meta\s+name=["']description["']\s+content=["']([^"']+)["']/i)
383    || content.match(/<meta\s+content=["']([^"']+)["']\s+name=["']description["']/i);
384  if (descMatch) summary = descMatch[1]!;
385 
386  if (!summary) {
387    const firstPMatch = content.match(/<p[^>]*>([^<]+)<\/p>/i);
388    if (firstPMatch) {
389      const text = firstPMatch[1]!.replace(/<[^>]+>/g, '').trim();
390      if (text.length > 20) {
391        summary = text.length > 120 ? text.slice(0, 117) + '...' : text;
392      }
393    }
394  }
395 
396  const mdPath = htmlPath.replace(/\.html$/i, '.md');
397  if (fs.existsSync(mdPath)) {
398    const mdContent = fs.readFileSync(mdPath, 'utf-8');
399    const fmMatch = mdContent.match(/^---\r?\n([\s\S]*?)\r?\n---/);
400    if (fmMatch) {
401      const lines = fmMatch[1]!.split('\n');
402      for (const line of lines) {
403        const colonIdx = line.indexOf(':');
404        if (colonIdx > 0) {
405          const key = line.slice(0, colonIdx).trim();
406          let value = line.slice(colonIdx + 1).trim();
407          if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
408            value = value.slice(1, -1);
409          }
410          if (key === 'title' && !title) title = value;
411          if (key === 'author' && !author) author = value;
412          if ((key === 'description' || key === 'summary') && !summary) summary = value;
413        }
414      }
415    }
416  }
417 
418  const contentImages: ImageInfo[] = [];
419  const imgRegex = /<img[^>]*\ssrc=["']([^"']+)["'][^>]*>/gi;
420  const matches = [...content.matchAll(imgRegex)];
421  for (const match of matches) {
422    const [fullTag, src] = match;
423    if (!src || src.startsWith('http')) continue;
424    const localPathMatch = fullTag.match(/data-local-path=["']([^"']+)["']/);
425    if (localPathMatch) {
426      contentImages.push({
427        placeholder: src,
428        localPath: localPathMatch[1]!,
429        originalPath: src,
430      });
431    }
432  }
433 
434  return { title, author, summary, contentImages };
435}
436 
437async function selectAndReplacePlaceholder(session: ChromeSession, placeholder: string): Promise<boolean> {
438  const result = await session.cdp.send<{ result: { value: boolean } }>('Runtime.evaluate', {
439    expression: `
440      (function() {
441        const editor = document.querySelector('.ProseMirror');
442        if (!editor) return false;
443 
444        const placeholder = ${JSON.stringify(placeholder)};
445        const walker = document.createTreeWalker(editor, NodeFilter.SHOW_TEXT, null, false);
446        let node;
447 
448        while ((node = walker.nextNode())) {
449          const text = node.textContent || '';
450          let searchStart = 0;
451          let idx;
452          // Search for exact match (not prefix of longer placeholder like XIMGPH_1 in XIMGPH_10)
453          while ((idx = text.indexOf(placeholder, searchStart)) !== -1) {
454            const afterIdx = idx + placeholder.length;
455            const charAfter = text[afterIdx];
456            // Exact match if next char is not a digit
457            if (charAfter === undefined || !/\\d/.test(charAfter)) {
458              node.parentElement.scrollIntoView({ behavior: 'smooth', block: 'center' });
459 
460              const range = document.createRange();
461              range.setStart(node, idx);
462              range.setEnd(node, idx + placeholder.length);
463              const sel = window.getSelection();
464              sel.removeAllRanges();
465              sel.addRange(range);
466              return true;
467            }
468            searchStart = afterIdx;
469          }
470        }
471        return false;
472      })()
473    `,
474    returnByValue: true,
475  }, { sessionId: session.sessionId });
476 
477  return result.result.value;
478}
479 
480async function pressDeleteKey(session: ChromeSession): Promise<void> {
481  await session.cdp.send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Backspace', code: 'Backspace', windowsVirtualKeyCode: 8 }, { sessionId: session.sessionId });
482  await sleep(50);
483  await session.cdp.send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Backspace', code: 'Backspace', windowsVirtualKeyCode: 8 }, { sessionId: session.sessionId });
484}
485 
486async function removeExtraEmptyLineAfterImage(session: ChromeSession): Promise<boolean> {
487  const removed = await evaluate<boolean>(session, `
488    (function() {
489      const editor = document.querySelector('.ProseMirror');
490      if (!editor) return false;
491 
492      const sel = window.getSelection();
493      if (!sel || sel.rangeCount === 0) return false;
494 
495      let node = sel.anchorNode;
496      if (!node) return false;
497      let element = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
498      if (!element || !editor.contains(element)) return false;
499 
500      const isEmptyParagraph = (el) => {
501        if (!el || el.tagName !== 'P') return false;
502        const text = (el.textContent || '').trim();
503        if (text.length > 0) return false;
504        return el.querySelectorAll('img, figure, video, iframe').length === 0;
505      };
506 
507      const hasImage = (el) => {
508        if (!el) return false;
509        return !!el.querySelector('img, figure img, picture img');
510      };
511 
512      const placeCursorAfter = (el) => {
513        if (!el) return;
514        const range = document.createRange();
515        range.setStartAfter(el);
516        range.collapse(true);
517        sel.removeAllRanges();
518        sel.addRange(range);
519      };
520 
521      // Case 1: caret is inside an empty paragraph right after an image block.
522      const emptyPara = element.closest('p');
523      if (emptyPara && editor.contains(emptyPara) && isEmptyParagraph(emptyPara)) {
524        const prev = emptyPara.previousElementSibling;
525        if (prev && hasImage(prev)) {
526          emptyPara.remove();
527          placeCursorAfter(prev);
528          return true;
529        }
530      }
531 
532      // Case 2: caret is on the image block itself; remove the next empty paragraph.
533      const imageBlock = element.closest('figure, p');
534      if (imageBlock && editor.contains(imageBlock) && hasImage(imageBlock)) {
535        const next = imageBlock.nextElementSibling;
536        if (next && isEmptyParagraph(next)) {
537          next.remove();
538          placeCursorAfter(imageBlock);
539          return true;
540        }
541      }
542 
543      return false;
544    })()
545  `);
546 
547  if (removed) console.log('[wechat] Removed extra empty line after image.');
548  return removed;
549}
550 
551export async function postArticle(options: ArticleOptions): Promise<void> {
552  const { title, content, htmlFile, markdownFile, theme, color, citeStatus = true, author, summary, images = [], submit = false, profileDir, cdpPort } = options;
553  let { contentImages = [] } = options;
554  let effectiveTitle = title || '';
555  let effectiveAuthor = author || '';
556  let effectiveSummary = summary || '';
557  let effectiveHtmlFile = htmlFile;
558 
559  if (markdownFile) {
560    console.log(`[wechat] Parsing markdown: ${markdownFile}`);
561    const parsed = await parseMarkdownWithPlaceholders(markdownFile, theme, color, citeStatus);
562    effectiveTitle = effectiveTitle || parsed.title;
563    effectiveAuthor = effectiveAuthor || parsed.author;
564    effectiveSummary = effectiveSummary || parsed.summary;
565    effectiveHtmlFile = parsed.htmlPath;
566    contentImages = parsed.contentImages;
567    console.log(`[wechat] Title: ${effectiveTitle || '(empty)'}`);
568    console.log(`[wechat] Author: ${effectiveAuthor || '(empty)'}`);
569    console.log(`[wechat] Summary: ${effectiveSummary || '(empty)'}`);
570    console.log(`[wechat] Found ${contentImages.length} images to insert`);
571  } else if (htmlFile && fs.existsSync(htmlFile)) {
572    console.log(`[wechat] Parsing HTML: ${htmlFile}`);
573    const meta = parseHtmlMeta(htmlFile);
574    effectiveTitle = effectiveTitle || meta.title;
575    effectiveAuthor = effectiveAuthor || meta.author;
576    effectiveSummary = effectiveSummary || meta.summary;
577    effectiveHtmlFile = htmlFile;
578    if (meta.contentImages.length > 0) {
579      contentImages = meta.contentImages;
580    }
581    console.log(`[wechat] Title: ${effectiveTitle || '(empty)'}`);
582    console.log(`[wechat] Author: ${effectiveAuthor || '(empty)'}`);
583    console.log(`[wechat] Summary: ${effectiveSummary || '(empty)'}`);
584    console.log(`[wechat] Found ${contentImages.length} images to insert`);
585  }
586 
587  if (effectiveTitle && effectiveTitle.length > 64) throw new Error(`Title too long: ${effectiveTitle.length} chars (max 64)`);
588  if (!content && !effectiveHtmlFile) throw new Error('Either --content, --html, or --markdown is required');
589 
590  let cdp: CdpConnection;
591  let chrome: ReturnType<typeof import('node:child_process').spawn> | null = null;
592 
593  // Try connecting to existing Chrome: explicit port > auto-detect > launch new
594  const portToTry = cdpPort ?? await findExistingChromeDebugPort();
595  if (portToTry) {
596    const existing = await tryConnectExisting(portToTry);
597    if (existing) {
598      console.log(`[cdp] Connected to existing Chrome on port ${portToTry}`);
599      cdp = existing;
600    } else {
601      console.log(`[cdp] Port ${portToTry} not available, launching new Chrome...`);
602      const launched = await launchChrome(WECHAT_URL, profileDir);
603      cdp = launched.cdp;
604      chrome = launched.chrome;
605    }
606  } else {
607    const launched = await launchChrome(WECHAT_URL, profileDir);
608    cdp = launched.cdp;
609    chrome = launched.chrome;
610  }
611 
612  try {
613    console.log('[wechat] Waiting for page load...');
614    await sleep(3000);
615 
616    let session: ChromeSession;
617    if (!chrome) {
618      // Reusing existing Chrome: find an already-logged-in tab (has token in URL)
619      const allTargets = await cdp.send<{ targetInfos: Array<{ targetId: string; url: string; type: string }> }>('Target.getTargets');
620      const loggedInTab = allTargets.targetInfos.find(t => t.type === 'page' && t.url.includes('mp.weixin.qq.com') && t.url.includes('token='));
621      const wechatTab = loggedInTab || allTargets.targetInfos.find(t => t.type === 'page' && t.url.includes('mp.weixin.qq.com'));
622 
623      if (wechatTab) {
624        console.log(`[wechat] Reusing existing tab: ${wechatTab.url.substring(0, 80)}...`);
625        const { sessionId: reuseSid } = await cdp.send<{ sessionId: string }>('Target.attachToTarget', { targetId: wechatTab.targetId, flatten: true });
626        await cdp.send('Page.enable', {}, { sessionId: reuseSid });
627        await cdp.send('Runtime.enable', {}, { sessionId: reuseSid });
628        await cdp.send('DOM.enable', {}, { sessionId: reuseSid });
629        session = { cdp, sessionId: reuseSid, targetId: wechatTab.targetId };
630 
631        // Navigate to home if not already there
632        const currentUrl = await evaluate<string>(session, 'window.location.href');
633        if (!currentUrl.includes('/cgi-bin/home')) {
634          console.log('[wechat] Navigating to home...');
635          await evaluate(session, `window.location.href = '${WECHAT_URL}cgi-bin/home?t=home/index'`);
636          await sleep(5000);
637        }
638      } else {
639        // No WeChat tab found, create one
640        console.log('[wechat] No WeChat tab found, opening...');
641        await cdp.send('Target.createTarget', { url: WECHAT_URL });
642        await sleep(5000);
643        session = await getPageSession(cdp, 'mp.weixin.qq.com');
644      }
645    } else {
646      session = await getPageSession(cdp, 'mp.weixin.qq.com');
647    }
648 
649    const url = await evaluate<string>(session, 'window.location.href');
650    if (!url.includes('/cgi-bin/')) {
651      const hasTelegram = !!(process.env.TELEGRAM_BOT_TOKEN && process.env.TELEGRAM_CHAT_ID);
652      console.log(`[wechat] Not logged in. Please scan QR code...${hasTelegram ? ' (sending to Telegram)' : ''}`);
653      const loggedIn = await waitForLogin(session);
654      if (!loggedIn) throw new Error('Login timeout');
655    }
656    console.log('[wechat] Logged in.');
657    await sleep(5000);
658 
659    // Wait for menu to be ready
660    const menuReady = await waitForElement(session, '.new-creation__menu', 40_000);
661    if (!menuReady) throw new Error('Home page menu did not load');
662 
663    const targets = await cdp.send<{ targetInfos: Array<{ targetId: string; url: string; type: string }> }>('Target.getTargets');
664    const initialIds = new Set(targets.targetInfos.map(t => t.targetId));
665 
666    await clickMenuByText(session, '文章');
667    await sleep(3000);
668 
669    const editorTargetId = await waitForNewTab(cdp, initialIds, 'mp.weixin.qq.com');
670    console.log('[wechat] Editor tab opened.');
671 
672    const { sessionId } = await cdp.send<{ sessionId: string }>('Target.attachToTarget', { targetId: editorTargetId, flatten: true });
673    session = { cdp, sessionId, targetId: editorTargetId };
674 
675    await cdp.send('Page.enable', {}, { sessionId });
676    await cdp.send('Runtime.enable', {}, { sessionId });
677    await cdp.send('DOM.enable', {}, { sessionId });
678 
679    // Wait for editor elements to fully load
680    console.log('[wechat] Waiting for editor to load...');
681    const editorLoaded = await waitForElement(session, '#title', 30_000);
682    if (!editorLoaded) throw new Error('Editor did not load (#title not found)');
683    await waitForElement(session, '.ProseMirror', 15_000);
684    await sleep(2000);
685 
686    if (effectiveTitle) {
687      console.log('[wechat] Filling title...');
688      await evaluate(session, `(function() { const el = document.querySelector('#title'); el.focus(); el.value = ${JSON.stringify(effectiveTitle)}; el.dispatchEvent(new Event('input', { bubbles: true })); el.dispatchEvent(new Event('change', { bubbles: true })); })()`);
689    }
690 
691    if (effectiveAuthor) {
692      console.log('[wechat] Filling author...');
693      await evaluate(session, `(function() { const el = document.querySelector('#author'); el.focus(); el.value = ${JSON.stringify(effectiveAuthor)}; el.dispatchEvent(new Event('input', { bubbles: true })); el.dispatchEvent(new Event('change', { bubbles: true })); })()`);
694    }
695 
696    await sleep(500);
697 
698    if (effectiveTitle) {
699      const actualTitle = await evaluate<string>(session, `document.querySelector('#title')?.value || ''`);
700      if (actualTitle === effectiveTitle) {
701        console.log('[wechat] Title verified OK.');
702      } else {
703        console.warn(`[wechat] Title verification failed. Expected: "${effectiveTitle}", got: "${actualTitle}"`);
704      }
705    }
706 
707    console.log('[wechat] Clicking on editor...');
708    await clickElement(session, '.ProseMirror');
709    await sleep(1000);
710 
711    console.log('[wechat] Ensuring editor focus...');
712    await clickElement(session, '.ProseMirror');
713    await sleep(500);
714 
715    if (effectiveHtmlFile && fs.existsSync(effectiveHtmlFile)) {
716      console.log(`[wechat] Copying HTML content from: ${effectiveHtmlFile}`);
717      await copyHtmlFromBrowser(cdp, effectiveHtmlFile, contentImages);
718      await sleep(500);
719      await prepareEditorPasteTarget(session, 'body content paste', { clickEditor: true });
720      console.log('[wechat] Pasting into editor...');
721      await pasteFromClipboardInEditor(session);
722      await sleep(3000);
723 
724      const editorHasContent = await evaluate<boolean>(session, `
725        (function() {
726          const editor = document.querySelector('.ProseMirror');
727          if (!editor) return false;
728          const text = editor.innerText?.trim() || '';
729          return text.length > 0;
730        })()
731      `);
732      if (editorHasContent) {
733        console.log('[wechat] Body content verified OK.');
734      } else {
735        console.warn('[wechat] Body content verification failed: editor appears empty after paste.');
736      }
737 
738      if (contentImages.length > 0) {
739        console.log(`[wechat] Inserting ${contentImages.length} images...`);
740        for (let i = 0; i < contentImages.length; i++) {
741          const img = contentImages[i]!;
742          console.log(`[wechat] [${i + 1}/${contentImages.length}] Processing: ${img.placeholder}`);
743 
744          const found = await selectAndReplacePlaceholder(session, img.placeholder);
745          if (!found) {
746            console.warn(`[wechat] Placeholder not found: ${img.placeholder}`);
747            continue;
748          }
749 
750          await sleep(500);
751 
752          console.log(`[wechat] Copying image: ${path.basename(img.localPath)}`);
753          await copyImageToClipboard(img.localPath);
754          await sleep(300);
755 
756          console.log('[wechat] Deleting placeholder with Backspace...');
757          await pressDeleteKey(session);
758          await sleep(200);
759 
760          console.log('[wechat] Pasting image...');
761          await prepareEditorPasteTarget(session, 'inline image paste');
762          await pasteFromClipboardInEditor(session);
763          await sleep(3000);
764          await removeExtraEmptyLineAfterImage(session);
765        }
766        console.log('[wechat] All images inserted.');
767      }
768    } else if (content) {
769      for (const img of images) {
770        if (fs.existsSync(img)) {
771          console.log(`[wechat] Pasting image: ${img}`);
772          await copyImageToClipboard(img);
773          await sleep(500);
774          await prepareEditorPasteTarget(session, 'leading image paste');
775          await pasteInEditor(session);
776          await sleep(2000);
777          await removeExtraEmptyLineAfterImage(session);
778        }
779      }
780 
781      console.log('[wechat] Typing content...');
782      await prepareEditorPasteTarget(session, 'content typing');
783      await typeText(session, content);
784      await sleep(1000);
785 
786      const editorHasContent = await evaluate<boolean>(session, `
787        (function() {
788          const editor = document.querySelector('.ProseMirror');
789          if (!editor) return false;
790          const text = editor.innerText?.trim() || '';
791          return text.length > 0;
792        })()
793      `);
794      if (editorHasContent) {
795        console.log('[wechat] Body content verified OK.');
796      } else {
797        console.warn('[wechat] Body content verification failed: editor appears empty after typing.');
798      }
799    }
800 
801    if (effectiveSummary) {
802      console.log(`[wechat] Filling summary (after content paste): ${effectiveSummary}`);
803      await evaluate(session, `
804        (function() {
805          const el = document.querySelector('#js_description');
806          if (!el) return;
807          el.focus();
808          el.select();
809          el.value = ${JSON.stringify(effectiveSummary)};
810          el.dispatchEvent(new Event('input', { bubbles: true }));
811          el.dispatchEvent(new Event('change', { bubbles: true }));
812          el.dispatchEvent(new Event('blur', { bubbles: true }));
813        })()
814      `);
815      await sleep(500);
816 
817      const actualSummary = await evaluate<string>(session, `document.querySelector('#js_description')?.value || ''`);
818      if (actualSummary === effectiveSummary) {
819        console.log('[wechat] Summary verified OK.');
820      } else {
821        console.warn(`[wechat] Summary verification failed. Expected: "${effectiveSummary}", got: "${actualSummary}"`);
822      }
823    }
824 
825    console.log('[wechat] Saving as draft...');
826    await evaluate(session, `document.querySelector('#js_submit button').click()`);
827    await sleep(3000);
828 
829    const saved = await evaluate<boolean>(session, `!!document.querySelector('.weui-desktop-toast')`);
830    if (saved) {
831      console.log('[wechat] Draft saved successfully!');
832    } else {
833      console.log('[wechat] Waiting for save confirmation...');
834      await sleep(5000);
835    }
836 
837    console.log('[wechat] Done. Browser window left open.');
838  } finally {
839    cdp.close();
840  }
841}
842 
843function printUsage(): never {
844  console.log(`Post article to WeChat Official Account
845 
846Usage:
847  npx -y bun wechat-article.ts [options]
848 
849Options:
850  --title <text>     Article title (auto-extracted from markdown)
851  --content <text>   Article content (use with --image)
852  --html <path>      HTML file to paste (alternative to --content)
853  --markdown <path>  Markdown file to convert and post (recommended)
854  --theme <name>     Theme for markdown (default, grace, simple, modern)
855  --color <name|hex> Primary color (blue, green, vermilion, etc. or hex)
856  --no-cite          Disable bottom citations for ordinary external links in markdown mode
857  --author <name>    Author name
858  --summary <text>   Article summary
859  --image <path>     Content image, can repeat (only with --content)
860  --submit           Save as draft
861  --profile <dir>    Chrome profile directory
862  --account <alias>  Select account by alias (for multi-account setups)
863  --cdp-port <port>  Connect to existing Chrome debug port instead of launching new instance
864 
865Examples:
866  npx -y bun wechat-article.ts --markdown article.md
867  npx -y bun wechat-article.ts --markdown article.md --theme grace --submit
868  npx -y bun wechat-article.ts --markdown article.md --no-cite
869  npx -y bun wechat-article.ts --title "标题" --content "内容" --image img.png
870  npx -y bun wechat-article.ts --title "标题" --html article.html --submit
871 
872Markdown mode:
873  Images in markdown are converted to placeholders. After pasting HTML,
874  each placeholder is selected, scrolled into view, deleted, and replaced
875  with the actual image via paste. Ordinary external links are converted to
876  bottom citations by default.
877`);
878  process.exit(0);
879}
880 
881async function main(): Promise<void> {
882  const args = process.argv.slice(2);
883  if (args.includes('--help') || args.includes('-h')) printUsage();
884 
885  const images: string[] = [];
886  let title: string | undefined;
887  let content: string | undefined;
888  let htmlFile: string | undefined;
889  let markdownFile: string | undefined;
890  let theme: string | undefined;
891  let color: string | undefined;
892  let citeStatus = true;
893  let author: string | undefined;
894  let summary: string | undefined;
895  let submit = false;
896  let profileDir: string | undefined;
897  let cdpPort: number | undefined;
898  let accountAlias: string | undefined;
899 
900  for (let i = 0; i < args.length; i++) {
901    const arg = args[i]!;
902    if (arg === '--title' && args[i + 1]) title = args[++i];
903    else if (arg === '--content' && args[i + 1]) content = args[++i];
904    else if (arg === '--html' && args[i + 1]) htmlFile = args[++i];
905    else if (arg === '--markdown' && args[i + 1]) markdownFile = args[++i];
906    else if (arg === '--theme' && args[i + 1]) theme = args[++i];
907    else if (arg === '--color' && args[i + 1]) color = args[++i];
908    else if (arg === '--cite') citeStatus = true;
909    else if (arg === '--no-cite') citeStatus = false;
910    else if (arg === '--author' && args[i + 1]) author = args[++i];
911    else if (arg === '--summary' && args[i + 1]) summary = args[++i];
912    else if (arg === '--image' && args[i + 1]) images.push(args[++i]!);
913    else if (arg === '--submit') submit = true;
914    else if (arg === '--profile' && args[i + 1]) profileDir = args[++i];
915    else if (arg === '--account' && args[i + 1]) accountAlias = args[++i];
916    else if (arg === '--cdp-port' && args[i + 1]) cdpPort = parseInt(args[++i]!, 10);
917  }
918 
919  const extConfig = loadWechatExtendConfig();
920  const resolved = resolveAccount(extConfig, accountAlias);
921  if (resolved.name) console.log(`[wechat] Account: ${resolved.name} (${resolved.alias})`);
922 
923  if (!author && resolved.default_author) author = resolved.default_author;
924 
925  if (!profileDir && resolved.alias) {
926    profileDir = resolved.chrome_profile_path || getAccountProfileDir(resolved.alias);
927  }
928 
929  if (!markdownFile && !htmlFile && !title) { console.error('Error: --title is required (or use --markdown/--html)'); process.exit(1); }
930  if (!markdownFile && !htmlFile && !content) { console.error('Error: --content, --html, or --markdown is required'); process.exit(1); }
931 
932  await postArticle({ title: title || '', content, htmlFile, markdownFile, theme, color, citeStatus, author, summary, images, submit, profileDir, cdpPort });
933}
934 
935await main().then(() => {
936  process.exit(0);
937}).catch((err) => {
938  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
939  process.exit(1);
940});
941