browser-cookie-bridge 1.4.6 → 1.5.0

package/src/grok-bot-export.js

@@ -0,0 +1,199 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readChromiumProfile } from "./chromium-reader.js";
+import { createZipArchive, readZipArchive } from "./zip-store.js";
+
+export const BUNDLE_EXTENSION = "bcbx";
+export const DEFAULT_BUNDLE_NAME = "GrokBot-Import.bcbx";
+export const GROK_BOT_PROMPT = `On your Grok Bot cloud computer only — do not access my local Mac and do not print cookie values.
+
+1. Save the attached GrokBot-Import.bcbx to the cloud computer.
+2. Unzip it: unzip -o GrokBot-Import.bcbx -d bcb-import && cd bcb-import
+3. Run: node import.mjs
+4. When prompted, ask me to take over and type the one-time decryption key privately through Agent Computer.
+5. Report only how many cookies were imported per domain, then delete the bcb-import folder and any copies of the bundle.`;
+
+const KDF = { name: "scrypt", N: 16384, r: 8, p: 1, keyLength: 32 };
+const SAME_SITE = {
+  unspecified: "unspecified",
+  no_restriction: "no_restriction",
+  lax: "lax",
+  strict: "strict",
+};
+
+export function buildGrokBotBundle({
+  cookies,
+  sourceBrowser,
+  onlyDomains = [],
+  passphrase = generatePassphrase(),
+  now = new Date(),
+  importerSource = defaultImporterSource(),
+} = {}) {
+  if (!Array.isArray(cookies)) throw new Error("Cookie export requires a cookie list.");
+  const filtered = filterCookies(cookies, onlyDomains);
+  const exportCookies = filtered.map(normalizeExportCookie).filter(Boolean);
+  if (exportCookies.length === 0) {
+    throw new Error(onlyDomains.length
+      ? "No cookies matched the selected domains."
+      : "No exportable cookies were found in the source browser.");
+  }
+
+  const salt = crypto.randomBytes(16);
+  const iv = crypto.randomBytes(12);
+  const key = crypto.scryptSync(passphrase, salt, KDF.keyLength, { N: KDF.N, r: KDF.r, p: KDF.p });
+  const payload = Buffer.from(JSON.stringify({ cookies: exportCookies }), "utf8");
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  const encrypted = Buffer.concat([cipher.update(payload), cipher.final(), cipher.getAuthTag()]);
+
+  const domains = uniqueDomains(exportCookies);
+  const manifest = {
+    format: "browser-cookie-bridge-grok-bot",
+    version: 1,
+    createdAt: now.toISOString(),
+    sourceBrowser,
+    cookieCount: exportCookies.length,
+    domainCount: domains.length,
+    domains,
+    salt: salt.toString("base64url"),
+    iv: iv.toString("base64url"),
+    authTag: encrypted.subarray(encrypted.length - 16).toString("base64url"),
+    kdf: KDF,
+  };
+  const payloadBody = encrypted.subarray(0, encrypted.length - 16);
+
+  const archive = createZipArchive([
+    { name: "manifest.json", data: Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8") },
+    { name: "payload.enc", data: payloadBody },
+    { name: "import.mjs", data: Buffer.from(importerSource, "utf8") },
+    { name: "PROMPT.txt", data: Buffer.from(`${GROK_BOT_PROMPT}\n`, "utf8") },
+  ]);
+
+  return {
+    archive,
+    manifest,
+    passphrase,
+    cookieCount: exportCookies.length,
+    domainCount: domains.length,
+    domains,
+    sourceBrowser,
+    bundleName: DEFAULT_BUNDLE_NAME,
+  };
+}
+
+export function writeGrokBotBundle({
+  outputPath,
+  cookies,
+  sourceBrowser,
+  onlyDomains = [],
+  passphrase,
+} = {}) {
+  const resolved = path.resolve(outputPath || DEFAULT_BUNDLE_NAME);
+  if (!resolved.endsWith(`.${BUNDLE_EXTENSION}`)) {
+    throw new Error(`Grok Bot bundles must use the .${BUNDLE_EXTENSION} extension.`);
+  }
+  const bundle = buildGrokBotBundle({ cookies, sourceBrowser, onlyDomains, passphrase });
+  fs.mkdirSync(path.dirname(resolved), { recursive: true });
+  fs.writeFileSync(resolved, bundle.archive);
+  fs.chmodSync(resolved, 0o600);
+  return {
+    outputPath: resolved,
+    passphrase: bundle.passphrase,
+    cookieCount: bundle.cookieCount,
+    domainCount: bundle.domainCount,
+    domains: bundle.domains,
+    sourceBrowser: bundle.sourceBrowser,
+    prompt: GROK_BOT_PROMPT,
+  };
+}
+
+export function exportGrokBotBundleFromProfile({
+  browser,
+  onlyDomains = [],
+  outputPath,
+  passphrase,
+} = {}) {
+  const payload = readChromiumProfile({
+    browser,
+    imports: { cookies: true, history: false },
+  });
+  const result = writeGrokBotBundle({
+    outputPath,
+    cookies: payload.cookies,
+    sourceBrowser: browser,
+    onlyDomains,
+    passphrase,
+  });
+  return {
+    ...result,
+    sourceCookieSkipped: payload.cookieStats.skipped,
+    sourceCookieTotal: payload.cookieStats.total,
+  };
+}
+
+export function parseGrokBotBundle(buffer) {
+  const entries = readZipArchive(buffer);
+  const manifest = JSON.parse(entries.get("manifest.json").toString("utf8"));
+  return {
+    manifest,
+    payload: entries.get("payload.enc"),
+    importer: entries.get("import.mjs")?.toString("utf8") || "",
+    prompt: entries.get("PROMPT.txt")?.toString("utf8") || "",
+  };
+}
+
+export function grokBotSummary(result) {
+  const domainNote = result.domainCount === 1 ? "1 domain" : `${result.domainCount} domains`;
+  const skipped = result.sourceCookieSkipped
+    ? ` ${result.sourceCookieSkipped} source cookie${result.sourceCookieSkipped === 1 ? " was" : "s were"} unreadable or unsupported.`
+    : "";
+  return `Grok Bot transfer file created: ${result.cookieCount} cookies across ${domainNote} from ${result.sourceBrowser}.${skipped} Attach ${path.basename(result.outputPath)} to any Grok Bot, paste the prompt, then enter the one-time key privately when asked.`;
+}
+
+export function filterCookies(cookies, onlyDomains = []) {
+  const domains = normalizeDomainFilters(onlyDomains);
+  if (!domains.length) return cookies;
+  return cookies.filter((cookie) => cookieMatchesDomains(cookie, domains));
+}
+
+export function normalizeDomainFilters(onlyDomains) {
+  const items = Array.isArray(onlyDomains) ? onlyDomains : String(onlyDomains || "").split(",");
+  return [...new Set(items.map((item) => String(item).trim().toLowerCase()).filter(Boolean))];
+}
+
+export function cookieMatchesDomains(cookie, domains) {
+  const host = String(cookie?.domain || "").replace(/^\./, "").toLowerCase();
+  if (!host) return false;
+  return domains.some((domain) => host === domain || host.endsWith(`.${domain}`));
+}
+
+function normalizeExportCookie(cookie) {
+  if (!cookie || typeof cookie.name !== "string" || typeof cookie.value !== "string") return null;
+  if (typeof cookie.domain !== "string") return null;
+  const host = cookie.domain.replace(/^\./, "").trim().toLowerCase();
+  if (!host || host.includes("/") || host.includes(":")) return null;
+  const persistent = !cookie.session && Number.isFinite(cookie.expirationDate) && cookie.expirationDate > 0;
+  return {
+    name: cookie.name,
+    value: cookie.value,
+    domain: cookie.hostOnly ? host : `.${host}`,
+    path: typeof cookie.path === "string" && cookie.path.startsWith("/") ? cookie.path : "/",
+    secure: Boolean(cookie.secure),
+    httpOnly: Boolean(cookie.httpOnly),
+    sameSite: SAME_SITE[cookie.sameSite] || "unspecified",
+    ...(persistent ? { expires: Math.trunc(cookie.expirationDate) } : {}),
+  };
+}
+
+function uniqueDomains(cookies) {
+  return [...new Set(cookies.map((cookie) => cookie.domain.replace(/^\./, "").toLowerCase()))].sort();
+}
+
+function generatePassphrase() {
+  return crypto.randomBytes(18).toString("base64url");
+}
+
+function defaultImporterSource() {
+  return fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), "grok-bot-importer.mjs"), "utf8");
+}

package/src/grok-bot-importer.mjs

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+/**
+ * One-time Grok Bot cookie importer for Browser Cookie Bridge bundles.
+ * Run on the Grok Bot cloud computer only. Never log cookie names or values.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { stdin as input, stdout as output } from "node:process";
+
+const CDP_PORTS = [9222, 9223, 9224, 9228, 9229, 9400];
+const SAME_SITE = {
+  unspecified: "Lax",
+  no_restriction: "None",
+  lax: "Lax",
+  strict: "Strict",
+};
+
+export async function main(argv = process.argv.slice(2)) {
+  const bundlePath = path.resolve(argv[0] || "GrokBot-Import.bcbx");
+  const bundleDir = path.dirname(bundlePath);
+  const manifestPath = path.join(bundleDir, "manifest.json");
+  const payloadPath = path.join(bundleDir, "payload.enc");
+  if (!fs.existsSync(manifestPath) || !fs.existsSync(payloadPath)) {
+    throw new Error("Expected manifest.json and payload.enc next to the bundle. Unzip GrokBot-Import.bcbx first.");
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  validateManifest(manifest);
+  const passphrase = await readPassphrase();
+  const cookies = decryptPayload({
+    manifest,
+    encrypted: fs.readFileSync(payloadPath),
+    passphrase,
+  });
+  const endpoint = await findDevToolsEndpoint();
+  const imported = await injectCookies(endpoint.webSocketDebuggerUrl, cookies);
+  reportSummary(imported, manifest.domains || []);
+  cleanup(bundleDir, bundlePath);
+}
+
+export function validateManifest(manifest) {
+  if (manifest?.format !== "browser-cookie-bridge-grok-bot" || manifest?.version !== 1) {
+    throw new Error("Unsupported Browser Cookie Bridge Grok Bot bundle.");
+  }
+  for (const key of ["salt", "iv", "authTag"]) {
+    if (typeof manifest[key] !== "string" || !manifest[key]) {
+      throw new Error(`Bundle manifest is missing ${key}.`);
+    }
+  }
+}
+
+export function decryptPayload({ manifest, encrypted, passphrase }) {
+  const key = crypto.scryptSync(
+    passphrase,
+    Buffer.from(manifest.salt, "base64url"),
+    32,
+    { N: manifest.kdf?.N ?? 16384, r: manifest.kdf?.r ?? 8, p: manifest.kdf?.p ?? 1 },
+  );
+  const decipher = crypto.createDecipheriv(
+    "aes-256-gcm",
+    key,
+    Buffer.from(manifest.iv, "base64url"),
+  );
+  decipher.setAuthTag(Buffer.from(manifest.authTag, "base64url"));
+  const plaintext = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+  const payload = JSON.parse(plaintext.toString("utf8"));
+  if (!Array.isArray(payload.cookies)) throw new Error("Decrypted bundle did not contain cookies.");
+  return payload.cookies;
+}
+
+export async function findDevToolsEndpoint() {
+  for (const port of CDP_PORTS) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(1500) });
+      if (!response.ok) continue;
+      const body = await response.json();
+      if (typeof body?.webSocketDebuggerUrl === "string") {
+        return { port, webSocketDebuggerUrl: body.webSocketDebuggerUrl, browser: body.Browser || "Chrome" };
+      }
+    } catch {
+      // Try the next port.
+    }
+  }
+  throw new Error("No local Chrome DevTools endpoint responded. Run the safe probe first.");
+}
+
+export async function injectCookies(webSocketDebuggerUrl, cookies) {
+  const ws = new WebSocket(webSocketDebuggerUrl);
+  await waitForOpen(ws);
+  let nextId = 1;
+  const cdpCookies = cookies.map(toCdpCookie);
+  const chunks = chunk(cdpCookies, 40);
+  let imported = 0;
+  for (const batch of chunks) {
+    const id = nextId++;
+    const response = await sendCommand(ws, { id, method: "Storage.setCookies", params: { cookies: batch } });
+    if (response.error) throw new Error(`Cookie injection failed: ${response.error.message}`);
+    imported += batch.length;
+  }
+  ws.close();
+  return { imported, batches: chunks.length };
+}
+
+function toCdpCookie(cookie) {
+  const entry = {
+    name: cookie.name,
+    value: cookie.value,
+    domain: cookie.domain,
+    path: cookie.path || "/",
+    secure: Boolean(cookie.secure),
+    httpOnly: Boolean(cookie.httpOnly),
+    sameSite: SAME_SITE[cookie.sameSite] || cookie.sameSite || "Lax",
+  };
+  if (Number.isFinite(cookie.expires) && cookie.expires > 0) entry.expires = cookie.expires;
+  return entry;
+}
+
+function chunk(items, size) {
+  const groups = [];
+  for (let index = 0; index < items.length; index += size) {
+    groups.push(items.slice(index, index + size));
+  }
+  return groups;
+}
+
+async function readPassphrase() {
+  if (process.env.BCB_IMPORT_KEY?.trim()) return process.env.BCB_IMPORT_KEY.trim();
+  const rl = readline.createInterface({ input, output });
+  try {
+    return (await rl.question("One-time decryption key: ")).trim();
+  } finally {
+    rl.close();
+  }
+}
+
+function waitForOpen(ws) {
+  return new Promise((resolve, reject) => {
+    ws.addEventListener("open", () => resolve(), { once: true });
+    ws.addEventListener("error", (event) => reject(event.error || new Error("DevTools connection failed")), { once: true });
+  });
+}
+
+function sendCommand(ws, message) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("DevTools command timed out")), 15000);
+    const onMessage = (event) => {
+      const payload = JSON.parse(String(event.data));
+      if (payload.id !== message.id) return;
+      clearTimeout(timeout);
+      ws.removeEventListener("message", onMessage);
+      resolve(payload);
+    };
+    ws.addEventListener("message", onMessage);
+    ws.send(JSON.stringify(message));
+  });
+}
+
+function reportSummary(result, domains) {
+  const domainNote = domains.length ? `${domains.length} selected domain${domains.length === 1 ? "" : "s"}` : "all exported domains";
+  console.log(`Imported ${result.imported} cookies across ${domainNote} in ${result.batches} batch${result.batches === 1 ? "" : "es"}.`);
+}
+
+function cleanup(bundleDir, bundlePath) {
+  for (const name of ["manifest.json", "payload.enc", "import.mjs", "PROMPT.txt"]) {
+    fs.rmSync(path.join(bundleDir, name), { force: true });
+  }
+  fs.rmSync(bundlePath, { force: true });
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
+  main().catch((error) => {
+    console.error(error.message || String(error));
+    process.exitCode = 1;
+  });
+}

package/src/paths.js

@@ -11,7 +11,7 @@ export const DEFAULT_PORT = 43128;
 export const EXTENSION_ID = "ihanfnkcipmlhmokbcinlkdfcfheofjb";
 export const EXTENSION_ORIGIN = `chrome-extension://${EXTENSION_ID}`;
 export const SOURCE_BROWSERS = ["brave", "chrome", "edge", "arc", "vivaldi", "opera", "comet"];
-export const TARGET_BROWSERS = [...SOURCE_BROWSERS, "codex", "browserless"];
+export const TARGET_BROWSERS = [...SOURCE_BROWSERS, "codex", "cursor", "browserless", "grok-bot"];
 
 export function projectRoot() {
   return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -91,3 +91,8 @@ export function codexCookiePaths(home = os.homedir()) {
     path.join(root, "codex-browser-app", "Cookies"),
   ];
 }
+
+export function cursorCookiePaths(home = os.homedir()) {
+  const root = path.join(home, "Library", "Application Support", "Cursor", "Partitions", "cursor-browser");
+  return [path.join(root, "Cookies")];
+}

package/src/zip-store.js

@@ -0,0 +1,92 @@
+import crc32 from "./crc32.js";
+
+const LOCAL_HEADER_SIGNATURE = 0x04034b50;
+const CENTRAL_DIRECTORY_SIGNATURE = 0x02014b50;
+const END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50;
+
+export function createZipArchive(entries) {
+  const localParts = [];
+  const centralParts = [];
+  let offset = 0;
+
+  for (const entry of entries) {
+    const name = Buffer.from(entry.name, "utf8");
+    const data = Buffer.isBuffer(entry.data) ? entry.data : Buffer.from(String(entry.data), "utf8");
+    const checksum = crc32(data);
+    const localHeader = Buffer.alloc(30 + name.length);
+    localHeader.writeUInt32LE(LOCAL_HEADER_SIGNATURE, 0);
+    localHeader.writeUInt16LE(20, 4);
+    localHeader.writeUInt16LE(0, 6);
+    localHeader.writeUInt16LE(0, 8);
+    localHeader.writeUInt16LE(0, 10);
+    localHeader.writeUInt16LE(0, 12);
+    localHeader.writeUInt32LE(checksum, 14);
+    localHeader.writeUInt32LE(data.length, 18);
+    localHeader.writeUInt32LE(data.length, 22);
+    localHeader.writeUInt16LE(name.length, 26);
+    localHeader.writeUInt16LE(0, 28);
+    name.copy(localHeader, 30);
+
+    const centralHeader = Buffer.alloc(46 + name.length);
+    centralHeader.writeUInt32LE(CENTRAL_DIRECTORY_SIGNATURE, 0);
+    centralHeader.writeUInt16LE(20, 4);
+    centralHeader.writeUInt16LE(20, 6);
+    centralHeader.writeUInt16LE(0, 8);
+    centralHeader.writeUInt16LE(0, 10);
+    centralHeader.writeUInt16LE(0, 12);
+    centralHeader.writeUInt16LE(0, 14);
+    centralHeader.writeUInt32LE(checksum, 16);
+    centralHeader.writeUInt32LE(data.length, 20);
+    centralHeader.writeUInt32LE(data.length, 24);
+    centralHeader.writeUInt16LE(name.length, 28);
+    centralHeader.writeUInt16LE(0, 30);
+    centralHeader.writeUInt16LE(0, 32);
+    centralHeader.writeUInt16LE(0, 34);
+    centralHeader.writeUInt16LE(0, 36);
+    centralHeader.writeUInt32LE(0, 38);
+    centralHeader.writeUInt32LE(offset, 42);
+    name.copy(centralHeader, 46);
+
+    localParts.push(localHeader, data);
+    centralParts.push(centralHeader);
+    offset += localHeader.length + data.length;
+  }
+
+  const centralDirectory = Buffer.concat(centralParts);
+  const endRecord = Buffer.alloc(22);
+  endRecord.writeUInt32LE(END_OF_CENTRAL_DIRECTORY_SIGNATURE, 0);
+  endRecord.writeUInt16LE(0, 4);
+  endRecord.writeUInt16LE(0, 6);
+  endRecord.writeUInt16LE(entries.length, 8);
+  endRecord.writeUInt16LE(entries.length, 10);
+  endRecord.writeUInt32LE(centralDirectory.length, 12);
+  endRecord.writeUInt32LE(offset, 16);
+  endRecord.writeUInt16LE(0, 20);
+
+  return Buffer.concat([...localParts, centralDirectory, endRecord]);
+}
+
+export function readZipArchive(buffer) {
+  const source = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+  const entries = new Map();
+  let offset = 0;
+
+  while (offset + 30 <= source.length) {
+    const signature = source.readUInt32LE(offset);
+    if (signature === END_OF_CENTRAL_DIRECTORY_SIGNATURE || signature === CENTRAL_DIRECTORY_SIGNATURE) break;
+    if (signature !== LOCAL_HEADER_SIGNATURE) {
+      throw new Error("Unsupported zip archive for Grok Bot bundle.");
+    }
+    const compressedSize = source.readUInt32LE(offset + 18);
+    const nameLength = source.readUInt16LE(offset + 26);
+    const extraLength = source.readUInt16LE(offset + 28);
+    const name = source.subarray(offset + 30, offset + 30 + nameLength).toString("utf8");
+    const dataStart = offset + 30 + nameLength + extraLength;
+    const dataEnd = dataStart + compressedSize;
+    entries.set(name, Buffer.from(source.subarray(dataStart, dataEnd)));
+    offset = dataEnd;
+  }
+
+  if (entries.size === 0) throw new Error("Grok Bot bundle archive was empty.");
+  return entries;
+}