browser-cookie-bridge 1.0.0

package/src/cli.js

@@ -0,0 +1,368 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { installApp } from "./app-installer.js";
+import { createBroker } from "./broker.js";
+import {
+  CODEX_RUNNING_ERROR,
+  directImportToCodex,
+  isCodexRunning,
+} from "./codex-direct-import.js";
+import { readChromiumProfile } from "./chromium-reader.js";
+import { installConfig, installRuntime, readConfig, updatePreferences } from "./config.js";
+import {
+  braveCookiePaths,
+  appLoginLaunchAgentPath,
+  codexCookiePaths,
+  configPath,
+  installedAppPath,
+  installedExtensionDir,
+  launchAgentPath,
+  loginSyncLaunchAgentPath,
+  SOURCE_BROWSERS,
+  TARGET_BROWSERS,
+} from "./paths.js";
+import {
+  installAppLogin,
+  installLoginSync,
+  installSchedule,
+  removeAppLogin,
+  removeLoginSync,
+  removeSchedule,
+} from "./scheduler.js";
+import { performUpdate, startDetachedUpdate } from "./updater.js";
+
+const HELP = `browser-cookie-bridge
+
+Local cookie and session transfer between Chromium browsers and into ChatGPT Codex.
+
+Commands:
+  setup [--hour 9] [--minute 0] [--no-schedule]
+  install-app [--no-open]
+  preferences --source brave --target codex --cookies on --history off --menu-bar on --auto-check-updates on
+  sync [--timeout 300]
+  doctor
+  enable-login-sync
+  disable-login-sync
+  enable-app-login
+  disable-app-login
+  remove-schedule
+  help
+`;
+
+export async function main(argv) {
+  const [command = "help", ...args] = argv;
+  switch (command) {
+    case "setup":
+      return setup(args);
+    case "sync":
+      return sync(args);
+    case "install-app":
+      return installDesktopApp(args);
+    case "preferences":
+      return preferences(args);
+    case "install-update":
+      return installUpdate(args);
+    case "perform-update":
+      return performUpdateWorker(args);
+    case "doctor":
+      return doctor();
+    case "enable-login-sync":
+      return enableLoginSync();
+    case "disable-login-sync":
+      return disableLoginSync();
+    case "enable-app-login":
+      return setAppLogin(true);
+    case "disable-app-login":
+      return setAppLogin(false);
+    case "remove-schedule":
+      return remove();
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(HELP);
+      return;
+    default:
+      throw new Error(`Unknown command: ${command}\n\n${HELP}`);
+  }
+}
+
+function installUpdate(args) {
+  assertMacOS();
+  const result = startDetachedUpdate({
+    version: stringFlag(args, "--version", ""),
+    appPath: stringFlag(args, "--app-path", ""),
+    appPID: integerFlag(args, "--app-pid", 0, 2, Number.MAX_SAFE_INTEGER),
+  });
+  console.log(`Update worker started: ${result.workerPID}`);
+}
+
+function performUpdateWorker(args) {
+  assertMacOS();
+  const result = performUpdate({
+    version: stringFlag(args, "--version", ""),
+    appPath: stringFlag(args, "--app-path", ""),
+    appPID: integerFlag(args, "--app-pid", 0, 2, Number.MAX_SAFE_INTEGER),
+  });
+  console.log(`Updated and relaunched: ${result.destination}`);
+}
+
+function preferences(args) {
+  const existing = readConfig();
+  const config = updatePreferences({
+    cookies: booleanFlag(args, "--cookies", existing.imports?.cookies !== false),
+    history: booleanFlag(args, "--history", existing.imports?.history === true),
+    sourceBrowser: stringFlag(args, "--source", existing.sourceBrowser || "brave"),
+    targetBrowser: stringFlag(args, "--target", existing.targetBrowser || "codex"),
+    menuBar: booleanFlag(args, "--menu-bar", existing.ui?.menuBar === true),
+    openAtLogin: booleanFlag(args, "--open-at-login", existing.ui?.openAtLogin !== false),
+    autoCheckUpdates: booleanFlag(args, "--auto-check-updates", existing.ui?.autoCheckUpdates !== false),
+  });
+  console.log(
+    `Saved: source=${config.sourceBrowser}, target=${config.targetBrowser}, cookies=${config.imports.cookies ? "on" : "off"}, history=${config.imports.history ? "on" : "off"}, menu-bar=${config.ui.menuBar ? "on" : "off"}, open-at-login=${config.ui.openAtLogin ? "on" : "off"}, auto-check-updates=${config.ui.autoCheckUpdates ? "on" : "off"}`,
+  );
+}
+
+function installDesktopApp(args) {
+  assertMacOS();
+  const firstInstall = !fs.existsSync(configPath());
+  const runtime = installRuntime();
+  const existing = fs.existsSync(configPath()) ? readConfig() : null;
+  const config = installConfig({
+    hour: existing?.schedule?.hour ?? 9,
+    minute: existing?.schedule?.minute ?? 0,
+  });
+  console.log("Building the native macOS app…");
+  const destination = installApp({ open: !args.includes("--no-open") });
+  if (config.ui.openAtLogin) {
+    installAppLogin({ appPath: destination, bootstrapNow: false });
+  } else {
+    removeAppLogin();
+  }
+  if (firstInstall) {
+    const cliPath = path.join(runtime, "bin", "brave-codex-cookie-sync.js");
+    installLoginSync({ cliPath });
+    console.log("Daily sync is off by default; sync at login is enabled.");
+  }
+  console.log(`Installed: ${destination}`);
+  console.log(destination.startsWith("/Applications/")
+    ? "The app is available in Applications and Spotlight."
+    : "The app is available in your user Applications folder and Spotlight.");
+}
+
+function setup(args) {
+  assertMacOS();
+  const hour = integerFlag(args, "--hour", 9, 0, 23);
+  const minute = integerFlag(args, "--minute", 0, 0, 59);
+  const noSchedule = args.includes("--no-schedule");
+  const runtime = installRuntime();
+  const config = installConfig({ hour, minute });
+  let plist = null;
+
+  if (!noSchedule) {
+    plist = installSchedule({
+      hour,
+      minute,
+      cliPath: path.join(runtime, "bin", "brave-codex-cookie-sync.js"),
+    });
+  }
+
+  console.log("Setup complete.");
+  console.log(`Pinned runtime: ${runtime}`);
+  if (config.targetBrowser === "codex") {
+    console.log(`Source browser: ${config.sourceBrowser} (read locally; no extension required)`);
+    console.log("Target integration: direct local Codex merge (Codex must be closed)");
+  } else {
+    console.log(`Source extension (${config.sourceBrowser}): ${installedExtensionDir(undefined, config.sourceBrowser)}`);
+    console.log(`Target extension (${config.targetBrowser}): ${installedExtensionDir(undefined, config.targetBrowser)}`);
+    console.log("In both browsers: open Extensions → Developer mode → Load unpacked → choose the generated extension folder");
+  }
+  if (plist) console.log(`Daily schedule: ${pad(hour)}:${pad(minute)} (${plist})`);
+  console.log(`Broker port: 127.0.0.1:${config.port}`);
+  console.log(config.targetBrowser === "codex"
+    ? "Codex is backed up and validated before its local browser data is changed."
+    : "Cookie values are transferred in memory and are not written to logs or disk.");
+}
+
+async function sync(args) {
+  assertMacOS();
+  const seconds = integerFlag(args, "--timeout", 300, 5, 3600);
+  const config = readConfig();
+  const isCodexTarget = (config.targetBrowser || "codex") === "codex";
+  if (isCodexTarget) {
+    if (isCodexRunning()) throw new Error(CODEX_RUNNING_ERROR);
+    const payload = readChromiumProfile({
+      browser: config.sourceBrowser || "brave",
+      imports: config.imports || { cookies: true, history: false },
+    });
+    console.log(`Read ${payload.cookies.length} cookies and ${payload.history.length} history URLs from ${config.sourceBrowser || "brave"}.`);
+    const result = directImportToCodex({
+      cookies: payload.cookies,
+      history: payload.history,
+      codexRunning: false,
+    });
+    console.log(directCodexSummary(result));
+    return result;
+  }
+  const broker = createBroker({
+    token: config.token,
+    port: config.port,
+    imports: config.imports || { cookies: true, history: false },
+    sourceBrowser: config.sourceBrowser || "brave",
+    targetBrowser: config.targetBrowser || "codex",
+    timeoutMs: seconds * 1000,
+    onEvent(event) {
+      if (event.type === "listening") {
+        console.log(`Waiting for ${config.sourceBrowser || "brave"} and ${config.targetBrowser || "codex"} extensions on 127.0.0.1:${event.port}…`);
+      } else if (event.type === "source") {
+        console.log(`Received ${event.cookies} cookies and ${event.history} history URLs in memory.`);
+      } else if (event.type === "complete") {
+        console.log(
+          `Cookies: ${event.imported} imported, ${event.skipped} skipped, ${event.failed} failed. History: ${event.historyImported} imported, ${event.historySkipped} skipped, ${event.historyFailed} failed.`,
+        );
+      }
+    },
+  });
+  await broker.listen();
+  const result = await broker.completion;
+  console.log(transferSummary(result));
+  return result;
+}
+
+export function directCodexSummary(result) {
+  const imported = result.imported + result.historyImported;
+  const skipped = result.skipped + result.historySkipped;
+  const failures = result.failed + result.historyFailed;
+  if (failures > 0) {
+    return `Direct Codex sync completed with warnings: ${imported} imported, ${skipped} skipped, ${failures} failed. Backup: ${result.backupPath}`;
+  }
+  return `Direct Codex sync complete: ${imported} imported and ${skipped} skipped. Reopen Codex to use the updated sessions. Backup: ${result.backupPath}`;
+}
+
+export function transferSummary(result) {
+  const failures = result.failed + result.historyFailed;
+  const imported = result.imported + result.historyImported;
+  const skipped = result.skipped + result.historySkipped;
+  return failures > 0
+    ? `Partially synced: ${imported} imported, ${skipped} skipped, ${failures} failed. Reload the destination extension and try again.`
+    : `Transfer complete: ${imported} imported and ${skipped} skipped.`;
+}
+
+function doctor() {
+  const home = os.homedir();
+  const brave = existing(braveCookiePaths(home));
+  const codex = existing(codexCookiePaths(home));
+  console.log(`Platform: ${process.platform} ${process.arch}`);
+  console.log(`Node: ${process.version}`);
+  console.log(`Configuration: ${status(configPath(home))}`);
+  const config = fs.existsSync(configPath(home)) ? readConfig(home) : null;
+  const source = config?.sourceBrowser || "brave";
+  const target = config?.targetBrowser || "codex";
+  console.log(`Selected source: ${source}`);
+  console.log(`Selected target: ${target}`);
+  console.log(`Source extension: ${status(installedExtensionDir(home, source))}`);
+  console.log(
+    target === "codex"
+      ? "Target integration: direct local Codex merge (Codex must be closed)"
+      : `Target extension: ${status(installedExtensionDir(home, target))}`,
+  );
+  console.log(`Daily schedule: ${status(launchAgentPath(home))}`);
+  console.log(`Sync at login: ${status(loginSyncLaunchAgentPath(home))}`);
+  console.log(`Open app at login: ${status(appLoginLaunchAgentPath(home))}`);
+  console.log(`Desktop app: ${status(installedAppPath(home))}`);
+  console.log(`Brave cookie stores detected: ${brave.length}`);
+  console.log(`Codex cookie stores detected: ${codex.length}`);
+  for (const file of brave) console.log(`  Brave: ${file}`);
+  for (const file of codex) console.log(`  Codex: ${file}`);
+  console.log("No cookie names, domains, values, or encryption keys were read.");
+}
+
+function enableLoginSync() {
+  assertMacOS();
+  const runtime = installRuntime();
+  if (!fs.existsSync(configPath())) installConfig({ hour: 9, minute: 0 });
+  const plist = installLoginSync({
+    cliPath: path.join(runtime, "bin", "brave-codex-cookie-sync.js"),
+  });
+  console.log(`Login sync enabled: ${plist}`);
+  const config = readConfig();
+  console.log(config.targetBrowser === "codex"
+    ? "A sync starts when you sign in and updates Codex only when Codex is closed."
+    : "A sync starts when you sign in and waits up to five minutes for both browser extensions.");
+}
+
+function disableLoginSync() {
+  console.log(removeLoginSync() ? "Login sync disabled." : "Login sync was not enabled.");
+}
+
+function setAppLogin(enabled) {
+  assertMacOS();
+  const existing = readConfig();
+  updatePreferences({
+    sourceBrowser: existing.sourceBrowser || "brave",
+    targetBrowser: existing.targetBrowser || "codex",
+    cookies: existing.imports?.cookies !== false,
+    history: existing.imports?.history === true,
+    menuBar: existing.ui?.menuBar === true,
+    openAtLogin: enabled,
+    autoCheckUpdates: existing.ui?.autoCheckUpdates !== false,
+  });
+  if (enabled) {
+    const appPath = installedAppPath();
+    if (!fs.existsSync(appPath)) throw new Error("Desktop app is not installed. Run install-app first.");
+    console.log(`App login enabled: ${installAppLogin({ appPath })}`);
+  } else {
+    removeAppLogin();
+    console.log("App login disabled.");
+  }
+}
+
+function remove() {
+  console.log(removeSchedule() ? "Daily schedule removed." : "No daily schedule was installed.");
+}
+
+function assertMacOS() {
+  if (process.platform !== "darwin") throw new Error("This release supports macOS only.");
+}
+
+function integerFlag(args, name, fallback, minimum, maximum) {
+  const index = args.indexOf(name);
+  if (index === -1) return fallback;
+  const value = Number(args[index + 1]);
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new Error(`${name} must be an integer from ${minimum} to ${maximum}`);
+  }
+  return value;
+}
+
+function booleanFlag(args, name, fallback) {
+  const value = stringFlag(args, name, fallback ? "on" : "off");
+  if (!["on", "off"].includes(value)) throw new Error(`${name} must be on or off`);
+  return value === "on";
+}
+
+function stringFlag(args, name, fallback) {
+  const index = args.indexOf(name);
+  if (index === -1) return fallback;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`${name} requires a value`);
+  if (name === "--source" && !SOURCE_BROWSERS.includes(value)) {
+    throw new Error(`${name} must be one of: ${SOURCE_BROWSERS.join(", ")}`);
+  }
+  if (name === "--target" && !TARGET_BROWSERS.includes(value)) {
+    throw new Error(`${name} must be one of: ${TARGET_BROWSERS.join(", ")}`);
+  }
+  return value;
+}
+
+function existing(paths) {
+  return paths.filter((candidate) => fs.existsSync(candidate));
+}
+
+function status(candidate) {
+  return fs.existsSync(candidate) ? candidate : "not installed";
+}
+
+function pad(value) {
+  return String(value).padStart(2, "0");
+}

package/src/codex-direct-import.js

@@ -0,0 +1,320 @@
+import fs from "node:fs";
+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";
+
+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 MAX_BACKUPS = 14;
+
+export function isCodexRunning({ processList } = {}) {
+  const output = processList ?? spawnSync("/bin/ps", ["-axo", "command="], {
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+  }).stdout;
+  return String(output).split("\n").some((command) =>
+    /\/ChatGPT\.app\/Contents\/MacOS\/ChatGPT(?:\s|$)/.test(command.trim()),
+  );
+}
+
+export function directImportToCodex({
+  cookies,
+  history = [],
+  home = os.homedir(),
+  codexRunning = isCodexRunning(),
+  now = new Date(),
+} = {}) {
+  if (!Array.isArray(cookies) || !Array.isArray(history)) {
+    throw new TypeError("cookies and history must be arrays");
+  }
+  if (codexRunning) throw new Error(CODEX_RUNNING_ERROR);
+
+  const cookiePath = codexCookiePaths(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.");
+  }
+  const historyPath = path.join(path.dirname(cookiePath), "History");
+  const backupRoot = path.join(appSupportDir(home), "backups", "codex");
+  const backupPath = path.join(backupRoot, backupDirectoryName(now));
+  fs.mkdirSync(backupPath, { recursive: true, mode: 0o700 });
+
+  const cookieBackup = path.join(backupPath, "Cookies");
+  try {
+    snapshotDatabase(cookiePath, cookieBackup);
+  } 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 error;
+  }
+  const cookieWorking = temporarySibling(cookiePath);
+  fs.copyFileSync(cookieBackup, cookieWorking);
+  fs.chmodSync(cookieWorking, 0o600);
+
+  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.");
+    }
+    historyBackup = path.join(backupPath, "History");
+    try {
+      snapshotDatabase(historyPath, historyBackup);
+    } catch (error) {
+      fs.rmSync(cookieWorking, { 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 error;
+    }
+    historyWorking = temporarySibling(historyPath);
+    fs.copyFileSync(historyBackup, historyWorking);
+    fs.chmodSync(historyWorking, 0o600);
+  }
+
+  let cookieResult;
+  let historyResult = { imported: 0, skipped: 0, failed: 0 };
+  try {
+    cookieResult = mergeCookies(cookieWorking, cookies, now);
+    if (historyWorking) historyResult = mergeHistory(historyWorking, history, now);
+    replaceDatabase(cookieWorking, cookiePath);
+    cookieResult.replaced = true;
+    if (historyWorking) {
+      replaceDatabase(historyWorking, historyPath);
+      historyResult.replaced = true;
+    }
+  } catch (error) {
+    restoreDatabase(cookieBackup, cookiePath);
+    if (historyBackup) restoreDatabase(historyBackup, historyPath);
+    throw new Error(`Codex data was restored from backup after the sync failed: ${error.message}`);
+  } finally {
+    fs.rmSync(cookieWorking, { force: true });
+    if (historyWorking) fs.rmSync(historyWorking, { force: true });
+  }
+
+  pruneBackups(backupRoot, MAX_BACKUPS);
+  return {
+    imported: cookieResult.imported,
+    skipped: cookieResult.skipped,
+    failed: cookieResult.failed,
+    historyImported: historyResult.imported,
+    historySkipped: historyResult.skipped,
+    historyFailed: historyResult.failed,
+    backupPath,
+    targetPath: cookiePath,
+    directCodexImport: true,
+  };
+}
+
+function mergeCookies(databasePath, cookies, now) {
+  const database = new DatabaseSync(databasePath);
+  let imported = 0;
+  let skipped = 0;
+  let failed = 0;
+  try {
+    assertIntegrity(database);
+    assertTableColumns(database, "cookies", [
+      "creation_utc", "host_key", "top_frame_site_key", "name", "value",
+      "encrypted_value", "path", "expires_utc", "is_secure", "is_httponly",
+      "last_access_utc", "has_expires", "is_persistent", "priority", "samesite",
+      "source_scheme", "source_port", "last_update_utc", "source_type",
+      "has_cross_site_ancestor",
+    ]);
+    const insert = database.prepare(`
+      INSERT OR REPLACE INTO cookies(
+        creation_utc, host_key, top_frame_site_key, name, value, encrypted_value,
+        path, expires_utc, is_secure, is_httponly, last_access_utc, has_expires,
+        is_persistent, priority, samesite, source_scheme, source_port,
+        last_update_utc, source_type, has_cross_site_ancestor
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, 1, ?)
+    `);
+    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;
+      }
+    }
+    database.exec("COMMIT");
+    assertIntegrity(database);
+  } catch (error) {
+    try { database.exec("ROLLBACK"); } catch {}
+    throw error;
+  } finally {
+    database.close();
+  }
+  return { imported, skipped, failed };
+}
+
+function mergeHistory(databasePath, history, now) {
+  const database = new DatabaseSync(databasePath);
+  let imported = 0;
+  let skipped = 0;
+  let failed = 0;
+  try {
+    assertIntegrity(database);
+    assertTableColumns(database, "urls", ["id", "url", "visit_count", "last_visit_time"]);
+    assertTableColumns(database, "visits", ["url", "visit_time", "transition"]);
+    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)",
+    );
+    const updateURL = database.prepare(
+      "UPDATE urls SET visit_count = visit_count + 1, last_visit_time = ? WHERE id = ?",
+    );
+    const insertVisit = database.prepare(
+      "INSERT INTO visits(url, visit_time, from_visit, transition, visit_duration) VALUES (?, ?, 0, 805306368, 0)",
+    );
+    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;
+      }
+    }
+    database.exec("COMMIT");
+    assertIntegrity(database);
+  } catch (error) {
+    try { database.exec("ROLLBACK"); } catch {}
+    throw error;
+  } finally {
+    database.close();
+  }
+  return { imported, skipped, failed };
+}
+
+function snapshotDatabase(source, destination) {
+  fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
+  const database = new DatabaseSync(source, { readOnly: true });
+  try {
+    assertIntegrity(database);
+    database.exec(`VACUUM INTO '${escapeSqlitePath(destination)}'`);
+  } finally {
+    database.close();
+  }
+  fs.chmodSync(destination, 0o600);
+}
+
+function replaceDatabase(source, target) {
+  fs.rmSync(`${target}-wal`, { force: true });
+  fs.rmSync(`${target}-shm`, { 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);
+}
+
+function assertIntegrity(database) {
+  const row = database.prepare("PRAGMA quick_check").get();
+  if (Object.values(row ?? {})[0] !== "ok") throw new Error("SQLite integrity check failed");
+}
+
+function assertTableColumns(database, table, required) {
+  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(", ")}`);
+}
+
+function normalizeCookie(cookie) {
+  if (!cookie || typeof cookie.name !== "string" || typeof cookie.value !== "string") return null;
+  if (typeof cookie.domain !== "string") return null;
+  const cleanHost = cookie.domain.replace(/^\./, "").trim().toLowerCase();
+  if (!cleanHost || cleanHost.includes("/") || cleanHost.includes(":")) return null;
+  const persistent = !cookie.session && Number.isFinite(cookie.expirationDate) && cookie.expirationDate > 0;
+  return {
+    name: cookie.name,
+    value: cookie.value,
+    domain: cookie.hostOnly ? cleanHost : `.${cleanHost}`,
+    topFrameSiteKey: typeof cookie.partitionKey?.topLevelSite === "string" ? cookie.partitionKey.topLevelSite : "",
+    hasCrossSiteAncestor: cookie.partitionKey?.hasCrossSiteAncestor ?? !cookie.partitionKey,
+    path: typeof cookie.path === "string" && cookie.path.startsWith("/") ? cookie.path : "/",
+    secure: Boolean(cookie.secure),
+    httpOnly: Boolean(cookie.httpOnly),
+    persistent,
+    expiresUtc: persistent ? chromiumTime(cookie.expirationDate) : 0,
+    sameSite: ({ unspecified: -1, no_restriction: 0, lax: 1, strict: 2 })[cookie.sameSite] ?? -1,
+  };
+}
+
+function pruneBackups(root, keep) {
+  if (!fs.existsSync(root)) return;
+  const directories = fs.readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort()
+    .reverse();
+  for (const name of directories.slice(keep)) {
+    fs.rmSync(path.join(root, name), { recursive: true, force: true });
+  }
+}
+
+function backupDirectoryName(now) {
+  const timestamp = now.toISOString().replace(/[:.]/g, "-");
+  return `${timestamp}-${process.pid}`;
+}
+
+function temporarySibling(target) {
+  return `${target}.browser-cookie-bridge-${process.pid}-${Date.now()}.tmp`;
+}
+
+function chromiumTime(unixSeconds) {
+  return Math.trunc((unixSeconds + CHROMIUM_EPOCH_OFFSET_SECONDS) * 1_000_000);
+}
+
+function escapeSqlitePath(target) {
+  return target.replaceAll("'", "''");
+}
+
+export { CODEX_RUNNING_ERROR };