1import fs from 'node:fs';
2import { mkdir, writeFile } from 'node:fs/promises';
3import os from 'node:os';
4import path from 'node:path';
5 
6import { parseMarkdown } from './md-to-html.js';
7import {
8  CHROME_CANDIDATES_BASIC,
9  CdpConnection,
10  copyHtmlToClipboard,
11  copyImageToClipboard,
12  findExistingChromeDebugPort,
13  getDefaultProfileDir,
14  launchChrome,
15  openPageSession,
16  pasteFromClipboard,
17  sleep,
18  waitForChromeDebugPort,
19} from './x-utils.js';
20 
21const X_ARTICLES_URL = 'https://x.com/compose/articles';
22 
23const I18N_SELECTORS = {
24  titleInput: [
25    'textarea[placeholder="Add a title"]',
26    'textarea[placeholder="添加标题"]',
27    'textarea[placeholder="タイトルを追加"]',
28    'textarea[placeholder="제목 추가"]',
29    'textarea[name="Article Title"]',
30  ],
31  addPhotosButton: [
32    '[aria-label="Add photos or video"]',
33    '[aria-label="添加照片或视频"]',
34    '[aria-label="写真や動画を追加"]',
35    '[aria-label="사진 또는 동영상 추가"]',
36  ],
37  previewButton: [
38    'a[href*="/preview"]',
39    '[data-testid="previewButton"]',
40    'button[aria-label*="preview" i]',
41    'button[aria-label*="预览" i]',
42    'button[aria-label*="プレビュー" i]',
43    'button[aria-label*="미리보기" i]',
44  ],
45  publishButton: [
46    '[data-testid="publishButton"]',
47    'button[aria-label*="publish" i]',
48    'button[aria-label*="发布" i]',
49    'button[aria-label*="公開" i]',
50    'button[aria-label*="게시" i]',
51  ],
52};
53 
54interface ArticleOptions {
55  markdownPath: string;
56  coverImage?: string;
57  title?: string;
58  submit?: boolean;
59  profileDir?: string;
60  chromePath?: string;
61}
62 
63export async function publishArticle(options: ArticleOptions): Promise<void> {
64  const { markdownPath, submit = false, profileDir = getDefaultProfileDir() } = options;
65 
66  console.log('[x-article] Parsing markdown...');
67  const parsed = await parseMarkdown(markdownPath, {
68    title: options.title,
69    coverImage: options.coverImage,
70  });
71 
72  console.log(`[x-article] Title: ${parsed.title}`);
73  console.log(`[x-article] Cover: ${parsed.coverImage ?? 'none'}`);
74  console.log(`[x-article] Content images: ${parsed.contentImages.length}`);
75 
76  // Save HTML to temp file
77  const htmlPath = path.join(os.tmpdir(), 'x-article-content.html');
78  await writeFile(htmlPath, parsed.html, 'utf-8');
79  console.log(`[x-article] HTML saved to: ${htmlPath}`);
80 
81  await mkdir(profileDir, { recursive: true });
82  const existingPort = await findExistingChromeDebugPort(profileDir);
83  const reusing = existingPort !== null;
84  let port = existingPort ?? 0;
85 
86  if (reusing) {
87    console.log(`[x-article] Reusing existing Chrome instance on port ${port}`);
88  } else {
89    console.log(`[x-article] Launching Chrome...`);
90    const launched = await launchChrome(X_ARTICLES_URL, profileDir, CHROME_CANDIDATES_BASIC, options.chromePath);
91    port = launched.port;
92  }
93 
94  let cdp: CdpConnection | null = null;
95 
96  try {
97    const wsUrl = await waitForChromeDebugPort(port, 30_000, { includeLastError: true });
98    cdp = await CdpConnection.connect(wsUrl, 30_000, { defaultTimeoutMs: 60_000 });
99 
100    const page = await openPageSession({
101      cdp,
102      reusing,
103      url: X_ARTICLES_URL,
104      matchTarget: (target) => target.type === 'page' && target.url.startsWith(X_ARTICLES_URL),
105      enablePage: true,
106      enableRuntime: true,
107      enableDom: true,
108    });
109    const { sessionId } = page;
110 
111    console.log('[x-article] Waiting for articles page...');
112    await sleep(1000);
113 
114    // Wait for and click "create" button
115    const waitForElement = async (selector: string, timeoutMs = 60_000): Promise<boolean> => {
116      const start = Date.now();
117      while (Date.now() - start < timeoutMs) {
118        const result = await cdp!.send<{ result: { value: boolean } }>('Runtime.evaluate', {
119          expression: `!!document.querySelector('${selector}')`,
120          returnByValue: true,
121        }, { sessionId });
122        if (result.result.value) return true;
123        await sleep(500);
124      }
125      return false;
126    };
127 
128    const clickElement = async (selector: string): Promise<boolean> => {
129      const result = await cdp!.send<{ result: { value: boolean } }>('Runtime.evaluate', {
130        expression: `(() => { const el = document.querySelector('${selector}'); if (el) { el.click(); return true; } return false; })()`,
131        returnByValue: true,
132      }, { sessionId });
133      return result.result.value;
134    };
135 
136    const typeText = async (selector: string, text: string): Promise<void> => {
137      await cdp!.send('Runtime.evaluate', {
138        expression: `(() => {
139          const el = document.querySelector('${selector}');
140          if (el) {
141            el.focus();
142            document.execCommand('insertText', false, ${JSON.stringify(text)});
143          }
144        })()`,
145      }, { sessionId });
146    };
147 
148    const pressKey = async (key: string, modifiers = 0): Promise<void> => {
149      await cdp!.send('Input.dispatchKeyEvent', {
150        type: 'keyDown',
151        key,
152        code: `Key${key.toUpperCase()}`,
153        modifiers,
154        windowsVirtualKeyCode: key.toUpperCase().charCodeAt(0),
155      }, { sessionId });
156      await cdp!.send('Input.dispatchKeyEvent', {
157        type: 'keyUp',
158        key,
159        code: `Key${key.toUpperCase()}`,
160        modifiers,
161        windowsVirtualKeyCode: key.toUpperCase().charCodeAt(0),
162      }, { sessionId });
163    };
164 
165    // Check if we're on the articles list page (has Write button)
166    console.log('[x-article] Looking for Write button...');
167    const writeButtonFound = await waitForElement('[data-testid="empty_state_button_text"]', 10_000);
168 
169    if (writeButtonFound) {
170      console.log('[x-article] Clicking Write button...');
171      await cdp.send('Runtime.evaluate', {
172        expression: `document.querySelector('[data-testid="empty_state_button_text"]')?.click()`,
173      }, { sessionId });
174      await sleep(2000);
175    }
176 
177    // Wait for editor (title textarea)
178    const titleSelectors = I18N_SELECTORS.titleInput.join(', ');
179    console.log('[x-article] Waiting for editor...');
180    const editorFound = await waitForElement(titleSelectors, 30_000);
181    if (!editorFound) {
182      console.log('[x-article] Editor not found. Please ensure you have X Premium and are logged in.');
183      await sleep(60_000);
184      throw new Error('Editor not found');
185    }
186 
187    // Upload cover image
188    if (parsed.coverImage) {
189      console.log('[x-article] Uploading cover image...');
190 
191      // Click "Add photos or video" button
192      const addPhotosSelectors = JSON.stringify(I18N_SELECTORS.addPhotosButton);
193      await cdp.send('Runtime.evaluate', {
194        expression: `(() => {
195          const selectors = ${addPhotosSelectors};
196          for (const sel of selectors) {
197            const el = document.querySelector(sel);
198            if (el) { el.click(); return true; }
199          }
200          return false;
201        })()`,
202      }, { sessionId });
203      await sleep(500);
204 
205      // Use file input directly
206      const { root } = await cdp.send<{ root: { nodeId: number } }>('DOM.getDocument', {}, { sessionId });
207      const { nodeId } = await cdp.send<{ nodeId: number }>('DOM.querySelector', {
208        nodeId: root.nodeId,
209        selector: '[data-testid="fileInput"], input[type="file"][accept*="image"]',
210      }, { sessionId });
211 
212      if (nodeId) {
213        await cdp.send('DOM.setFileInputFiles', {
214          nodeId,
215          files: [parsed.coverImage],
216        }, { sessionId });
217        console.log('[x-article] Cover image file set');
218 
219        // Wait for Apply button to appear and click it
220        console.log('[x-article] Waiting for Apply button...');
221        const applyFound = await waitForElement('[data-testid="applyButton"]', 15_000);
222        if (applyFound) {
223          // Check if modal is present
224          const isModalOpen = async (): Promise<boolean> => {
225            const result = await cdp!.send<{ result: { value: boolean } }>('Runtime.evaluate', {
226              expression: `!!document.querySelector('[role="dialog"][aria-modal="true"]')`,
227              returnByValue: true,
228            }, { sessionId });
229            return result.result.value;
230          };
231 
232          // Click Apply button with retry logic
233          const maxRetries = 3;
234          for (let attempt = 1; attempt <= maxRetries; attempt++) {
235            console.log(`[x-article] Clicking Apply button (attempt ${attempt}/${maxRetries})...`);
236 
237            await cdp.send('Runtime.evaluate', {
238              expression: `document.querySelector('[data-testid="applyButton"]')?.click()`,
239            }, { sessionId });
240 
241            // Wait for modal to close (up to 5 seconds per attempt)
242            const closeTimeout = 5000;
243            const checkInterval = 300;
244            const startTime = Date.now();
245            let modalClosed = false;
246 
247            while (Date.now() - startTime < closeTimeout) {
248              await sleep(checkInterval);
249              const stillOpen = await isModalOpen();
250              if (!stillOpen) {
251                modalClosed = true;
252                break;
253              }
254            }
255 
256            if (modalClosed) {
257              console.log('[x-article] Cover image applied, modal closed');
258              await sleep(500);
259              break;
260            }
261 
262            if (attempt < maxRetries) {
263              console.log('[x-article] Modal still open, retrying...');
264            } else {
265              console.log('[x-article] Modal did not close after all attempts, continuing anyway...');
266            }
267          }
268        } else {
269          console.log('[x-article] Apply button not found, continuing...');
270        }
271      }
272    }
273 
274    // Fill title using keyboard input
275    if (parsed.title) {
276      console.log('[x-article] Filling title...');
277 
278      // Focus title input
279      const titleInputSelectors = JSON.stringify(I18N_SELECTORS.titleInput);
280      await cdp.send('Runtime.evaluate', {
281        expression: `(() => {
282          const selectors = ${titleInputSelectors};
283          for (const sel of selectors) {
284            const el = document.querySelector(sel);
285            if (el) { el.focus(); return true; }
286          }
287          return false;
288        })()`,
289      }, { sessionId });
290      await sleep(200);
291 
292      // Type title character by character using insertText
293      await cdp.send('Input.insertText', { text: parsed.title }, { sessionId });
294      await sleep(300);
295 
296      // Tab out to trigger save
297      await cdp.send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Tab', code: 'Tab', windowsVirtualKeyCode: 9 }, { sessionId });
298      await cdp.send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Tab', code: 'Tab', windowsVirtualKeyCode: 9 }, { sessionId });
299      await sleep(500);
300    }
301 
302    // Insert HTML content
303    console.log('[x-article] Inserting content...');
304 
305    // Read HTML content
306    const htmlContent = fs.readFileSync(htmlPath, 'utf-8');
307 
308    // Focus on DraftEditor body
309    await cdp.send('Runtime.evaluate', {
310      expression: `(() => {
311        const editor = document.querySelector('.DraftEditor-editorContainer [contenteditable="true"]');
312        if (editor) {
313          editor.focus();
314          editor.click();
315          return true;
316        }
317        return false;
318      })()`,
319    }, { sessionId });
320    await sleep(300);
321 
322    // Method 1: Simulate paste event with HTML data
323    console.log('[x-article] Attempting to insert HTML via paste event...');
324    const pasteResult = await cdp.send<{ result: { value: boolean } }>('Runtime.evaluate', {
325      expression: `(() => {
326        const editor = document.querySelector('.DraftEditor-editorContainer [contenteditable="true"]');
327        if (!editor) return false;
328 
329        const html = ${JSON.stringify(htmlContent)};
330 
331        // Create a paste event with HTML data
332        const dt = new DataTransfer();
333        dt.setData('text/html', html);
334        dt.setData('text/plain', html.replace(/<[^>]*>/g, ''));
335 
336        const pasteEvent = new ClipboardEvent('paste', {
337          bubbles: true,
338          cancelable: true,
339          clipboardData: dt
340        });
341 
342        editor.dispatchEvent(pasteEvent);
343        return true;
344      })()`,
345      returnByValue: true,
346    }, { sessionId });
347 
348    await sleep(1000);
349 
350    // Check if content was inserted
351    const contentCheck = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
352      expression: `document.querySelector('.DraftEditor-editorContainer [data-contents="true"]')?.innerText?.length || 0`,
353      returnByValue: true,
354    }, { sessionId });
355 
356    if (contentCheck.result.value > 50) {
357      console.log(`[x-article] Content inserted successfully (${contentCheck.result.value} chars)`);
358    } else {
359      console.log('[x-article] Paste event may not have worked, trying insertHTML...');
360 
361      // Method 2: Use execCommand insertHTML
362      await cdp.send('Runtime.evaluate', {
363        expression: `(() => {
364          const editor = document.querySelector('.DraftEditor-editorContainer [contenteditable="true"]');
365          if (!editor) return false;
366          editor.focus();
367          document.execCommand('insertHTML', false, ${JSON.stringify(htmlContent)});
368          return true;
369        })()`,
370      }, { sessionId });
371 
372      await sleep(1000);
373 
374      // Check again
375      const check2 = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
376        expression: `document.querySelector('.DraftEditor-editorContainer [data-contents="true"]')?.innerText?.length || 0`,
377        returnByValue: true,
378      }, { sessionId });
379 
380      if (check2.result.value > 50) {
381        console.log(`[x-article] Content inserted via execCommand (${check2.result.value} chars)`);
382      } else {
383        console.log('[x-article] Auto-insert failed. HTML copied to clipboard - please paste manually (Cmd+V)');
384        copyHtmlToClipboard(htmlPath);
385        // Wait for manual paste
386        console.log('[x-article] Waiting 30s for manual paste...');
387        await sleep(30_000);
388      }
389    }
390 
391    // Insert content images (reverse order to maintain positions)
392    if (parsed.contentImages.length > 0) {
393      console.log('[x-article] Inserting content images...');
394 
395      // First, check what placeholders exist in the editor
396      const editorContent = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
397        expression: `document.querySelector('.DraftEditor-editorContainer [data-contents="true"]')?.innerText || ''`,
398        returnByValue: true,
399      }, { sessionId });
400 
401      console.log('[x-article] Checking for placeholders in content...');
402      for (const img of parsed.contentImages) {
403        // Use regex for exact match (not followed by digit, e.g., XIMGPH_1 should not match XIMGPH_10)
404        const regex = new RegExp(img.placeholder + '(?!\\d)');
405        if (regex.test(editorContent.result.value)) {
406          console.log(`[x-article] Found: ${img.placeholder}`);
407        } else {
408          console.log(`[x-article] NOT found: ${img.placeholder}`);
409        }
410      }
411 
412      // Process images in XIMGPH order (1, 2, 3, ...) regardless of blockIndex
413      const getPlaceholderIndex = (placeholder: string): number => {
414        const match = placeholder.match(/XIMGPH_(\d+)/);
415        return match ? Number(match[1]) : Number.POSITIVE_INFINITY;
416      };
417      const sortedImages = [...parsed.contentImages].sort(
418        (a, b) => getPlaceholderIndex(a.placeholder) - getPlaceholderIndex(b.placeholder),
419      );
420 
421      for (let i = 0; i < sortedImages.length; i++) {
422        const img = sortedImages[i]!;
423        console.log(`[x-article] [${i + 1}/${sortedImages.length}] Inserting image at placeholder: ${img.placeholder}`);
424 
425        // Helper to select placeholder with retry
426        const selectPlaceholder = async (maxRetries = 3): Promise<boolean> => {
427          for (let attempt = 1; attempt <= maxRetries; attempt++) {
428            // Find, scroll to, and select the placeholder text in DraftEditor
429            await cdp!.send('Runtime.evaluate', {
430              expression: `(() => {
431                const editor = document.querySelector('.DraftEditor-editorContainer [data-contents="true"]');
432                if (!editor) return false;
433 
434                const placeholder = ${JSON.stringify(img.placeholder)};
435 
436                // Search through all text nodes in the editor
437                const walker = document.createTreeWalker(editor, NodeFilter.SHOW_TEXT, null, false);
438                let node;
439 
440                while ((node = walker.nextNode())) {
441                  const text = node.textContent || '';
442                  let searchStart = 0;
443                  let idx;
444                  // Search for exact match (not prefix of longer placeholder like XIMGPH_1 in XIMGPH_10)
445                  while ((idx = text.indexOf(placeholder, searchStart)) !== -1) {
446                    const afterIdx = idx + placeholder.length;
447                    const charAfter = text[afterIdx];
448                    // Exact match if next char is not a digit (XIMGPH_1 should not match XIMGPH_10)
449                    if (charAfter === undefined || !/\\d/.test(charAfter)) {
450                      // Found exact placeholder - scroll to it first
451                      const parentElement = node.parentElement;
452                      if (parentElement) {
453                        parentElement.scrollIntoView({ behavior: 'smooth', block: 'center' });
454                      }
455 
456                      // Select it
457                      const range = document.createRange();
458                      range.setStart(node, idx);
459                      range.setEnd(node, idx + placeholder.length);
460                      const sel = window.getSelection();
461                      sel.removeAllRanges();
462                      sel.addRange(range);
463                      return true;
464                    }
465                    searchStart = afterIdx;
466                  }
467                }
468                return false;
469              })()`,
470            }, { sessionId });
471 
472            // Wait for scroll and selection to settle
473            await sleep(800);
474 
475            // Verify selection matches the placeholder
476            const selectionCheck = await cdp!.send<{ result: { value: string } }>('Runtime.evaluate', {
477              expression: `window.getSelection()?.toString() || ''`,
478              returnByValue: true,
479            }, { sessionId });
480 
481            const selectedText = selectionCheck.result.value.trim();
482            if (selectedText === img.placeholder) {
483              console.log(`[x-article] Selection verified: "${selectedText}"`);
484              return true;
485            }
486 
487            if (attempt < maxRetries) {
488              console.log(`[x-article] Selection attempt ${attempt} got "${selectedText}", retrying...`);
489              await sleep(500);
490            } else {
491              console.warn(`[x-article] Selection failed after ${maxRetries} attempts, got: "${selectedText}"`);
492            }
493          }
494          return false;
495        };
496 
497        // Try to select the placeholder
498        const selected = await selectPlaceholder(3);
499        if (!selected) {
500          console.warn(`[x-article] Skipping image - could not select placeholder: ${img.placeholder}`);
501          continue;
502        }
503 
504        console.log(`[x-article] Copying image: ${path.basename(img.localPath)}`);
505 
506        // Copy image to clipboard
507        if (!copyImageToClipboard(img.localPath)) {
508          console.warn(`[x-article] Failed to copy image to clipboard`);
509          continue;
510        }
511 
512        // Wait for clipboard to be fully ready
513        await sleep(1000);
514 
515        // Delete placeholder using execCommand (more reliable than keyboard events for DraftJS)
516        console.log(`[x-article] Deleting placeholder...`);
517        const deleteResult = await cdp.send<{ result: { value: boolean } }>('Runtime.evaluate', {
518          expression: `(() => {
519            const sel = window.getSelection();
520            if (!sel || sel.isCollapsed) return false;
521            // Try execCommand delete first
522            if (document.execCommand('delete', false)) return true;
523            // Fallback: replace selection with empty using insertText
524            document.execCommand('insertText', false, '');
525            return true;
526          })()`,
527          returnByValue: true,
528        }, { sessionId });
529 
530        await sleep(500);
531 
532        // Check that placeholder is no longer in editor (exact match, not substring)
533        const afterDelete = await cdp.send<{ result: { value: boolean } }>('Runtime.evaluate', {
534          expression: `(() => {
535            const editor = document.querySelector('.DraftEditor-editorContainer [data-contents="true"]');
536            if (!editor) return true;
537            const text = editor.innerText;
538            const placeholder = ${JSON.stringify(img.placeholder)};
539            // Use regex to find exact match (not followed by digit)
540            const regex = new RegExp(placeholder + '(?!\\\\d)');
541            return !regex.test(text);
542          })()`,
543          returnByValue: true,
544        }, { sessionId });
545 
546        if (!afterDelete.result.value) {
547          console.warn(`[x-article] Placeholder may not have been deleted, trying dispatchEvent...`);
548          // Try selecting and deleting with InputEvent
549          await selectPlaceholder(1);
550          await sleep(300);
551          await cdp.send('Runtime.evaluate', {
552            expression: `(() => {
553              const editor = document.querySelector('.DraftEditor-editorContainer [contenteditable="true"]');
554              if (!editor) return;
555              editor.focus();
556              // Dispatch beforeinput and input events for deletion
557              const beforeEvent = new InputEvent('beforeinput', { inputType: 'deleteContentBackward', bubbles: true, cancelable: true });
558              editor.dispatchEvent(beforeEvent);
559              const inputEvent = new InputEvent('input', { inputType: 'deleteContentBackward', bubbles: true });
560              editor.dispatchEvent(inputEvent);
561            })()`,
562          }, { sessionId });
563          await sleep(500);
564        }
565 
566        // Count existing image blocks before paste
567        const imgCountBefore = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
568          expression: `document.querySelectorAll('section[data-block="true"][contenteditable="false"] img[src^="blob:"]').length`,
569          returnByValue: true,
570        }, { sessionId });
571 
572        // Focus editor to ensure cursor is in position
573        await cdp.send('Runtime.evaluate', {
574          expression: `(() => {
575            const editor = document.querySelector('.DraftEditor-editorContainer [contenteditable="true"]');
576            if (editor) editor.focus();
577          })()`,
578        }, { sessionId });
579        await sleep(300);
580 
581        // Paste image using paste script (activates Chrome, sends real keystroke)
582        console.log(`[x-article] Pasting image...`);
583        if (pasteFromClipboard('Google Chrome', 5, 1000)) {
584          console.log(`[x-article] Image pasted: ${path.basename(img.localPath)}`);
585        } else {
586          console.warn(`[x-article] Failed to paste image after retries`);
587        }
588 
589        // Verify image appeared in editor
590        console.log(`[x-article] Verifying image upload...`);
591        const expectedImgCount = imgCountBefore.result.value + 1;
592        let imgUploadOk = false;
593        const imgWaitStart = Date.now();
594        while (Date.now() - imgWaitStart < 15_000) {
595          const r = await cdp!.send<{ result: { value: number } }>('Runtime.evaluate', {
596            expression: `document.querySelectorAll('section[data-block="true"][contenteditable="false"] img[src^="blob:"]').length`,
597            returnByValue: true,
598          }, { sessionId });
599          if (r.result.value >= expectedImgCount) {
600            imgUploadOk = true;
601            break;
602          }
603          await sleep(1000);
604        }
605 
606        if (imgUploadOk) {
607          console.log(`[x-article] Image upload verified (${expectedImgCount} image block(s))`);
608          // Wait for DraftEditor DOM to stabilize after image insertion
609          await sleep(3000);
610        } else {
611          console.warn(`[x-article] Image upload not detected after 15s`);
612          if (i === 0) {
613            console.error('[x-article] First image paste failed. Run check-paste-permissions.ts to diagnose.');
614          }
615        }
616      }
617 
618      console.log('[x-article] All images processed.');
619 
620      // Final verification: check placeholder residue and image count
621      console.log('[x-article] Running post-composition verification...');
622      const finalEditorContent = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
623        expression: `document.querySelector('.DraftEditor-editorContainer [data-contents="true"]')?.innerText || ''`,
624        returnByValue: true,
625      }, { sessionId });
626 
627      const remainingPlaceholders: string[] = [];
628      for (const img of parsed.contentImages) {
629        const regex = new RegExp(img.placeholder + '(?!\\d)');
630        if (regex.test(finalEditorContent.result.value)) {
631          remainingPlaceholders.push(img.placeholder);
632        }
633      }
634 
635      const finalImgCount = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
636        expression: `document.querySelectorAll('section[data-block="true"][contenteditable="false"] img[src^="blob:"]').length`,
637        returnByValue: true,
638      }, { sessionId });
639 
640      const expectedCount = parsed.contentImages.length;
641      const actualCount = finalImgCount.result.value;
642 
643      if (remainingPlaceholders.length > 0 || actualCount < expectedCount) {
644        console.warn('[x-article] ⚠ POST-COMPOSITION CHECK FAILED:');
645        if (remainingPlaceholders.length > 0) {
646          console.warn(`[x-article]   Remaining placeholders: ${remainingPlaceholders.join(', ')}`);
647        }
648        if (actualCount < expectedCount) {
649          console.warn(`[x-article]   Image count: expected ${expectedCount}, found ${actualCount}`);
650        }
651        console.warn('[x-article]   Please check the article before publishing.');
652      } else {
653        console.log(`[x-article] ✓ Verification passed: ${actualCount} image(s), no remaining placeholders.`);
654      }
655    }
656 
657    // Before preview: blur editor to trigger save
658    console.log('[x-article] Triggering content save...');
659    await cdp.send('Runtime.evaluate', {
660      expression: `(() => {
661        // Blur editor to trigger any pending saves
662        const editor = document.querySelector('.DraftEditor-editorContainer [contenteditable="true"]');
663        if (editor) {
664          editor.blur();
665        }
666        // Also click elsewhere to ensure focus is lost
667        document.body.click();
668      })()`,
669    }, { sessionId });
670    await sleep(1500);
671 
672    // Click Preview button
673    console.log('[x-article] Opening preview...');
674    const previewSelectors = JSON.stringify(I18N_SELECTORS.previewButton);
675    const previewClicked = await cdp.send<{ result: { value: boolean } }>('Runtime.evaluate', {
676      expression: `(() => {
677        const selectors = ${previewSelectors};
678        for (const sel of selectors) {
679          const el = document.querySelector(sel);
680          if (el) { el.click(); return true; }
681        }
682        return false;
683      })()`,
684      returnByValue: true,
685    }, { sessionId });
686 
687    if (previewClicked.result.value) {
688      console.log('[x-article] Preview opened');
689      await sleep(3000);
690    } else {
691      console.log('[x-article] Preview button not found');
692    }
693 
694    // Check for publish button
695    if (submit) {
696      console.log('[x-article] Publishing...');
697      const publishSelectors = JSON.stringify(I18N_SELECTORS.publishButton);
698      await cdp.send('Runtime.evaluate', {
699        expression: `(() => {
700          const selectors = ${publishSelectors};
701          for (const sel of selectors) {
702            const el = document.querySelector(sel);
703            if (el && !el.disabled) { el.click(); return true; }
704          }
705          return false;
706        })()`,
707      }, { sessionId });
708      await sleep(3000);
709      console.log('[x-article] Article published!');
710    } else {
711      console.log('[x-article] Article composed (draft mode).');
712      console.log('[x-article] Browser remains open for manual review.');
713    }
714 
715  } finally {
716    // Disconnect CDP but keep browser open
717    if (cdp) {
718      cdp.close();
719    }
720    // Don't kill Chrome - let user review and close manually
721  }
722}
723 
724function printUsage(): never {
725  console.log(`Publish Markdown article to X (Twitter) Articles
726 
727Usage:
728  npx -y bun x-article.ts <markdown_file> [options]
729 
730Options:
731  --title <title>     Override title
732  --cover <image>     Override cover image
733  --submit            Actually publish (default: draft only)
734  --profile <dir>     Chrome profile directory
735  --help              Show this help
736 
737Markdown frontmatter:
738  ---
739  title: My Article Title
740  cover_image: /path/to/cover.jpg
741  ---
742 
743Example:
744  npx -y bun x-article.ts article.md
745  npx -y bun x-article.ts article.md --cover ./hero.png
746  npx -y bun x-article.ts article.md --submit
747`);
748  process.exit(0);
749}
750 
751async function main(): Promise<void> {
752  const args = process.argv.slice(2);
753  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
754    printUsage();
755  }
756 
757  let markdownPath: string | undefined;
758  let title: string | undefined;
759  let coverImage: string | undefined;
760  let submit = false;
761  let profileDir: string | undefined;
762 
763  for (let i = 0; i < args.length; i++) {
764    const arg = args[i]!;
765    if (arg === '--title' && args[i + 1]) {
766      title = args[++i];
767    } else if (arg === '--cover' && args[i + 1]) {
768      const raw = args[++i]!;
769      coverImage = path.isAbsolute(raw) ? raw : path.resolve(process.cwd(), raw);
770    } else if (arg === '--submit') {
771      submit = true;
772    } else if (arg === '--profile' && args[i + 1]) {
773      profileDir = args[++i];
774    } else if (!arg.startsWith('-')) {
775      markdownPath = arg;
776    }
777  }
778 
779  if (!markdownPath) {
780    console.error('Error: Markdown file path required');
781    process.exit(1);
782  }
783 
784  if (!fs.existsSync(markdownPath)) {
785    console.error(`Error: File not found: ${markdownPath}`);
786    process.exit(1);
787  }
788 
789  await publishArticle({ markdownPath, title, coverImage, submit, profileDir });
790}
791 
792await main().catch((err) => {
793  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
794  process.exit(1);
795});
796