1import fs from 'node:fs';
2import { mkdir, writeFile } from 'node:fs/promises';
3import os from 'node:os';
4import path from 'node:path';
5import {
6  CdpConnection,
7  copyHtmlToClipboard,
8  copyImageToClipboard,
9  findChromeExecutable,
10  findExistingChromeDebugPort,
11  getDefaultProfileDir,
12  launchChrome,
13  pasteFromClipboard,
14  sleep,
15  waitForChromeDebugPort,
16} from './weibo-utils.js';
17import { parseMarkdown } from './md-to-html.js';
18 
19const WEIBO_ARTICLE_URL = 'https://card.weibo.com/article/v3/editor';
20 
21const TITLE_MAX_LENGTH = 32;
22const SUMMARY_MAX_LENGTH = 44;
23 
24interface ArticleOptions {
25  markdownPath: string;
26  coverImage?: string;
27  title?: string;
28  summary?: string;
29  profileDir?: string;
30  chromePath?: string;
31}
32 
33export async function publishArticle(options: ArticleOptions): Promise<void> {
34  const { markdownPath, profileDir = getDefaultProfileDir() } = options;
35 
36  console.log('[weibo-article] Parsing markdown...');
37  const parsed = await parseMarkdown(markdownPath, {
38    title: options.title,
39    coverImage: options.coverImage,
40  });
41 
42  let title = parsed.title;
43  if (title.length > TITLE_MAX_LENGTH) {
44    console.warn(`[weibo-article] Title exceeds ${TITLE_MAX_LENGTH} chars (${title.length}), truncating at word boundary...`);
45    const truncated = title.slice(0, TITLE_MAX_LENGTH);
46    const breakChars = ['：', '，', '、', '。', ' ', '—', '→', '｜', '|', '-'];
47    let lastBreak = -1;
48    for (const ch of breakChars) {
49      const idx = truncated.lastIndexOf(ch);
50      if (idx > lastBreak) lastBreak = idx;
51    }
52    title = lastBreak > TITLE_MAX_LENGTH * 0.4
53      ? truncated.slice(0, lastBreak).replace(/[\s→—\-|｜：，]+$/, '')
54      : truncated;
55  }
56 
57  let summary = options.summary || parsed.summary || '';
58  if (summary.length > SUMMARY_MAX_LENGTH) {
59    console.warn(`[weibo-article] Summary exceeds ${SUMMARY_MAX_LENGTH} chars (${summary.length}), regenerating from content...`);
60    summary = parsed.shortSummary || summary.slice(0, SUMMARY_MAX_LENGTH - 1) + '\u2026';
61  }
62 
63  console.log(`[weibo-article] Title (${title.length}/${TITLE_MAX_LENGTH}): ${title}`);
64  console.log(`[weibo-article] Summary (${summary.length}/${SUMMARY_MAX_LENGTH}): ${summary}`);
65  console.log(`[weibo-article] Cover: ${parsed.coverImage ?? 'none'}`);
66  console.log(`[weibo-article] Content images: ${parsed.contentImages.length}`);
67 
68  const htmlPath = path.join(os.tmpdir(), 'weibo-article-content.html');
69  await writeFile(htmlPath, parsed.html, 'utf-8');
70  console.log(`[weibo-article] HTML saved to: ${htmlPath}`);
71 
72  await mkdir(profileDir, { recursive: true });
73 
74  // Try reusing an existing Chrome instance with the same profile
75  const existingPort = await findExistingChromeDebugPort(profileDir);
76  let port: number;
77 
78  if (existingPort) {
79    console.log(`[weibo-article] Found existing Chrome on port ${existingPort}, reusing...`);
80    port = existingPort;
81  } else {
82    const chromePath = findChromeExecutable(options.chromePath);
83    if (!chromePath) throw new Error('Chrome not found. Set WEIBO_BROWSER_CHROME_PATH env var.');
84 
85    port = await launchChrome(WEIBO_ARTICLE_URL, profileDir, chromePath);
86  }
87 
88  let cdp: CdpConnection | null = null;
89 
90  try {
91    const wsUrl = await waitForChromeDebugPort(port, 30_000);
92    cdp = await CdpConnection.connect(wsUrl, 30_000, { defaultTimeoutMs: 60_000 });
93 
94    const targets = await cdp.send<{ targetInfos: Array<{ targetId: string; url: string; type: string }> }>('Target.getTargets');
95    // Always create a fresh tab for the article editor
96    const { targetId } = await cdp.send<{ targetId: string }>('Target.createTarget', { url: WEIBO_ARTICLE_URL });
97    const pageTarget = { targetId, url: WEIBO_ARTICLE_URL, type: 'page' };
98    console.log('[weibo-article] Opened article editor in new tab');
99 
100    const { sessionId } = await cdp.send<{ sessionId: string }>('Target.attachToTarget', { targetId: pageTarget.targetId, flatten: true });
101 
102    await cdp.send('Page.enable', {}, { sessionId });
103    await cdp.send('Runtime.enable', {}, { sessionId });
104    await cdp.send('DOM.enable', {}, { sessionId });
105 
106    console.log('[weibo-article] Waiting for article editor page...');
107    await sleep(3000);
108 
109    const waitForElement = async (expression: string, timeoutMs = 60_000): Promise<boolean> => {
110      const start = Date.now();
111      while (Date.now() - start < timeoutMs) {
112        const result = await cdp!.send<{ result: { value: boolean } }>('Runtime.evaluate', {
113          expression,
114          returnByValue: true,
115        }, { sessionId });
116        if (result.result.value) return true;
117        await sleep(500);
118      }
119      return false;
120    };
121 
122    // Step 1: Find and click "写文章" button
123    console.log('[weibo-article] Looking for "写文章" button...');
124    const writeButtonFound = await waitForElement(`
125      !!Array.from(document.querySelectorAll('button, a, div[role="button"]')).find(el => el.textContent?.trim() === '写文章')
126    `, 15_000);
127 
128    if (writeButtonFound) {
129      console.log('[weibo-article] Clicking "写文章" button...');
130      await cdp.send('Runtime.evaluate', {
131        expression: `
132          const btn = Array.from(document.querySelectorAll('button, a, div[role="button"]')).find(el => el.textContent?.trim() === '写文章');
133          if (btn) btn.click();
134        `,
135      }, { sessionId });
136      await sleep(1000);
137 
138      // Wait for title input to become editable (not readonly)
139      console.log('[weibo-article] Waiting for editor to become editable...');
140      const editable = await waitForElement(`
141        (() => {
142          const el = document.querySelector('textarea[placeholder="请输入标题"]');
143          return el && !el.readOnly && !el.disabled;
144        })()
145      `, 15_000);
146 
147      if (!editable) {
148        console.warn('[weibo-article] Title input still readonly after waiting. Proceeding anyway...');
149      }
150    } else {
151      // Maybe we're already on the editor page
152      console.log('[weibo-article] "写文章" button not found, checking if editor is already loaded...');
153      const editorExists = await waitForElement(`
154        !!document.querySelector('textarea[placeholder="请输入标题"]')
155      `, 10_000);
156      if (!editorExists) {
157        throw new Error('Weibo article editor not found. Please ensure you are logged in.');
158      }
159    }
160 
161    // Step 2: Fill title
162    if (title) {
163      console.log('[weibo-article] Filling title...');
164 
165      // Check if title input exists
166      const titleExists = await cdp.send<{ result: { value: boolean } }>('Runtime.evaluate', {
167        expression: `!!document.querySelector('textarea[placeholder="请输入标题"]')`,
168        returnByValue: true,
169      }, { sessionId });
170 
171      if (!titleExists.result.value) {
172        console.error('[weibo-article] Title input NOT found: textarea[placeholder="请输入标题"]');
173      } else {
174        console.log('[weibo-article] Title input found');
175 
176        // Focus and use Input.insertText via CDP (more reliable for React/Vue controlled inputs)
177        await cdp.send('Runtime.evaluate', {
178          expression: `(() => {
179            const el = document.querySelector('textarea[placeholder="请输入标题"]');
180            if (el) { el.focus(); el.value = ''; }
181          })()`,
182        }, { sessionId });
183        await sleep(200);
184 
185        await cdp.send('Input.insertText', { text: title }, { sessionId });
186        await sleep(500);
187 
188        // Verify title was entered
189        const titleCheck = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
190          expression: `document.querySelector('textarea[placeholder="请输入标题"]')?.value || ''`,
191          returnByValue: true,
192        }, { sessionId });
193 
194        if (titleCheck.result.value === title) {
195          console.log(`[weibo-article] Title verified: "${titleCheck.result.value}"`);
196        } else if (titleCheck.result.value.length > 0) {
197          console.warn(`[weibo-article] Title partially entered: "${titleCheck.result.value}" (expected: "${title}")`);
198        } else {
199          console.warn('[weibo-article] Title input appears empty after insertion, trying execCommand fallback...');
200          await cdp.send('Runtime.evaluate', {
201            expression: `(() => {
202              const el = document.querySelector('textarea[placeholder="请输入标题"]');
203              if (el) { el.focus(); document.execCommand('insertText', false, ${JSON.stringify(title)}); }
204            })()`,
205          }, { sessionId });
206          await sleep(300);
207 
208          const titleRecheck = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
209            expression: `document.querySelector('textarea[placeholder="请输入标题"]')?.value || ''`,
210            returnByValue: true,
211          }, { sessionId });
212          console.log(`[weibo-article] Title after fallback: "${titleRecheck.result.value}"`);
213        }
214      }
215    }
216 
217    // Step 3: Fill summary (导语)
218    if (summary) {
219      console.log('[weibo-article] Filling summary...');
220 
221      const summaryExists = await cdp.send<{ result: { value: boolean } }>('Runtime.evaluate', {
222        expression: `!!document.querySelector('textarea[placeholder="导语（选填）"]')`,
223        returnByValue: true,
224      }, { sessionId });
225 
226      if (!summaryExists.result.value) {
227        console.error('[weibo-article] Summary input NOT found: textarea[placeholder="导语（选填）"]');
228      } else {
229        console.log('[weibo-article] Summary input found');
230 
231        await cdp.send('Runtime.evaluate', {
232          expression: `(() => {
233            const el = document.querySelector('textarea[placeholder="导语（选填）"]');
234            if (el) { el.focus(); el.value = ''; }
235          })()`,
236        }, { sessionId });
237        await sleep(200);
238 
239        await cdp.send('Input.insertText', { text: summary }, { sessionId });
240        await sleep(500);
241 
242        // Verify summary was entered
243        const summaryCheck = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
244          expression: `document.querySelector('textarea[placeholder="导语（选填）"]')?.value || ''`,
245          returnByValue: true,
246        }, { sessionId });
247 
248        if (summaryCheck.result.value === summary) {
249          console.log(`[weibo-article] Summary verified: "${summaryCheck.result.value}"`);
250        } else if (summaryCheck.result.value.length > 0) {
251          console.warn(`[weibo-article] Summary partially entered: "${summaryCheck.result.value}"`);
252        } else {
253          console.warn('[weibo-article] Summary input appears empty, trying execCommand fallback...');
254          await cdp.send('Runtime.evaluate', {
255            expression: `(() => {
256              const el = document.querySelector('textarea[placeholder="导语（选填）"]');
257              if (el) { el.focus(); document.execCommand('insertText', false, ${JSON.stringify(summary)}); }
258            })()`,
259          }, { sessionId });
260          await sleep(300);
261 
262          const summaryRecheck = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
263            expression: `document.querySelector('textarea[placeholder="导语（选填）"]')?.value || ''`,
264            returnByValue: true,
265          }, { sessionId });
266          console.log(`[weibo-article] Summary after fallback: "${summaryRecheck.result.value}"`);
267        }
268      }
269    }
270 
271    // Step 4: Insert HTML content into ProseMirror editor
272    console.log('[weibo-article] Inserting content...');
273 
274    const htmlContent = fs.readFileSync(htmlPath, 'utf-8');
275 
276    // Check if ProseMirror editor exists
277    const editorExists2 = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
278      expression: `(() => {
279        const el = document.querySelector('div[contenteditable="true"]');
280        if (!el) return 'NOT_FOUND';
281        return 'class=' + el.className;
282      })()`,
283      returnByValue: true,
284    }, { sessionId });
285 
286    if (editorExists2.result.value === 'NOT_FOUND') {
287      console.error('[weibo-article] ProseMirror editor NOT found: div[contenteditable="true"]');
288    } else {
289      console.log(`[weibo-article] Editor found (${editorExists2.result.value})`);
290    }
291 
292    // Focus ProseMirror editor
293    await cdp.send('Runtime.evaluate', {
294      expression: `(() => {
295        const editor = document.querySelector('div[contenteditable="true"]');
296        if (editor) { editor.focus(); editor.click(); }
297      })()`,
298    }, { sessionId });
299    await sleep(300);
300 
301    // Method 1: Copy HTML to system clipboard, then real paste keystroke
302    console.log('[weibo-article] Copying HTML to clipboard and pasting...');
303    copyHtmlToClipboard(htmlPath);
304    await sleep(500);
305 
306    // Focus editor again before paste
307    await cdp.send('Runtime.evaluate', {
308      expression: `document.querySelector('div[contenteditable="true"]')?.focus()`,
309    }, { sessionId });
310    await sleep(200);
311 
312    pasteFromClipboard('Google Chrome', 5, 500);
313    await sleep(2000);
314 
315    // Check if content was inserted
316    const contentCheck = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
317      expression: `document.querySelector('div[contenteditable="true"]')?.innerText?.length || 0`,
318      returnByValue: true,
319    }, { sessionId });
320 
321    if (contentCheck.result.value > 50) {
322      console.log(`[weibo-article] Content inserted via clipboard paste (${contentCheck.result.value} chars)`);
323    } else {
324      console.log(`[weibo-article] Clipboard paste got ${contentCheck.result.value} chars, trying DataTransfer paste event...`);
325 
326      // Method 2: Simulate paste event with HTML data
327      await cdp.send('Runtime.evaluate', {
328        expression: `(() => {
329          const editor = document.querySelector('div[contenteditable="true"]');
330          if (!editor) return false;
331          editor.focus();
332 
333          const html = ${JSON.stringify(htmlContent)};
334          const dt = new DataTransfer();
335          dt.setData('text/html', html);
336          dt.setData('text/plain', html.replace(/<[^>]*>/g, ''));
337 
338          const pasteEvent = new ClipboardEvent('paste', {
339            bubbles: true, cancelable: true, clipboardData: dt
340          });
341          editor.dispatchEvent(pasteEvent);
342          return true;
343        })()`,
344        returnByValue: true,
345      }, { sessionId });
346      await sleep(1000);
347 
348      const check2 = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
349        expression: `document.querySelector('div[contenteditable="true"]')?.innerText?.length || 0`,
350        returnByValue: true,
351      }, { sessionId });
352 
353      if (check2.result.value > 50) {
354        console.log(`[weibo-article] Content inserted via DataTransfer (${check2.result.value} chars)`);
355      } else {
356        console.log(`[weibo-article] DataTransfer got ${check2.result.value} chars, trying insertHTML...`);
357 
358        // Method 3: execCommand insertHTML
359        await cdp.send('Runtime.evaluate', {
360          expression: `(() => {
361            const editor = document.querySelector('div[contenteditable="true"]');
362            if (!editor) return false;
363            editor.focus();
364            document.execCommand('insertHTML', false, ${JSON.stringify(htmlContent)});
365            return true;
366          })()`,
367        }, { sessionId });
368        await sleep(1000);
369 
370        const check3 = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
371          expression: `document.querySelector('div[contenteditable="true"]')?.innerText?.length || 0`,
372          returnByValue: true,
373        }, { sessionId });
374 
375        if (check3.result.value > 50) {
376          console.log(`[weibo-article] Content inserted via execCommand (${check3.result.value} chars)`);
377        } else {
378          console.error('[weibo-article] All auto-insert methods failed. HTML is on clipboard - please paste manually (Cmd+V)');
379          console.log('[weibo-article] Waiting 30s for manual paste...');
380          await sleep(30_000);
381        }
382      }
383    }
384 
385    // Step 5: Insert content images
386    if (parsed.contentImages.length > 0) {
387      console.log('[weibo-article] Inserting content images...');
388 
389      const editorContent = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
390        expression: `document.querySelector('div[contenteditable="true"]')?.innerText || ''`,
391        returnByValue: true,
392      }, { sessionId });
393 
394      console.log('[weibo-article] Checking for placeholders in content...');
395      let placeholderCount = 0;
396      for (const img of parsed.contentImages) {
397        const regex = new RegExp(img.placeholder + '(?!\\d)');
398        if (regex.test(editorContent.result.value)) {
399          console.log(`[weibo-article] Found: ${img.placeholder}`);
400          placeholderCount++;
401        } else {
402          console.log(`[weibo-article] NOT found: ${img.placeholder}`);
403        }
404      }
405      console.log(`[weibo-article] ${placeholderCount}/${parsed.contentImages.length} placeholders found in editor`);
406 
407      const getPlaceholderIndex = (placeholder: string): number => {
408        const match = placeholder.match(/WBIMGPH_(\d+)/);
409        return match ? Number(match[1]) : Number.POSITIVE_INFINITY;
410      };
411      const sortedImages = [...parsed.contentImages].sort(
412        (a, b) => getPlaceholderIndex(a.placeholder) - getPlaceholderIndex(b.placeholder),
413      );
414 
415      for (let i = 0; i < sortedImages.length; i++) {
416        const img = sortedImages[i]!;
417        console.log(`[weibo-article] [${i + 1}/${sortedImages.length}] Inserting image at placeholder: ${img.placeholder}`);
418 
419        const selectPlaceholder = async (maxRetries = 3): Promise<boolean> => {
420          for (let attempt = 1; attempt <= maxRetries; attempt++) {
421            await cdp!.send('Runtime.evaluate', {
422              expression: `(() => {
423                const editor = document.querySelector('div[contenteditable="true"]');
424                if (!editor) return false;
425 
426                const placeholder = ${JSON.stringify(img.placeholder)};
427 
428                const walker = document.createTreeWalker(editor, NodeFilter.SHOW_TEXT, null, false);
429                let node;
430 
431                while ((node = walker.nextNode())) {
432                  const text = node.textContent || '';
433                  let searchStart = 0;
434                  let idx;
435                  while ((idx = text.indexOf(placeholder, searchStart)) !== -1) {
436                    const afterIdx = idx + placeholder.length;
437                    const charAfter = text[afterIdx];
438                    if (charAfter === undefined || !/\\d/.test(charAfter)) {
439                      const parentElement = node.parentElement;
440                      if (parentElement) {
441                        parentElement.scrollIntoView({ behavior: 'instant', block: 'center' });
442                      }
443 
444                      const range = document.createRange();
445                      range.setStart(node, idx);
446                      range.setEnd(node, idx + placeholder.length);
447                      const sel = window.getSelection();
448                      sel.removeAllRanges();
449                      sel.addRange(range);
450                      return true;
451                    }
452                    searchStart = afterIdx;
453                  }
454                }
455                return false;
456              })()`,
457            }, { sessionId });
458 
459            await sleep(800);
460 
461            const selectionCheck = await cdp!.send<{ result: { value: string } }>('Runtime.evaluate', {
462              expression: `window.getSelection()?.toString() || ''`,
463              returnByValue: true,
464            }, { sessionId });
465 
466            const selectedText = selectionCheck.result.value.trim();
467            if (selectedText === img.placeholder) {
468              console.log(`[weibo-article] Selection verified: "${selectedText}"`);
469              return true;
470            }
471 
472            if (attempt < maxRetries) {
473              console.log(`[weibo-article] Selection attempt ${attempt} got "${selectedText}", retrying...`);
474              await sleep(500);
475            } else {
476              console.warn(`[weibo-article] Selection failed after ${maxRetries} attempts, got: "${selectedText}"`);
477            }
478          }
479          return false;
480        };
481 
482        // Step A: Copy image to clipboard first (slow due to Swift compilation)
483        console.log(`[weibo-article] Copying image to clipboard: ${path.basename(img.localPath)}`);
484        if (!copyImageToClipboard(img.localPath)) {
485          console.warn(`[weibo-article] Failed to copy image to clipboard`);
486          continue;
487        }
488        await sleep(500);
489 
490        // Step B: Select placeholder text (paste will replace the selection)
491        const selected = await selectPlaceholder(3);
492        if (!selected) {
493          console.warn(`[weibo-article] Skipping image - could not select placeholder: ${img.placeholder}`);
494          continue;
495        }
496 
497        // Step C: Delete selected placeholder via Backspace (ProseMirror-compatible)
498        console.log(`[weibo-article] Deleting placeholder via Backspace...`);
499        await cdp.send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Backspace', code: 'Backspace', windowsVirtualKeyCode: 8 }, { sessionId });
500        await cdp.send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Backspace', code: 'Backspace', windowsVirtualKeyCode: 8 }, { sessionId });
501        await sleep(500);
502 
503        // Verify placeholder was deleted
504        const placeholderGone = await cdp.send<{ result: { value: boolean } }>('Runtime.evaluate', {
505          expression: `(() => {
506            const editor = document.querySelector('div[contenteditable="true"]');
507            if (!editor) return true;
508            const placeholder = ${JSON.stringify(img.placeholder)};
509            const regex = new RegExp(placeholder + '(?!\\\\d)');
510            return !regex.test(editor.innerText);
511          })()`,
512          returnByValue: true,
513        }, { sessionId });
514 
515        if (placeholderGone.result.value) {
516          console.log(`[weibo-article] Placeholder deleted`);
517        } else {
518          console.warn(`[weibo-article] Placeholder may still exist, trying execCommand delete...`);
519          // Re-select and delete via execCommand
520          await selectPlaceholder(1);
521          await cdp.send('Runtime.evaluate', {
522            expression: `document.execCommand('delete')`,
523          }, { sessionId });
524          await sleep(300);
525        }
526 
527        // Step D: Focus editor and paste image
528        await cdp.send('Runtime.evaluate', {
529          expression: `document.querySelector('div[contenteditable="true"]')?.focus()`,
530        }, { sessionId });
531        await sleep(200);
532 
533        // Count images before paste
534        const imgCountBefore = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
535          expression: `document.querySelectorAll('div[contenteditable="true"] img').length`,
536          returnByValue: true,
537        }, { sessionId });
538 
539        // Paste image at cursor position (where placeholder was)
540        console.log(`[weibo-article] Pasting image...`);
541        if (pasteFromClipboard('Google Chrome', 5, 1000)) {
542          console.log(`[weibo-article] Paste keystroke sent for: ${path.basename(img.localPath)}`);
543        } else {
544          console.warn(`[weibo-article] Failed to paste image after retries`);
545        }
546 
547        // Verify image appeared in editor
548        console.log(`[weibo-article] Verifying image insertion...`);
549        const expectedImgCount = imgCountBefore.result.value + 1;
550        let imgInserted = false;
551        const imgWaitStart = Date.now();
552        while (Date.now() - imgWaitStart < 15_000) {
553          const r = await cdp!.send<{ result: { value: number } }>('Runtime.evaluate', {
554            expression: `document.querySelectorAll('div[contenteditable="true"] img').length`,
555            returnByValue: true,
556          }, { sessionId });
557          if (r.result.value >= expectedImgCount) {
558            imgInserted = true;
559            break;
560          }
561          await sleep(1000);
562        }
563 
564        if (imgInserted) {
565          console.log(`[weibo-article] Image insertion verified (${expectedImgCount} image(s) in editor)`);
566 
567          await sleep(1000);
568 
569          // Clean up extra empty <p> before the image (Tiptap invisible chars + <br>)
570          console.log(`[weibo-article] Cleaning up empty lines around image...`);
571          await cdp!.send('Runtime.evaluate', {
572            expression: `(() => {
573              const editor = document.querySelector('div[contenteditable="true"]');
574              if (!editor) return;
575              const imageViews = editor.querySelectorAll('.image-view__body');
576              const lastView = imageViews[imageViews.length - 1];
577              const imgBlock = lastView?.closest('div[data-type], .ProseMirror > *') || lastView?.parentElement;
578              if (!imgBlock) return;
579              let prev = imgBlock.previousElementSibling;
580              let removed = 0;
581              while (prev) {
582                const tag = prev.tagName?.toLowerCase();
583                const text = prev.textContent?.replace(/\\u200b/g, '').trim();
584                const hasOnlyBreaks = prev.querySelectorAll('br, .Tiptap-invisible-character').length > 0;
585                if ((tag === 'p' || tag === 'div') && (!text || text === '') && hasOnlyBreaks) {
586                  const toRemove = prev;
587                  prev = prev.previousElementSibling;
588                  toRemove.remove();
589                  removed++;
590                  if (removed >= 2) break;
591                } else {
592                  break;
593                }
594              }
595            })()`,
596          }, { sessionId });
597 
598          // Fill image caption if alt text exists
599          const altText = img.alt?.trim();
600          if (altText) {
601            console.log(`[weibo-article] Setting image caption: "${altText}"`);
602            const captionResult = await cdp!.send<{ result: { value: string } }>('Runtime.evaluate', {
603              expression: `(() => {
604                const editor = document.querySelector('div[contenteditable="true"]');
605                if (!editor) return 'no_editor';
606                const views = editor.querySelectorAll('.image-view__body');
607                const lastView = views[views.length - 1];
608                if (!lastView) return 'no_view';
609                const captionSpan = lastView.querySelector('.image-view__caption span[data-node-view-content]');
610                if (!captionSpan) return 'no_caption_span';
611                captionSpan.focus();
612                captionSpan.textContent = ${JSON.stringify(altText)};
613                captionSpan.dispatchEvent(new Event('input', { bubbles: true }));
614                return 'set';
615              })()`,
616              returnByValue: true,
617            }, { sessionId });
618            console.log(`[weibo-article] Caption result: ${captionResult.result.value}`);
619            await sleep(300);
620          }
621        } else {
622          console.warn(`[weibo-article] Image insertion not detected after 15s`);
623          if (i === 0) {
624            console.error('[weibo-article] First image paste failed. Check Accessibility permissions for your terminal app.');
625          }
626        }
627 
628        // Wait for editor to stabilize
629        await sleep(2000);
630      }
631 
632      console.log('[weibo-article] All images processed.');
633 
634      // Clean up extra empty <p> before images (Tiptap invisible chars + <br>)
635      console.log('[weibo-article] Cleaning up extra line breaks before images...');
636      const cleanupResult = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
637        expression: `(() => {
638          const editor = document.querySelector('div[contenteditable="true"]');
639          if (!editor) return 0;
640          let removed = 0;
641          const imageViews = editor.querySelectorAll('.image-view__body');
642          for (const view of imageViews) {
643            const imgBlock = view.closest('div[data-type], .ProseMirror > *') || view.parentElement;
644            if (!imgBlock) continue;
645            let prev = imgBlock.previousElementSibling;
646            while (prev) {
647              const tag = prev.tagName?.toLowerCase();
648              const text = prev.textContent?.replace(/\\u200b/g, '').trim();
649              const hasOnlyBreaks = prev.querySelectorAll('br, .Tiptap-invisible-character').length > 0;
650              if ((tag === 'p' || tag === 'div') && (!text || text === '') && hasOnlyBreaks) {
651                const toRemove = prev;
652                prev = toRemove.previousElementSibling;
653                toRemove.remove();
654                removed++;
655              } else {
656                break;
657              }
658            }
659          }
660          return removed;
661        })()`,
662        returnByValue: true,
663      }, { sessionId });
664      if (cleanupResult.result.value > 0) {
665        console.log(`[weibo-article] Removed ${cleanupResult.result.value} extra line break(s) before images.`);
666      }
667      await sleep(500);
668 
669      // Final verification
670      console.log('[weibo-article] Running post-composition verification...');
671      const finalEditorContent = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
672        expression: `document.querySelector('div[contenteditable="true"]')?.innerText || ''`,
673        returnByValue: true,
674      }, { sessionId });
675 
676      const remainingPlaceholders: string[] = [];
677      for (const img of parsed.contentImages) {
678        const regex = new RegExp(img.placeholder + '(?!\\d)');
679        if (regex.test(finalEditorContent.result.value)) {
680          remainingPlaceholders.push(img.placeholder);
681        }
682      }
683 
684      const finalImgCount = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
685        expression: `document.querySelectorAll('div[contenteditable="true"] img').length`,
686        returnByValue: true,
687      }, { sessionId });
688 
689      const expectedCount = parsed.contentImages.length;
690      const actualCount = finalImgCount.result.value;
691 
692      if (remainingPlaceholders.length > 0 || actualCount < expectedCount) {
693        console.warn('[weibo-article] POST-COMPOSITION CHECK FAILED:');
694        if (remainingPlaceholders.length > 0) {
695          console.warn(`[weibo-article]   Remaining placeholders: ${remainingPlaceholders.join(', ')}`);
696        }
697        if (actualCount < expectedCount) {
698          console.warn(`[weibo-article]   Image count: expected ${expectedCount}, found ${actualCount}`);
699        }
700        console.warn('[weibo-article]   Please check the article before publishing.');
701      } else {
702        console.log(`[weibo-article] Verification passed: ${actualCount} image(s), no remaining placeholders.`);
703      }
704    }
705 
706    // Step 6: Set cover image
707    const coverImagePath = parsed.coverImage;
708    if (coverImagePath && fs.existsSync(coverImagePath)) {
709      console.log(`[weibo-article] Setting cover image: ${path.basename(coverImagePath)}`);
710 
711      // Scroll to top first
712      await cdp.send('Runtime.evaluate', {
713        expression: `window.scrollTo(0, 0)`,
714      }, { sessionId });
715      await sleep(500);
716 
717      // 1. Click cover area to open dialog (cover-empty or cover-preview)
718      // First scroll element into view
719      await cdp.send('Runtime.evaluate', {
720        expression: `(() => {
721          const el = document.querySelector('.cover-empty') || document.querySelector('.cover-preview');
722          if (el) { el.scrollIntoView({ block: 'center' }); return true; }
723          return false;
724        })()`,
725        returnByValue: true,
726      }, { sessionId });
727      await sleep(1000);
728 
729      // Then get coordinates after scroll settles
730      const coverBtnPos = await cdp.send<{ result: { value: { x: number; y: number } | null } }>('Runtime.evaluate', {
731        expression: `(() => {
732          const el = document.querySelector('.cover-empty') || document.querySelector('.cover-preview');
733          if (el) {
734            const rect = el.getBoundingClientRect();
735            return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
736          }
737          return null;
738        })()`,
739        returnByValue: true,
740      }, { sessionId });
741 
742      if (coverBtnPos.result.value) {
743        const { x, y } = coverBtnPos.result.value;
744        console.log(`[weibo-article] "设置文章封面" at (${x}, ${y}), clicking...`);
745        await cdp.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 }, { sessionId });
746        await sleep(100);
747        await cdp.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 }, { sessionId });
748      } else {
749        console.warn('[weibo-article] "设置文章封面" (.cover-empty) not found');
750      }
751      await sleep(2000);
752 
753      // Wait for dialog to appear
754      const dialogReady = await waitForElement(`!!document.querySelector('.n-dialog')`, 10_000);
755      console.log(`[weibo-article] Dialog appeared: ${dialogReady}`);
756 
757      // 2. Click "图片库" tab
758      const tabClicked = await cdp.send<{ result: { value: boolean } }>('Runtime.evaluate', {
759        expression: `(() => {
760          const tabs = document.querySelectorAll('.n-tabs-tab');
761          for (const t of tabs) {
762            if (t.querySelector('.n-tabs-tab__label span')?.textContent?.trim() === '图片库') { t.click(); return true; }
763          }
764          return false;
765        })()`,
766        returnByValue: true,
767      }, { sessionId });
768      console.log(`[weibo-article] "图片库" tab clicked: ${tabClicked.result.value}`);
769      await sleep(1000);
770 
771      // 3. Count existing items before upload
772      const itemCountBefore = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
773        expression: `document.querySelectorAll('.image-list .image-item').length`,
774        returnByValue: true,
775      }, { sessionId });
776      console.log(`[weibo-article] Items before upload: ${itemCountBefore.result.value}`);
777 
778      // 4. Upload via hidden file input
779      console.log('[weibo-article] Uploading cover image via file input...');
780      const absPath = path.resolve(coverImagePath);
781 
782      // Get DOM document root first, then find file input via DOM.querySelector
783      const docRoot = await cdp.send<{ root: { nodeId: number } }>('DOM.getDocument', { depth: -1 }, { sessionId });
784      const fileInputNodes = await cdp.send<{ nodeIds: number[] }>('DOM.querySelectorAll', {
785        nodeId: docRoot.root.nodeId,
786        selector: 'input[type="file"]',
787      }, { sessionId });
788 
789      const fileInputNodeId = fileInputNodes.nodeIds?.[0];
790      if (!fileInputNodeId) {
791        console.warn('[weibo-article] File input not found, skipping cover image');
792      } else {
793        await cdp.send('DOM.setFileInputFiles', {
794          nodeId: fileInputNodeId,
795          files: [absPath],
796        }, { sessionId });
797        console.log('[weibo-article] File set on input, waiting for upload...');
798 
799        // 5. Wait for a new item to appear (item count increases)
800        let uploadSuccess = false;
801        const uploadStart = Date.now();
802        while (Date.now() - uploadStart < 30_000) {
803          const state = await cdp.send<{ result: { value: { count: number; firstSrc: string } } }>('Runtime.evaluate', {
804            expression: `(() => {
805              const items = document.querySelectorAll('.image-list .image-item');
806              const first = items[0];
807              const img = first?.querySelector('img');
808              return { count: items.length, firstSrc: img?.src || '' };
809            })()`,
810            returnByValue: true,
811          }, { sessionId });
812          const { count, firstSrc } = state.result.value;
813          if (count > itemCountBefore.result.value && firstSrc.startsWith('https://')) {
814            console.log(`[weibo-article] New image uploaded (${count} items, src: https://...)`);
815            uploadSuccess = true;
816            break;
817          }
818          if (firstSrc.startsWith('blob:')) {
819            console.log('[weibo-article] Cover image uploading (blob detected)...');
820          }
821          await sleep(1000);
822        }
823 
824        if (!uploadSuccess) {
825          // Fallback: check if first item has https (maybe count didn't change but image was replaced)
826          const fallback = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
827            expression: `document.querySelector('.image-list .image-item img')?.src || ''`,
828            returnByValue: true,
829          }, { sessionId });
830          if (fallback.result.value.startsWith('https://')) {
831            console.log('[weibo-article] Cover image ready (fallback check)');
832            uploadSuccess = true;
833          } else {
834            console.warn('[weibo-article] Cover image upload timed out after 30s');
835          }
836        }
837 
838        if (uploadSuccess) {
839          // 6. Click first item to select it
840          const clickResult = await cdp.send<{ result: { value: boolean } }>('Runtime.evaluate', {
841            expression: `(() => {
842              const item = document.querySelector('.image-list .image-item');
843              if (item) { item.click(); return true; }
844              return false;
845            })()`,
846            returnByValue: true,
847          }, { sessionId });
848          console.log(`[weibo-article] First item clicked: ${clickResult.result.value}`);
849          await sleep(500);
850 
851          // Verify selection
852          const selected = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
853            expression: `(() => {
854              const items = document.querySelectorAll('.image-list .image-item');
855              const selectedIdx = Array.from(items).findIndex(i => i.classList.contains('is-selected'));
856              return 'selected_index=' + selectedIdx + ' total=' + items.length;
857            })()`,
858            returnByValue: true,
859          }, { sessionId });
860          console.log(`[weibo-article] Selection: ${selected.result.value}`);
861 
862          // 7. Click "下一步" in dialog (image selection → crop)
863          const nextResult = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
864            expression: `(() => {
865              const dialog = document.querySelector('.n-dialog');
866              if (!dialog) return 'no_dialog';
867              const buttons = dialog.querySelectorAll('.n-button');
868              for (const b of buttons) {
869                const text = b.querySelector('.n-button__content')?.textContent?.trim() || '';
870                if (text === '下一步') { b.click(); return 'clicked'; }
871              }
872              return 'not_found';
873            })()`,
874            returnByValue: true,
875          }, { sessionId });
876          console.log(`[weibo-article] "下一步" (select→crop): ${nextResult.result.value}`);
877          await sleep(3000);
878 
879          // 8. Click "确定" in crop dialog
880          // First check button state and dispatch full pointer event sequence
881          const confirmInfo = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
882            expression: `(() => {
883              const dialog = document.querySelector('.n-dialog');
884              if (!dialog) return 'no_dialog';
885              const buttons = dialog.querySelectorAll('.n-button');
886              for (const b of buttons) {
887                const text = b.querySelector('.n-button__content')?.textContent?.trim() || '';
888                if (text === '确定' || text === '确认') {
889                  const disabled = b.disabled || b.classList.contains('n-button--disabled');
890                  const rect = b.getBoundingClientRect();
891                  return 'found:' + text + ':disabled=' + disabled + ':y=' + rect.y + ':h=' + rect.height;
892                }
893              }
894              const allTexts = Array.from(buttons).map(b => b.querySelector('.n-button__content')?.textContent?.trim() || '').join(',');
895              return 'not_found:' + allTexts;
896            })()`,
897            returnByValue: true,
898          }, { sessionId });
899          console.log(`[weibo-article] Confirm button info: ${confirmInfo.result.value}`);
900 
901          // Use full pointer event simulation via JS (not CDP Input.dispatchMouseEvent)
902          const confirmClickResult = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
903            expression: `(() => {
904              const dialog = document.querySelector('.n-dialog');
905              if (!dialog) return 'no_dialog';
906              const buttons = dialog.querySelectorAll('.n-button');
907              for (const b of buttons) {
908                const text = b.querySelector('.n-button__content')?.textContent?.trim() || '';
909                if (text === '确定' || text === '确认') {
910                  b.scrollIntoView({ block: 'center' });
911                  const rect = b.getBoundingClientRect();
912                  const cx = rect.x + rect.width / 2;
913                  const cy = rect.y + rect.height / 2;
914                  const opts = { bubbles: true, cancelable: true, clientX: cx, clientY: cy, button: 0 };
915                  b.dispatchEvent(new PointerEvent('pointerdown', opts));
916                  b.dispatchEvent(new MouseEvent('mousedown', opts));
917                  b.dispatchEvent(new PointerEvent('pointerup', opts));
918                  b.dispatchEvent(new MouseEvent('mouseup', opts));
919                  b.dispatchEvent(new MouseEvent('click', opts));
920                  return 'dispatched:' + text;
921                }
922              }
923              return 'not_found';
924            })()`,
925            returnByValue: true,
926          }, { sessionId });
927          console.log(`[weibo-article] Confirm click: ${confirmClickResult.result.value}`);
928          await sleep(2000);
929 
930          // Check dialog state
931          const afterConfirm = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
932            expression: `(() => {
933              const dialog = document.querySelector('.n-dialog');
934              if (!dialog) return 'closed';
935              const buttons = dialog.querySelectorAll('.n-button');
936              return 'open:' + Array.from(buttons).map(b => b.querySelector('.n-button__content')?.textContent?.trim() || '').join(',');
937            })()`,
938            returnByValue: true,
939          }, { sessionId });
940          console.log(`[weibo-article] After confirm: ${afterConfirm.result.value}`);
941 
942          // If still open, try focusing the button and pressing Enter
943          if (afterConfirm.result.value !== 'closed') {
944            console.log('[weibo-article] Dialog still open, trying focus + Enter...');
945            await cdp!.send('Runtime.evaluate', {
946              expression: `(() => {
947                const dialog = document.querySelector('.n-dialog');
948                if (!dialog) return;
949                const buttons = dialog.querySelectorAll('.n-button');
950                for (const b of buttons) {
951                  const text = b.querySelector('.n-button__content')?.textContent?.trim() || '';
952                  if (text === '确定' || text === '确认') { b.focus(); return; }
953                }
954              })()`,
955            }, { sessionId });
956            await sleep(200);
957            await cdp!.send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13 }, { sessionId });
958            await cdp!.send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13 }, { sessionId });
959            await sleep(2000);
960 
961            const afterEnter = await cdp!.send<{ result: { value: string } }>('Runtime.evaluate', {
962              expression: `!document.querySelector('.n-dialog') ? 'closed' : 'still_open'`,
963              returnByValue: true,
964            }, { sessionId });
965            console.log(`[weibo-article] After Enter: ${afterEnter.result.value}`);
966          }
967 
968          await sleep(1000);
969 
970          // Verify cover was set (cover-preview with img should exist)
971          const coverSet = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
972            expression: `(() => {
973              const preview = document.querySelector('.cover-preview .cover-img');
974              if (preview) return 'cover_set';
975              const empty = document.querySelector('.cover-empty');
976              if (empty) return 'cover_empty_still_exists';
977              return 'cover_unknown';
978            })()`,
979            returnByValue: true,
980          }, { sessionId });
981          console.log(`[weibo-article] Cover result: ${coverSet.result.value}`);
982        }
983      }
984    } else if (coverImagePath) {
985      console.warn(`[weibo-article] Cover image not found: ${coverImagePath}`);
986    } else {
987      console.log('[weibo-article] No cover image specified');
988    }
989 
990    console.log('[weibo-article] Article composed. Please review and publish manually.');
991    console.log('[weibo-article] Browser remains open for manual review.');
992 
993  } finally {
994    if (cdp) {
995      cdp.close();
996    }
997  }
998}
999 
1000function printUsage(): never {
1001  console.log(`Publish Markdown article to Weibo Headline Articles
1002 
1003Usage:
1004  npx -y bun weibo-article.ts <markdown_file> [options]
1005 
1006Options:
1007  --title <title>       Override title (max 32 chars)
1008  --summary <text>      Override summary (max 44 chars)
1009  --cover <image>       Override cover image
1010  --profile <dir>       Chrome profile directory
1011  --help                Show this help
1012 
1013Markdown frontmatter:
1014  ---
1015  title: My Article Title
1016  summary: Brief description
1017  cover_image: /path/to/cover.jpg
1018  ---
1019 
1020Example:
1021  npx -y bun weibo-article.ts article.md
1022  npx -y bun weibo-article.ts article.md --cover ./hero.png
1023  npx -y bun weibo-article.ts article.md --title "Custom Title"
1024`);
1025  process.exit(0);
1026}
1027 
1028async function main(): Promise<void> {
1029  const args = process.argv.slice(2);
1030  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
1031    printUsage();
1032  }
1033 
1034  let markdownPath: string | undefined;
1035  let title: string | undefined;
1036  let summary: string | undefined;
1037  let coverImage: string | undefined;
1038  let profileDir: string | undefined;
1039 
1040  for (let i = 0; i < args.length; i++) {
1041    const arg = args[i]!;
1042    if (arg === '--title' && args[i + 1]) {
1043      title = args[++i];
1044    } else if (arg === '--summary' && args[i + 1]) {
1045      summary = args[++i];
1046    } else if (arg === '--cover' && args[i + 1]) {
1047      const raw = args[++i]!;
1048      coverImage = path.isAbsolute(raw) ? raw : path.resolve(process.cwd(), raw);
1049    } else if (arg === '--profile' && args[i + 1]) {
1050      profileDir = args[++i];
1051    } else if (!arg.startsWith('-')) {
1052      markdownPath = arg;
1053    }
1054  }
1055 
1056  if (!markdownPath) {
1057    console.error('Error: Markdown file path required');
1058    process.exit(1);
1059  }
1060 
1061  if (!fs.existsSync(markdownPath)) {
1062    console.error(`Error: File not found: ${markdownPath}`);
1063    process.exit(1);
1064  }
1065 
1066  await publishArticle({ markdownPath, title, summary, coverImage, profileDir });
1067}
1068 
1069await main().catch((err) => {
1070  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
1071  process.exit(1);
1072});
1073