Add baoyu-skills package

baoyu-skills/skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/cookie-file.ts

@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+
+import { resolveGeminiWebCookiePath } from './paths.js';
+
+export type CookieMap = Record<string, string>;
+
+export type CookieFileData =
+  | {
+      cookies: CookieMap;
+      updated_at: number;
+      source?: string;
+    }
+  | {
+      version: number;
+      updatedAt: string;
+      cookieMap: CookieMap;
+      source?: string;
+    };
+
+export async function read_cookie_file(p: string = resolveGeminiWebCookiePath()): Promise<CookieMap | null> {
+  try {
+    if (!fs.existsSync(p) || !fs.statSync(p).isFile()) return null;
+    const raw = await readFile(p, 'utf8');
+    const data = JSON.parse(raw) as unknown;
+
+    if (data && typeof data === 'object' && 'cookies' in (data as any)) {
+      const cookies = (data as any).cookies as unknown;
+      if (cookies && typeof cookies === 'object') {
+        const out: CookieMap = {};
+        for (const [k, v] of Object.entries(cookies as Record<string, unknown>)) {
+          if (typeof v === 'string') out[k] = v;
+        }
+        return out;
+      }
+    }
+
+    if (data && typeof data === 'object' && 'cookieMap' in (data as any)) {
+      const cookies = (data as any).cookieMap as unknown;
+      if (cookies && typeof cookies === 'object') {
+        const out: CookieMap = {};
+        for (const [k, v] of Object.entries(cookies as Record<string, unknown>)) {
+          if (typeof v === 'string') out[k] = v;
+        }
+        return Object.keys(out).length > 0 ? out : null;
+      }
+    }
+
+    if (data && typeof data === 'object') {
+      const out: CookieMap = {};
+      for (const [k, v] of Object.entries(data as Record<string, unknown>)) {
+        if (typeof v === 'string') out[k] = v;
+      }
+      return Object.keys(out).length > 0 ? out : null;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function write_cookie_file(
+  cookies: CookieMap,
+  p: string = resolveGeminiWebCookiePath(),
+  source?: string,
+): Promise<void> {
+  const dir = path.dirname(p);
+  await mkdir(dir, { recursive: true });
+
+  const payload: CookieFileData = {
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    cookieMap: cookies,
+    source,
+  };
+  await writeFile(p, JSON.stringify(payload, null, 2), 'utf8');
+}
+
+export const readCookieFile = read_cookie_file;
+export const writeCookieFile = write_cookie_file;

baoyu-skills/skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/decorators.ts

@@ -0,0 +1,34 @@
+import { APIError, ImageGenerationError } from '../exceptions.js';
+import { sleep } from './http.js';
+
+export function running(retry: number = 0) {
+  return <TArgs extends unknown[], TResult>(
+    fn: (client: any, ...args: TArgs) => Promise<TResult>,
+  ): ((client: any, ...args: TArgs) => Promise<TResult>) => {
+    const wrap = async (client: any, ...args: TArgs): Promise<TResult> => {
+      try {
+        if (!client?._running) {
+          await client.init?.({
+            timeout: client.timeout,
+            auto_close: client.auto_close,
+            close_delay: client.close_delay,
+            auto_refresh: client.auto_refresh,
+            refresh_interval: client.refresh_interval,
+            verbose: false,
+          });
+        }
+        return await fn(client, ...args);
+      } catch (e) {
+        let r = retry;
+        if (e instanceof ImageGenerationError) r = Math.min(1, r);
+        if (e instanceof APIError && r > 0) {
+          await sleep(1000);
+          return await running(r - 1)(fn)(client, ...args);
+        }
+        throw e;
+      }
+    };
+    return wrap;
+  };
+}
+

baoyu-skills/skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/get-access-token.ts

@@ -0,0 +1,192 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+import { Endpoint, Headers } from '../constants.js';
+import { AuthError } from '../exceptions.js';
+import { cookie_header, extract_set_cookie_value, fetch_with_timeout } from './http.js';
+import { logger } from './logger.js';
+import { read_cookie_file, write_cookie_file } from './cookie-file.js';
+import { resolveGeminiWebDataDir, resolveGeminiWebCookiePath } from './paths.js';
+import { load_browser_cookies } from './load-browser-cookies.js';
+
+async function send_request(cookies: Record<string, string>, verbose: boolean): Promise<[string, Record<string, string>]> {
+  const res = await fetch_with_timeout(Endpoint.INIT, {
+    method: 'GET',
+    headers: { ...Headers.GEMINI, Cookie: cookie_header(cookies) },
+    redirect: 'follow',
+    timeout_ms: 30_000,
+  });
+
+  if (!res.ok) throw new Error(`Init failed: ${res.status} ${res.statusText}`);
+  const text = await res.text();
+  const m = text.match(/\"SNlM0e\":\"(.*?)\"/);
+  if (!m) throw new Error('Missing SNlM0e in response');
+  if (verbose) logger.debug('Init succeeded. Initializing client...');
+  return [m[1]!, cookies];
+}
+
+function merge_cookie_maps(...maps: Array<Record<string, string> | null | undefined>): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const m of maps) {
+    if (!m) continue;
+    for (const [k, v] of Object.entries(m)) {
+      if (typeof v === 'string' && v.length > 0) out[k] = v;
+    }
+  }
+  return out;
+}
+
+function read_cached_1psidts_file(dir: string, sid: string): string | null {
+  try {
+    const p = path.join(dir, `.cached_1psidts_${sid}.txt`);
+    if (!fs.existsSync(p) || !fs.statSync(p).isFile()) return null;
+    const v = fs.readFileSync(p, 'utf8').trim();
+    return v || null;
+  } catch {
+    return null;
+  }
+}
+
+function list_cached_1psidts(dir: string): Array<{ sid: string; sidts: string }> {
+  const out: Array<{ sid: string; sidts: string }> = [];
+  try {
+    if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return out;
+    for (const f of fs.readdirSync(dir)) {
+      if (!f.startsWith('.cached_1psidts_') || !f.endsWith('.txt')) continue;
+      const sid = f.slice('.cached_1psidts_'.length, -'.txt'.length);
+      if (!sid) continue;
+      const sidts = read_cached_1psidts_file(dir, sid);
+      if (sidts) out.push({ sid, sidts });
+    }
+  } catch {}
+  return out;
+}
+
+async function fetch_google_extra_cookies(proxy: string | null, verbose: boolean): Promise<Record<string, string>> {
+  void proxy;
+  try {
+    const res = await fetch_with_timeout(Endpoint.GOOGLE, { timeout_ms: 15_000 });
+    const setCookie = res.headers.get('set-cookie');
+    const nid = extract_set_cookie_value(setCookie, 'NID');
+    if (nid) return { NID: nid };
+  } catch (e) {
+    if (verbose) logger.debug(`Skipping google.com preflight: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  return {};
+}
+
+export async function get_access_token(
+  base_cookies: Record<string, string>,
+  proxy: string | null = null,
+  verbose: boolean = false,
+): Promise<[string, Record<string, string>]> {
+  const extra = await fetch_google_extra_cookies(proxy, verbose);
+
+  const cacheDir = resolveGeminiWebDataDir();
+  const candidates: Record<string, string>[] = [];
+
+  const cookieFilePath = resolveGeminiWebCookiePath();
+  const cachedFile = await read_cookie_file(cookieFilePath);
+  const forceLogin = !!(process.env.GEMINI_WEB_LOGIN?.trim() || process.env.GEMINI_WEB_FORCE_LOGIN?.trim());
+  const shouldUseChromeFirst = forceLogin || (!cachedFile && !base_cookies['__Secure-1PSID'] && !base_cookies['__Secure-1PSIDTS']);
+
+  if (shouldUseChromeFirst) {
+    try {
+      const browser = await load_browser_cookies('google.com', verbose);
+      for (const cookies of Object.values(browser)) {
+        candidates.push(merge_cookie_maps(extra, cookies));
+      }
+    } catch (e) {
+      if (verbose) logger.warning(`Failed to load cookies via Chrome CDP: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
+  if (base_cookies['__Secure-1PSID'] && base_cookies['__Secure-1PSIDTS']) {
+    candidates.push(merge_cookie_maps(extra, base_cookies));
+  } else if (verbose) {
+    logger.debug('Skipping loading base cookies. Either __Secure-1PSID or __Secure-1PSIDTS is not provided.');
+  }
+
+  if (cachedFile) {
+    candidates.push(merge_cookie_maps(extra, cachedFile));
+  }
+
+  if (base_cookies['__Secure-1PSID'] && !base_cookies['__Secure-1PSIDTS']) {
+    const sid = base_cookies['__Secure-1PSID'];
+    const sidts = read_cached_1psidts_file(cacheDir, sid);
+    if (sidts) {
+      candidates.push(merge_cookie_maps(extra, base_cookies, { '__Secure-1PSIDTS': sidts }));
+    } else if (verbose) {
+      logger.debug('Skipping loading cached cookies. Cache file not found or empty.');
+    }
+  } else if (!base_cookies['__Secure-1PSID']) {
+    const caches = list_cached_1psidts(cacheDir);
+    for (const c of caches) {
+      candidates.push(merge_cookie_maps(extra, { '__Secure-1PSID': c.sid, '__Secure-1PSIDTS': c.sidts }));
+    }
+    if (caches.length === 0 && verbose) {
+      logger.debug('Skipping loading cached cookies. Cookies will be cached after successful initialization.');
+    }
+  }
+
+  const unique: Record<string, string>[] = [];
+  const seen = new Set<string>();
+  for (const c of candidates) {
+    const key = `${c['__Secure-1PSID'] ?? ''}:${c['__Secure-1PSIDTS'] ?? ''}:${c.NID ?? ''}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(c);
+  }
+
+  const try_candidates = async (): Promise<[string, Record<string, string>]> => {
+    if (unique.length === 0) throw new Error('no candidates');
+    const attempts = unique.map(async (c, i) => {
+      try {
+        if (verbose) logger.debug(`Init attempt (${i + 1}/${unique.length})...`);
+        return await send_request(c, verbose);
+      } catch (e) {
+        if (verbose) logger.debug(`Init attempt (${i + 1}/${unique.length}) failed: ${e instanceof Error ? e.message : String(e)}`);
+        throw e;
+      }
+    });
+    return (await Promise.any(attempts)) as [string, Record<string, string>];
+  };
+
+  try {
+    const [token, cookies] = await try_candidates();
+    await write_cookie_file(cookies, resolveGeminiWebCookiePath(), 'init').catch(() => {});
+    return [token, cookies];
+  } catch {
+    if (verbose) logger.debug('Cookie attempts failed. Falling back to Chrome CDP cookie load...');
+  }
+
+  const browser = await load_browser_cookies('google.com', verbose);
+  let valid = 0;
+  for (const cookies of Object.values(browser)) {
+    if (cookies['__Secure-1PSID']) valid++;
+    if (base_cookies['__Secure-1PSID'] && cookies['__Secure-1PSID'] && cookies['__Secure-1PSID'] !== base_cookies['__Secure-1PSID']) {
+      if (verbose) logger.debug('Skipping loaded browser cookies: __Secure-1PSID does not match the one provided.');
+      continue;
+    }
+    unique.push(merge_cookie_maps(extra, cookies));
+  }
+
+  if (valid === 0) {
+    throw new AuthError(
+      'No valid cookies available for initialization. Please pass __Secure-1PSID and __Secure-1PSIDTS manually.',
+    );
+  }
+
+  try {
+    const [token, cookies] = await try_candidates();
+    await write_cookie_file(cookies, resolveGeminiWebCookiePath(), 'init').catch(() => {});
+    return [token, cookies];
+  } catch {
+    throw new AuthError(
+      `Failed to initialize client. SECURE_1PSIDTS could get expired frequently, please make sure cookie values are up to date. (Failed initialization attempts: ${unique.length})`,
+    );
+  }
+}
+
+export const getAccessToken = get_access_token;

baoyu-skills/skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/http.ts

@@ -0,0 +1,57 @@
+export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    const t = setTimeout(() => {
+      if (signal) signal.removeEventListener('abort', onAbort);
+      resolve();
+    }, ms);
+
+    const onAbort = () => {
+      clearTimeout(t);
+      if (signal) signal.removeEventListener('abort', onAbort);
+      resolve();
+    };
+
+    if (signal) {
+      if (signal.aborted) {
+        onAbort();
+      } else {
+        signal.addEventListener('abort', onAbort, { once: true });
+      }
+    }
+  });
+}
+
+export function cookie_header(cookies: Record<string, string>): string {
+  return Object.entries(cookies)
+    .filter(([, v]) => typeof v === 'string' && v.length > 0)
+    .map(([k, v]) => `${k}=${v}`)
+    .join('; ');
+}
+
+export const cookieHeader = cookie_header;
+
+export function extract_set_cookie_value(setCookie: string | null, name: string): string | null {
+  if (!setCookie) return null;
+  const re = new RegExp(`(?:^|[;,\\s])${name.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')}=([^;]+)`, 'i');
+  const m = setCookie.match(re);
+  if (!m) return null;
+  return m[1] ?? null;
+}
+
+export async function fetch_with_timeout(
+  url: string,
+  init: RequestInit & { timeout_ms?: number } = {},
+): Promise<Response> {
+  const { timeout_ms, ...rest } = init;
+  if (!timeout_ms || timeout_ms <= 0) return fetch(url, rest);
+
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), timeout_ms);
+  try {
+    return await fetch(url, { ...rest, signal: ctl.signal });
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+export const fetchWithTimeout = fetch_with_timeout;

baoyu-skills/skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/index.ts

@@ -0,0 +1,20 @@
+export { running } from './decorators.js';
+export { get_access_token, getAccessToken } from './get-access-token.js';
+export { load_browser_cookies, loadBrowserCookies } from './load-browser-cookies.js';
+export { logger, set_log_level, setLogLevel } from './logger.js';
+export { extract_json_from_response, extractJsonFromResponse, get_nested_value, getNestedValue } from './parsing.js';
+export { rotate_1psidts, rotate1psidts } from './rotate-1psidts.js';
+export { upload_file, uploadFile, parse_file_name, parseFileName } from './upload-file.js';
+export { read_cookie_file, readCookieFile, write_cookie_file, writeCookieFile } from './cookie-file.js';
+export {
+  resolveUserDataRoot,
+  resolveGeminiWebChromeProfileDir,
+  resolveGeminiWebCookiePath,
+  resolveGeminiWebDataDir,
+  resolveGeminiWebSessionPath,
+  resolveGeminiWebSessionsDir,
+} from './paths.js';
+export { cookie_header, cookieHeader, fetch_with_timeout, fetchWithTimeout, sleep } from './http.js';
+
+export const rotate_tasks = new Map<string, unknown>();
+

baoyu-skills/skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/load-browser-cookies.ts

@@ -0,0 +1,285 @@
+import process from 'node:process';
+
+import {
+  CdpConnection,
+  discoverRunningChromeDebugPort,
+  findChromeExecutable as findChromeExecutableBase,
+  findExistingChromeDebugPort,
+  gracefulKillChrome,
+  getFreePort,
+  launchChrome as launchChromeBase,
+  openPageSession,
+  sleep,
+  waitForChromeDebugPort,
+  type PlatformCandidates,
+} from 'baoyu-chrome-cdp';
+
+import { Endpoint, Headers } from '../constants.js';
+import { logger } from './logger.js';
+import { cookie_header, fetch_with_timeout } from './http.js';
+import { read_cookie_file, type CookieMap, write_cookie_file } from './cookie-file.js';
+import { resolveGeminiWebChromeProfileDir, resolveGeminiWebCookiePath } from './paths.js';
+
+const GEMINI_APP_URL = 'https://gemini.google.com/app';
+
+const CHROME_CANDIDATES_FULL: PlatformCandidates = {
+  darwin: [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+    '/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+  ],
+  win32: [
+    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+    'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+    'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
+    'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
+  ],
+  default: [
+    '/usr/bin/google-chrome',
+    '/usr/bin/google-chrome-stable',
+    '/usr/bin/chromium',
+    '/usr/bin/chromium-browser',
+    '/snap/bin/chromium',
+    '/usr/bin/microsoft-edge',
+  ],
+};
+
+async function get_free_port(): Promise<number> {
+  return await getFreePort('GEMINI_WEB_DEBUG_PORT');
+}
+
+function find_chrome_executable(): string | null {
+  return findChromeExecutableBase({
+    candidates: CHROME_CANDIDATES_FULL,
+    envNames: ['GEMINI_WEB_CHROME_PATH'],
+  }) ?? null;
+}
+
+async function find_existing_chrome_debug_port(profileDir: string): Promise<number | null> {
+  return await findExistingChromeDebugPort({ profileDir });
+}
+
+async function launch_chrome(profileDir: string, port: number) {
+  const chromePath = find_chrome_executable();
+  if (!chromePath) throw new Error('Chrome executable not found.');
+
+  return await launchChromeBase({
+    chromePath,
+    profileDir,
+    port,
+    url: GEMINI_APP_URL,
+    extraArgs: ['--disable-popup-blocking'],
+  });
+}
+
+async function is_gemini_session_ready(cookies: CookieMap, verbose: boolean): Promise<boolean> {
+  if (!cookies['__Secure-1PSID']) return false;
+
+  try {
+    const res = await fetch_with_timeout(Endpoint.INIT, {
+      method: 'GET',
+      headers: { ...Headers.GEMINI, Cookie: cookie_header(cookies) },
+      redirect: 'follow',
+      timeout_ms: 30_000,
+    });
+
+    if (!res.ok) {
+      if (verbose) logger.debug(`Gemini init check failed: ${res.status} ${res.statusText}`);
+      return false;
+    }
+
+    const text = await res.text();
+    return /\"SNlM0e\":\"(.*?)\"/.test(text);
+  } catch (e) {
+    if (verbose) logger.debug(`Gemini init check error: ${e instanceof Error ? e.message : String(e)}`);
+    return false;
+  }
+}
+
+async function fetch_cookies_from_existing_chrome(
+  timeoutMs: number,
+  verbose: boolean,
+): Promise<CookieMap | null> {
+  const discovered = await discoverRunningChromeDebugPort();
+  if (discovered === null) return null;
+
+  if (verbose) logger.info(`Found reusable Chrome debugging session on port ${discovered.port}. Connecting via WebSocket...`);
+
+  let cdp: CdpConnection | null = null;
+  let targetId: string | null = null;
+  let createdTarget = false;
+  try {
+    const connectStart = Date.now();
+    const connectTimeout = 30_000;
+    let lastConnErr: unknown = null;
+    while (Date.now() - connectStart < connectTimeout) {
+      try {
+        cdp = await CdpConnection.connect(discovered.wsUrl, 5_000);
+        break;
+      } catch (e) {
+        lastConnErr = e;
+        if (verbose) logger.debug(`WebSocket connect attempt failed: ${e instanceof Error ? e.message : String(e)}, retrying...`);
+        await sleep(1000);
+      }
+    }
+    if (!cdp) {
+      if (verbose) logger.debug(`Could not connect to Chrome after ${connectTimeout / 1000}s: ${lastConnErr instanceof Error ? lastConnErr.message : String(lastConnErr)}`);
+      return null;
+    }
+
+    const page = await openPageSession({
+      cdp,
+      reusing: false,
+      url: GEMINI_APP_URL,
+      matchTarget: (target) => target.type === 'page' && target.url.includes('gemini.google.com'),
+      enableNetwork: true,
+      activateTarget: false,
+    });
+    const { sessionId } = page;
+    targetId = page.targetId;
+    createdTarget = page.createdTarget;
+
+    if (verbose) logger.debug(createdTarget ? 'No Gemini tab found, creating new tab...' : 'Found existing Gemini tab, attaching...');
+
+    const start = Date.now();
+    let last: CookieMap = {};
+
+    while (Date.now() - start < timeoutMs) {
+      const { cookies } = await cdp.send<{ cookies: Array<{ name: string; value: string }> }>(
+        'Network.getCookies',
+        { urls: ['https://gemini.google.com/', 'https://accounts.google.com/', 'https://www.google.com/'] },
+        { sessionId, timeoutMs: 10_000 },
+      );
+
+      const cookieMap: CookieMap = {};
+      for (const cookie of cookies) {
+        if (cookie?.name && typeof cookie.value === 'string') cookieMap[cookie.name] = cookie.value;
+      }
+
+      last = cookieMap;
+      if (await is_gemini_session_ready(cookieMap, verbose)) return cookieMap;
+
+      await sleep(1000);
+    }
+
+    if (verbose) logger.debug(`Existing Chrome did not yield valid cookies. Last keys: ${Object.keys(last).join(', ')}`);
+    return null;
+  } catch (e) {
+    if (verbose) logger.debug(`Failed to connect to existing Chrome debugging session: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  } finally {
+    if (cdp) {
+      if (createdTarget && targetId) {
+        try { await cdp.send('Target.closeTarget', { targetId }, { timeoutMs: 5_000 }); } catch {}
+      }
+      cdp.close();
+    }
+  }
+}
+
+async function fetch_google_cookies_via_cdp(
+  profileDir: string,
+  timeoutMs: number,
+  verbose: boolean,
+): Promise<CookieMap> {
+  const existingPort = await find_existing_chrome_debug_port(profileDir);
+  const reusing = existingPort !== null;
+  const port = existingPort ?? await get_free_port();
+  const chrome = reusing ? null : await launch_chrome(profileDir, port);
+
+  let cdp: CdpConnection | null = null;
+  let targetId: string | null = null;
+  try {
+    const wsUrl = await waitForChromeDebugPort(port, 30_000, { includeLastError: true });
+    cdp = await CdpConnection.connect(wsUrl, 15_000);
+
+    if (verbose) {
+      logger.info(reusing
+        ? `Reusing existing Chrome on port ${port}. Waiting for a valid Gemini session...`
+        : 'Chrome opened. If needed, complete Google login in the window. Waiting for a valid Gemini session...');
+    }
+
+    const page = await openPageSession({
+      cdp,
+      reusing,
+      url: GEMINI_APP_URL,
+      matchTarget: (target) => target.type === 'page' && target.url.includes('gemini.google.com'),
+      enableNetwork: true,
+    });
+    const { sessionId } = page;
+    targetId = page.targetId;
+
+    const start = Date.now();
+    let last: CookieMap = {};
+
+    while (Date.now() - start < timeoutMs) {
+      const { cookies } = await cdp.send<{ cookies: Array<{ name: string; value: string }> }>(
+        'Network.getCookies',
+        { urls: ['https://gemini.google.com/', 'https://accounts.google.com/', 'https://www.google.com/'] },
+        { sessionId, timeoutMs: 10_000 },
+      );
+
+      const cookieMap: CookieMap = {};
+      for (const cookie of cookies) {
+        if (cookie?.name && typeof cookie.value === 'string') cookieMap[cookie.name] = cookie.value;
+      }
+
+      last = cookieMap;
+      if (await is_gemini_session_ready(cookieMap, verbose)) {
+        return cookieMap;
+      }
+
+      await sleep(1000);
+    }
+
+    throw new Error(`Timed out waiting for a valid Gemini session. Last keys: ${Object.keys(last).join(', ')}`);
+  } finally {
+    if (cdp) {
+      if (reusing && targetId) {
+        try {
+          await cdp.send('Target.closeTarget', { targetId }, { timeoutMs: 5_000 });
+        } catch {}
+      }
+      cdp.close();
+    }
+
+    if (chrome) await gracefulKillChrome(chrome, port);
+  }
+}
+
+export async function load_browser_cookies(domain_name: string = '', verbose: boolean = true): Promise<Record<string, CookieMap>> {
+  const force = process.env.GEMINI_WEB_LOGIN?.trim() || process.env.GEMINI_WEB_FORCE_LOGIN?.trim();
+  if (!force) {
+    const cached = await read_cookie_file();
+    if (cached) return { chrome: cached };
+  }
+
+  const hasExplicitProfile = !!(process.env.GEMINI_WEB_CHROME_PROFILE_DIR?.trim() || process.env.BAOYU_CHROME_PROFILE_DIR?.trim());
+  const existingCookies = hasExplicitProfile ? null : await fetch_cookies_from_existing_chrome(30_000, verbose);
+  if (existingCookies) {
+    const filtered: CookieMap = {};
+    for (const [key, value] of Object.entries(existingCookies)) {
+      if (typeof value === 'string' && value.length > 0) filtered[key] = value;
+    }
+
+    await write_cookie_file(filtered, resolveGeminiWebCookiePath(), 'cdp-existing');
+    void domain_name;
+    return { chrome: filtered };
+  }
+
+  const profileDir = process.env.GEMINI_WEB_CHROME_PROFILE_DIR?.trim() || resolveGeminiWebChromeProfileDir();
+  const cookies = await fetch_google_cookies_via_cdp(profileDir, 120_000, verbose);
+
+  const filtered: CookieMap = {};
+  for (const [key, value] of Object.entries(cookies)) {
+    if (typeof value === 'string' && value.length > 0) filtered[key] = value;
+  }
+
+  await write_cookie_file(filtered, resolveGeminiWebCookiePath(), 'cdp');
+  void domain_name;
+  return { chrome: filtered };
+}
+
+export const loadBrowserCookies = load_browser_cookies;

baoyu-skills/skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/logger.ts

@@ -0,0 +1,42 @@
+export type LogLevel = 'TRACE' | 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR' | 'CRITICAL' | number;
+
+const lvl: Record<Exclude<LogLevel, number>, number> = {
+  TRACE: 0,
+  DEBUG: 1,
+  INFO: 2,
+  WARNING: 3,
+  ERROR: 4,
+  CRITICAL: 5,
+};
+
+let cur = lvl.INFO;
+
+function toNum(level: LogLevel): number {
+  if (typeof level === 'number') return level;
+  return lvl[level] ?? lvl.INFO;
+}
+
+export function set_log_level(level: LogLevel): void {
+  cur = toNum(level);
+}
+
+export const setLogLevel = set_log_level;
+
+function emit(level: Exclude<LogLevel, number>, args: unknown[]): void {
+  if (lvl[level] < cur) return;
+  const prefix = `[gemini_webapi] ${level}:`;
+
+  if (level === 'WARNING') console.warn(prefix, ...args);
+  else if (level === 'ERROR' || level === 'CRITICAL') console.error(prefix, ...args);
+  else console.log(prefix, ...args);
+}
+
+export const logger = {
+  trace: (...args: unknown[]) => emit('TRACE', args),
+  debug: (...args: unknown[]) => emit('DEBUG', args),
+  info: (...args: unknown[]) => emit('INFO', args),
+  warning: (...args: unknown[]) => emit('WARNING', args),
+  error: (...args: unknown[]) => emit('ERROR', args),
+  success: (...args: unknown[]) => emit('INFO', args),
+};
+

baoyu-skills/skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/parsing.ts

@@ -0,0 +1,44 @@
+import { logger } from './logger.js';
+
+export function get_nested_value<T = unknown>(data: unknown, path: number[], def?: T): T {
+  let cur: unknown = data;
+  for (let i = 0; i < path.length; i++) {
+    const k = path[i]!;
+    if (!Array.isArray(cur)) {
+      logger.debug(`Safe navigation: path ${JSON.stringify(path)} ended at index ${i} (key '${k}'), returning default.`);
+      return def as T;
+    }
+    cur = cur[k];
+    if (cur === undefined) {
+      logger.debug(`Safe navigation: path ${JSON.stringify(path)} ended at index ${i} (key '${k}'), returning default.`);
+      return def as T;
+    }
+  }
+
+  if (cur == null && def !== undefined) return def as T;
+  return cur as T;
+}
+
+export function extract_json_from_response(text: string): unknown {
+  if (typeof text !== 'string') {
+    throw new TypeError(`Input text is expected to be a string, got ${typeof text} instead.`);
+  }
+
+  let last: unknown = undefined;
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      last = JSON.parse(trimmed) as unknown;
+    } catch {}
+  }
+
+  if (last === undefined) {
+    throw new Error('Could not find a valid JSON object or array in the response.');
+  }
+
+  return last;
+}
+
+export const extractJsonFromResponse = extract_json_from_response;
+export const getNestedValue = get_nested_value;

baoyu-skills/skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/paths.ts

@@ -0,0 +1,60 @@
+import { execSync } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+
+const APP_DATA_DIR = 'baoyu-skills';
+const GEMINI_DATA_DIR = 'gemini-web';
+const COOKIE_FILE_NAME = 'cookies.json';
+const PROFILE_DIR_NAME = 'chrome-profile';
+
+export function resolveUserDataRoot(): string {
+  if (process.platform === 'win32') {
+    return process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming');
+  }
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support');
+  }
+  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), '.local', 'share');
+}
+
+export function resolveGeminiWebDataDir(): string {
+  const override = process.env.GEMINI_WEB_DATA_DIR?.trim();
+  if (override) return path.resolve(override);
+  return path.join(resolveUserDataRoot(), APP_DATA_DIR, GEMINI_DATA_DIR);
+}
+
+export function resolveGeminiWebCookiePath(): string {
+  const override = process.env.GEMINI_WEB_COOKIE_PATH?.trim();
+  if (override) return path.resolve(override);
+  return path.join(resolveGeminiWebDataDir(), COOKIE_FILE_NAME);
+}
+
+let _wslHome: string | null | undefined;
+function getWslWindowsHome(): string | null {
+  if (_wslHome !== undefined) return _wslHome;
+  if (!process.env.WSL_DISTRO_NAME) { _wslHome = null; return null; }
+  try {
+    const raw = execSync('cmd.exe /C "echo %USERPROFILE%"', { encoding: 'utf-8', timeout: 5000 }).trim().replace(/\r/g, '');
+    _wslHome = execSync(`wslpath -u "${raw}"`, { encoding: 'utf-8', timeout: 5000 }).trim() || null;
+  } catch { _wslHome = null; }
+  return _wslHome;
+}
+
+export function resolveGeminiWebChromeProfileDir(): string {
+  const override = process.env.BAOYU_CHROME_PROFILE_DIR?.trim() || process.env.GEMINI_WEB_CHROME_PROFILE_DIR?.trim();
+  if (override) return path.resolve(override);
+  const wslHome = getWslWindowsHome();
+  if (wslHome) return path.join(wslHome, '.local', 'share', APP_DATA_DIR, PROFILE_DIR_NAME);
+  return path.join(resolveUserDataRoot(), APP_DATA_DIR, PROFILE_DIR_NAME);
+}
+
+export function resolveGeminiWebSessionsDir(): string {
+  return path.join(resolveGeminiWebDataDir(), 'sessions');
+}
+
+export function resolveGeminiWebSessionPath(name: string): string {
+  const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+  return path.join(resolveGeminiWebSessionsDir(), `${sanitized}.json`);
+}
+

baoyu-skills/skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/rotate-1psidts.ts

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { mkdir, writeFile } from 'node:fs/promises';
+
+import { Endpoint, Headers } from '../constants.js';
+import { AuthError } from '../exceptions.js';
+import { cookie_header, extract_set_cookie_value, fetch_with_timeout } from './http.js';
+import { resolveGeminiWebDataDir } from './paths.js';
+
+export async function rotate_1psidts(cookies: Record<string, string>, _proxy?: string | null): Promise<string | null> {
+  const p = resolveGeminiWebDataDir();
+  await mkdir(p, { recursive: true });
+
+  const sid = cookies['__Secure-1PSID'];
+  if (!sid) throw new Error('Missing __Secure-1PSID cookie.');
+
+  const cachePath = path.join(p, `.cached_1psidts_${sid}.txt`);
+
+  try {
+    const st = fs.statSync(cachePath);
+    if (Date.now() - st.mtimeMs <= 60_000) return null;
+  } catch {}
+
+  const res = await fetch_with_timeout(Endpoint.ROTATE_COOKIES, {
+    method: 'POST',
+    headers: { ...Headers.ROTATE_COOKIES, Cookie: cookie_header(cookies) },
+    body: '[000,"-0000000000000000000"]',
+    redirect: 'follow',
+    timeout_ms: 30_000,
+  });
+
+  if (res.status === 401) throw new AuthError('Failed to refresh cookies (401).');
+  if (!res.ok) throw new Error(`RotateCookies failed: ${res.status} ${res.statusText}`);
+
+  const setCookie = res.headers.get('set-cookie');
+  const v = extract_set_cookie_value(setCookie, '__Secure-1PSIDTS');
+  if (v) {
+    await writeFile(cachePath, v, 'utf8');
+    return v;
+  }
+
+  return null;
+}
+
+export const rotate1psidts = rotate_1psidts;
+

baoyu-skills/skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/upload-file.ts

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+
+import { Endpoint, Headers } from '../constants.js';
+
+export async function upload_file(file: string, _proxy?: string | null): Promise<string> {
+  if (!fs.existsSync(file) || !fs.statSync(file).isFile()) {
+    throw new Error(`${file} is not a valid file.`);
+  }
+
+  const filename = path.basename(file);
+  const content = await readFile(file);
+
+  const form = new FormData();
+  form.append('file', new Blob([content]), filename);
+
+  const res = await fetch(Endpoint.UPLOAD, {
+    method: 'POST',
+    headers: { ...Headers.UPLOAD },
+    body: form,
+    redirect: 'follow',
+  });
+
+  if (!res.ok) {
+    throw new Error(`Upload failed: ${res.status} ${res.statusText}`);
+  }
+
+  return await res.text();
+}
+
+export function parse_file_name(file: string): string {
+  if (!fs.existsSync(file) || !fs.statSync(file).isFile()) {
+    throw new Error(`${file} is not a valid file.`);
+  }
+  return path.basename(file);
+}
+
+export const uploadFile = upload_file;
+export const parseFileName = parse_file_name;
+