1import fs from 'node:fs';
2import { readdir } from 'node:fs/promises';
3import path from 'node:path';
4import process from 'node:process';
5 
6import {
7  CdpConnection,
8  findChromeExecutable,
9  getDefaultProfileDir,
10  getAccountProfileDir,
11  launchChrome,
12  sleep,
13} from './cdp.ts';
14import { loadWechatExtendConfig, resolveAccount } from './wechat-extend-config.ts';
15 
16const WECHAT_URL = 'https://mp.weixin.qq.com/';
17 
18interface MarkdownMeta {
19  title: string;
20  author: string;
21  content: string;
22}
23 
24function parseMarkdownFile(filePath: string): MarkdownMeta {
25  const text = fs.readFileSync(filePath, 'utf-8');
26  let title = '';
27  let author = '';
28  let content = '';
29 
30  const fmMatch = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
31  if (fmMatch) {
32    const fm = fmMatch[1]!;
33    const titleMatch = fm.match(/^title:\s*(.+)$/m);
34    if (titleMatch) title = titleMatch[1]!.trim().replace(/^["']|["']$/g, '');
35    const authorMatch = fm.match(/^author:\s*(.+)$/m);
36    if (authorMatch) author = authorMatch[1]!.trim().replace(/^["']|["']$/g, '');
37  }
38 
39  const bodyText = fmMatch ? text.slice(fmMatch[0].length) : text;
40 
41  if (!title) {
42    const h1Match = bodyText.match(/^#\s+(.+)$/m);
43    if (h1Match) title = h1Match[1]!.trim();
44  }
45 
46  const lines = bodyText.split('\n');
47  const paragraphs: string[] = [];
48  for (const line of lines) {
49    const trimmed = line.trim();
50    if (!trimmed) continue;
51    if (trimmed.startsWith('#')) continue;
52    if (trimmed.startsWith('![')) continue;
53    if (trimmed.startsWith('---')) continue;
54    paragraphs.push(trimmed);
55    if (paragraphs.join('\n').length > 1200) break;
56  }
57  content = paragraphs.join('\n');
58 
59  return { title, author, content };
60}
61 
62function compressTitle(title: string, maxLen = 20): string {
63  if (title.length <= maxLen) return title;
64 
65  const prefixes = ['如何', '为什么', '什么是', '怎样', '怎么', '关于'];
66  let t = title;
67  for (const p of prefixes) {
68    if (t.startsWith(p) && t.length > maxLen) {
69      t = t.slice(p.length);
70      if (t.length <= maxLen) return t;
71    }
72  }
73 
74  const fillers = ['的', '了', '在', '是', '和', '与', '以及', '或者', '或', '还是', '而且', '并且', '但是', '但', '因为', '所以', '如果', '那么', '虽然', '不过', '然而', '——', '…'];
75  for (const f of fillers) {
76    if (t.length <= maxLen) break;
77    t = t.replace(new RegExp(f, 'g'), '');
78  }
79 
80  if (t.length > maxLen) t = t.slice(0, maxLen);
81 
82  return t;
83}
84 
85function compressContent(content: string, maxLen = 1000): string {
86  if (content.length <= maxLen) return content;
87 
88  const lines = content.split('\n');
89  const result: string[] = [];
90  let len = 0;
91 
92  for (const line of lines) {
93    if (len + line.length + 1 > maxLen) {
94      const remaining = maxLen - len - 1;
95      if (remaining > 20) result.push(line.slice(0, remaining - 3) + '...');
96      break;
97    }
98    result.push(line);
99    len += line.length + 1;
100  }
101 
102  return result.join('\n');
103}
104 
105async function loadImagesFromDir(dir: string): Promise<string[]> {
106  const entries = await readdir(dir);
107  const images = entries
108    .filter(f => /\.(png|jpg|jpeg|gif|webp)$/i.test(f))
109    .sort()
110    .map(f => path.join(dir, f));
111  return images;
112}
113 
114interface WeChatBrowserOptions {
115  title?: string;
116  content?: string;
117  images?: string[];
118  imagesDir?: string;
119  markdownFile?: string;
120  submit?: boolean;
121  timeoutMs?: number;
122  profileDir?: string;
123  chromePath?: string;
124}
125 
126export async function postToWeChat(options: WeChatBrowserOptions): Promise<void> {
127  const { submit = false, timeoutMs = 120_000, profileDir = getDefaultProfileDir() } = options;
128 
129  let title = options.title || '';
130  let content = options.content || '';
131  let images = options.images || [];
132 
133  if (options.markdownFile) {
134    const absPath = path.isAbsolute(options.markdownFile) ? options.markdownFile : path.resolve(process.cwd(), options.markdownFile);
135    if (!fs.existsSync(absPath)) throw new Error(`Markdown file not found: ${absPath}`);
136    const meta = parseMarkdownFile(absPath);
137    if (!title) title = meta.title;
138    if (!content) content = meta.content;
139    console.log(`[wechat-browser] Parsed markdown: title="${meta.title}", content=${meta.content.length} chars`);
140  }
141 
142  if (options.imagesDir) {
143    const absDir = path.isAbsolute(options.imagesDir) ? options.imagesDir : path.resolve(process.cwd(), options.imagesDir);
144    if (!fs.existsSync(absDir)) throw new Error(`Images directory not found: ${absDir}`);
145    images = await loadImagesFromDir(absDir);
146    console.log(`[wechat-browser] Found ${images.length} images in ${absDir}`);
147  }
148 
149  if (title.length > 20) {
150    const original = title;
151    title = compressTitle(title, 20);
152    console.log(`[wechat-browser] Title compressed: "${original}" → "${title}"`);
153  }
154 
155  if (content.length > 1000) {
156    const original = content.length;
157    content = compressContent(content, 1000);
158    console.log(`[wechat-browser] Content compressed: ${original} → ${content.length} chars`);
159  }
160 
161  if (!title) throw new Error('Title is required (use --title or --markdown)');
162  if (!content) throw new Error('Content is required (use --content or --markdown)');
163  if (images.length === 0) throw new Error('At least one image is required (use --image or --images)');
164 
165  for (const img of images) {
166    if (!fs.existsSync(img)) throw new Error(`Image not found: ${img}`);
167  }
168 
169  const chromePath = findChromeExecutable(options.chromePath);
170  if (!chromePath) throw new Error('Chrome not found. Set WECHAT_BROWSER_CHROME_PATH env var.');
171 
172  console.log(`[wechat-browser] Launching Chrome (profile: ${profileDir})`);
173 
174  const launched = await launchChrome(WECHAT_URL, profileDir, chromePath);
175  const chrome = launched.chrome;
176 
177  let cdp: CdpConnection | null = null;
178 
179  try {
180    cdp = launched.cdp;
181 
182    const targets = await cdp.send<{ targetInfos: Array<{ targetId: string; url: string; type: string }> }>('Target.getTargets');
183    let pageTarget = targets.targetInfos.find((t) => t.type === 'page' && t.url.includes('mp.weixin.qq.com'));
184 
185    if (!pageTarget) {
186      const { targetId } = await cdp.send<{ targetId: string }>('Target.createTarget', { url: WECHAT_URL });
187      pageTarget = { targetId, url: WECHAT_URL, type: 'page' };
188    }
189 
190    let { sessionId } = await cdp.send<{ sessionId: string }>('Target.attachToTarget', { targetId: pageTarget.targetId, flatten: true });
191 
192    await cdp.send('Page.enable', {}, { sessionId });
193    await cdp.send('Runtime.enable', {}, { sessionId });
194    await cdp.send('DOM.enable', {}, { sessionId });
195 
196    console.log('[wechat-browser] Waiting for page load...');
197    await sleep(3000);
198 
199    const checkLoginStatus = async (): Promise<boolean> => {
200      const result = await cdp!.send<{ result: { value: string } }>('Runtime.evaluate', {
201        expression: `window.location.href`,
202        returnByValue: true,
203      }, { sessionId });
204      return result.result.value.includes('/cgi-bin/home');
205    };
206 
207    const waitForLogin = async (): Promise<boolean> => {
208      const start = Date.now();
209      while (Date.now() - start < timeoutMs) {
210        if (await checkLoginStatus()) return true;
211        await sleep(2000);
212      }
213      return false;
214    };
215 
216    let isLoggedIn = await checkLoginStatus();
217    if (!isLoggedIn) {
218      console.log('[wechat-browser] Not logged in. Please scan QR code to log in...');
219      isLoggedIn = await waitForLogin();
220      if (!isLoggedIn) throw new Error('Timed out waiting for login. Please log in first.');
221    }
222    console.log('[wechat-browser] Logged in.');
223 
224    await sleep(2000);
225 
226    console.log('[wechat-browser] Looking for "贴图" menu...');
227    const menuResult = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
228      expression: `
229        const menuItems = document.querySelectorAll('.new-creation__menu .new-creation__menu-item');
230        const count = menuItems.length;
231        const texts = Array.from(menuItems).map(m => m.querySelector('.new-creation__menu-title')?.textContent?.trim() || m.textContent?.trim() || '');
232        JSON.stringify({ count, texts });
233      `,
234      returnByValue: true,
235    }, { sessionId });
236    console.log(`[wechat-browser] Menu items: ${menuResult.result.value}`);
237 
238    const getTargets = async () => {
239      return await cdp!.send<{ targetInfos: Array<{ targetId: string; url: string; type: string }> }>('Target.getTargets');
240    };
241 
242    const initialTargets = await getTargets();
243    const initialIds = new Set(initialTargets.targetInfos.map(t => t.targetId));
244    console.log(`[wechat-browser] Initial targets count: ${initialTargets.targetInfos.length}`);
245 
246    console.log('[wechat-browser] Finding "贴图" menu position...');
247    const menuPos = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
248      expression: `
249        (function() {
250          const menuItems = document.querySelectorAll('.new-creation__menu .new-creation__menu-item');
251          console.log('Found menu items:', menuItems.length);
252          for (const item of menuItems) {
253            const title = item.querySelector('.new-creation__menu-title');
254            const text = title?.textContent?.trim() || '';
255            console.log('Menu item text:', text);
256            if (text === '图文' || text === '贴图') {
257              item.scrollIntoView({ block: 'center' });
258              const rect = item.getBoundingClientRect();
259              console.log('Found 贴图，rect:', JSON.stringify(rect));
260              return JSON.stringify({ x: rect.x + rect.width / 2, y: rect.y + rect.height / 2, width: rect.width, height: rect.height });
261            }
262          }
263          return 'null';
264        })()
265      `,
266      returnByValue: true,
267    }, { sessionId });
268    console.log(`[wechat-browser] Menu position: ${menuPos.result.value}`);
269 
270    const pos = menuPos.result.value !== 'null' ? JSON.parse(menuPos.result.value) : null;
271    if (!pos) throw new Error('贴图 menu not found or not visible');
272 
273    console.log('[wechat-browser] Clicking "贴图" menu with mouse events...');
274    await cdp.send('Input.dispatchMouseEvent', {
275      type: 'mousePressed',
276      x: pos.x,
277      y: pos.y,
278      button: 'left',
279      clickCount: 1,
280    }, { sessionId });
281    await sleep(100);
282    await cdp.send('Input.dispatchMouseEvent', {
283      type: 'mouseReleased',
284      x: pos.x,
285      y: pos.y,
286      button: 'left',
287      clickCount: 1,
288    }, { sessionId });
289 
290    console.log('[wechat-browser] Waiting for editor...');
291    await sleep(3000);
292 
293    const waitForEditor = async (): Promise<{ targetId: string; isNewTab: boolean } | null> => {
294      const start = Date.now();
295 
296      while (Date.now() - start < 30_000) {
297        const targets = await getTargets();
298        const pageTargets = targets.targetInfos.filter(t => t.type === 'page');
299 
300        for (const t of pageTargets) {
301          console.log(`[wechat-browser] Target: ${t.url}`);
302        }
303 
304        const newTab = pageTargets.find(t => !initialIds.has(t.targetId) && t.url.includes('mp.weixin.qq.com'));
305        if (newTab) {
306          console.log(`[wechat-browser] Found new tab: ${newTab.url}`);
307          return { targetId: newTab.targetId, isNewTab: true };
308        }
309 
310        const editorTab = pageTargets.find(t => t.url.includes('appmsg'));
311        if (editorTab) {
312          console.log(`[wechat-browser] Found editor tab: ${editorTab.url}`);
313          return { targetId: editorTab.targetId, isNewTab: !initialIds.has(editorTab.targetId) };
314        }
315 
316        const currentUrl = await cdp!.send<{ result: { value: string } }>('Runtime.evaluate', {
317          expression: `window.location.href`,
318          returnByValue: true,
319        }, { sessionId });
320        console.log(`[wechat-browser] Current page URL: ${currentUrl.result.value}`);
321 
322        if (currentUrl.result.value.includes('appmsg')) {
323          console.log(`[wechat-browser] Current page navigated to editor`);
324          return { targetId: pageTarget!.targetId, isNewTab: false };
325        }
326 
327        await sleep(1000);
328      }
329      return null;
330    };
331 
332    const editorInfo = await waitForEditor();
333    if (!editorInfo) {
334      const finalTargets = await getTargets();
335      console.log(`[wechat-browser] Final targets: ${finalTargets.targetInfos.filter(t => t.type === 'page').map(t => t.url).join(', ')}`);
336      throw new Error('Editor not found.');
337    }
338 
339    if (editorInfo.isNewTab) {
340      console.log('[wechat-browser] Switching to editor tab...');
341      const editorSession = await cdp.send<{ sessionId: string }>('Target.attachToTarget', { targetId: editorInfo.targetId, flatten: true });
342      sessionId = editorSession.sessionId;
343 
344      await cdp.send('Page.enable', {}, { sessionId });
345      await cdp.send('Runtime.enable', {}, { sessionId });
346      await cdp.send('DOM.enable', {}, { sessionId });
347    } else {
348      console.log('[wechat-browser] Editor opened in current page');
349    }
350 
351    await cdp.send('Page.enable', {}, { sessionId });
352    await cdp.send('Runtime.enable', {}, { sessionId });
353    await cdp.send('DOM.enable', {}, { sessionId });
354 
355    await sleep(2000);
356 
357    console.log('[wechat-browser] Uploading all images at once...');
358    const absolutePaths = images.map(p => path.isAbsolute(p) ? p : path.resolve(process.cwd(), p));
359    console.log(`[wechat-browser] Images: ${absolutePaths.join(', ')}`);
360 
361    // --- PRIMARY approach: intercept file chooser dialog ---
362    let uploadSuccess = false;
363    try {
364      console.log('[wechat-browser] [primary] Enabling file chooser interception...');
365      await cdp.send('Page.setInterceptFileChooserDialog', { enabled: true }, { sessionId });
366 
367      // Set up listener for file chooser opened event BEFORE clicking
368      const fileChooserPromise = new Promise<{ backendNodeId: number; mode: string }>((resolve, reject) => {
369        const timeout = setTimeout(() => reject(new Error('File chooser dialog not opened within 10s')), 10_000);
370        cdp!.on('Page.fileChooserOpened', (params: unknown) => {
371          clearTimeout(timeout);
372          const p = params as { backendNodeId: number; mode: string };
373          console.log(`[wechat-browser] [primary] File chooser opened: backendNodeId=${p.backendNodeId}, mode=${p.mode}`);
374          resolve(p);
375        });
376      });
377 
378      // Trigger file chooser by calling .click() on the file input with userGesture
379      const fileInputSelectors = [
380        '.js_upload_btn_container input[type=file]',
381        'input[type=file][multiple][accept*="image"]',
382        'input[type=file][accept*="image"]',
383        'input[type=file][multiple]',
384        'input[type=file]',
385      ];
386 
387      console.log('[wechat-browser] [primary] Clicking file input via JS .click() with userGesture...');
388      const clickResult = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
389        expression: `
390          (function() {
391            const selectors = ${JSON.stringify(fileInputSelectors)};
392            for (const sel of selectors) {
393              const el = document.querySelector(sel);
394              if (el) {
395                el.click();
396                return JSON.stringify({ clicked: sel });
397              }
398            }
399            const debug = [];
400            document.querySelectorAll('input[type=file]').forEach((inp, i) => {
401              debug.push({ i, accept: inp.accept, multiple: inp.multiple, parentClass: inp.parentElement?.className?.slice(0, 60) });
402            });
403            return JSON.stringify({ error: 'no file input found', fileInputs: debug });
404          })()
405        `,
406        returnByValue: true,
407        userGesture: true,
408      }, { sessionId });
409      console.log(`[wechat-browser] [primary] Click result: ${clickResult.result.value}`);
410 
411      const clickStatus = JSON.parse(clickResult.result.value);
412      if (clickStatus.error) {
413        throw new Error(`File input not found: ${clickStatus.error}`);
414      }
415 
416      // Wait for the file chooser event
417      console.log('[wechat-browser] [primary] Waiting for file chooser dialog...');
418      const chooser = await fileChooserPromise;
419 
420      console.log(`[wechat-browser] [primary] Setting files via backendNodeId=${chooser.backendNodeId}...`);
421      await cdp.send('DOM.setFileInputFiles', {
422        files: absolutePaths,
423        backendNodeId: chooser.backendNodeId,
424      }, { sessionId });
425      console.log('[wechat-browser] [primary] Files set successfully via file chooser interception');
426      uploadSuccess = true;
427    } catch (primaryErr) {
428      console.log(`[wechat-browser] [primary] File chooser approach failed: ${primaryErr instanceof Error ? primaryErr.message : String(primaryErr)}`);
429      // Disable interception before falling back
430      try { await cdp.send('Page.setInterceptFileChooserDialog', { enabled: false }, { sessionId }); } catch {}
431    }
432 
433    // --- FALLBACK approach: direct DOM.setFileInputFiles on nodeId ---
434    if (!uploadSuccess) {
435      console.log('[wechat-browser] [fallback] Trying direct DOM.setFileInputFiles...');
436      const { root } = await cdp.send<{ root: { nodeId: number } }>('DOM.getDocument', {}, { sessionId });
437 
438      const fileInputSelectors = [
439        '.js_upload_btn_container input[type=file]',
440        'input[type=file][multiple][accept*="image"]',
441        'input[type=file][accept*="image"]',
442        'input[type=file][multiple]',
443        'input[type=file]',
444      ];
445 
446      let nodeId = 0;
447      for (const sel of fileInputSelectors) {
448        const result = await cdp.send<{ nodeId: number }>('DOM.querySelector', { nodeId: root.nodeId, selector: sel }, { sessionId });
449        if (result.nodeId) {
450          console.log(`[wechat-browser] [fallback] Found file input with selector: ${sel}`);
451          nodeId = result.nodeId;
452          break;
453        }
454      }
455 
456      if (!nodeId) throw new Error('File input not found with any selector');
457 
458      await cdp.send('DOM.setFileInputFiles', { nodeId, files: absolutePaths }, { sessionId });
459      console.log('[wechat-browser] [fallback] Files set via nodeId');
460 
461      // Dispatch change event
462      await cdp.send('Runtime.evaluate', {
463        expression: `
464          (function() {
465            const selectors = ${JSON.stringify(fileInputSelectors)};
466            for (const sel of selectors) {
467              const el = document.querySelector(sel);
468              if (el) {
469                el.dispatchEvent(new Event('change', { bubbles: true }));
470                el.dispatchEvent(new Event('input', { bubbles: true }));
471                return 'dispatched on ' + sel;
472              }
473            }
474            return 'no input found for event dispatch';
475          })()
476        `,
477        returnByValue: true,
478      }, { sessionId });
479      console.log('[wechat-browser] [fallback] Change event dispatched');
480    }
481 
482    // Wait for images to upload
483    console.log('[wechat-browser] Waiting for images to upload...');
484    const targetCount = absolutePaths.length;
485    for (let i = 0; i < 30; i++) {
486      await sleep(2000);
487      const uploadCheck = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
488        expression: `
489          JSON.stringify({
490            uploaded: document.querySelectorAll('.weui-desktop-upload__thumb, .pic_item, [class*=upload_thumb], [class*="pic_item"], [class*="upload__thumb"]').length,
491            loading: document.querySelectorAll('[class*="upload_loading"], [class*="uploading"], .weui-desktop-upload__loading').length
492          })
493        `,
494        returnByValue: true,
495      }, { sessionId });
496      const status = JSON.parse(uploadCheck.result.value);
497      console.log(`[wechat-browser] Upload progress: ${status.uploaded}/${targetCount} (loading: ${status.loading})`);
498      if (status.uploaded >= targetCount) break;
499    }
500 
501    console.log('[wechat-browser] Filling title...');
502    await cdp.send('Runtime.evaluate', {
503      expression: `
504        const titleInput = document.querySelector('#title');
505        if (titleInput) {
506          titleInput.value = ${JSON.stringify(title)};
507          titleInput.dispatchEvent(new Event('input', { bubbles: true }));
508        } else {
509          throw new Error('Title input not found');
510        }
511      `,
512    }, { sessionId });
513    await sleep(500);
514 
515    console.log('[wechat-browser] Filling content...');
516    // Try ProseMirror editor first (new WeChat UI), then fallback to old editor
517    const contentResult = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
518      expression: `
519        (function() {
520          const contentHtml = ${JSON.stringify('<p>' + content.split('\n').filter(l => l.trim()).join('</p><p>') + '</p>')};
521 
522          // New UI: ProseMirror contenteditable
523          const pm = document.querySelector('.ProseMirror[contenteditable=true]');
524          if (pm) {
525            pm.innerHTML = contentHtml;
526            pm.dispatchEvent(new Event('input', { bubbles: true }));
527            return 'ProseMirror: content set, length=' + pm.textContent.length;
528          }
529 
530          // Old UI: .js_pmEditorArea
531          const oldEditor = document.querySelector('.js_pmEditorArea');
532          if (oldEditor) {
533            return JSON.stringify({ type: 'old', x: oldEditor.getBoundingClientRect().x + 50, y: oldEditor.getBoundingClientRect().y + 20 });
534          }
535 
536          return 'editor_not_found';
537        })()
538      `,
539      returnByValue: true,
540    }, { sessionId });
541 
542    const contentStatus = contentResult.result.value;
543    console.log(`[wechat-browser] Content result: ${contentStatus}`);
544 
545    if (contentStatus === 'editor_not_found') {
546      throw new Error('Content editor not found');
547    }
548 
549    // Fallback: old editor uses keyboard simulation
550    if (contentStatus.startsWith('{')) {
551      const editorClickPos = JSON.parse(contentStatus);
552      if (editorClickPos.type === 'old') {
553        console.log('[wechat-browser] Using old editor with keyboard simulation...');
554        await cdp.send('Input.dispatchMouseEvent', {
555          type: 'mousePressed',
556          x: editorClickPos.x,
557          y: editorClickPos.y,
558          button: 'left',
559          clickCount: 1,
560        }, { sessionId });
561        await sleep(50);
562        await cdp.send('Input.dispatchMouseEvent', {
563          type: 'mouseReleased',
564          x: editorClickPos.x,
565          y: editorClickPos.y,
566          button: 'left',
567          clickCount: 1,
568        }, { sessionId });
569        await sleep(300);
570 
571        const lines = content.split('\n');
572        for (let i = 0; i < lines.length; i++) {
573          const line = lines[i];
574          if (line!.length > 0) {
575            await cdp.send('Input.insertText', { text: line }, { sessionId });
576          }
577          if (i < lines.length - 1) {
578            await cdp.send('Input.dispatchKeyEvent', {
579              type: 'keyDown',
580              key: 'Enter',
581              code: 'Enter',
582              windowsVirtualKeyCode: 13,
583            }, { sessionId });
584            await cdp.send('Input.dispatchKeyEvent', {
585              type: 'keyUp',
586              key: 'Enter',
587              code: 'Enter',
588              windowsVirtualKeyCode: 13,
589            }, { sessionId });
590          }
591          await sleep(50);
592        }
593        console.log('[wechat-browser] Content typed via keyboard.');
594      }
595    }
596    await sleep(500);
597 
598    if (submit) {
599      console.log('[wechat-browser] Saving as draft...');
600      const submitResult = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
601        expression: `
602          (function() {
603            // Try new UI: find button by text
604            const allBtns = document.querySelectorAll('button');
605            for (const btn of allBtns) {
606              const text = btn.textContent?.trim();
607              if (text === '保存为草稿') {
608                btn.click();
609                return 'clicked:保存为草稿';
610              }
611            }
612            // Fallback: old UI selector
613            const oldBtn = document.querySelector('#js_submit');
614            if (oldBtn) {
615              oldBtn.click();
616              return 'clicked:#js_submit';
617            }
618            // List available buttons for debugging
619            const btnTexts = [];
620            allBtns.forEach(b => {
621              const t = b.textContent?.trim();
622              if (t && t.length < 20) btnTexts.push(t);
623            });
624            return 'not_found:' + btnTexts.join(',');
625          })()
626        `,
627        returnByValue: true,
628      }, { sessionId });
629      console.log(`[wechat-browser] Submit result: ${submitResult.result.value}`);
630      await sleep(3000);
631 
632      // Verify save success by checking for toast
633      const toastCheck = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
634        expression: `
635          const toasts = document.querySelectorAll('.weui-desktop-toast, [class*=toast]');
636          const msgs = [];
637          toasts.forEach(t => { const text = t.textContent?.trim(); if (text) msgs.push(text); });
638          JSON.stringify(msgs);
639        `,
640        returnByValue: true,
641      }, { sessionId });
642      console.log(`[wechat-browser] Toast messages: ${toastCheck.result.value}`);
643      console.log('[wechat-browser] Draft saved!');
644    } else {
645      console.log('[wechat-browser] Article composed (preview mode). Add --submit to save as draft.');
646    }
647  } finally {
648    if (cdp) {
649      cdp.close();
650    }
651    console.log('[wechat-browser] Done. Browser window left open.');
652  }
653}
654 
655function printUsage(): never {
656  console.log(`Post image-text (贴图) to WeChat Official Account
657 
658Usage:
659  npx -y bun wechat-browser.ts [options]
660 
661Options:
662  --markdown <path>  Markdown file for title/content extraction
663  --images <dir>     Directory containing images (PNG/JPG)
664  --title <text>     Article title (max 20 chars, auto-compressed)
665  --content <text>   Article content (max 1000 chars, auto-compressed)
666  --image <path>     Add image (can be repeated)
667  --submit           Save as draft (default: preview only)
668  --profile <dir>    Chrome profile directory
669  --account <alias>  Select account by alias (for multi-account setups)
670  --help             Show this help
671 
672Examples:
673  npx -y bun wechat-browser.ts --markdown article.md --images ./photos/
674  npx -y bun wechat-browser.ts --title "测试" --content "内容" --image ./photo.png
675  npx -y bun wechat-browser.ts --markdown article.md --images ./photos/ --submit
676`);
677  process.exit(0);
678}
679 
680async function main(): Promise<void> {
681  const args = process.argv.slice(2);
682  if (args.includes('--help') || args.includes('-h')) printUsage();
683 
684  const images: string[] = [];
685  let submit = false;
686  let profileDir: string | undefined;
687  let title: string | undefined;
688  let content: string | undefined;
689  let markdownFile: string | undefined;
690  let imagesDir: string | undefined;
691  let accountAlias: string | undefined;
692 
693  for (let i = 0; i < args.length; i++) {
694    const arg = args[i]!;
695    if (arg === '--image' && args[i + 1]) {
696      images.push(args[++i]!);
697    } else if (arg === '--images' && args[i + 1]) {
698      imagesDir = args[++i];
699    } else if (arg === '--title' && args[i + 1]) {
700      title = args[++i];
701    } else if (arg === '--content' && args[i + 1]) {
702      content = args[++i];
703    } else if (arg === '--markdown' && args[i + 1]) {
704      markdownFile = args[++i];
705    } else if (arg === '--submit') {
706      submit = true;
707    } else if (arg === '--profile' && args[i + 1]) {
708      profileDir = args[++i];
709    } else if (arg === '--account' && args[i + 1]) {
710      accountAlias = args[++i];
711    }
712  }
713 
714  const extConfig = loadWechatExtendConfig();
715  const resolved = resolveAccount(extConfig, accountAlias);
716  if (resolved.name) console.log(`[wechat-browser] Account: ${resolved.name} (${resolved.alias})`);
717 
718  if (!profileDir && resolved.alias) {
719    profileDir = resolved.chrome_profile_path || getAccountProfileDir(resolved.alias);
720  }
721 
722  if (!markdownFile && !title) {
723    console.error('Error: --title or --markdown is required');
724    process.exit(1);
725  }
726  if (!markdownFile && !content) {
727    console.error('Error: --content or --markdown is required');
728    process.exit(1);
729  }
730  if (images.length === 0 && !imagesDir) {
731    console.error('Error: --image or --images is required');
732    process.exit(1);
733  }
734 
735  await postToWeChat({ title, content, images: images.length > 0 ? images : undefined, imagesDir, markdownFile, submit, profileDir });
736}
737 
738await main().catch((err) => {
739  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
740  process.exit(1);
741});
742