@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/chunk-XBWPBZBN.js

@@ -0,0 +1,125 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  activityMonitor
+} from "./chunk-DAPBPCBP.js";
+import {
+  getWebSearchConfigPath
+} from "./chunk-VRB2IYGG.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/perplexity.js
+import { existsSync, readFileSync } from "node:fs";
+var PERPLEXITY_API_URL = "https://api.perplexity.ai/chat/completions", CONFIG_PATH = getWebSearchConfigPath(), RATE_LIMIT = {
+  maxRequests: 10,
+  windowMs: 60 * 1e3
+}, requestTimestamps = [], cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH))
+    return cachedConfig = {}, cachedConfig;
+  let content = readFileSync(CONFIG_PATH, "utf-8");
+  try {
+    return cachedConfig = JSON.parse(content), cachedConfig;
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+}
+function normalizeApiKey(value) {
+  if (typeof value != "string")
+    return null;
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function getApiKey() {
+  let config = loadConfig(), key = normalizeApiKey(process.env.PERPLEXITY_API_KEY) ?? normalizeApiKey(config.perplexityApiKey);
+  if (!key)
+    throw new Error(`Perplexity API key not found. Either:
+  1. Create ${CONFIG_PATH} with { "perplexityApiKey": "your-key" }
+  2. Set PERPLEXITY_API_KEY environment variable
+Get a key at https://perplexity.ai/settings/api`);
+  return key;
+}
+function checkRateLimit() {
+  let now = Date.now(), windowStart = now - RATE_LIMIT.windowMs;
+  for (; requestTimestamps.length > 0 && requestTimestamps[0] < windowStart; )
+    requestTimestamps.shift();
+  if (requestTimestamps.length >= RATE_LIMIT.maxRequests) {
+    let waitMs = requestTimestamps[0] + RATE_LIMIT.windowMs - now;
+    throw new Error(`Rate limited. Try again in ${Math.ceil(waitMs / 1e3)}s`);
+  }
+  requestTimestamps.push(now);
+}
+function validateDomainFilter(domains) {
+  return domains.filter((d) => {
+    let domain = d.startsWith("-") ? d.slice(1) : d;
+    return /^[a-zA-Z0-9][a-zA-Z0-9-_.]*\.[a-zA-Z]{2,}$/.test(domain);
+  });
+}
+function isPerplexityAvailable() {
+  let config = loadConfig();
+  return !!(normalizeApiKey(process.env.PERPLEXITY_API_KEY) ?? normalizeApiKey(config.perplexityApiKey));
+}
+async function searchWithPerplexity(query, options = {}) {
+  checkRateLimit();
+  let activityId = activityMonitor.logStart({ type: "api", query });
+  activityMonitor.updateRateLimit({
+    used: requestTimestamps.length,
+    max: RATE_LIMIT.maxRequests,
+    oldestTimestamp: requestTimestamps[0] ?? null,
+    windowMs: RATE_LIMIT.windowMs
+  });
+  let apiKey = getApiKey(), numResults = Math.min(options.numResults ?? 5, 20), requestBody = {
+    model: "sonar",
+    messages: [{ role: "user", content: query }],
+    max_tokens: 1024,
+    return_related_questions: !1
+  };
+  if (options.recencyFilter && (requestBody.search_recency_filter = options.recencyFilter), options.domainFilter && options.domainFilter.length > 0) {
+    let validated = validateDomainFilter(options.domainFilter);
+    validated.length > 0 && (requestBody.search_domain_filter = validated);
+  }
+  let response;
+  try {
+    response = await fetch(PERPLEXITY_API_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody),
+      signal: options.signal
+    });
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), err;
+  }
+  if (!response.ok) {
+    activityMonitor.logComplete(activityId, response.status);
+    let errorText = await response.text();
+    throw new Error(`Perplexity API error ${response.status}: ${errorText}`);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    let message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Perplexity API returned invalid JSON: ${message}`);
+  }
+  let answer = data.choices?.[0]?.message?.content || "", citations = Array.isArray(data.citations) ? data.citations : [], results = [];
+  for (let i = 0; i < Math.min(citations.length, numResults); i++) {
+    let citation = citations[i];
+    typeof citation == "string" ? results.push({ title: `Source ${i + 1}`, url: citation, snippet: "" }) : citation && typeof citation == "object" && typeof citation.url == "string" && results.push({
+      title: citation.title || `Source ${i + 1}`,
+      url: citation.url,
+      snippet: ""
+    });
+  }
+  return activityMonitor.logComplete(activityId, response.status), { answer, results };
+}
+
+export {
+  isPerplexityAvailable,
+  searchWithPerplexity
+};

package/dist/node-runtime/chunk-XTHQ7XR7.js

@@ -0,0 +1,509 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  getChromeProfileFromConfig,
+  isBrowserCookieAccessAllowed,
+  normalizeChromeProfile
+} from "./chunk-DMMTJQMQ.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/gemini-web.js
+import { basename } from "node:path";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/chrome-cookies.js
+import { execFile } from "node:child_process";
+import { pbkdf2Sync, createDecipheriv } from "node:crypto";
+import { copyFileSync, existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir, homedir, platform } from "node:os";
+import { join } from "node:path";
+var GOOGLE_ORIGINS = [
+  "https://gemini.google.com",
+  "https://accounts.google.com",
+  "https://www.google.com"
+], ALL_COOKIE_NAMES = /* @__PURE__ */ new Set([
+  "__Secure-1PSID",
+  "__Secure-1PSIDTS",
+  "__Secure-1PSIDCC",
+  "__Secure-1PAPISID",
+  "NID",
+  "AEC",
+  "SOCS",
+  "__Secure-BUCKET",
+  "__Secure-ENID",
+  "SID",
+  "HSID",
+  "SSID",
+  "APISID",
+  "SAPISID",
+  "__Secure-3PSID",
+  "__Secure-3PSIDTS",
+  "__Secure-3PAPISID",
+  "SIDCC"
+]), MACOS_BROWSER_CONFIGS = [
+  {
+    name: "Helium",
+    baseDir: "Library/Application Support/net.imput.helium",
+    keychainService: "Helium Storage Key",
+    keychainAccount: "Helium"
+  },
+  {
+    name: "Chrome",
+    baseDir: "Library/Application Support/Google/Chrome",
+    keychainService: "Chrome Safe Storage",
+    keychainAccount: "Chrome"
+  },
+  {
+    name: "Arc",
+    baseDir: "Library/Application Support/Arc/User Data",
+    keychainService: "Arc Safe Storage",
+    keychainAccount: "Arc"
+  }
+], LINUX_BROWSER_CONFIGS = [
+  { name: "Chromium", baseDir: ".config/chromium", secretToolApp: "chromium" },
+  { name: "Chrome", baseDir: ".config/google-chrome", secretToolApp: "chrome" }
+];
+async function getGoogleCookies(options) {
+  let currentPlatform = platform(), configs = currentPlatform === "darwin" ? MACOS_BROWSER_CONFIGS : currentPlatform === "linux" ? LINUX_BROWSER_CONFIGS : [];
+  if (configs.length === 0)
+    return null;
+  let warnings = [], profile = options?.profile ?? "Default", hosts = GOOGLE_ORIGINS.map((origin) => new URL(origin).hostname);
+  for (let config of configs) {
+    let cookiesPath = join(homedir(), config.baseDir, profile, "Cookies");
+    if (!existsSync(cookiesPath))
+      continue;
+    let password = await readBrowserPassword(config, currentPlatform);
+    if (!password) {
+      warnings.push(`Could not read ${config.name} cookie encryption password`);
+      continue;
+    }
+    let key = pbkdf2Sync(password, "saltysalt", currentPlatform === "darwin" ? 1003 : 1, 16, "sha1"), tempDir = mkdtempSync(join(tmpdir(), "pi-chrome-cookies-"));
+    try {
+      let tempDb = join(tempDir, "Cookies");
+      copyFileSync(cookiesPath, tempDb), copySidecar(cookiesPath, tempDb, "-wal"), copySidecar(cookiesPath, tempDb, "-shm");
+      let stripHash = await readMetaVersion(tempDb) >= 24, rows = await queryCookieRows(tempDb, hosts);
+      if (!rows) {
+        warnings.push(`Failed to query ${config.name} cookie database`);
+        continue;
+      }
+      let cookies = {};
+      for (let row of rows) {
+        let name = row.name;
+        if (!ALL_COOKIE_NAMES.has(name) || cookies[name])
+          continue;
+        let value = typeof row.value == "string" && row.value.length > 0 ? row.value : null;
+        if (!value) {
+          let encrypted = row.encrypted_value;
+          encrypted instanceof Uint8Array && (value = decryptCookieValue(encrypted, key, stripHash));
+        }
+        value && (cookies[name] = value);
+      }
+      if (options?.requiredCookies?.length && !options.requiredCookies.every((name) => !!cookies[name]))
+        continue;
+      return { cookies, warnings };
+    } finally {
+      rmSync(tempDir, { recursive: !0, force: !0 });
+    }
+  }
+  return null;
+}
+function decryptCookieValue(encrypted, key, stripHash) {
+  let buf = Buffer.from(encrypted);
+  if (buf.length < 3)
+    return null;
+  let prefix = buf.subarray(0, 3).toString("utf8");
+  if (!/^v\d\d$/.test(prefix))
+    return null;
+  let ciphertext = buf.subarray(3);
+  if (!ciphertext.length)
+    return "";
+  try {
+    let iv = Buffer.alloc(16, 32), decipher = createDecipheriv("aes-128-cbc", key, iv);
+    decipher.setAutoPadding(!1);
+    let plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]), unpadded = removePkcs7Padding(plaintext), bytes = stripHash && unpadded.length >= 32 ? unpadded.subarray(32) : unpadded, decoded = new TextDecoder("utf-8", { fatal: !0 }).decode(bytes), i = 0;
+    for (; i < decoded.length && decoded.charCodeAt(i) < 32; )
+      i++;
+    return decoded.slice(i);
+  } catch {
+    return null;
+  }
+}
+function removePkcs7Padding(buf) {
+  if (!buf.length)
+    return buf;
+  let padding = buf[buf.length - 1];
+  return !padding || padding > 16 ? buf : buf.subarray(0, buf.length - padding);
+}
+function readBrowserPassword(config, currentPlatform) {
+  return currentPlatform === "darwin" ? !config.keychainAccount || !config.keychainService ? Promise.resolve(null) : readKeychainPassword(config.keychainAccount, config.keychainService) : currentPlatform === "linux" ? readLinuxPassword(config.secretToolApp) : Promise.resolve(null);
+}
+function readKeychainPassword(account, service) {
+  return new Promise((resolve) => {
+    execFile("security", ["find-generic-password", "-w", "-a", account, "-s", service], { timeout: 5e3 }, (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      resolve(stdout.trim() || null);
+    });
+  });
+}
+function readLinuxPassword(secretToolApp) {
+  return secretToolApp ? new Promise((resolve) => {
+    execFile("secret-tool", ["lookup", "application", secretToolApp], { timeout: 5e3 }, (err, stdout) => {
+      if (err) {
+        resolve("peanuts");
+        return;
+      }
+      resolve(stdout.trim() || "peanuts");
+    });
+  }) : Promise.resolve("peanuts");
+}
+var sqliteModule = null;
+async function importSqlite() {
+  if (sqliteModule)
+    return sqliteModule;
+  let orig = process.emitWarning.bind(process);
+  process.emitWarning = ((warning, ...args) => {
+    if (!(typeof warning == "string" ? warning : warning?.message ?? "").includes("SQLite is an experimental feature"))
+      return orig(warning, ...args);
+  });
+  try {
+    return sqliteModule = await import("node:sqlite"), sqliteModule;
+  } catch {
+    return null;
+  } finally {
+    process.emitWarning = orig;
+  }
+}
+function supportsReadBigInts() {
+  let [major, minor] = process.versions.node.split(".").map(Number);
+  return major > 24 ? !0 : major < 24 ? !1 : minor >= 4;
+}
+async function readMetaVersion(dbPath) {
+  let sqlite = await importSqlite();
+  if (!sqlite)
+    return 0;
+  let opts = { readOnly: !0 };
+  supportsReadBigInts() && (opts.readBigInts = !0);
+  let db = new sqlite.DatabaseSync(dbPath, opts);
+  try {
+    let val = db.prepare("SELECT value FROM meta WHERE key = 'version'").all()[0]?.value;
+    return typeof val == "number" ? Math.floor(val) : typeof val == "bigint" ? Number(val) : typeof val == "string" && parseInt(val, 10) || 0;
+  } catch {
+    return 0;
+  } finally {
+    db.close();
+  }
+}
+async function queryCookieRows(dbPath, hosts) {
+  let sqlite = await importSqlite();
+  if (!sqlite)
+    return null;
+  let clauses = [];
+  for (let host of hosts)
+    for (let candidate of expandHosts(host)) {
+      let esc = candidate.replaceAll("'", "''");
+      clauses.push(`host_key = '${esc}'`), clauses.push(`host_key = '.${esc}'`), clauses.push(`host_key LIKE '%.${esc}'`);
+    }
+  let where = clauses.join(" OR "), opts = { readOnly: !0 };
+  supportsReadBigInts() && (opts.readBigInts = !0);
+  let db = new sqlite.DatabaseSync(dbPath, opts);
+  try {
+    return db.prepare(`SELECT name, value, host_key, encrypted_value FROM cookies WHERE (${where}) ORDER BY expires_utc DESC`).all();
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+function expandHosts(host) {
+  let parts = host.split(".").filter(Boolean);
+  if (parts.length <= 1)
+    return [host];
+  let candidates = /* @__PURE__ */ new Set();
+  candidates.add(host);
+  for (let i = 1; i <= parts.length - 2; i++) {
+    let c = parts.slice(i).join(".");
+    c && candidates.add(c);
+  }
+  return Array.from(candidates);
+}
+function copySidecar(srcDb, targetDb, suffix) {
+  let sidecar = `${srcDb}${suffix}`;
+  if (existsSync(sidecar))
+    try {
+      copyFileSync(sidecar, `${targetDb}${suffix}`);
+    } catch {
+    }
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/gemini-web.js
+var GEMINI_APP_URL = "https://gemini.google.com/app", GEMINI_STREAM_GENERATE_URL = "https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate", GEMINI_UPLOAD_URL = "https://content-push.googleapis.com/upload", GEMINI_UPLOAD_PUSH_ID = "feeds/mcudyrk2a4khkz", GOOGLE_LIST_ACCOUNTS_URL = "https://accounts.google.com/ListAccounts?gpsia=1&source=ChromiumBrowser&laf=b64bin&json=standard", USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", MODEL_HEADER_NAME = "x-goog-ext-525001261-jspb", MODEL_HEADERS = {
+  "gemini-3-pro": '[1,null,null,null,"9d8ca3786ebdfbea",null,null,0,[4]]',
+  "gemini-2.5-pro": '[1,null,null,null,"4af6c7f5da75d65d",null,null,0,[4]]',
+  "gemini-2.5-flash": '[1,null,null,null,"9ec249fc9ad08861",null,null,0,[4]]'
+}, REQUIRED_COOKIES = ["__Secure-1PSID", "__Secure-1PSIDTS"];
+async function isGeminiWebAvailable(chromeProfile) {
+  if (!isBrowserCookieAccessAllowed())
+    return null;
+  let result = await getGoogleCookies({
+    profile: normalizeChromeProfile(chromeProfile) ?? getChromeProfileFromConfig(),
+    requiredCookies: REQUIRED_COOKIES
+  });
+  return result ? result.cookies : null;
+}
+async function getActiveGoogleEmail(cookies) {
+  let cookieHeader = buildCookieHeader(cookies);
+  if (!cookieHeader)
+    return null;
+  try {
+    let html = await fetchWithCookieRedirects(GEMINI_APP_URL, cookieHeader, 10, AbortSignal.timeout(1e4)), email = extractEmailFromGeminiHtml(html);
+    if (email)
+      return email;
+  } catch {
+  }
+  try {
+    let response = await fetchWithCookieRedirects(GOOGLE_LIST_ACCOUNTS_URL, cookieHeader, 10, AbortSignal.timeout(1e4));
+    return extractEmailFromListAccounts(response);
+  } catch {
+    return null;
+  }
+}
+async function queryWithCookies(prompt, cookieMap, options = {}) {
+  let model = options.model && MODEL_HEADERS[options.model] ? options.model : "gemini-2.5-flash", timeoutMs = options.timeoutMs ?? 12e4, fullPrompt = prompt;
+  options.youtubeUrl && (fullPrompt = `${fullPrompt}
+
+YouTube video: ${options.youtubeUrl}`);
+  let result = await runGeminiWebOnce(fullPrompt, cookieMap, model, options.files, timeoutMs, options.signal);
+  if (isModelUnavailable(result.errorCode) && model !== "gemini-2.5-flash") {
+    let fallback = await runGeminiWebOnce(fullPrompt, cookieMap, "gemini-2.5-flash", options.files, timeoutMs, options.signal);
+    if (fallback.errorMessage)
+      throw new Error(fallback.errorMessage);
+    if (!fallback.text)
+      throw new Error("Gemini Web returned empty response (fallback model)");
+    return fallback.text;
+  }
+  if (result.errorMessage)
+    throw new Error(result.errorMessage);
+  if (!result.text)
+    throw new Error("Gemini Web returned empty response");
+  return result.text;
+}
+async function runGeminiWebOnce(prompt, cookieMap, model, files, timeoutMs, signal) {
+  let effectiveSignal = withTimeout(signal, timeoutMs), cookieHeader = buildCookieHeader(cookieMap), accessToken = await fetchAccessToken(cookieHeader, effectiveSignal), uploaded = [];
+  if (files)
+    for (let filePath of files)
+      uploaded.push(await uploadFile(filePath, cookieHeader, effectiveSignal));
+  let fReq = buildFReqPayload(prompt, uploaded), params = new URLSearchParams();
+  params.set("at", accessToken), params.set("f.req", fReq);
+  let res = await fetch(GEMINI_STREAM_GENERATE_URL, {
+    method: "POST",
+    headers: {
+      "content-type": "application/x-www-form-urlencoded;charset=utf-8",
+      host: "gemini.google.com",
+      origin: "https://gemini.google.com",
+      referer: "https://gemini.google.com/",
+      "x-same-domain": "1",
+      "user-agent": USER_AGENT,
+      cookie: cookieHeader,
+      [MODEL_HEADER_NAME]: MODEL_HEADERS[model]
+    },
+    body: params.toString(),
+    signal: effectiveSignal
+  }), rawText = await res.text();
+  if (!res.ok)
+    return { text: "", errorMessage: `Gemini request failed: ${res.status}` };
+  try {
+    return parseStreamGenerateResponse(rawText);
+  } catch (err) {
+    let errorCode;
+    try {
+      let json = JSON.parse(trimJsonEnvelope(rawText));
+      errorCode = extractErrorCode(json);
+    } catch {
+    }
+    return {
+      text: "",
+      errorCode,
+      errorMessage: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function fetchAccessToken(cookieHeader, signal) {
+  let html = await fetchWithCookieRedirects(GEMINI_APP_URL, cookieHeader, 10, signal);
+  for (let key of ["SNlM0e", "thykhd"]) {
+    let match = html.match(new RegExp(`"${key}":"(.*?)"`));
+    if (match?.[1])
+      return match[1];
+  }
+  throw new Error("Unable to authenticate with Gemini. Make sure you're signed into gemini.google.com in a supported Chromium-based browser.");
+}
+async function fetchWithCookieRedirects(url, cookieHeader, maxRedirects, signal) {
+  let current = url;
+  for (let i = 0; i <= maxRedirects; i++) {
+    let res = await fetch(current, {
+      headers: { "user-agent": USER_AGENT, cookie: cookieHeader },
+      redirect: "manual",
+      signal
+    });
+    if (res.status >= 300 && res.status < 400) {
+      let location = res.headers.get("location");
+      if (location) {
+        current = new URL(location, current).toString();
+        continue;
+      }
+    }
+    return await res.text();
+  }
+  throw new Error(`Too many redirects (>${maxRedirects})`);
+}
+function extractEmailFromGeminiHtml(html) {
+  let patterns = [
+    // Gemini bootstraps the active account in oPEP7c. Prefer it over generic
+    // feature/config entries that may contain other signed-in Google accounts.
+    /"oPEP7c"\s*:\s*"([^"]+)"/,
+    // The Google account menu aria-label is rendered for the active account.
+    /aria-label="Google Account:[^"]*?\(([^)]+)\)"/,
+    /"displayEmail"\s*:\s*"([^"]+)"/,
+    /"defaultEmail"\s*:\s*"([^"]+)"/,
+    /"email"\s*:\s*"([^"]+)"/,
+    /"identifier"\s*:\s*"([^"]+)"/,
+    /"gaiaIdentifier"\s*:\s*"([^"]+)"/
+  ];
+  for (let pattern of patterns) {
+    let match = html.match(pattern), email = normalizeEmail(match?.[1]);
+    if (email)
+      return email;
+  }
+  return findFirstEmail(html);
+}
+function extractEmailFromListAccounts(text) {
+  let trimmed = text.replace(/^\)\]\}'\s*/, "");
+  try {
+    return findEmailInValue(JSON.parse(trimmed)) ?? findFirstEmail(trimmed);
+  } catch {
+    return findFirstEmail(trimmed);
+  }
+}
+function findEmailInValue(value) {
+  if (typeof value == "string")
+    return normalizeEmail(value);
+  if (Array.isArray(value)) {
+    for (let item of value) {
+      let email = findEmailInValue(item);
+      if (email)
+        return email;
+    }
+    return null;
+  }
+  if (value && typeof value == "object")
+    for (let item of Object.values(value)) {
+      let email = findEmailInValue(item);
+      if (email)
+        return email;
+    }
+  return null;
+}
+function findFirstEmail(text) {
+  return decodeEmailEscapes(text).match(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i)?.[0] ?? null;
+}
+function normalizeEmail(value) {
+  if (!value)
+    return null;
+  let normalized = decodeEmailEscapes(value.trim());
+  return /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i.test(normalized) ? normalized : null;
+}
+function decodeEmailEscapes(value) {
+  return value.replace(/\\u0040/gi, "@").replace(/\\x40/gi, "@").replace(/&#64;/gi, "@").replace(/&commat;/gi, "@").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+}
+async function uploadFile(filePath, cookieHeader, signal) {
+  let data = readFileSync(filePath), fileName = basename(filePath), boundary = "----FormBoundary" + Math.random().toString(36).slice(2), header = `--${boundary}\r
+Content-Disposition: form-data; name="file"; filename="${fileName}"\r
+Content-Type: application/octet-stream\r
+\r
+`, footer = `\r
+--${boundary}--\r
+`, body = Buffer.concat([
+    Buffer.from(header, "utf-8"),
+    data,
+    Buffer.from(footer, "utf-8")
+  ]), res = await fetch(GEMINI_UPLOAD_URL, {
+    method: "POST",
+    headers: {
+      "content-type": `multipart/form-data; boundary=${boundary}`,
+      "push-id": GEMINI_UPLOAD_PUSH_ID,
+      "user-agent": USER_AGENT,
+      cookie: cookieHeader
+    },
+    body,
+    signal
+  });
+  if (!res.ok) {
+    let text = await res.text();
+    throw new Error(`File upload failed: ${res.status} (${text.slice(0, 200)})`);
+  }
+  return { id: await res.text(), name: fileName };
+}
+function buildFReqPayload(prompt, uploaded) {
+  let innerList = [uploaded.length > 0 ? [prompt, 0, null, uploaded.map((file) => [[file.id, 1]])] : [prompt], null, null];
+  return JSON.stringify([null, JSON.stringify(innerList)]);
+}
+function withTimeout(signal, timeoutMs) {
+  let timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function buildCookieHeader(cookieMap) {
+  return Object.entries(cookieMap).filter(([, value]) => typeof value == "string" && value.length > 0).map(([name, value]) => `${name}=${value}`).join("; ");
+}
+function getNestedValue(value, pathParts) {
+  let current = value;
+  for (let part of pathParts) {
+    if (current == null || !Array.isArray(current))
+      return;
+    current = current[part];
+  }
+  return current;
+}
+function trimJsonEnvelope(text) {
+  let start = text.indexOf("["), end = text.lastIndexOf("]");
+  if (start === -1 || end === -1 || end <= start)
+    throw new Error("Gemini response did not contain a JSON payload.");
+  return text.slice(start, end + 1);
+}
+function extractErrorCode(responseJson) {
+  let code = getNestedValue(responseJson, [0, 5, 2, 0, 1, 0]);
+  return typeof code == "number" && code >= 0 ? code : void 0;
+}
+function isModelUnavailable(errorCode) {
+  return errorCode === 1052;
+}
+function extractCandidateText(candidate) {
+  let textRaw = getNestedValue(candidate, [1, 0]), text = typeof textRaw == "string" ? textRaw : "";
+  if (/^http:\/\/googleusercontent\.com\/card_content\/\d+/.test(text)) {
+    let alt = getNestedValue(candidate, [22, 0]);
+    typeof alt == "string" && alt.length > 0 && (text = alt);
+  }
+  return text;
+}
+function parseStreamGenerateResponse(rawText) {
+  let responseJson = JSON.parse(trimJsonEnvelope(rawText)), errorCode = extractErrorCode(responseJson), parts = Array.isArray(responseJson) ? responseJson : [], firstCandidateSeen, latestNonEmptyText = "";
+  for (let i = 0; i < parts.length; i++) {
+    let partBody = getNestedValue(parts[i], [2]);
+    if (!(!partBody || typeof partBody != "string"))
+      try {
+        let parsed = JSON.parse(partBody), candidateList = getNestedValue(parsed, [4]);
+        if (!Array.isArray(candidateList) || candidateList.length === 0)
+          continue;
+        let firstCandidate = candidateList[0];
+        firstCandidateSeen === void 0 && (firstCandidateSeen = firstCandidate);
+        let text2 = extractCandidateText(firstCandidate);
+        text2.length > 0 && (latestNonEmptyText = text2);
+      } catch {
+      }
+  }
+  return { text: latestNonEmptyText.length > 0 ? latestNonEmptyText : extractCandidateText(firstCandidateSeen), errorCode };
+}
+
+export {
+  isGeminiWebAvailable,
+  getActiveGoogleEmail,
+  queryWithCookies
+};