1import fs from 'node:fs';
2import { mkdir } from 'node:fs/promises';
3import process from 'node:process';
4import {
5  CHROME_CANDIDATES_FULL,
6  CdpConnection,
7  copyImageToClipboard,
8  findExistingChromeDebugPort,
9  getDefaultProfileDir,
10  gracefulKillChrome,
11  launchChrome,
12  openPageSession,
13  pasteFromClipboard,
14  sleep,
15  waitForXSessionPersistence,
16  waitForChromeDebugPort,
17} from './x-utils.js';
18 
19const X_COMPOSE_URL = 'https://x.com/compose/post';
20 
21interface XBrowserOptions {
22  text?: string;
23  images?: string[];
24  submit?: boolean;
25  timeoutMs?: number;
26  profileDir?: string;
27  chromePath?: string;
28}
29 
30export async function postToX(options: XBrowserOptions): Promise<void> {
31  const { text, images = [], submit = false, timeoutMs = 120_000, profileDir = getDefaultProfileDir() } = options;
32 
33  await mkdir(profileDir, { recursive: true });
34 
35  const existingPort = await findExistingChromeDebugPort(profileDir);
36  const reusing = existingPort !== null;
37  let port = existingPort ?? 0;
38  let chrome: Awaited<ReturnType<typeof launchChrome>>['chrome'] | null = null;
39  if (!reusing) {
40    const launched = await launchChrome(X_COMPOSE_URL, profileDir, CHROME_CANDIDATES_FULL, options.chromePath);
41    port = launched.port;
42    chrome = launched.chrome;
43  }
44 
45  if (reusing) console.log(`[x-browser] Reusing existing Chrome on port ${port}`);
46  else console.log(`[x-browser] Launching Chrome (profile: ${profileDir})`);
47 
48  let cdp: CdpConnection | null = null;
49  let sessionId: string | null = null;
50  let loggedInDuringRun = false;
51 
52  try {
53    const wsUrl = await waitForChromeDebugPort(port, 30_000, { includeLastError: true });
54    cdp = await CdpConnection.connect(wsUrl, 30_000, { defaultTimeoutMs: 15_000 });
55 
56    const page = await openPageSession({
57      cdp,
58      reusing,
59      url: X_COMPOSE_URL,
60      matchTarget: (target) => target.type === 'page' && target.url.includes('x.com'),
61      enablePage: true,
62      enableRuntime: true,
63      enableNetwork: true,
64    });
65    const activeSessionId = page.sessionId;
66    sessionId = activeSessionId;
67    await cdp.send('Input.setIgnoreInputEvents', { ignore: false }, { sessionId: activeSessionId });
68 
69    console.log('[x-browser] Waiting for X editor...');
70    await sleep(3000);
71 
72    const waitForEditor = async (): Promise<boolean> => {
73      const start = Date.now();
74      while (Date.now() - start < timeoutMs) {
75        const result = await cdp!.send<{ result: { value: boolean } }>('Runtime.evaluate', {
76          expression: `!!document.querySelector('[data-testid="tweetTextarea_0"]')`,
77          returnByValue: true,
78        }, { sessionId: activeSessionId });
79        if (result.result.value) return true;
80        await sleep(1000);
81      }
82      return false;
83    };
84 
85    const editorFound = await waitForEditor();
86    if (!editorFound) {
87      console.log('[x-browser] Editor not found. Please log in to X in the browser window.');
88      console.log('[x-browser] Waiting for login...');
89      const loggedIn = await waitForEditor();
90      if (!loggedIn) throw new Error('Timed out waiting for X editor. Please log in first.');
91      loggedInDuringRun = true;
92    }
93 
94    if (text) {
95      console.log('[x-browser] Typing text...');
96      await cdp.send('Runtime.evaluate', {
97        expression: `
98          const editor = document.querySelector('[data-testid="tweetTextarea_0"]');
99          if (editor) {
100            editor.focus();
101            document.execCommand('insertText', false, ${JSON.stringify(text)});
102          }
103        `,
104      }, { sessionId: activeSessionId });
105      await sleep(500);
106    }
107 
108    for (const imagePath of images) {
109      if (!fs.existsSync(imagePath)) {
110        console.warn(`[x-browser] Image not found: ${imagePath}`);
111        continue;
112      }
113 
114      console.log(`[x-browser] Pasting image: ${imagePath}`);
115 
116      if (!copyImageToClipboard(imagePath)) {
117        console.warn(`[x-browser] Failed to copy image to clipboard: ${imagePath}`);
118        continue;
119      }
120 
121      // Count uploaded images before paste
122      const imgCountBefore = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
123        expression: `document.querySelectorAll('img[src^="blob:"]').length`,
124        returnByValue: true,
125      }, { sessionId: activeSessionId });
126 
127      // Wait for clipboard to be ready
128      await sleep(500);
129 
130      // Focus the editor
131      await cdp.send('Runtime.evaluate', {
132        expression: `document.querySelector('[data-testid="tweetTextarea_0"]')?.focus()`,
133      }, { sessionId: activeSessionId });
134      await sleep(200);
135 
136      // Use paste script (handles platform differences, activates Chrome)
137      console.log('[x-browser] Pasting from clipboard...');
138      const pasteSuccess = pasteFromClipboard('Google Chrome', 5, 500);
139 
140      if (!pasteSuccess) {
141        // Fallback to CDP (may not work for images on X)
142        console.log('[x-browser] Paste script failed, trying CDP fallback...');
143        const modifiers = process.platform === 'darwin' ? 4 : 2;
144        await cdp.send('Input.dispatchKeyEvent', {
145          type: 'keyDown',
146          key: 'v',
147          code: 'KeyV',
148          modifiers,
149          windowsVirtualKeyCode: 86,
150        }, { sessionId: activeSessionId });
151        await cdp.send('Input.dispatchKeyEvent', {
152          type: 'keyUp',
153          key: 'v',
154          code: 'KeyV',
155          modifiers,
156          windowsVirtualKeyCode: 86,
157        }, { sessionId: activeSessionId });
158      }
159 
160      console.log('[x-browser] Verifying image upload...');
161      const expectedImgCount = imgCountBefore.result.value + 1;
162      let imgUploadOk = false;
163      const imgWaitStart = Date.now();
164      while (Date.now() - imgWaitStart < 15_000) {
165        const r = await cdp!.send<{ result: { value: number } }>('Runtime.evaluate', {
166          expression: `document.querySelectorAll('img[src^="blob:"]').length`,
167          returnByValue: true,
168        }, { sessionId: activeSessionId });
169        if (r.result.value >= expectedImgCount) {
170          imgUploadOk = true;
171          break;
172        }
173        await sleep(1000);
174      }
175 
176      if (imgUploadOk) {
177        console.log('[x-browser] Image upload verified');
178      } else {
179        console.warn('[x-browser] Image upload not detected after 15s. Run check-paste-permissions.ts to diagnose.');
180      }
181    }
182 
183    if (submit) {
184      console.log('[x-browser] Submitting post...');
185      await cdp.send('Runtime.evaluate', {
186        expression: `document.querySelector('[data-testid="tweetButton"]')?.click()`,
187      }, { sessionId: activeSessionId });
188      await sleep(2000);
189      console.log('[x-browser] Post submitted!');
190    } else {
191      console.log('[x-browser] Post composed. Please review and click the publish button in the browser.');
192    }
193  } finally {
194    let leaveChromeOpen = !submit;
195    if (chrome && submit && loggedInDuringRun && cdp && sessionId) {
196      console.log('[x-browser] Waiting for X session cookies to persist...');
197      const sessionReady = await waitForXSessionPersistence({ cdp, sessionId });
198      if (!sessionReady) {
199        console.warn('[x-browser] X session cookies not observed yet. Leaving Chrome open so login can finish persisting.');
200        leaveChromeOpen = true;
201      }
202    }
203 
204    if (cdp) {
205      cdp.close();
206    }
207    if (chrome) {
208      if (leaveChromeOpen) {
209        chrome.unref();
210      } else {
211        await gracefulKillChrome(chrome, port);
212      }
213    }
214  }
215}
216 
217function printUsage(): never {
218  console.log(`Post to X (Twitter) using real Chrome browser
219 
220Usage:
221  npx -y bun x-browser.ts [options] [text]
222 
223Options:
224  --image <path>   Add image (can be repeated, max 4)
225  --submit         Actually post (default: preview only)
226  --profile <dir>  Chrome profile directory
227  --help           Show this help
228 
229Examples:
230  npx -y bun x-browser.ts "Hello from CLI!"
231  npx -y bun x-browser.ts "Check this out" --image ./screenshot.png
232  npx -y bun x-browser.ts "Post it!" --image a.png --image b.png --submit
233`);
234  process.exit(0);
235}
236 
237async function main(): Promise<void> {
238  const args = process.argv.slice(2);
239  if (args.includes('--help') || args.includes('-h')) printUsage();
240 
241  const images: string[] = [];
242  let submit = false;
243  let profileDir: string | undefined;
244  const textParts: string[] = [];
245 
246  for (let i = 0; i < args.length; i++) {
247    const arg = args[i]!;
248    if (arg === '--image' && args[i + 1]) {
249      images.push(args[++i]!);
250    } else if (arg === '--submit') {
251      submit = true;
252    } else if (arg === '--profile' && args[i + 1]) {
253      profileDir = args[++i];
254    } else if (!arg.startsWith('-')) {
255      textParts.push(arg);
256    }
257  }
258 
259  const text = textParts.join(' ').trim() || undefined;
260 
261  if (!text && images.length === 0) {
262    console.error('Error: Provide text or at least one image.');
263    process.exit(1);
264  }
265 
266  await postToX({ text, images, submit, profileDir });
267}
268 
269await main().catch((err) => {
270  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
271  process.exit(1);
272});
273