1import { execSync, type ChildProcess } from 'node:child_process';
2import path from 'node:path';
3import process from 'node:process';
4 
5import {
6  CdpConnection,
7  findChromeExecutable as findChromeExecutableBase,
8  findExistingChromeDebugPort as findExistingChromeDebugPortBase,
9  getFreePort as getFreePortBase,
10  launchChrome as launchChromeBase,
11  resolveSharedChromeProfileDir,
12  sleep,
13  waitForChromeDebugPort,
14  type PlatformCandidates,
15} from 'baoyu-chrome-cdp';
16 
17export { CdpConnection, sleep, waitForChromeDebugPort };
18 
19const CHROME_CANDIDATES_FULL: PlatformCandidates = {
20  darwin: [
21    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
22    '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
23    '/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta',
24    '/Applications/Chromium.app/Contents/MacOS/Chromium',
25    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
26  ],
27  win32: [
28    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
29    'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
30    'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
31    'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
32  ],
33  default: [
34    '/usr/bin/google-chrome',
35    '/usr/bin/google-chrome-stable',
36    '/usr/bin/chromium',
37    '/usr/bin/chromium-browser',
38    '/snap/bin/chromium',
39    '/usr/bin/microsoft-edge',
40  ],
41};
42 
43let wslHome: string | null | undefined;
44function getWslWindowsHome(): string | null {
45  if (wslHome !== undefined) return wslHome;
46  if (!process.env.WSL_DISTRO_NAME) {
47    wslHome = null;
48    return null;
49  }
50  try {
51    const raw = execSync('cmd.exe /C "echo %USERPROFILE%"', {
52      encoding: 'utf-8',
53      timeout: 5_000,
54    }).trim().replace(/\r/g, '');
55    wslHome = execSync(`wslpath -u "${raw}"`, {
56      encoding: 'utf-8',
57      timeout: 5_000,
58    }).trim() || null;
59  } catch {
60    wslHome = null;
61  }
62  return wslHome;
63}
64 
65export async function getFreePort(): Promise<number> {
66  return await getFreePortBase('WECHAT_BROWSER_DEBUG_PORT');
67}
68 
69export function findChromeExecutable(chromePathOverride?: string): string | undefined {
70  if (chromePathOverride?.trim()) return chromePathOverride.trim();
71  return findChromeExecutableBase({
72    candidates: CHROME_CANDIDATES_FULL,
73    envNames: ['WECHAT_BROWSER_CHROME_PATH'],
74  });
75}
76 
77export function getDefaultProfileDir(): string {
78  return resolveSharedChromeProfileDir({
79    envNames: ['BAOYU_CHROME_PROFILE_DIR', 'WECHAT_BROWSER_PROFILE_DIR'],
80    wslWindowsHome: getWslWindowsHome(),
81  });
82}
83 
84export function getAccountProfileDir(alias: string): string {
85  const base = getDefaultProfileDir();
86  return path.join(path.dirname(base), `wechat-${alias}`);
87}
88 
89export interface ChromeSession {
90  cdp: CdpConnection;
91  sessionId: string;
92  targetId: string;
93}
94 
95export async function tryConnectExisting(port: number): Promise<CdpConnection | null> {
96  try {
97    const wsUrl = await waitForChromeDebugPort(port, 5_000, { includeLastError: true });
98    return await CdpConnection.connect(wsUrl, 5_000);
99  } catch {
100    return null;
101  }
102}
103 
104export async function findExistingChromeDebugPort(profileDir = getDefaultProfileDir()): Promise<number | null> {
105  return await findExistingChromeDebugPortBase({ profileDir });
106}
107 
108export async function launchChrome(
109  url: string,
110  profileDir?: string,
111  chromePathOverride?: string,
112): Promise<{ cdp: CdpConnection; chrome: ChildProcess }> {
113  const chromePath = findChromeExecutable(chromePathOverride);
114  if (!chromePath) throw new Error('Chrome not found. Set WECHAT_BROWSER_CHROME_PATH env var.');
115 
116  const profile = profileDir ?? getDefaultProfileDir();
117  const port = await getFreePort();
118  console.log(`[cdp] Launching Chrome (profile: ${profile})`);
119 
120  const chrome = await launchChromeBase({
121    chromePath,
122    profileDir: profile,
123    port,
124    url,
125    extraArgs: ['--disable-blink-features=AutomationControlled', '--start-maximized'],
126  });
127 
128  const wsUrl = await waitForChromeDebugPort(port, 30_000, { includeLastError: true });
129  const cdp = await CdpConnection.connect(wsUrl, 30_000);
130 
131  return { cdp, chrome };
132}
133 
134export async function getPageSession(cdp: CdpConnection, urlPattern: string): Promise<ChromeSession> {
135  const targets = await cdp.send<{ targetInfos: Array<{ targetId: string; url: string; type: string }> }>('Target.getTargets');
136  const pageTarget = targets.targetInfos.find((target) => target.type === 'page' && target.url.includes(urlPattern));
137 
138  if (!pageTarget) throw new Error(`Page not found: ${urlPattern}`);
139 
140  const { sessionId } = await cdp.send<{ sessionId: string }>('Target.attachToTarget', {
141    targetId: pageTarget.targetId,
142    flatten: true,
143  });
144 
145  await cdp.send('Page.enable', {}, { sessionId });
146  await cdp.send('Runtime.enable', {}, { sessionId });
147  await cdp.send('DOM.enable', {}, { sessionId });
148 
149  return { cdp, sessionId, targetId: pageTarget.targetId };
150}
151 
152export async function waitForNewTab(
153  cdp: CdpConnection,
154  initialIds: Set<string>,
155  urlPattern: string,
156  timeoutMs = 30_000,
157): Promise<string> {
158  const start = Date.now();
159  while (Date.now() - start < timeoutMs) {
160    const targets = await cdp.send<{ targetInfos: Array<{ targetId: string; url: string; type: string }> }>('Target.getTargets');
161    const newTab = targets.targetInfos.find((target) => (
162      target.type === 'page' &&
163      !initialIds.has(target.targetId) &&
164      target.url.includes(urlPattern)
165    ));
166    if (newTab) return newTab.targetId;
167    await sleep(500);
168  }
169  throw new Error(`New tab not found: ${urlPattern}`);
170}
171 
172export async function clickElement(session: ChromeSession, selector: string): Promise<void> {
173  const position = await session.cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
174    expression: `
175      (function() {
176        const el = document.querySelector('${selector}');
177        if (!el) return 'null';
178        el.scrollIntoView({ block: 'center' });
179        const rect = el.getBoundingClientRect();
180        return JSON.stringify({ x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 });
181      })()
182    `,
183    returnByValue: true,
184  }, { sessionId: session.sessionId });
185 
186  if (position.result.value === 'null') throw new Error(`Element not found: ${selector}`);
187  const pos = JSON.parse(position.result.value);
188 
189  await session.cdp.send('Input.dispatchMouseEvent', {
190    type: 'mousePressed',
191    x: pos.x,
192    y: pos.y,
193    button: 'left',
194    clickCount: 1,
195  }, { sessionId: session.sessionId });
196  await sleep(50);
197  await session.cdp.send('Input.dispatchMouseEvent', {
198    type: 'mouseReleased',
199    x: pos.x,
200    y: pos.y,
201    button: 'left',
202    clickCount: 1,
203  }, { sessionId: session.sessionId });
204}
205 
206export async function typeText(session: ChromeSession, text: string): Promise<void> {
207  const lines = text.split('\n');
208  for (let index = 0; index < lines.length; index += 1) {
209    const line = lines[index];
210    if (line.length > 0) {
211      await session.cdp.send('Input.insertText', { text: line }, { sessionId: session.sessionId });
212    }
213    if (index < lines.length - 1) {
214      await session.cdp.send('Input.dispatchKeyEvent', {
215        type: 'keyDown',
216        key: 'Enter',
217        code: 'Enter',
218        windowsVirtualKeyCode: 13,
219      }, { sessionId: session.sessionId });
220      await session.cdp.send('Input.dispatchKeyEvent', {
221        type: 'keyUp',
222        key: 'Enter',
223        code: 'Enter',
224        windowsVirtualKeyCode: 13,
225      }, { sessionId: session.sessionId });
226    }
227    await sleep(30);
228  }
229}
230 
231export async function pasteFromClipboard(session: ChromeSession): Promise<void> {
232  const modifiers = process.platform === 'darwin' ? 4 : 2;
233  await session.cdp.send('Input.dispatchKeyEvent', {
234    type: 'keyDown',
235    key: 'v',
236    code: 'KeyV',
237    modifiers,
238    windowsVirtualKeyCode: 86,
239  }, { sessionId: session.sessionId });
240  await session.cdp.send('Input.dispatchKeyEvent', {
241    type: 'keyUp',
242    key: 'v',
243    code: 'KeyV',
244    modifiers,
245    windowsVirtualKeyCode: 86,
246  }, { sessionId: session.sessionId });
247}
248 
249export async function evaluate<T = unknown>(session: ChromeSession, expression: string): Promise<T> {
250  const result = await session.cdp.send<{ result: { value: T } }>('Runtime.evaluate', {
251    expression,
252    returnByValue: true,
253  }, { sessionId: session.sessionId });
254  return result.result.value;
255}
256