browser-cookie-bridge 1.0.0

package/src/config.js

@@ -0,0 +1,141 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import {
+  DEFAULT_PORT,
+  configPath,
+  installedExtensionDir,
+  projectRoot,
+  SOURCE_BROWSERS,
+  TARGET_BROWSERS,
+} from "./paths.js";
+
+export function readConfig(home) {
+  const target = configPath(home);
+  if (!fs.existsSync(target)) {
+    throw new Error("Not configured. Run `browser-cookie-bridge setup` first.");
+  }
+  const config = JSON.parse(fs.readFileSync(target, "utf8"));
+  if (!config.token || !Number.isInteger(config.port)) {
+    throw new Error(`Invalid configuration at ${target}`);
+  }
+  return config;
+}
+
+export function installConfig({ home, hour = 9, minute = 0 }) {
+  const target = configPath(home);
+  const support = path.dirname(target);
+  fs.mkdirSync(support, { recursive: true, mode: 0o700 });
+
+  let existing = {};
+  if (fs.existsSync(target)) {
+    existing = JSON.parse(fs.readFileSync(target, "utf8"));
+  }
+
+  const sourceBrowser = SOURCE_BROWSERS.includes(existing.sourceBrowser) ? existing.sourceBrowser : "brave";
+  const configuredTarget = TARGET_BROWSERS.includes(existing.targetBrowser) ? existing.targetBrowser : "codex";
+  const config = {
+    version: 1,
+    token: existing.token || crypto.randomBytes(32).toString("base64url"),
+    port: existing.port || DEFAULT_PORT,
+    nodePath: process.execPath,
+    sourceBrowser,
+    targetBrowser: configuredTarget === sourceBrowser ? "codex" : configuredTarget,
+    imports: {
+      cookies: existing.imports?.cookies !== false,
+      passwords: false,
+      history: existing.imports?.history === true,
+    },
+    ui: {
+      menuBar: existing.ui?.menuBar !== false,
+      openAtLogin: existing.ui?.openAtLogin !== false,
+      autoCheckUpdates: existing.ui?.autoCheckUpdates !== false,
+    },
+    schedule: { hour, minute },
+    createdAt: existing.createdAt || new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+
+  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, "atlas"), { recursive: true, force: true });
+  return config;
+}
+
+export function updatePreferences({ home, cookies, history, sourceBrowser, targetBrowser, menuBar, openAtLogin, autoCheckUpdates }) {
+  const config = readConfig(home);
+  if (!SOURCE_BROWSERS.includes(sourceBrowser)) {
+    throw new Error(`Unsupported source browser: ${sourceBrowser}`);
+  }
+  if (!TARGET_BROWSERS.includes(targetBrowser)) {
+    throw new Error(`Unsupported target browser: ${targetBrowser}`);
+  }
+  if (sourceBrowser === targetBrowser) {
+    throw new Error("Source and target browsers must be different");
+  }
+  config.sourceBrowser = sourceBrowser;
+  config.targetBrowser = targetBrowser;
+  config.imports = { cookies: Boolean(cookies), passwords: false, history: Boolean(history) };
+  config.ui = {
+    menuBar: Boolean(menuBar),
+    openAtLogin: Boolean(openAtLogin),
+    autoCheckUpdates: Boolean(autoCheckUpdates),
+  };
+  config.updatedAt = new Date().toISOString();
+  writePrivateJson(configPath(home), config);
+  return config;
+}
+
+export function installRuntime(home) {
+  const source = projectRoot();
+  const target = path.join(path.dirname(configPath(home)), "runtime");
+  if (path.resolve(source) === path.resolve(target)) return target;
+
+  fs.mkdirSync(target, { recursive: true, mode: 0o700 });
+  for (const name of ["bin", "src", "extension-template"]) {
+    fs.rmSync(path.join(target, name), { recursive: true, force: true });
+    fs.cpSync(path.join(source, name), path.join(target, name), { recursive: true, force: true });
+  }
+  const appSource = path.join(source, "macos-app");
+  const appTarget = path.join(target, "macos-app");
+  fs.rmSync(appTarget, { recursive: true, force: true });
+  fs.mkdirSync(appTarget, { recursive: true, mode: 0o700 });
+  for (const name of ["Sources", "Resources"]) {
+    fs.cpSync(path.join(appSource, name), path.join(appTarget, name), { recursive: true, force: true });
+  }
+  for (const name of ["Package.swift", "Info.plist"]) {
+    fs.copyFileSync(path.join(appSource, name), path.join(appTarget, name));
+  }
+  for (const name of ["package.json", "README.md", "LICENSE"]) {
+    fs.copyFileSync(path.join(source, name), path.join(target, name));
+  }
+  fs.chmodSync(path.join(target, "bin", "brave-codex-cookie-sync.js"), 0o700);
+  return target;
+}
+
+function installExtension(config, home, browser, role) {
+  const source = path.join(projectRoot(), "extension-template");
+  const target = installedExtensionDir(home, browser);
+  fs.mkdirSync(target, { recursive: true, mode: 0o700 });
+
+  for (const name of ["manifest.json", "background.js"]) {
+    fs.copyFileSync(path.join(source, name), path.join(target, name));
+  }
+
+  const generated = [
+    "// Generated locally by Browser Cookie Bridge. Do not share this file.",
+    `globalThis.SYNC_CONFIG = ${JSON.stringify({ token: config.token, port: config.port })};`,
+    `globalThis.SYNC_ROLE = ${JSON.stringify(role)};`,
+    `globalThis.SYNC_BROWSER = ${JSON.stringify(browser)};`,
+    "",
+  ].join("\n");
+  fs.writeFileSync(path.join(target, "config.js"), generated, { mode: 0o600 });
+}
+
+function writePrivateJson(target, value) {
+  const temporary = `${target}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temporary, target);
+  fs.chmodSync(target, 0o600);
+}

package/src/paths.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const APP_ID = "com.apoorvdarshan.brave-codex-cookie-sync";
+export const LOGIN_SYNC_APP_ID = `${APP_ID}.login-sync`;
+export const APP_LOGIN_APP_ID = `${APP_ID}.app-login`;
+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"];
+
+export function projectRoot() {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
+
+export function appSupportDir(home = os.homedir()) {
+  return path.join(home, "Library", "Application Support", "BraveCodexCookieSync");
+}
+
+export function configPath(home = os.homedir()) {
+  return path.join(appSupportDir(home), "config.json");
+}
+
+export function installedExtensionDir(home = os.homedir(), role = "brave") {
+  return path.join(appSupportDir(home), `extension-${role}`);
+}
+
+export function launchAgentPath(home = os.homedir()) {
+  return path.join(home, "Library", "LaunchAgents", `${APP_ID}.plist`);
+}
+
+export function loginSyncLaunchAgentPath(home = os.homedir()) {
+  return path.join(home, "Library", "LaunchAgents", `${LOGIN_SYNC_APP_ID}.plist`);
+}
+
+export function appLoginLaunchAgentPath(home = os.homedir()) {
+  return path.join(home, "Library", "LaunchAgents", `${APP_LOGIN_APP_ID}.plist`);
+}
+
+export function userInstalledAppPath(home = os.homedir()) {
+  return path.join(home, "Applications", "Browser Cookie Bridge.app");
+}
+
+export function systemInstalledAppPath() {
+  return path.join("/Applications", "Browser Cookie Bridge.app");
+}
+
+export function installedAppPath(home = os.homedir()) {
+  const systemApp = systemInstalledAppPath();
+  const isCurrentUser = path.resolve(home) === path.resolve(os.homedir());
+  return isCurrentUser && fs.existsSync(systemApp) ? systemApp : userInstalledAppPath(home);
+}
+
+export function braveCookiePaths(home = os.homedir()) {
+  const root = path.join(
+    home,
+    "Library",
+    "Application Support",
+    "BraveSoftware",
+    "Brave-Browser",
+  );
+  return ["Default", ...Array.from({ length: 20 }, (_, index) => `Profile ${index + 1}`)]
+    .flatMap((profile) => [
+      path.join(root, profile, "Network", "Cookies"),
+      path.join(root, profile, "Cookies"),
+    ]);
+}
+
+export function codexCookiePaths(home = os.homedir()) {
+  const root = path.join(home, "Library", "Application Support", "Codex");
+  return [
+    path.join(root, "Default", "Partitions", "codex-browser-app", "Network", "Cookies"),
+    path.join(root, "Default", "Partitions", "codex-browser-app", "Cookies"),
+    path.join(root, "Default", "Cookies"),
+    path.join(root, "codex-browser-app", "Cookies"),
+  ];
+}

package/src/scheduler.js

@@ -0,0 +1,150 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import {
+  APP_ID,
+  APP_LOGIN_APP_ID,
+  LOGIN_SYNC_APP_ID,
+  appSupportDir,
+  appLoginLaunchAgentPath,
+  launchAgentPath,
+  loginSyncLaunchAgentPath,
+} from "./paths.js";
+
+export function installSchedule({ hour, minute, cliPath, nodePath = process.execPath, home = os.homedir() }) {
+  const plist = launchAgentPath(home);
+  const support = appSupportDir(home);
+  fs.mkdirSync(path.dirname(plist), { recursive: true });
+  fs.mkdirSync(path.join(support, "logs"), { recursive: true, mode: 0o700 });
+
+  const content = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${APP_ID}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xml(nodePath)}</string>
+    <string>${xml(cliPath)}</string>
+    <string>sync</string>
+    <string>--timeout</string>
+    <string>300</string>
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key><integer>${hour}</integer>
+    <key>Minute</key><integer>${minute}</integer>
+  </dict>
+  <key>ProcessType</key><string>Background</string>
+  <key>StandardOutPath</key><string>${xml(path.join(support, "logs", "sync.log"))}</string>
+  <key>StandardErrorPath</key><string>${xml(path.join(support, "logs", "sync-error.log"))}</string>
+</dict>
+</plist>
+`;
+  fs.writeFileSync(plist, content, { mode: 0o600 });
+
+  bootstrap(plist, "daily schedule");
+  return plist;
+}
+
+export function installLoginSync({ cliPath, nodePath = process.execPath, home = os.homedir() }) {
+  const plist = loginSyncLaunchAgentPath(home);
+  const support = appSupportDir(home);
+  fs.mkdirSync(path.dirname(plist), { recursive: true });
+  fs.mkdirSync(path.join(support, "logs"), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(plist, buildLoginSyncPlist({ cliPath, nodePath, support }), { mode: 0o600 });
+  bootstrap(plist, "login sync");
+  return plist;
+}
+
+export function buildLoginSyncPlist({ cliPath, nodePath, support }) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LOGIN_SYNC_APP_ID}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xml(nodePath)}</string>
+    <string>${xml(cliPath)}</string>
+    <string>sync</string>
+    <string>--timeout</string>
+    <string>300</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>ProcessType</key><string>Background</string>
+  <key>StandardOutPath</key><string>${xml(path.join(support, "logs", "login-sync.log"))}</string>
+  <key>StandardErrorPath</key><string>${xml(path.join(support, "logs", "login-sync-error.log"))}</string>
+</dict>
+</plist>
+`;
+}
+
+export function installAppLogin({ appPath, home = os.homedir(), bootstrapNow = true }) {
+  const plist = appLoginLaunchAgentPath(home);
+  fs.mkdirSync(path.dirname(plist), { recursive: true });
+  fs.writeFileSync(plist, buildAppLoginPlist({ appPath }), { mode: 0o600 });
+  if (bootstrapNow) bootstrap(plist, "app login launch");
+  return plist;
+}
+
+export function buildAppLoginPlist({ appPath }) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${APP_LOGIN_APP_ID}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/usr/bin/open</string>
+    <string>${xml(appPath)}</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>ProcessType</key><string>Interactive</string>
+</dict>
+</plist>
+`;
+}
+
+export function removeSchedule(home = os.homedir()) {
+  const plist = launchAgentPath(home);
+  if (!fs.existsSync(plist)) return false;
+  spawnSync("launchctl", ["bootout", `gui/${process.getuid()}`, plist], { stdio: "ignore" });
+  fs.unlinkSync(plist);
+  return true;
+}
+
+export function removeLoginSync(home = os.homedir()) {
+  const plist = loginSyncLaunchAgentPath(home);
+  if (!fs.existsSync(plist)) return false;
+  spawnSync("launchctl", ["bootout", `gui/${process.getuid()}`, plist], { stdio: "ignore" });
+  fs.unlinkSync(plist);
+  return true;
+}
+
+export function removeAppLogin(home = os.homedir()) {
+  const plist = appLoginLaunchAgentPath(home);
+  if (!fs.existsSync(plist)) return false;
+  spawnSync("launchctl", ["bootout", `gui/${process.getuid()}`, plist], { stdio: "ignore" });
+  fs.unlinkSync(plist);
+  return true;
+}
+
+function bootstrap(plist, description) {
+  const domain = `gui/${process.getuid()}`;
+  spawnSync("launchctl", ["bootout", domain, plist], { stdio: "ignore" });
+  const result = spawnSync("launchctl", ["bootstrap", domain, plist], { encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr.trim() || `launchctl could not install the ${description}`);
+  }
+}
+
+function xml(value) {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}

package/src/updater.js

@@ -0,0 +1,144 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import {
+  appSupportDir,
+  installedAppPath,
+  systemInstalledAppPath,
+  userInstalledAppPath,
+} from "./paths.js";
+import { installAppLogin } from "./scheduler.js";
+
+export function startDetachedUpdate({ version, appPath, appPID, home = os.homedir() }) {
+  validateUpdateRequest({ version, appPath, appPID, home });
+  const support = appSupportDir(home);
+  const logs = path.join(support, "logs");
+  fs.mkdirSync(logs, { recursive: true, mode: 0o700 });
+  const logPath = path.join(logs, "update.log");
+  const log = fs.openSync(logPath, "a", 0o600);
+  const cliPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "bin", "brave-codex-cookie-sync.js");
+  const child = spawn(process.execPath, [
+    cliPath,
+    "perform-update",
+    "--version", version,
+    "--app-path", appPath,
+    "--app-pid", String(appPID),
+  ], {
+    detached: true,
+    stdio: ["ignore", log, log],
+    env: process.env,
+  });
+  child.unref();
+  fs.closeSync(log);
+  return { workerPID: child.pid, logPath };
+}
+
+export function performUpdate({ version, appPath, appPID, home = os.homedir() }) {
+  const destination = validateUpdateRequest({ version, appPath, appPID, home });
+  const resultPath = path.join(appSupportDir(home), "update-result.json");
+  const currentUserApp = installedAppPath(home);
+  try {
+    waitForProcessToExit(appPID, 30_000);
+    const npxPath = findNpx();
+    const result = spawnSync(npxPath, [
+      "--yes",
+      `browser-cookie-bridge@${version}`,
+      "install-app",
+      "--no-open",
+    ], {
+      encoding: "utf8",
+      maxBuffer: 32 * 1024 * 1024,
+      env: { ...process.env, npm_config_yes: "true" },
+    });
+    if (result.status !== 0) {
+      throw new Error(result.stderr.trim() || result.stdout.trim() || `npx exited with status ${result.status}`);
+    }
+    if (!fs.existsSync(currentUserApp)) throw new Error("The downloaded app was not installed");
+    if (destination !== currentUserApp) replaceAppContents(currentUserApp, destination);
+    installAppLogin({ appPath: destination, bootstrapNow: false });
+    writeUpdateResult(resultPath, { status: "success", version });
+    relaunch(destination);
+    return { destination, version };
+  } catch (error) {
+    writeUpdateResult(resultPath, { status: "failed", version, message: error.message });
+    if (fs.existsSync(destination)) relaunch(destination);
+    throw error;
+  }
+}
+
+function replaceAppContents(source, destination) {
+  if (!fs.existsSync(destination)) throw new Error(`Installed app not found at ${destination}`);
+  const sourceContents = path.join(source, "Contents");
+  const destinationContents = path.join(destination, "Contents");
+  const stagedContents = path.join(destination, ".Contents.update");
+  const previousContents = path.join(destination, ".Contents.previous");
+  fs.rmSync(stagedContents, { recursive: true, force: true });
+  fs.rmSync(previousContents, { recursive: true, force: true });
+  fs.cpSync(sourceContents, stagedContents, { recursive: true, force: true });
+  fs.renameSync(destinationContents, previousContents);
+  try {
+    fs.renameSync(stagedContents, destinationContents);
+    fs.rmSync(previousContents, { recursive: true, force: true });
+  } catch (error) {
+    if (!fs.existsSync(destinationContents) && fs.existsSync(previousContents)) {
+      fs.renameSync(previousContents, destinationContents);
+    }
+    throw error;
+  }
+  spawnSync("/usr/bin/xattr", ["-dr", "com.apple.quarantine", destination], { stdio: "ignore" });
+}
+
+export function validateUpdateRequest({ version, appPath, appPID, home = os.homedir() }) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version ?? "")) {
+    throw new Error("Invalid update version");
+  }
+  if (!Number.isInteger(appPID) || appPID <= 1) throw new Error("Invalid app process ID");
+  const resolved = path.resolve(appPath ?? "");
+  const allowed = new Set([
+    path.resolve(systemInstalledAppPath()),
+    path.resolve(userInstalledAppPath(home)),
+  ]);
+  if (!allowed.has(resolved)) throw new Error(`Refusing to replace unexpected app path: ${resolved}`);
+  return resolved;
+}
+
+function findNpx() {
+  const sibling = path.join(path.dirname(process.execPath), "npx");
+  if (fs.existsSync(sibling)) return sibling;
+  const result = spawnSync("/usr/bin/which", ["npx"], { encoding: "utf8" });
+  const discovered = result.status === 0 ? result.stdout.trim() : "";
+  if (!discovered || !fs.existsSync(discovered)) throw new Error("npx was not found beside the configured Node.js runtime");
+  return discovered;
+}
+
+function waitForProcessToExit(pid, timeoutMilliseconds) {
+  const deadline = Date.now() + timeoutMilliseconds;
+  while (processExists(pid)) {
+    if (Date.now() >= deadline) throw new Error("The previous app did not quit in time");
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 250);
+  }
+}
+
+function processExists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+
+function relaunch(appPath) {
+  const result = spawnSync("/usr/bin/open", ["-g", appPath], { encoding: "utf8" });
+  if (result.status !== 0) throw new Error(result.stderr.trim() || "The updated app could not be relaunched");
+}
+
+function writeUpdateResult(target, value) {
+  fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+  const temporary = `${target}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify({ ...value, date: new Date().toISOString() })}\n`, { mode: 0o600 });
+  fs.renameSync(temporary, target);
+  fs.chmodSync(target, 0o600);
+}