1import fs from 'node:fs';
2import { mkdir } from 'node:fs/promises';
3import path from 'node:path';
4import process from 'node:process';
5import {
6  CdpConnection,
7  findChromeExecutable,
8  findExistingChromeDebugPort,
9  getDefaultProfileDir,
10  killChromeByProfile,
11  launchChrome as launchWeiboChrome,
12  sleep,
13  waitForChromeDebugPort,
14} from './weibo-utils.js';
15 
16const WEIBO_HOME_URL = 'https://weibo.com/';
17 
18const MAX_FILES = 18;
19 
20interface WeiboPostOptions {
21  text?: string;
22  images?: string[];
23  videos?: string[];
24  timeoutMs?: number;
25  profileDir?: string;
26  chromePath?: string;
27}
28 
29export async function postToWeibo(options: WeiboPostOptions): Promise<void> {
30  const { text, images = [], videos = [], timeoutMs = 120_000, profileDir = getDefaultProfileDir() } = options;
31 
32  const allFiles = [...images, ...videos];
33  if (allFiles.length > MAX_FILES) {
34    throw new Error(`Too many files: ${allFiles.length} (max ${MAX_FILES})`);
35  }
36 
37  await mkdir(profileDir, { recursive: true });
38 
39  const chromePath = findChromeExecutable(options.chromePath);
40  if (!chromePath) throw new Error('Chrome not found. Set WEIBO_BROWSER_CHROME_PATH env var.');
41 
42  let port: number;
43  const existingPort = await findExistingChromeDebugPort(profileDir);
44 
45  if (existingPort) {
46    console.log(`[weibo-post] Found existing Chrome on port ${existingPort}, checking health...`);
47    try {
48      const wsUrl = await waitForChromeDebugPort(existingPort, 5_000);
49      const testCdp = await CdpConnection.connect(wsUrl, 5_000, { defaultTimeoutMs: 5_000 });
50      await testCdp.send('Target.getTargets');
51      testCdp.close();
52      console.log('[weibo-post] Existing Chrome is responsive, reusing.');
53      port = existingPort;
54    } catch {
55      console.log('[weibo-post] Existing Chrome unresponsive, restarting...');
56      killChromeByProfile(profileDir);
57      await sleep(2000);
58      port = await launchWeiboChrome(WEIBO_HOME_URL, profileDir, chromePath);
59    }
60  } else {
61    port = await launchWeiboChrome(WEIBO_HOME_URL, profileDir, chromePath);
62  }
63 
64  let cdp: CdpConnection | null = null;
65 
66  try {
67    const wsUrl = await waitForChromeDebugPort(port, 30_000);
68    cdp = await CdpConnection.connect(wsUrl, 30_000, { defaultTimeoutMs: 15_000 });
69 
70    const targets = await cdp.send<{ targetInfos: Array<{ targetId: string; url: string; type: string }> }>('Target.getTargets');
71    let pageTarget = targets.targetInfos.find((t) => t.type === 'page' && t.url.includes('weibo.com'));
72 
73    if (!pageTarget) {
74      const { targetId } = await cdp.send<{ targetId: string }>('Target.createTarget', { url: WEIBO_HOME_URL });
75      pageTarget = { targetId, url: WEIBO_HOME_URL, type: 'page' };
76    }
77 
78    const { sessionId } = await cdp.send<{ sessionId: string }>('Target.attachToTarget', { targetId: pageTarget.targetId, flatten: true });
79 
80    await cdp.send('Target.activateTarget', { targetId: pageTarget.targetId });
81 
82    await cdp.send('Page.enable', {}, { sessionId });
83    await cdp.send('Runtime.enable', {}, { sessionId });
84    await cdp.send('Input.setIgnoreInputEvents', { ignore: false }, { sessionId });
85 
86    const currentUrl = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
87      expression: `window.location.href`,
88      returnByValue: true,
89    }, { sessionId });
90 
91    if (!currentUrl.result.value.includes('weibo.com/') || currentUrl.result.value.includes('card.weibo.com')) {
92      console.log('[weibo-post] Navigating to Weibo home...');
93      await cdp.send('Page.navigate', { url: WEIBO_HOME_URL }, { sessionId });
94      await sleep(3000);
95    }
96 
97    console.log('[weibo-post] Waiting for Weibo editor...');
98    await sleep(3000);
99 
100    const waitForEditor = async (): Promise<boolean> => {
101      const start = Date.now();
102      while (Date.now() - start < timeoutMs) {
103        const result = await cdp!.send<{ result: { value: boolean } }>('Runtime.evaluate', {
104          expression: `!!document.querySelector('#homeWrap textarea')`,
105          returnByValue: true,
106        }, { sessionId });
107        if (result.result.value) return true;
108        await sleep(1000);
109      }
110      return false;
111    };
112 
113    const editorFound = await waitForEditor();
114    if (!editorFound) {
115      console.log('[weibo-post] Editor not found. Please log in to Weibo in the browser window.');
116      console.log('[weibo-post] Waiting for login...');
117      const loggedIn = await waitForEditor();
118      if (!loggedIn) throw new Error('Timed out waiting for Weibo editor. Please log in first.');
119    }
120 
121    if (text) {
122      console.log('[weibo-post] Typing text...');
123 
124      // Focus and use Input.insertText via CDP
125      await cdp.send('Runtime.evaluate', {
126        expression: `(() => {
127          const editor = document.querySelector('#homeWrap textarea');
128          if (editor) { editor.focus(); editor.value = ''; }
129        })()`,
130      }, { sessionId });
131      await sleep(200);
132 
133      await cdp.send('Input.insertText', { text }, { sessionId });
134      await sleep(500);
135 
136      // Verify text was entered
137      const textCheck = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
138        expression: `document.querySelector('#homeWrap textarea')?.value || ''`,
139        returnByValue: true,
140      }, { sessionId });
141 
142      if (textCheck.result.value.length > 0) {
143        console.log(`[weibo-post] Text verified (${textCheck.result.value.length} chars)`);
144      } else {
145        console.warn('[weibo-post] Text input appears empty, trying execCommand fallback...');
146        await cdp.send('Runtime.evaluate', {
147          expression: `(() => {
148            const editor = document.querySelector('#homeWrap textarea');
149            if (editor) { editor.focus(); document.execCommand('insertText', false, ${JSON.stringify(text)}); }
150          })()`,
151        }, { sessionId });
152        await sleep(300);
153 
154        const textRecheck = await cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
155          expression: `document.querySelector('#homeWrap textarea')?.value || ''`,
156          returnByValue: true,
157        }, { sessionId });
158        console.log(`[weibo-post] Text after fallback: ${textRecheck.result.value.length} chars`);
159      }
160    }
161 
162    if (allFiles.length > 0) {
163      const missing = allFiles.filter((f) => !fs.existsSync(f));
164      if (missing.length > 0) {
165        throw new Error(`Files not found: ${missing.join(', ')}`);
166      }
167 
168      const absolutePaths = allFiles.map((f) => path.resolve(f));
169      console.log(`[weibo-post] Uploading ${absolutePaths.length} file(s) via file input...`);
170 
171      await cdp.send('DOM.enable', {}, { sessionId });
172 
173      const { root } = await cdp.send<{ root: { nodeId: number } }>('DOM.getDocument', {}, { sessionId });
174 
175      const { nodeId } = await cdp.send<{ nodeId: number }>('DOM.querySelector', {
176        nodeId: root.nodeId,
177        selector: '#homeWrap input[type="file"]',
178      }, { sessionId });
179 
180      if (!nodeId || nodeId === 0) {
181        throw new Error('File input not found. Make sure the Weibo compose area is visible.');
182      }
183 
184      await cdp.send('DOM.setFileInputFiles', {
185        nodeId,
186        files: absolutePaths,
187      }, { sessionId });
188 
189      console.log('[weibo-post] Files set on input. Waiting for upload...');
190      await sleep(2000);
191 
192      const uploadCheck = await cdp.send<{ result: { value: number } }>('Runtime.evaluate', {
193        expression: `document.querySelectorAll('#homeWrap img[src^="blob:"], #homeWrap img[src^="data:"], #homeWrap video').length`,
194        returnByValue: true,
195      }, { sessionId });
196 
197      if (uploadCheck.result.value > 0) {
198        console.log(`[weibo-post] Upload verified (${uploadCheck.result.value} media item(s) detected)`);
199      } else {
200        console.warn('[weibo-post] Upload may still be in progress. Please verify in browser.');
201      }
202    }
203 
204    console.log('[weibo-post] Post composed. Please review and click the publish button in the browser.');
205    console.log('[weibo-post] Browser remains open for manual review.');
206 
207  } finally {
208    if (cdp) {
209      cdp.close();
210    }
211  }
212}
213 
214function printUsage(): never {
215  console.log(`Post to Weibo using real Chrome browser
216 
217Usage:
218  npx -y bun weibo-post.ts [options] [text]
219 
220Options:
221  --image <path>   Add image (can be repeated)
222  --video <path>   Add video (can be repeated)
223  --profile <dir>  Chrome profile directory
224  --help           Show this help
225 
226Max ${MAX_FILES} files total (images + videos combined).
227 
228Examples:
229  npx -y bun weibo-post.ts "Hello from CLI!"
230  npx -y bun weibo-post.ts "Check this out" --image ./screenshot.png
231  npx -y bun weibo-post.ts "Post it!" --image a.png --image b.png
232  npx -y bun weibo-post.ts "Watch this" --video ./clip.mp4
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  const videos: string[] = [];
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 === '--video' && args[i + 1]) {
251      videos.push(args[++i]!);
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 && videos.length === 0) {
262    console.error('Error: Provide text or at least one image/video.');
263    process.exit(1);
264  }
265 
266  await postToWeibo({ text, images, videos, profileDir });
267}
268 
269await main().catch((err) => {
270  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
271  process.exit(1);
272});
273