1import process from 'node:process';
2 
3import {
4  CdpConnection,
5  discoverRunningChromeDebugPort,
6  findChromeExecutable as findChromeExecutableBase,
7  findExistingChromeDebugPort,
8  gracefulKillChrome,
9  getFreePort,
10  launchChrome as launchChromeBase,
11  openPageSession,
12  sleep,
13  waitForChromeDebugPort,
14  type PlatformCandidates,
15} from 'baoyu-chrome-cdp';
16 
17import { Endpoint, Headers } from '../constants.js';
18import { logger } from './logger.js';
19import { cookie_header, fetch_with_timeout } from './http.js';
20import { read_cookie_file, type CookieMap, write_cookie_file } from './cookie-file.js';
21import { resolveGeminiWebChromeProfileDir, resolveGeminiWebCookiePath } from './paths.js';
22 
23const GEMINI_APP_URL = 'https://gemini.google.com/app';
24 
25const CHROME_CANDIDATES_FULL: PlatformCandidates = {
26  darwin: [
27    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
28    '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
29    '/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta',
30    '/Applications/Chromium.app/Contents/MacOS/Chromium',
31    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
32  ],
33  win32: [
34    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
35    'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
36    'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
37    'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
38  ],
39  default: [
40    '/usr/bin/google-chrome',
41    '/usr/bin/google-chrome-stable',
42    '/usr/bin/chromium',
43    '/usr/bin/chromium-browser',
44    '/snap/bin/chromium',
45    '/usr/bin/microsoft-edge',
46  ],
47};
48 
49async function get_free_port(): Promise<number> {
50  return await getFreePort('GEMINI_WEB_DEBUG_PORT');
51}
52 
53function find_chrome_executable(): string | null {
54  return findChromeExecutableBase({
55    candidates: CHROME_CANDIDATES_FULL,
56    envNames: ['GEMINI_WEB_CHROME_PATH'],
57  }) ?? null;
58}
59 
60async function find_existing_chrome_debug_port(profileDir: string): Promise<number | null> {
61  return await findExistingChromeDebugPort({ profileDir });
62}
63 
64async function launch_chrome(profileDir: string, port: number) {
65  const chromePath = find_chrome_executable();
66  if (!chromePath) throw new Error('Chrome executable not found.');
67 
68  return await launchChromeBase({
69    chromePath,
70    profileDir,
71    port,
72    url: GEMINI_APP_URL,
73    extraArgs: ['--disable-popup-blocking'],
74  });
75}
76 
77async function is_gemini_session_ready(cookies: CookieMap, verbose: boolean): Promise<boolean> {
78  if (!cookies['__Secure-1PSID']) return false;
79 
80  try {
81    const res = await fetch_with_timeout(Endpoint.INIT, {
82      method: 'GET',
83      headers: { ...Headers.GEMINI, Cookie: cookie_header(cookies) },
84      redirect: 'follow',
85      timeout_ms: 30_000,
86    });
87 
88    if (!res.ok) {
89      if (verbose) logger.debug(`Gemini init check failed: ${res.status} ${res.statusText}`);
90      return false;
91    }
92 
93    const text = await res.text();
94    return /\"SNlM0e\":\"(.*?)\"/.test(text);
95  } catch (e) {
96    if (verbose) logger.debug(`Gemini init check error: ${e instanceof Error ? e.message : String(e)}`);
97    return false;
98  }
99}
100 
101async function fetch_cookies_from_existing_chrome(
102  timeoutMs: number,
103  verbose: boolean,
104): Promise<CookieMap | null> {
105  const discovered = await discoverRunningChromeDebugPort();
106  if (discovered === null) return null;
107 
108  if (verbose) logger.info(`Found reusable Chrome debugging session on port ${discovered.port}. Connecting via WebSocket...`);
109 
110  let cdp: CdpConnection | null = null;
111  let targetId: string | null = null;
112  let createdTarget = false;
113  try {
114    const connectStart = Date.now();
115    const connectTimeout = 30_000;
116    let lastConnErr: unknown = null;
117    while (Date.now() - connectStart < connectTimeout) {
118      try {
119        cdp = await CdpConnection.connect(discovered.wsUrl, 5_000);
120        break;
121      } catch (e) {
122        lastConnErr = e;
123        if (verbose) logger.debug(`WebSocket connect attempt failed: ${e instanceof Error ? e.message : String(e)}, retrying...`);
124        await sleep(1000);
125      }
126    }
127    if (!cdp) {
128      if (verbose) logger.debug(`Could not connect to Chrome after ${connectTimeout / 1000}s: ${lastConnErr instanceof Error ? lastConnErr.message : String(lastConnErr)}`);
129      return null;
130    }
131 
132    const page = await openPageSession({
133      cdp,
134      reusing: false,
135      url: GEMINI_APP_URL,
136      matchTarget: (target) => target.type === 'page' && target.url.includes('gemini.google.com'),
137      enableNetwork: true,
138      activateTarget: false,
139    });
140    const { sessionId } = page;
141    targetId = page.targetId;
142    createdTarget = page.createdTarget;
143 
144    if (verbose) logger.debug(createdTarget ? 'No Gemini tab found, creating new tab...' : 'Found existing Gemini tab, attaching...');
145 
146    const start = Date.now();
147    let last: CookieMap = {};
148 
149    while (Date.now() - start < timeoutMs) {
150      const { cookies } = await cdp.send<{ cookies: Array<{ name: string; value: string }> }>(
151        'Network.getCookies',
152        { urls: ['https://gemini.google.com/', 'https://accounts.google.com/', 'https://www.google.com/'] },
153        { sessionId, timeoutMs: 10_000 },
154      );
155 
156      const cookieMap: CookieMap = {};
157      for (const cookie of cookies) {
158        if (cookie?.name && typeof cookie.value === 'string') cookieMap[cookie.name] = cookie.value;
159      }
160 
161      last = cookieMap;
162      if (await is_gemini_session_ready(cookieMap, verbose)) return cookieMap;
163 
164      await sleep(1000);
165    }
166 
167    if (verbose) logger.debug(`Existing Chrome did not yield valid cookies. Last keys: ${Object.keys(last).join(', ')}`);
168    return null;
169  } catch (e) {
170    if (verbose) logger.debug(`Failed to connect to existing Chrome debugging session: ${e instanceof Error ? e.message : String(e)}`);
171    return null;
172  } finally {
173    if (cdp) {
174      if (createdTarget && targetId) {
175        try { await cdp.send('Target.closeTarget', { targetId }, { timeoutMs: 5_000 }); } catch {}
176      }
177      cdp.close();
178    }
179  }
180}
181 
182async function fetch_google_cookies_via_cdp(
183  profileDir: string,
184  timeoutMs: number,
185  verbose: boolean,
186): Promise<CookieMap> {
187  const existingPort = await find_existing_chrome_debug_port(profileDir);
188  const reusing = existingPort !== null;
189  const port = existingPort ?? await get_free_port();
190  const chrome = reusing ? null : await launch_chrome(profileDir, port);
191 
192  let cdp: CdpConnection | null = null;
193  let targetId: string | null = null;
194  try {
195    const wsUrl = await waitForChromeDebugPort(port, 30_000, { includeLastError: true });
196    cdp = await CdpConnection.connect(wsUrl, 15_000);
197 
198    if (verbose) {
199      logger.info(reusing
200        ? `Reusing existing Chrome on port ${port}. Waiting for a valid Gemini session...`
201        : 'Chrome opened. If needed, complete Google login in the window. Waiting for a valid Gemini session...');
202    }
203 
204    const page = await openPageSession({
205      cdp,
206      reusing,
207      url: GEMINI_APP_URL,
208      matchTarget: (target) => target.type === 'page' && target.url.includes('gemini.google.com'),
209      enableNetwork: true,
210    });
211    const { sessionId } = page;
212    targetId = page.targetId;
213 
214    const start = Date.now();
215    let last: CookieMap = {};
216 
217    while (Date.now() - start < timeoutMs) {
218      const { cookies } = await cdp.send<{ cookies: Array<{ name: string; value: string }> }>(
219        'Network.getCookies',
220        { urls: ['https://gemini.google.com/', 'https://accounts.google.com/', 'https://www.google.com/'] },
221        { sessionId, timeoutMs: 10_000 },
222      );
223 
224      const cookieMap: CookieMap = {};
225      for (const cookie of cookies) {
226        if (cookie?.name && typeof cookie.value === 'string') cookieMap[cookie.name] = cookie.value;
227      }
228 
229      last = cookieMap;
230      if (await is_gemini_session_ready(cookieMap, verbose)) {
231        return cookieMap;
232      }
233 
234      await sleep(1000);
235    }
236 
237    throw new Error(`Timed out waiting for a valid Gemini session. Last keys: ${Object.keys(last).join(', ')}`);
238  } finally {
239    if (cdp) {
240      if (reusing && targetId) {
241        try {
242          await cdp.send('Target.closeTarget', { targetId }, { timeoutMs: 5_000 });
243        } catch {}
244      }
245      cdp.close();
246    }
247 
248    if (chrome) await gracefulKillChrome(chrome, port);
249  }
250}
251 
252export async function load_browser_cookies(domain_name: string = '', verbose: boolean = true): Promise<Record<string, CookieMap>> {
253  const force = process.env.GEMINI_WEB_LOGIN?.trim() || process.env.GEMINI_WEB_FORCE_LOGIN?.trim();
254  if (!force) {
255    const cached = await read_cookie_file();
256    if (cached) return { chrome: cached };
257  }
258 
259  const hasExplicitProfile = !!(process.env.GEMINI_WEB_CHROME_PROFILE_DIR?.trim() || process.env.BAOYU_CHROME_PROFILE_DIR?.trim());
260  const existingCookies = hasExplicitProfile ? null : await fetch_cookies_from_existing_chrome(30_000, verbose);
261  if (existingCookies) {
262    const filtered: CookieMap = {};
263    for (const [key, value] of Object.entries(existingCookies)) {
264      if (typeof value === 'string' && value.length > 0) filtered[key] = value;
265    }
266 
267    await write_cookie_file(filtered, resolveGeminiWebCookiePath(), 'cdp-existing');
268    void domain_name;
269    return { chrome: filtered };
270  }
271 
272  const profileDir = process.env.GEMINI_WEB_CHROME_PROFILE_DIR?.trim() || resolveGeminiWebChromeProfileDir();
273  const cookies = await fetch_google_cookies_via_cdp(profileDir, 120_000, verbose);
274 
275  const filtered: CookieMap = {};
276  for (const [key, value] of Object.entries(cookies)) {
277    if (typeof value === 'string' && value.length > 0) filtered[key] = value;
278  }
279 
280  await write_cookie_file(filtered, resolveGeminiWebCookiePath(), 'cdp');
281  void domain_name;
282  return { chrome: filtered };
283}
284 
285export const loadBrowserCookies = load_browser_cookies;
286