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