browser-cookie-bridge 1.4.6 → 1.5.0

package/src/codex-direct-import.js

@@ -3,11 +3,41 @@ import os from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { DatabaseSync } from "node:sqlite";
-import { appSupportDir, codexCookiePaths } from "./paths.js";
+import { appSupportDir, codexCookiePaths, cursorCookiePaths } from "./paths.js";
 
 const CHROMIUM_EPOCH_OFFSET_SECONDS = 11_644_473_600;
 const CODEX_RUNNING_ERROR = "ChatGPT Codex is open. Quit it completely, then click Sync now again.";
+const CURSOR_RUNNING_ERROR = "Cursor is open. Quit it completely, then click Sync now again.";
 const MAX_BACKUPS = 14;
+const DIRECT_TARGETS = {
+  codex: {
+    name: "Codex",
+    applicationName: "ChatGPT Codex",
+    storageName: "Codex browser",
+    cookiePaths: codexCookiePaths,
+    backupDirectory: "codex",
+    processPattern: /^\/.*\.app\/Contents\/MacOS\/ChatGPT$/,
+    runningError: CODEX_RUNNING_ERROR,
+    historySupported: true,
+    siteStorageSupported: true,
+  },
+  cursor: {
+    name: "Cursor",
+    applicationName: "Cursor",
+    storageName: "Cursor browser",
+    cookiePaths: cursorCookiePaths,
+    backupDirectory: "cursor",
+    processPattern: /^\/.*\.app\/Contents\/MacOS\/Cursor$/,
+    runningError: CURSOR_RUNNING_ERROR,
+    historySupported: false,
+    siteStorageSupported: false,
+    cookieSchemaVersion: "24",
+    cookieIndex: {
+      name: "cookies_unique_index",
+      columns: ["host_key", "top_frame_site_key", "has_cross_site_ancestor", "name", "path", "source_scheme", "source_port"],
+    },
+  },
+};
 const SITE_STORAGE_DIRECTORIES = [
   "Local Storage",
   "IndexedDB",
@@ -20,37 +50,67 @@ const SITE_STORAGE_DIRECTORIES = [
 ];
 
 export function isCodexRunning({ processList } = {}) {
-  const output = processList ?? spawnSync("/bin/ps", ["-axo", "command="], {
-    encoding: "utf8",
-    maxBuffer: 16 * 1024 * 1024,
-  }).stdout;
+  return isDirectTargetRunning({ target: "codex", processList });
+}
+
+export function isCursorRunning({ processList } = {}) {
+  return isDirectTargetRunning({ target: "cursor", processList });
+}
+
+export function isDirectTargetRunning({ target, processList } = {}) {
+  const definition = directTargetDefinition(target);
+  let output = processList;
+  if (output === undefined) {
+    const result = spawnSync("/bin/ps", ["-axo", "comm="], {
+      encoding: "utf8",
+      maxBuffer: 16 * 1024 * 1024,
+    });
+    if (result.error || result.status !== 0) {
+      throw new Error(`Could not verify whether ${definition.applicationName} is running; refusing to modify its browser data.`);
+    }
+    output = result.stdout;
+  }
   return String(output).split("\n").some((command) =>
-    /\/ChatGPT\.app\/Contents\/MacOS\/ChatGPT(?:\s|$)/.test(command.trim()),
+    definition.processPattern.test(command.trim()),
   );
 }
 
-export function directImportToCodex({
+export function directImportToEmbeddedBrowser({
+  target = "codex",
   cookies,
   history = [],
   sourceProfilePath,
   siteStorage = false,
   sourceCookieSkipped = 0,
   home = os.homedir(),
-  codexRunning = isCodexRunning(),
+  runningCheck = () => isDirectTargetRunning({ target }),
+  databaseReplacer = replaceDatabase,
+  databaseRestorer = restoreDatabase,
   now = new Date(),
 } = {}) {
+  const definition = directTargetDefinition(target);
+  const checkRunning = runningCheck;
   if (!Array.isArray(cookies) || !Array.isArray(history)) {
     throw new TypeError("cookies and history must be arrays");
   }
-  if (codexRunning) throw new Error(CODEX_RUNNING_ERROR);
+  if (checkRunning()) throw new Error(definition.runningError);
+  if (!definition.historySupported && history.length > 0) {
+    throw new Error(`${definition.storageName} does not expose a compatible history store. Turn off History URLs and try again.`);
+  }
+  if (!definition.siteStorageSupported && siteStorage) {
+    throw new Error(`${definition.storageName} full site-data import is not supported yet. Turn off Full site data and try again.`);
+  }
+  if (target === "cursor" && cookies.length === 0) {
+    throw new Error("No readable cookies were found to import into Cursor.");
+  }
 
-  const cookiePath = codexCookiePaths(home).find((candidate) => fs.existsSync(candidate));
+  const cookiePath = definition.cookiePaths(home).find((candidate) => fs.existsSync(candidate));
   if (!cookiePath) {
-    throw new Error("Codex browser storage was not found. Open the Codex browser once, quit Codex, then try again.");
+    throw new Error(`${definition.storageName} storage was not found. Open the browser in ${definition.applicationName} once, quit ${definition.applicationName}, then try again.`);
   }
   const historyPath = path.join(path.dirname(cookiePath), "History");
-  const codexProfilePath = codexProfileRoot(cookiePath);
-  const backupRoot = path.join(appSupportDir(home), "backups", "codex");
+  const targetProfilePath = directTargetProfileRoot(cookiePath);
+  const backupRoot = path.join(appSupportDir(home), "backups", definition.backupDirectory);
   const backupPath = path.join(backupRoot, backupDirectoryName(now));
   fs.mkdirSync(backupPath, { recursive: true, mode: 0o700 });
 
@@ -60,34 +120,49 @@ export function directImportToCodex({
   } catch (error) {
     fs.rmSync(backupPath, { recursive: true, force: true });
     if (/locked|busy/i.test(error.message)) {
-      throw new Error("Codex is still releasing its browser database. Wait a few seconds after quitting Codex, then try again.");
+      throw new Error(`${definition.applicationName} is still releasing its browser database. Wait a few seconds after quitting ${definition.applicationName}, then try again.`);
     }
     throw error;
   }
   const cookieWorking = temporarySibling(cookiePath);
-  fs.copyFileSync(cookieBackup, cookieWorking);
-  fs.chmodSync(cookieWorking, 0o600);
+  try {
+    fs.copyFileSync(cookieBackup, cookieWorking);
+    fs.chmodSync(cookieWorking, 0o600);
+  } catch (error) {
+    removeDatabaseArtifacts(cookieWorking);
+    fs.rmSync(backupPath, { recursive: true, force: true });
+    throw error;
+  }
 
   let historyBackup = null;
   let historyWorking = null;
   if (history.length > 0) {
     if (!fs.existsSync(historyPath)) {
-      fs.rmSync(cookieWorking, { force: true });
-      throw new Error("Codex history storage was not found. Open the Codex browser once, quit Codex, then try again.");
+      removeDatabaseArtifacts(cookieWorking);
+      fs.rmSync(backupPath, { recursive: true, force: true });
+      throw new Error(`${definition.storageName} history storage was not found. Open the browser in ${definition.applicationName} once, quit ${definition.applicationName}, then try again.`);
     }
     historyBackup = path.join(backupPath, "History");
     try {
       snapshotDatabase(historyPath, historyBackup);
     } catch (error) {
-      fs.rmSync(cookieWorking, { force: true });
+      removeDatabaseArtifacts(cookieWorking);
+      fs.rmSync(backupPath, { recursive: true, force: true });
       if (/locked|busy/i.test(error.message)) {
-        throw new Error("Codex is still releasing its history database. Wait a few seconds after quitting Codex, then try again.");
+        throw new Error(`${definition.applicationName} is still releasing its history database. Wait a few seconds after quitting ${definition.applicationName}, then try again.`);
       }
       throw error;
     }
     historyWorking = temporarySibling(historyPath);
-    fs.copyFileSync(historyBackup, historyWorking);
-    fs.chmodSync(historyWorking, 0o600);
+    try {
+      fs.copyFileSync(historyBackup, historyWorking);
+      fs.chmodSync(historyWorking, 0o600);
+    } catch (error) {
+      removeDatabaseArtifacts(cookieWorking);
+      removeDatabaseArtifacts(historyWorking);
+      fs.rmSync(backupPath, { recursive: true, force: true });
+      throw error;
+    }
   }
 
   let siteStoragePlan = [];
@@ -96,38 +171,65 @@ export function directImportToCodex({
       if (!sourceProfilePath || !fs.existsSync(sourceProfilePath)) {
         throw new Error("The selected source profile was not found for full site-data import.");
       }
-      siteStoragePlan = prepareSiteStorageTransfer({ sourceProfilePath, codexProfilePath, backupPath });
+      siteStoragePlan = prepareSiteStorageTransfer({ sourceProfilePath, targetProfilePath, backupPath });
     } catch (error) {
-      fs.rmSync(cookieWorking, { force: true });
-      if (historyWorking) fs.rmSync(historyWorking, { force: true });
+      removeDatabaseArtifacts(cookieWorking);
+      if (historyWorking) removeDatabaseArtifacts(historyWorking);
+      fs.rmSync(backupPath, { recursive: true, force: true });
       throw error;
     }
   }
 
   let cookieResult;
   let historyResult = { imported: 0, skipped: 0, failed: 0 };
+  let cookieReplaced = false;
+  let historyReplaced = false;
   try {
-    cookieResult = mergeCookies(cookieWorking, cookies, now);
-    if (historyWorking) historyResult = mergeHistory(historyWorking, history, now);
-    replaceDatabase(cookieWorking, cookiePath);
+    cookieResult = mergeCookies(cookieWorking, cookies, now, definition);
+    if (historyWorking) historyResult = mergeHistory(historyWorking, history, now, definition.name);
+    if (target === "cursor" && cookieResult.imported === 0) {
+      throw new Error("No valid cookies were available to import into Cursor.");
+    }
+    if (checkRunning()) throw new Error(definition.runningError);
+    cookieReplaced = true;
+    databaseReplacer(cookieWorking, cookiePath);
     cookieResult.replaced = true;
     if (historyWorking) {
-      replaceDatabase(historyWorking, historyPath);
+      historyReplaced = true;
+      databaseReplacer(historyWorking, historyPath);
       historyResult.replaced = true;
     }
     commitSiteStorageTransfer(siteStoragePlan);
   } catch (error) {
-    restoreDatabase(cookieBackup, cookiePath);
-    if (historyBackup) restoreDatabase(historyBackup, historyPath);
-    restoreSiteStorageTransfer(siteStoragePlan);
-    throw new Error(`Codex data was restored from backup after the sync failed: ${error.message}`);
+    const siteStorageTouched = siteStoragePlan.some((item) => item.touched);
+    const restoreErrors = [];
+    if (cookieReplaced) {
+      try { databaseRestorer(cookieBackup, cookiePath); } catch (restoreError) { restoreErrors.push(`cookies: ${restoreError.message}`); }
+    }
+    if (historyReplaced) {
+      try { databaseRestorer(historyBackup, historyPath); } catch (restoreError) { restoreErrors.push(`history: ${restoreError.message}`); }
+    }
+    if (siteStorageTouched) {
+      try { restoreSiteStorageTransfer(siteStoragePlan); } catch (restoreError) { restoreErrors.push(`site storage: ${restoreError.message}`); }
+    }
+    if (restoreErrors.length > 0) {
+      pruneBackupsSafely(backupRoot, MAX_BACKUPS, backupPath);
+      throw new Error(`${definition.name} sync failed and recovery was incomplete (${restoreErrors.join("; ")}): ${error.message}`);
+    }
+    if (cookieReplaced || historyReplaced || siteStorageTouched) {
+      pruneBackupsSafely(backupRoot, MAX_BACKUPS, backupPath);
+      throw new Error(`${definition.name} data was restored from backup after the sync failed: ${error.message}`);
+    }
+    fs.rmSync(backupPath, { recursive: true, force: true });
+    pruneBackupsSafely(backupRoot, MAX_BACKUPS);
+    throw error;
   } finally {
-    fs.rmSync(cookieWorking, { force: true });
-    if (historyWorking) fs.rmSync(historyWorking, { force: true });
+    removeDatabaseArtifacts(cookieWorking);
+    if (historyWorking) removeDatabaseArtifacts(historyWorking);
     cleanupSiteStorageTransfer(siteStoragePlan);
   }
 
-  pruneBackups(backupRoot, MAX_BACKUPS);
+  const backupCleanupWarning = pruneBackupsSafely(backupRoot, MAX_BACKUPS, backupPath);
   return {
     imported: cookieResult.imported,
     skipped: cookieResult.skipped,
@@ -137,26 +239,50 @@ export function directImportToCodex({
     historyFailed: historyResult.failed,
     backupPath,
     targetPath: cookiePath,
-    directCodexImport: true,
+    targetID: target,
+    targetName: definition.name,
+    directEmbeddedBrowserImport: true,
+    directCodexImport: target === "codex",
     siteStorageImported: siteStoragePlan.filter((item) => item.committed).length,
     siteStorageNames: siteStoragePlan.filter((item) => item.committed).map((item) => item.name),
     sourceCookieSkipped: Number.isInteger(sourceCookieSkipped) && sourceCookieSkipped > 0 ? sourceCookieSkipped : 0,
+    backupCleanupWarning,
   };
 }
 
-function codexProfileRoot(cookiePath) {
+export function directImportToCodex(options = {}) {
+  return directImportToEmbeddedBrowser({
+    ...options,
+    target: "codex",
+  });
+}
+
+export function directImportToCursor(options = {}) {
+  return directImportToEmbeddedBrowser({
+    ...options,
+    target: "cursor",
+  });
+}
+
+function directTargetDefinition(target) {
+  const definition = DIRECT_TARGETS[target];
+  if (!definition) throw new Error(`Unsupported direct browser target: ${target}`);
+  return definition;
+}
+
+function directTargetProfileRoot(cookiePath) {
   const parent = path.dirname(cookiePath);
   return path.basename(parent) === "Network" ? path.dirname(parent) : parent;
 }
 
-function prepareSiteStorageTransfer({ sourceProfilePath, codexProfilePath, backupPath }) {
+function prepareSiteStorageTransfer({ sourceProfilePath, targetProfilePath, backupPath }) {
   const plan = [];
   try {
-    fs.mkdirSync(codexProfilePath, { recursive: true, mode: 0o700 });
+    fs.mkdirSync(targetProfilePath, { recursive: true, mode: 0o700 });
     for (const name of SITE_STORAGE_DIRECTORIES) {
       const source = path.join(sourceProfilePath, name);
       if (!fs.existsSync(source)) continue;
-      const destination = path.join(codexProfilePath, name);
+      const destination = path.join(targetProfilePath, name);
       const backup = path.join(backupPath, "Site Storage", name);
       const stage = `${destination}.browser-cookie-bridge-${process.pid}-${Date.now()}.stage`;
       const existed = fs.existsSync(destination);
@@ -210,11 +336,11 @@ function copyStorageTree(source, destination) {
   });
 }
 
-function mergeCookies(databasePath, cookies, now) {
+function mergeCookies(databasePath, cookies, now, definition) {
   const database = new DatabaseSync(databasePath);
   let imported = 0;
   let skipped = 0;
-  let failed = 0;
+  const failed = 0;
   try {
     assertIntegrity(database);
     assertTableColumns(database, "cookies", [
@@ -223,7 +349,8 @@ function mergeCookies(databasePath, cookies, now) {
       "last_access_utc", "has_expires", "is_persistent", "priority", "samesite",
       "source_scheme", "source_port", "last_update_utc", "source_type",
       "has_cross_site_ancestor",
-    ]);
+    ], definition.name);
+    assertCookieSchema(database, definition);
     const insert = database.prepare(`
       INSERT OR REPLACE INTO cookies(
         creation_utc, host_key, top_frame_site_key, name, value, encrypted_value,
@@ -235,36 +362,32 @@ function mergeCookies(databasePath, cookies, now) {
     const currentTime = chromiumTime(now.getTime() / 1000);
     database.exec("BEGIN IMMEDIATE");
     for (const cookie of cookies) {
-      try {
-        const normalized = normalizeCookie(cookie);
-        if (!normalized) {
-          skipped += 1;
-          continue;
-        }
-        insert.run(
-          currentTime,
-          normalized.domain,
-          normalized.topFrameSiteKey,
-          normalized.name,
-          normalized.value,
-          Buffer.alloc(0),
-          normalized.path,
-          normalized.expiresUtc,
-          normalized.secure ? 1 : 0,
-          normalized.httpOnly ? 1 : 0,
-          currentTime,
-          normalized.persistent ? 1 : 0,
-          normalized.persistent ? 1 : 0,
-          normalized.sameSite,
-          normalized.secure ? 2 : 1,
-          normalized.secure ? 443 : 80,
-          currentTime,
-          normalized.hasCrossSiteAncestor ? 1 : 0,
-        );
-        imported += 1;
-      } catch {
-        failed += 1;
+      const normalized = normalizeCookie(cookie);
+      if (!normalized) {
+        skipped += 1;
+        continue;
       }
+      insert.run(
+        currentTime,
+        normalized.domain,
+        normalized.topFrameSiteKey,
+        normalized.name,
+        normalized.value,
+        Buffer.alloc(0),
+        normalized.path,
+        normalized.expiresUtc,
+        normalized.secure ? 1 : 0,
+        normalized.httpOnly ? 1 : 0,
+        currentTime,
+        normalized.persistent ? 1 : 0,
+        normalized.persistent ? 1 : 0,
+        normalized.sameSite,
+        normalized.secure ? 2 : 1,
+        normalized.secure ? 443 : 80,
+        currentTime,
+        normalized.hasCrossSiteAncestor ? 1 : 0,
+      );
+      imported += 1;
     }
     database.exec("COMMIT");
     assertIntegrity(database);
@@ -277,15 +400,15 @@ function mergeCookies(databasePath, cookies, now) {
   return { imported, skipped, failed };
 }
 
-function mergeHistory(databasePath, history, now) {
+function mergeHistory(databasePath, history, now, targetName) {
   const database = new DatabaseSync(databasePath);
   let imported = 0;
   let skipped = 0;
-  let failed = 0;
+  const failed = 0;
   try {
     assertIntegrity(database);
-    assertTableColumns(database, "urls", ["id", "url", "visit_count", "last_visit_time"]);
-    assertTableColumns(database, "visits", ["url", "visit_time", "transition"]);
+    assertTableColumns(database, "urls", ["id", "url", "visit_count", "last_visit_time"], targetName);
+    assertTableColumns(database, "visits", ["url", "visit_time", "transition"], targetName);
     const findURL = database.prepare("SELECT id FROM urls WHERE url = ? LIMIT 1");
     const insertURL = database.prepare(
       "INSERT INTO urls(url, title, visit_count, typed_count, last_visit_time, hidden) VALUES (?, '', 1, 0, ?, 0)",
@@ -299,24 +422,20 @@ function mergeHistory(databasePath, history, now) {
     const currentTime = chromiumTime(now.getTime() / 1000);
     database.exec("BEGIN IMMEDIATE");
     for (const item of history) {
-      try {
-        if (!item || typeof item.url !== "string" || !/^https?:\/\//.test(item.url)) {
-          skipped += 1;
-          continue;
-        }
-        const existing = findURL.get(item.url);
-        let urlID;
-        if (existing) {
-          urlID = existing.id;
-          updateURL.run(currentTime, urlID);
-        } else {
-          urlID = insertURL.run(item.url, currentTime).lastInsertRowid;
-        }
-        insertVisit.run(urlID, currentTime);
-        imported += 1;
-      } catch {
-        failed += 1;
+      if (!item || typeof item.url !== "string" || !/^https?:\/\//.test(item.url)) {
+        skipped += 1;
+        continue;
+      }
+      const existing = findURL.get(item.url);
+      let urlID;
+      if (existing) {
+        urlID = existing.id;
+        updateURL.run(currentTime, urlID);
+      } else {
+        urlID = insertURL.run(item.url, currentTime).lastInsertRowid;
       }
+      insertVisit.run(urlID, currentTime);
+      imported += 1;
     }
     database.exec("COMMIT");
     assertIntegrity(database);
@@ -342,18 +461,26 @@ function snapshotDatabase(source, destination) {
 }
 
 function replaceDatabase(source, target) {
+  fs.chmodSync(source, 0o600);
   fs.rmSync(`${target}-wal`, { force: true });
   fs.rmSync(`${target}-shm`, { force: true });
+  fs.rmSync(`${target}-journal`, { force: true });
   fs.renameSync(source, target);
-  fs.chmodSync(target, 0o600);
 }
 
 function restoreDatabase(backup, target) {
   if (!fs.existsSync(backup)) return;
-  fs.rmSync(`${target}-wal`, { force: true });
-  fs.rmSync(`${target}-shm`, { force: true });
-  fs.copyFileSync(backup, target);
-  fs.chmodSync(target, 0o600);
+  const staged = temporarySibling(target);
+  try {
+    fs.copyFileSync(backup, staged);
+    fs.chmodSync(staged, 0o600);
+    fs.rmSync(`${target}-wal`, { force: true });
+    fs.rmSync(`${target}-shm`, { force: true });
+    fs.rmSync(`${target}-journal`, { force: true });
+    fs.renameSync(staged, target);
+  } finally {
+    fs.rmSync(staged, { force: true });
+  }
 }
 
 function assertIntegrity(database) {
@@ -361,10 +488,26 @@ function assertIntegrity(database) {
   if (Object.values(row ?? {})[0] !== "ok") throw new Error("SQLite integrity check failed");
 }
 
-function assertTableColumns(database, table, required) {
+function assertTableColumns(database, table, required, targetName) {
   const columns = new Set(database.prepare(`PRAGMA table_info(${table})`).all().map((row) => row.name));
   const missing = required.filter((name) => !columns.has(name));
-  if (missing.length > 0) throw new Error(`Unsupported Codex ${table} schema; missing ${missing.join(", ")}`);
+  if (missing.length > 0) throw new Error(`Unsupported ${targetName} ${table} schema; missing ${missing.join(", ")}`);
+}
+
+function assertCookieSchema(database, definition) {
+  if (!definition.cookieSchemaVersion) return;
+  const meta = Object.fromEntries(database.prepare("SELECT key, value FROM meta WHERE key IN ('version', 'last_compatible_version')").all().map((row) => [row.key, row.value]));
+  if (String(meta.version) !== definition.cookieSchemaVersion || String(meta.last_compatible_version) !== definition.cookieSchemaVersion) {
+    throw new Error(`Unsupported ${definition.name} cookies schema version: ${meta.version ?? "missing"}`);
+  }
+  const expected = definition.cookieIndex;
+  const index = database.prepare("PRAGMA index_list(cookies)").all().find((row) => row.name === expected.name);
+  const columns = index
+    ? database.prepare(`PRAGMA index_info(${expected.name})`).all().map((row) => row.name)
+    : [];
+  if (!index || Number(index.unique) !== 1 || Number(index.partial) !== 0 || columns.join("\n") !== expected.columns.join("\n")) {
+    throw new Error(`Unsupported ${definition.name} cookies uniqueness schema`);
+  }
 }
 
 function normalizeCookie(cookie) {
@@ -388,18 +531,36 @@ function normalizeCookie(cookie) {
   };
 }
 
-function pruneBackups(root, keep) {
+function pruneBackups(root, keep, protectedPath) {
   if (!fs.existsSync(root)) return;
+  const protectedName = protectedPath ? path.basename(protectedPath) : null;
   const directories = fs.readdirSync(root, { withFileTypes: true })
     .filter((entry) => entry.isDirectory())
     .map((entry) => entry.name)
     .sort()
     .reverse();
-  for (const name of directories.slice(keep)) {
+  const removable = directories.filter((name) => name !== protectedName);
+  const retainedOthers = protectedName && directories.includes(protectedName) ? Math.max(0, keep - 1) : keep;
+  for (const name of removable.slice(retainedOthers)) {
     fs.rmSync(path.join(root, name), { recursive: true, force: true });
   }
 }
 
+function pruneBackupsSafely(root, keep, protectedPath) {
+  try {
+    pruneBackups(root, keep, protectedPath);
+    return null;
+  } catch (error) {
+    return `The transfer succeeded, but old backups could not be pruned: ${error.message}`;
+  }
+}
+
+function removeDatabaseArtifacts(target) {
+  for (const suffix of ["", "-journal", "-wal", "-shm"]) {
+    fs.rmSync(`${target}${suffix}`, { force: true });
+  }
+}
+
 function backupDirectoryName(now) {
   const timestamp = now.toISOString().replace(/[:.]/g, "-");
   return `${timestamp}-${process.pid}`;
@@ -417,4 +578,4 @@ function escapeSqlitePath(target) {
   return target.replaceAll("'", "''");
 }
 
-export { CODEX_RUNNING_ERROR };
+export { CODEX_RUNNING_ERROR, CURSOR_RUNNING_ERROR };

package/src/config.js

@@ -34,6 +34,12 @@ export function installConfig({ home, hour = 9, minute = 0, nodePath = process.e
 
   const sourceBrowser = SOURCE_BROWSERS.includes(existing.sourceBrowser) ? existing.sourceBrowser : "brave";
   const configuredTarget = TARGET_BROWSERS.includes(existing.targetBrowser) ? existing.targetBrowser : "codex";
+  const rememberedImports = {
+    history: existing.rememberedImports?.history === true
+      || (configuredTarget !== "cursor" && existing.imports?.history === true),
+    siteStorage: existing.rememberedImports?.siteStorage === true
+      || (configuredTarget !== "cursor" && existing.imports?.siteStorage === true),
+  };
   const config = {
     version: 2,
     token: existing.token || crypto.randomBytes(32).toString("base64url"),
@@ -44,9 +50,10 @@ export function installConfig({ home, hour = 9, minute = 0, nodePath = process.e
     imports: {
       cookies: existing.imports?.cookies !== false,
       passwords: false,
-      history: existing.imports?.history === true,
-      siteStorage: existing.imports?.siteStorage === true,
+      history: configuredTarget !== "cursor" && configuredTarget !== "grok-bot" && existing.imports?.history === true,
+      siteStorage: configuredTarget !== "cursor" && configuredTarget !== "grok-bot" && existing.imports?.siteStorage === true,
     },
+    rememberedImports,
     ui: {
       menuBar: existing.ui?.menuBar !== false,
       openAtLogin: existing.ui?.openAtLogin !== false,
@@ -59,6 +66,9 @@ export function installConfig({ home, hour = 9, minute = 0, nodePath = process.e
       region: ["sfo", "lon", "ams"].includes(existing.browserless?.region) ? existing.browserless.region : "sfo",
       onlyDomains: cleanDomains(existing.browserless?.onlyDomains),
     },
+    grokBot: {
+      onlyDomains: cleanDomains(existing.grokBot?.onlyDomains),
+    },
     schedule: { hour, minute },
     createdAt: existing.createdAt || new Date().toISOString(),
     updatedAt: new Date().toISOString(),
@@ -67,6 +77,7 @@ export function installConfig({ home, hour = 9, minute = 0, nodePath = process.e
   writePrivateJson(target, config);
   for (const browser of SOURCE_BROWSERS) installExtension(config, home, browser, "browser");
   fs.rmSync(installedExtensionDir(home, "codex"), { recursive: true, force: true });
+  fs.rmSync(installedExtensionDir(home, "cursor"), { recursive: true, force: true });
   fs.rmSync(installedExtensionDir(home, "atlas"), { recursive: true, force: true });
   return config;
 }
@@ -86,6 +97,7 @@ export function updatePreferences({
   browserlessProfileName,
   browserlessRegion,
   browserlessOnlyDomains,
+  grokBotOnlyDomains,
 }) {
   const config = readConfig(home);
   if (!SOURCE_BROWSERS.includes(sourceBrowser)) {
@@ -97,14 +109,29 @@ export function updatePreferences({
   if (sourceBrowser === targetBrowser) {
     throw new Error("Source and target browsers must be different");
   }
+  const previousTarget = config.targetBrowser;
+  const rememberedImports = {
+    history: config.rememberedImports?.history === true,
+    siteStorage: config.rememberedImports?.siteStorage === true,
+  };
+  if (previousTarget !== "cursor" && targetBrowser === "cursor") {
+    rememberedImports.history = config.imports?.history === true;
+    rememberedImports.siteStorage = config.imports?.siteStorage === true;
+  }
+  const leavingCursor = previousTarget === "cursor" && targetBrowser !== "cursor";
+  const effectiveHistory = leavingCursor ? rememberedImports.history : Boolean(history);
+  const effectiveSiteStorage = leavingCursor ? rememberedImports.siteStorage : Boolean(siteStorage);
   config.sourceBrowser = sourceBrowser;
   config.targetBrowser = targetBrowser;
   config.imports = {
     cookies: Boolean(cookies),
     passwords: false,
-    history: Boolean(history),
-    siteStorage: Boolean(siteStorage),
+    history: targetBrowser !== "cursor" && targetBrowser !== "grok-bot" && effectiveHistory,
+    siteStorage: targetBrowser !== "cursor" && targetBrowser !== "grok-bot" && effectiveSiteStorage,
   };
+  config.rememberedImports = targetBrowser === "cursor"
+    ? rememberedImports
+    : { history: effectiveHistory, siteStorage: effectiveSiteStorage };
   config.ui = {
     menuBar: Boolean(menuBar),
     openAtLogin: Boolean(openAtLogin),
@@ -119,6 +146,9 @@ export function updatePreferences({
     region,
     onlyDomains: cleanDomains(browserlessOnlyDomains ?? config.browserless?.onlyDomains),
   };
+  config.grokBot = {
+    onlyDomains: cleanDomains(grokBotOnlyDomains ?? config.grokBot?.onlyDomains),
+  };
   config.updatedAt = new Date().toISOString();
   writePrivateJson(configPath(home), config);
   return config;

package/src/crc32.js

@@ -0,0 +1,19 @@
+const TABLE = (() => {
+  const values = new Uint32Array(256);
+  for (let index = 0; index < 256; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = (value & 1) ? (0xEDB88320 ^ (value >>> 1)) : (value >>> 1);
+    }
+    values[index] = value >>> 0;
+  }
+  return values;
+})();
+
+export default function crc32(buffer) {
+  let crc = 0xFFFFFFFF;
+  for (const byte of buffer) {
+    crc = TABLE[(crc ^ byte) & 0xFF] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xFFFFFFFF) >>> 0;
+}