browser-cookie-bridge 1.0.0 → 1.2.0

package/src/cli.js

@@ -9,6 +9,7 @@ import {
   isCodexRunning,
 } from "./codex-direct-import.js";
 import { readChromiumProfile } from "./chromium-reader.js";
+import { uploadBrowserlessProfile } from "./browserless.js";
 import { installConfig, installRuntime, readConfig, updatePreferences } from "./config.js";
 import {
   braveCookiePaths,
@@ -19,6 +20,9 @@ import {
   installedExtensionDir,
   launchAgentPath,
   loginSyncLaunchAgentPath,
+  systemInstalledAppPath,
+  userInstalledAppPath,
+  APP_ID,
   SOURCE_BROWSERS,
   TARGET_BROWSERS,
 } from "./paths.js";
@@ -39,8 +43,9 @@ Local cookie and session transfer between Chromium browsers and into ChatGPT Cod
 Commands:
   setup [--hour 9] [--minute 0] [--no-schedule]
   install-app [--no-open]
+  bootstrap-bundled --app-path /Applications/Browser Cookie Bridge.app
   preferences --source brave --target codex --cookies on --history off --menu-bar on --auto-check-updates on
-  sync [--timeout 300]
+  sync [--timeout 300] [--allow-cloud-upload]
   doctor
   enable-login-sync
   disable-login-sync
@@ -59,6 +64,8 @@ export async function main(argv) {
       return sync(args);
     case "install-app":
       return installDesktopApp(args);
+    case "bootstrap-bundled":
+      return bootstrapBundledApp(args);
     case "preferences":
       return preferences(args);
     case "install-update":
@@ -97,9 +104,9 @@ function installUpdate(args) {
   console.log(`Update worker started: ${result.workerPID}`);
 }
 
-function performUpdateWorker(args) {
+async function performUpdateWorker(args) {
   assertMacOS();
-  const result = performUpdate({
+  const result = await performUpdate({
     version: stringFlag(args, "--version", ""),
     appPath: stringFlag(args, "--app-path", ""),
     appPID: integerFlag(args, "--app-pid", 0, 2, Number.MAX_SAFE_INTEGER),
@@ -117,6 +124,9 @@ function preferences(args) {
     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),
+    browserlessProfileName: stringFlag(args, "--browserless-profile", existing.browserless?.profileName || "browser-cookie-bridge"),
+    browserlessRegion: stringFlag(args, "--browserless-region", existing.browserless?.region || "sfo"),
+    browserlessOnlyDomains: optionalStringFlag(args, "--browserless-domains", (existing.browserless?.onlyDomains || []).join(",")),
   });
   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"}`,
@@ -150,6 +160,67 @@ function installDesktopApp(args) {
     : "The app is available in your user Applications folder and Spotlight.");
 }
 
+function bootstrapBundledApp(args) {
+  assertMacOS();
+  const appPath = path.resolve(stringFlag(args, "--app-path", ""));
+  if (!appPath.endsWith(".app") || !fs.existsSync(appPath)) {
+    throw new Error("--app-path must point to the running Browser Cookie Bridge app");
+  }
+
+  const firstInstall = !fs.existsSync(configPath());
+  const runtime = installRuntime();
+  const existing = firstInstall ? null : readConfig();
+  const config = installConfig({
+    hour: existing?.schedule?.hour ?? 9,
+    minute: existing?.schedule?.minute ?? 0,
+    nodePath: process.execPath,
+  });
+
+  if (config.ui.openAtLogin) {
+    installAppLogin({ appPath, bootstrapNow: false });
+  } else {
+    removeAppLogin();
+  }
+
+  const bundledCLI = path.join(runtime, "bin", "brave-codex-cookie-sync.js");
+  if (firstInstall || fs.existsSync(loginSyncLaunchAgentPath())) {
+    installLoginSync({
+      cliPath: bundledCLI,
+      nodePath: process.execPath,
+    });
+  }
+  if (fs.existsSync(launchAgentPath())) {
+    installSchedule({
+      hour: config.schedule.hour,
+      minute: config.schedule.minute,
+      cliPath: bundledCLI,
+      nodePath: process.execPath,
+    });
+  }
+
+  archiveDuplicateUserApp(appPath);
+
+  console.log(`Bundled runtime ready: ${runtime}`);
+}
+
+function archiveDuplicateUserApp(currentAppPath) {
+  if (path.resolve(currentAppPath) !== path.resolve(systemInstalledAppPath())) return;
+  const duplicate = userInstalledAppPath();
+  if (!fs.existsSync(duplicate)) return;
+  const infoPath = path.join(duplicate, "Contents", "Info.plist");
+  const info = fs.existsSync(infoPath) ? fs.readFileSync(infoPath, "utf8") : "";
+  if (!info.includes(`<string>${APP_ID}</string>`)) return;
+
+  const trash = path.join(os.homedir(), ".Trash");
+  fs.mkdirSync(trash, { recursive: true, mode: 0o700 });
+  let archived = path.join(trash, "Browser Cookie Bridge previous installation.app");
+  for (let suffix = 2; fs.existsSync(archived); suffix += 1) {
+    archived = path.join(trash, `Browser Cookie Bridge previous installation ${suffix}.app`);
+  }
+  fs.renameSync(duplicate, archived);
+  console.log(`Archived duplicate app: ${archived}`);
+}
+
 function setup(args) {
   assertMacOS();
   const hour = integerFlag(args, "--hour", 9, 0, 23);
@@ -172,6 +243,10 @@ function setup(args) {
   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 if (config.targetBrowser === "browserless") {
+    console.log(`Source browser: ${config.sourceBrowser} (captured locally by the Browserless CLI)`);
+    console.log(`Cloud destination: Browserless ${config.browserless?.region || "sfo"} / ${config.browserless?.profileName || "browser-cookie-bridge"}`);
+    console.log("Browserless uploads are manual-only and require --allow-cloud-upload.");
   } else {
     console.log(`Source extension (${config.sourceBrowser}): ${installedExtensionDir(undefined, config.sourceBrowser)}`);
     console.log(`Target extension (${config.targetBrowser}): ${installedExtensionDir(undefined, config.targetBrowser)}`);
@@ -188,7 +263,25 @@ async function sync(args) {
   assertMacOS();
   const seconds = integerFlag(args, "--timeout", 300, 5, 3600);
   const config = readConfig();
-  const isCodexTarget = (config.targetBrowser || "codex") === "codex";
+  const target = config.targetBrowser || "codex";
+  const isCodexTarget = target === "codex";
+  if (target === "browserless") {
+    if (!args.includes("--allow-cloud-upload")) {
+      throw new Error("Browserless cloud uploads are manual-only. Start one from the app or pass --allow-cloud-upload explicitly.");
+    }
+    const source = config.sourceBrowser || "brave";
+    const local = readChromiumProfile({ browser: source, imports: { cookies: false, history: false } });
+    console.log(`Preparing ${source} profile ${local.profileName} for an explicit Browserless cloud upload…`);
+    const result = await uploadBrowserlessProfile({
+      browser: source,
+      localProfile: local.profileName,
+      profileName: config.browserless?.profileName || "browser-cookie-bridge",
+      region: config.browserless?.region || "sfo",
+      onlyDomains: config.browserless?.onlyDomains || [],
+    });
+    console.log(result.summary);
+    return result;
+  }
   if (isCodexTarget) {
     if (isCodexRunning()) throw new Error(CODEX_RUNNING_ERROR);
     const payload = readChromiumProfile({
@@ -264,6 +357,8 @@ function doctor() {
   console.log(
     target === "codex"
       ? "Target integration: direct local Codex merge (Codex must be closed)"
+      : target === "browserless"
+        ? `Target integration: optional Browserless cloud upload (${config?.browserless?.region || "sfo"}); manual only`
       : `Target extension: ${status(installedExtensionDir(home, target))}`,
   );
   console.log(`Daily schedule: ${status(launchAgentPath(home))}`);
@@ -288,6 +383,8 @@ function enableLoginSync() {
   const config = readConfig();
   console.log(config.targetBrowser === "codex"
     ? "A sync starts when you sign in and updates Codex only when Codex is closed."
+    : config.targetBrowser === "browserless"
+      ? "Browserless uploads remain manual-only; login sync will not send data to the cloud."
     : "A sync starts when you sign in and waits up to five minutes for both browser extensions.");
 }
 
@@ -306,6 +403,9 @@ function setAppLogin(enabled) {
     menuBar: existing.ui?.menuBar === true,
     openAtLogin: enabled,
     autoCheckUpdates: existing.ui?.autoCheckUpdates !== false,
+    browserlessProfileName: existing.browserless?.profileName,
+    browserlessRegion: existing.browserless?.region,
+    browserlessOnlyDomains: existing.browserless?.onlyDomains,
   });
   if (enabled) {
     const appPath = installedAppPath();
@@ -355,6 +455,11 @@ function stringFlag(args, name, fallback) {
   return value;
 }
 
+function optionalStringFlag(args, name, fallback) {
+  const index = args.indexOf(name);
+  return index === -1 ? fallback : (args[index + 1] ?? "");
+}
+
 function existing(paths) {
   return paths.filter((candidate) => fs.existsSync(candidate));
 }

package/src/config.js

@@ -22,7 +22,7 @@ export function readConfig(home) {
   return config;
 }
 
-export function installConfig({ home, hour = 9, minute = 0 }) {
+export function installConfig({ home, hour = 9, minute = 0, nodePath = process.execPath }) {
   const target = configPath(home);
   const support = path.dirname(target);
   fs.mkdirSync(support, { recursive: true, mode: 0o700 });
@@ -35,10 +35,10 @@ export function installConfig({ home, hour = 9, minute = 0 }) {
   const sourceBrowser = SOURCE_BROWSERS.includes(existing.sourceBrowser) ? existing.sourceBrowser : "brave";
   const configuredTarget = TARGET_BROWSERS.includes(existing.targetBrowser) ? existing.targetBrowser : "codex";
   const config = {
-    version: 1,
+    version: 2,
     token: existing.token || crypto.randomBytes(32).toString("base64url"),
     port: existing.port || DEFAULT_PORT,
-    nodePath: process.execPath,
+    nodePath,
     sourceBrowser,
     targetBrowser: configuredTarget === sourceBrowser ? "codex" : configuredTarget,
     imports: {
@@ -51,6 +51,11 @@ export function installConfig({ home, hour = 9, minute = 0 }) {
       openAtLogin: existing.ui?.openAtLogin !== false,
       autoCheckUpdates: existing.ui?.autoCheckUpdates !== false,
     },
+    browserless: {
+      profileName: cleanProfileName(existing.browserless?.profileName) || "browser-cookie-bridge",
+      region: ["sfo", "lon", "ams"].includes(existing.browserless?.region) ? existing.browserless.region : "sfo",
+      onlyDomains: cleanDomains(existing.browserless?.onlyDomains),
+    },
     schedule: { hour, minute },
     createdAt: existing.createdAt || new Date().toISOString(),
     updatedAt: new Date().toISOString(),
@@ -63,7 +68,19 @@ export function installConfig({ home, hour = 9, minute = 0 }) {
   return config;
 }
 
-export function updatePreferences({ home, cookies, history, sourceBrowser, targetBrowser, menuBar, openAtLogin, autoCheckUpdates }) {
+export function updatePreferences({
+  home,
+  cookies,
+  history,
+  sourceBrowser,
+  targetBrowser,
+  menuBar,
+  openAtLogin,
+  autoCheckUpdates,
+  browserlessProfileName,
+  browserlessRegion,
+  browserlessOnlyDomains,
+}) {
   const config = readConfig(home);
   if (!SOURCE_BROWSERS.includes(sourceBrowser)) {
     throw new Error(`Unsupported source browser: ${sourceBrowser}`);
@@ -82,38 +99,56 @@ export function updatePreferences({ home, cookies, history, sourceBrowser, targe
     openAtLogin: Boolean(openAtLogin),
     autoCheckUpdates: Boolean(autoCheckUpdates),
   };
+  const region = browserlessRegion ?? config.browserless?.region ?? "sfo";
+  if (!["sfo", "lon", "ams"].includes(region)) throw new Error("Browserless region must be sfo, lon, or ams");
+  config.browserless = {
+    profileName: cleanProfileName(browserlessProfileName ?? config.browserless?.profileName) || "browser-cookie-bridge",
+    region,
+    onlyDomains: cleanDomains(browserlessOnlyDomains ?? config.browserless?.onlyDomains),
+  };
   config.updatedAt = new Date().toISOString();
   writePrivateJson(configPath(home), config);
   return config;
 }
 
-export function installRuntime(home) {
-  const source = projectRoot();
+export function installRuntime(home, 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"]) {
+  for (const name of ["bin", "src", "extension-template", "node_modules"]) {
     fs.rmSync(path.join(target, name), { recursive: true, force: true });
     fs.cpSync(path.join(source, name), path.join(target, name), { recursive: true, force: true });
   }
+  fs.rmSync(path.join(target, "node_modules", ".bin"), { 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 });
+  if (fs.existsSync(appSource)) {
+    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.swift", "Info.plist"]) {
-    fs.copyFileSync(path.join(appSource, name), path.join(appTarget, name));
-  }
-  for (const name of ["package.json", "README.md", "LICENSE"]) {
+  for (const name of ["package.json", "README.md", "LICENSE", "THIRD_PARTY_NOTICES.md"]) {
     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 cleanProfileName(value) {
+  return typeof value === "string" ? value.trim().slice(0, 100) : "";
+}
+
+function cleanDomains(value) {
+  const items = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+  return [...new Set(items.map((item) => String(item).trim().toLowerCase()).filter(Boolean))].slice(0, 50);
+}
+
 function installExtension(config, home, browser, role) {
   const source = path.join(projectRoot(), "extension-template");
   const target = installedExtensionDir(home, browser);

package/src/paths.js

@@ -10,7 +10,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"];
+export const TARGET_BROWSERS = [...SOURCE_BROWSERS, "codex", "browserless"];
 
 export function projectRoot() {
   return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");

package/src/updater.js

@@ -2,10 +2,12 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
+import crypto from "node:crypto";
+import { Readable } from "node:stream";
+import { finished } from "node:stream/promises";
 import { fileURLToPath } from "node:url";
 import {
   appSupportDir,
-  installedAppPath,
   systemInstalledAppPath,
   userInstalledAppPath,
 } from "./paths.js";
@@ -35,33 +37,28 @@ export function startDetachedUpdate({ version, appPath, appPID, home = os.homedi
   return { workerPID: child.pid, logPath };
 }
 
-export function performUpdate({ version, appPath, appPID, home = os.homedir() }) {
+export async 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);
+  const support = appSupportDir(home);
+  const resultPath = path.join(support, "update-result.json");
+  let mounted = null;
   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);
+    const release = await downloadReleaseDMG({ version, architecture: process.arch, support });
+    mounted = mountReleaseDMG(release.dmgPath, support);
+    const sourceApp = path.join(mounted.mountPoint, "Browser Cookie Bridge.app");
+    if (!fs.existsSync(sourceApp)) throw new Error("The downloaded DMG does not contain Browser Cookie Bridge.app");
+    replaceAppContents(sourceApp, destination);
     installAppLogin({ appPath: destination, bootstrapNow: false });
     writeUpdateResult(resultPath, { status: "success", version });
+    unmountReleaseDMG(mounted);
+    mounted = null;
+    fs.rmSync(release.dmgPath, { force: true });
+    fs.rmSync(release.checksumPath, { force: true });
     relaunch(destination);
     return { destination, version };
   } catch (error) {
+    if (mounted) unmountReleaseDMG(mounted);
     writeUpdateResult(resultPath, { status: "failed", version, message: error.message });
     if (fs.existsSync(destination)) relaunch(destination);
     throw error;
@@ -104,13 +101,78 @@ export function validateUpdateRequest({ version, appPath, appPID, home = os.home
   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;
+export function releaseAssetName(version, architecture = process.arch) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version ?? "")) throw new Error("Invalid update version");
+  if (!["arm64", "x64"].includes(architecture)) throw new Error(`Unsupported macOS architecture: ${architecture}`);
+  return `Browser-Cookie-Bridge-${architecture}.dmg`;
+}
+
+export function parseChecksum(text, expectedFilename) {
+  const match = text.trim().match(/^([a-f0-9]{64})\s+\*?(.+)$/i);
+  if (!match || match[2] !== expectedFilename) throw new Error("Invalid release checksum file");
+  return match[1].toLowerCase();
+}
+
+async function downloadReleaseDMG({ version, architecture, support }) {
+  const updates = path.join(support, "updates");
+  fs.mkdirSync(updates, { recursive: true, mode: 0o700 });
+  const filename = releaseAssetName(version, architecture);
+  const base = `https://github.com/apoorvdarshan/browser-cookie-bridge/releases/download/v${version}`;
+  const dmgPath = path.join(updates, filename);
+  const checksumPath = `${dmgPath}.sha256`;
+  await downloadFile(`${base}/${filename}`, dmgPath);
+  await downloadFile(`${base}/${filename}.sha256`, checksumPath);
+  const expected = parseChecksum(fs.readFileSync(checksumPath, "utf8"), filename);
+  const actual = await fileSHA256(dmgPath);
+  if (actual !== expected) throw new Error("The downloaded update failed its SHA-256 verification");
+  return { dmgPath, checksumPath };
+}
+
+async function downloadFile(url, target) {
+  const response = await fetch(url, {
+    headers: { "User-Agent": "Browser-Cookie-Bridge-Updater" },
+    redirect: "follow",
+  });
+  if (!response.ok || !response.body) throw new Error(`Could not download update (${response.status})`);
+  const temporary = `${target}.${process.pid}.tmp`;
+  const output = fs.createWriteStream(temporary, { mode: 0o600 });
+  try {
+    await finished(Readable.fromWeb(response.body).pipe(output));
+    fs.renameSync(temporary, target);
+  } catch (error) {
+    fs.rmSync(temporary, { force: true });
+    throw error;
+  }
+}
+
+async function fileSHA256(target) {
+  const hash = crypto.createHash("sha256");
+  const input = fs.createReadStream(target);
+  input.on("data", (chunk) => hash.update(chunk));
+  await finished(input);
+  return hash.digest("hex");
+}
+
+function mountReleaseDMG(dmgPath, support) {
+  const mountPoint = path.join(support, "updates", `mounted-${process.pid}`);
+  fs.rmSync(mountPoint, { recursive: true, force: true });
+  fs.mkdirSync(mountPoint, { recursive: true, mode: 0o700 });
+  const result = spawnSync("/usr/bin/hdiutil", [
+    "attach", dmgPath,
+    "-mountpoint", mountPoint,
+    "-nobrowse",
+    "-readonly",
+  ], { encoding: "utf8" });
+  if (result.status !== 0) {
+    fs.rmSync(mountPoint, { recursive: true, force: true });
+    throw new Error(result.stderr.trim() || "The update DMG could not be mounted");
+  }
+  return { mountPoint };
+}
+
+function unmountReleaseDMG({ mountPoint }) {
+  spawnSync("/usr/bin/hdiutil", ["detach", mountPoint, "-force"], { stdio: "ignore" });
+  fs.rmSync(mountPoint, { recursive: true, force: true });
 }
 
 function waitForProcessToExit(pid, timeoutMilliseconds) {