1import fs from 'node:fs';
2import { mkdir } from 'node:fs/promises';
3import path from 'node:path';
4import process from 'node:process';
5import {
6  CHROME_CANDIDATES_FULL,
7  CdpConnection,
8  findExistingChromeDebugPort,
9  getDefaultProfileDir,
10  gracefulKillChrome,
11  launchChrome,
12  openPageSession,
13  sleep,
14  waitForXSessionPersistence,
15  waitForChromeDebugPort,
16} from './x-utils.js';
17 
18const X_COMPOSE_URL = 'https://x.com/compose/post';
19 
20interface XVideoOptions {
21  text?: string;
22  videoPath: string;
23  submit?: boolean;
24  timeoutMs?: number;
25  profileDir?: string;
26  chromePath?: string;
27}
28 
29export async function postVideoToX(options: XVideoOptions): Promise<void> {
30  const { text, videoPath, submit = false, timeoutMs = 120_000, profileDir = getDefaultProfileDir() } = options;
31 
32  if (!fs.existsSync(videoPath)) throw new Error(`Video not found: ${videoPath}`);
33 
34  const absVideoPath = path.resolve(videoPath);
35  console.log(`[x-video] Video: ${absVideoPath}`);
36 
37  await mkdir(profileDir, { recursive: true });
38 
39  const existingPort = await findExistingChromeDebugPort(profileDir);
40  const reusing = existingPort !== null;
41  let port = existingPort ?? 0;
42  let chrome: Awaited<ReturnType<typeof launchChrome>>['chrome'] | null = null;
43  if (!reusing) {
44    const launched = await launchChrome(X_COMPOSE_URL, profileDir, CHROME_CANDIDATES_FULL, options.chromePath);
45    port = launched.port;
46    chrome = launched.chrome;
47  }
48 
49  if (reusing) console.log(`[x-video] Reusing existing Chrome on port ${port}`);
50  else console.log(`[x-video] Launching Chrome (profile: ${profileDir})`);
51 
52  let cdp: CdpConnection | null = null;
53  let sessionId: string | null = null;
54  let targetId: string | null = null;
55  let loggedInDuringRun = false;
56 
57  try {
58    const wsUrl = await waitForChromeDebugPort(port, 30_000, { includeLastError: true });
59    cdp = await CdpConnection.connect(wsUrl, 30_000, { defaultTimeoutMs: 30_000 });
60 
61    const page = await openPageSession({
62      cdp,
63      reusing,
64      url: X_COMPOSE_URL,
65      matchTarget: (target) => target.type === 'page' && target.url.includes('x.com'),
66      enablePage: true,
67      enableRuntime: true,
68      enableDom: true,
69      enableNetwork: true,
70    });
71    const activeSessionId = page.sessionId;
72    sessionId = activeSessionId;
73    targetId = page.targetId;
74    await cdp.send('Input.setIgnoreInputEvents', { ignore: false }, { sessionId: activeSessionId });
75 
76    console.log('[x-video] Waiting for X editor...');
77    await sleep(3000);
78 
79    const waitForEditor = async (): Promise<boolean> => {
80      const start = Date.now();
81      while (Date.now() - start < timeoutMs) {
82        const result = await cdp!.send<{ result: { value: boolean } }>('Runtime.evaluate', {
83          expression: `!!document.querySelector('[data-testid="tweetTextarea_0"]')`,
84          returnByValue: true,
85        }, { sessionId: activeSessionId });
86        if (result.result.value) return true;
87        await sleep(1000);
88      }
89      return false;
90    };
91 
92    const editorFound = await waitForEditor();
93    if (!editorFound) {
94      console.log('[x-video] Editor not found. Please log in to X in the browser window.');
95      console.log('[x-video] Waiting for login...');
96      const loggedIn = await waitForEditor();
97      if (!loggedIn) throw new Error('Timed out waiting for X editor. Please log in first.');
98      loggedInDuringRun = true;
99    }
100 
101    // Upload video FIRST (before typing text to avoid text being cleared)
102    console.log('[x-video] Uploading video...');
103 
104    const { root } = await cdp.send<{ root: { nodeId: number } }>('DOM.getDocument', {}, { sessionId: activeSessionId });
105    const { nodeId } = await cdp.send<{ nodeId: number }>('DOM.querySelector', {
106      nodeId: root.nodeId,
107      selector: 'input[type="file"][accept*="video"], input[data-testid="fileInput"], input[type="file"]',
108    }, { sessionId: activeSessionId });
109 
110    if (!nodeId || nodeId === 0) {
111      throw new Error('Could not find file input for video upload.');
112    }
113 
114    await cdp.send('DOM.setFileInputFiles', {
115      nodeId,
116      files: [absVideoPath],
117    }, { sessionId: activeSessionId });
118    console.log('[x-video] Video file set, uploading in background...');
119 
120    // Wait a moment for upload to start, then type text while video processes
121    await sleep(2000);
122 
123    // Type text while video uploads in background
124    if (text) {
125      console.log('[x-video] Typing text...');
126      await cdp.send('Runtime.evaluate', {
127        expression: `
128          const editor = document.querySelector('[data-testid="tweetTextarea_0"]');
129          if (editor) {
130            editor.focus();
131            document.execCommand('insertText', false, ${JSON.stringify(text)});
132          }
133        `,
134      }, { sessionId: activeSessionId });
135      await sleep(500);
136    }
137 
138    // Wait for video to finish processing by checking if tweet button is enabled
139    console.log('[x-video] Waiting for video processing...');
140    const waitForVideoReady = async (maxWaitMs = 180_000): Promise<boolean> => {
141      const start = Date.now();
142      let dots = 0;
143      while (Date.now() - start < maxWaitMs) {
144        const result = await cdp!.send<{ result: { value: { hasMedia: boolean; buttonEnabled: boolean } } }>('Runtime.evaluate', {
145          expression: `(() => {
146            const hasMedia = !!document.querySelector('[data-testid="attachments"] video, [data-testid="videoPlayer"], video');
147            const tweetBtn = document.querySelector('[data-testid="tweetButton"]');
148            const buttonEnabled = tweetBtn && !tweetBtn.disabled && tweetBtn.getAttribute('aria-disabled') !== 'true';
149            return { hasMedia, buttonEnabled };
150          })()`,
151          returnByValue: true,
152        }, { sessionId: activeSessionId });
153 
154        const { hasMedia, buttonEnabled } = result.result.value;
155        if (hasMedia && buttonEnabled) {
156          console.log('');
157          return true;
158        }
159 
160        process.stdout.write('.');
161        dots++;
162        if (dots % 60 === 0) console.log(''); // New line every 60 dots
163        await sleep(2000);
164      }
165      console.log('');
166      return false;
167    };
168 
169    const videoReady = await waitForVideoReady();
170    if (videoReady) {
171      console.log('[x-video] Video ready!');
172    } else {
173      console.log('[x-video] Video may still be processing. Please check browser window.');
174    }
175 
176    if (submit) {
177      console.log('[x-video] Submitting post...');
178      await cdp.send('Runtime.evaluate', {
179        expression: `document.querySelector('[data-testid="tweetButton"]')?.click()`,
180      }, { sessionId: activeSessionId });
181      await sleep(5000);
182      console.log('[x-video] Post submitted!');
183    } else {
184      console.log('[x-video] Post composed (preview mode). Add --submit to post.');
185      console.log('[x-video] Browser stays open for review.');
186    }
187  } finally {
188    let leaveChromeOpen = !submit;
189    if (chrome && submit && loggedInDuringRun && cdp && sessionId) {
190      console.log('[x-video] Waiting for X session cookies to persist...');
191      const sessionReady = await waitForXSessionPersistence({ cdp, sessionId });
192      if (!sessionReady) {
193        console.warn('[x-video] X session cookies not observed yet. Leaving Chrome open so login can finish persisting.');
194        leaveChromeOpen = true;
195      }
196    }
197 
198    if (cdp) {
199      if (reusing && submit && targetId) {
200        try { await cdp.send('Target.closeTarget', { targetId }, { timeoutMs: 5_000 }); } catch {}
201      }
202      cdp.close();
203    }
204    if (chrome && submit) {
205      if (leaveChromeOpen) {
206        chrome.unref();
207      } else {
208        await gracefulKillChrome(chrome, port);
209      }
210    }
211  }
212}
213 
214function printUsage(): never {
215  console.log(`Post video to X (Twitter) using real Chrome browser
216 
217Usage:
218  npx -y bun x-video.ts [options] --video <path> [text]
219 
220Options:
221  --video <path>   Video file path (required, supports mp4/mov/webm)
222  --submit         Actually post (default: preview only)
223  --profile <dir>  Chrome profile directory
224  --help           Show this help
225 
226Examples:
227  npx -y bun x-video.ts --video ./clip.mp4 "Check out this video!"
228  npx -y bun x-video.ts --video ./demo.mp4 --submit
229  npx -y bun x-video.ts --video ./video.mp4 "Multi-line text
230works too"
231 
232Notes:
233  - Video is uploaded first, then text is added (to avoid text being cleared)
234  - Video processing may take 30-60 seconds depending on file size
235  - Maximum video length on X: 140 seconds (regular) or 60 min (Premium)
236  - Supported formats: MP4, MOV, WebM
237`);
238  process.exit(0);
239}
240 
241async function main(): Promise<void> {
242  const args = process.argv.slice(2);
243  if (args.includes('--help') || args.includes('-h')) printUsage();
244 
245  let videoPath: string | undefined;
246  let submit = false;
247  let profileDir: string | undefined;
248  const textParts: string[] = [];
249 
250  for (let i = 0; i < args.length; i++) {
251    const arg = args[i]!;
252    if (arg === '--video' && args[i + 1]) {
253      videoPath = args[++i]!;
254    } else if (arg === '--submit') {
255      submit = true;
256    } else if (arg === '--profile' && args[i + 1]) {
257      profileDir = args[++i];
258    } else if (!arg.startsWith('-')) {
259      textParts.push(arg);
260    }
261  }
262 
263  const text = textParts.join(' ').trim() || undefined;
264 
265  if (!videoPath) {
266    console.error('Error: --video <path> is required.');
267    printUsage();
268  }
269 
270  await postVideoToX({ text, videoPath, submit, profileDir });
271}
272 
273await main().catch((err) => {
274  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
275  process.exit(1);
276});
277