browser-cookie-bridge 1.1.0 → 1.3.0

package/macos-app/Sources/BraveCodexSyncApp/SyncModel.swift

@@ -1,10 +1,12 @@
 import AppKit
 import Foundation
+import Security
 
 extension Notification.Name {
   static let menuBarVisibilityChanged = Notification.Name("BraveCodexSync.menuBarVisibilityChanged")
   static let nativeAlert = Notification.Name("BraveCodexSync.nativeAlert")
   static let updateStateChanged = Notification.Name("BraveCodexSync.updateStateChanged")
+  static let syncStateChanged = Notification.Name("BraveCodexSync.syncStateChanged")
 }
 
 struct NativeAlert {
@@ -20,6 +22,31 @@ struct UpdateMenuState {
   let installing: Bool
 }
 
+struct SyncMenuState {
+  let uploading: Bool
+  let canceling: Bool
+}
+
+struct BrowserlessProfileAssessment: Decodable {
+  let browser: String?
+  let profileName: String?
+  let profileBytes: Int64
+  let indexedDBBytes: Int64
+  let localStorageBytes: Int64
+  let freeBytes: Int64?
+  let severity: String
+  let temporarySpaceWarning: Bool
+  let serverArtifactCapBytes: Int64
+  let summary: String
+}
+
+private struct BrowserlessProgressEvent: Decodable {
+  let phase: String
+  let fraction: Double?
+  let detail: String?
+  let assessment: BrowserlessProfileAssessment?
+}
+
 struct BrowserChoice: Identifiable, Hashable {
   let id: String
   let name: String
@@ -30,7 +57,7 @@ struct BrowserChoice: Identifiable, Hashable {
 
 @MainActor
 final class SyncModel: ObservableObject {
-  enum State { case ready, syncing, success, warning, error }
+  enum State { case ready, syncing, success, canceled, warning, error }
 
   let browsers = [
     BrowserChoice(id: "brave", name: "Brave", bundleIdentifier: "com.brave.Browser", applicationName: "Brave Browser", extensionURL: "brave://extensions"),
@@ -60,6 +87,17 @@ final class SyncModel: ObservableObject {
   @Published var selectedSourceID = "brave"
   @Published var selectedTargetID = "codex"
   @Published var codexRunning = false
+  @Published var sourceBrowserRunning = false
+  @Published var browserlessConfigured = false
+  @Published var browserlessProfileName = "browser-cookie-bridge"
+  @Published var browserlessRegion = "sfo"
+  @Published var browserlessOnlyDomains = ""
+  @Published var showingBrowserlessSetup = false
+  @Published var browserlessAssessment: BrowserlessProfileAssessment?
+  @Published var isInspectingBrowserlessProfile = false
+  @Published var uploadProgress = 0.0
+  @Published var uploadElapsedSeconds = 0
+  @Published var uploadCanceling = false
   @Published var primaryStatus = "Ready to sync"
   @Published var secondaryStatus = "Choose what to move, then start a transfer"
 
@@ -69,10 +107,14 @@ final class SyncModel: ObservableObject {
   private var launchAgent: URL { home.appending(path: "Library/LaunchAgents/com.apoorvdarshan.brave-codex-cookie-sync.plist") }
   private var loginSyncAgent: URL { home.appending(path: "Library/LaunchAgents/com.apoorvdarshan.brave-codex-cookie-sync.login-sync.plist") }
   private var appLoginAgent: URL { home.appending(path: "Library/LaunchAgents/com.apoorvdarshan.brave-codex-cookie-sync.app-login.plist") }
-  private var codexStatusTimer: Timer?
+  private var endpointStatusTimer: Timer?
   private var updateTimer: Timer?
   private var didCheckAfterLaunch = false
   private var didConsumeUpdateResult = false
+  private var assessedBrowserID: String?
+  private var activeSyncProcess: Process?
+  private var uploadTimer: Timer?
+  private var uploadStartedAt: Date?
 
   var selectedBrowser: BrowserChoice {
     browsers.first(where: { $0.id == selectedSourceID }) ?? browsers[0]
@@ -82,10 +124,29 @@ final class SyncModel: ObservableObject {
     browsers.first(where: { $0.id == selectedTargetID })
   }
 
-  var targetName: String { selectedTargetBrowser?.name ?? "ChatGPT Codex" }
+  var isBrowserlessTarget: Bool { selectedTargetID == "browserless" }
+  var targetName: String {
+    isBrowserlessTarget ? "Browserless Cloud" : selectedTargetBrowser?.name ?? "ChatGPT Codex"
+  }
   var codexBlocked: Bool { selectedTargetID == "codex" && codexRunning }
+  var browserlessBlocked: Bool {
+    isBrowserlessTarget && (!browserlessConfigured || sourceBrowserRunning || selectedSourceID == "comet")
+  }
+  var syncBlocked: Bool { codexBlocked || browserlessBlocked }
+  var formattedUploadElapsed: String {
+    let minutes = uploadElapsedSeconds / 60
+    let seconds = uploadElapsedSeconds % 60
+    return String(format: "%d:%02d", minutes, seconds)
+  }
   var sourceIcon: NSImage { browserIcon(selectedBrowser) }
-  var targetIcon: NSImage { selectedTargetBrowser.map(browserIcon) ?? codexIcon }
+  var targetIcon: NSImage {
+    isBrowserlessTarget ? browserlessIcon : selectedTargetBrowser.map(browserIcon) ?? codexIcon
+  }
+  var browserlessIcon: NSImage {
+    bundledIcon("browserless")
+      ?? NSImage(systemSymbolName: "cloud.fill", accessibilityDescription: "Browserless Cloud")
+      ?? NSImage()
+  }
   var codexIcon: NSImage {
     bundledIcon("chatgpt-codex")
       ?? chatGPTResource("app.icns")
@@ -119,9 +180,10 @@ final class SyncModel: ObservableObject {
     bootstrapBundledRuntimeIfNeeded()
     let calendar = Calendar.current
     scheduleTime = calendar.date(bySettingHour: 9, minute: 0, second: 0, of: Date()) ?? Date()
-    updateCodexRunningStatus()
-    codexStatusTimer = Timer.scheduledTimer(withTimeInterval: 2, repeats: true) { [weak self] _ in
-      Task { @MainActor in self?.updateCodexRunningStatus() }
+    updateEndpointRunningStatus()
+    refreshBrowserlessPreflight()
+    endpointStatusTimer = Timer.scheduledTimer(withTimeInterval: 2, repeats: true) { [weak self] _ in
+      Task { @MainActor in self?.updateEndpointRunningStatus() }
     }
     updateTimer = Timer.scheduledTimer(withTimeInterval: 24 * 60 * 60, repeats: true) { [weak self] _ in
       Task { @MainActor in
@@ -191,7 +253,7 @@ final class SyncModel: ObservableObject {
       let configuredSource = config.sourceBrowser ?? "brave"
       selectedSourceID = browsers.contains(where: { $0.id == configuredSource }) ? configuredSource : "brave"
       let configuredTarget = config.targetBrowser ?? "codex"
-      selectedTargetID = configuredTarget == "codex" || browsers.contains(where: { $0.id == configuredTarget })
+      selectedTargetID = configuredTarget == "codex" || configuredTarget == "browserless" || browsers.contains(where: { $0.id == configuredTarget })
         ? configuredTarget
         : "codex"
       if selectedTargetID == selectedSourceID { selectedTargetID = "codex" }
@@ -199,12 +261,17 @@ final class SyncModel: ObservableObject {
       historyEnabled = config.imports?.history ?? false
       menuBarEnabled = config.ui?.menuBar ?? true
       autoCheckUpdates = config.ui?.autoCheckUpdates ?? true
+      browserlessProfileName = config.browserless?.profileName ?? "browser-cookie-bridge"
+      browserlessRegion = config.browserless?.region ?? "sfo"
+      browserlessOnlyDomains = (config.browserless?.onlyDomains ?? []).joined(separator: ", ")
     }
+    browserlessConfigured = BrowserlessCredentialStore.read() != nil
     NotificationCenter.default.post(name: .menuBarVisibilityChanged, object: menuBarEnabled)
     extensionsReady = requiredExtensionIDs.allSatisfy {
       FileManager.default.fileExists(atPath: support.appending(path: "extension-\($0)/manifest.json").path)
     }
-    updateCodexRunningStatus()
+    updateEndpointRunningStatus()
+    refreshBrowserlessPreflight()
     consumeUpdateResultIfNeeded()
     if autoCheckUpdates && !didCheckAfterLaunch {
       didCheckAfterLaunch = true
@@ -215,15 +282,19 @@ final class SyncModel: ObservableObject {
   func selectSource(_ id: String) {
     guard browsers.contains(where: { $0.id == id }), id != selectedSourceID, id != selectedTargetID else { return }
     selectedSourceID = id
+    browserlessAssessment = nil
+    assessedBrowserID = nil
     persistPreferences(successMessage: "Export source changed to \(selectedBrowser.name)")
   }
 
   func selectTarget(_ id: String) {
-    let validTarget = id == "codex" || browsers.contains(where: { $0.id == id })
+    let validTarget = id == "codex" || id == "browserless" || browsers.contains(where: { $0.id == id })
     guard validTarget, id != selectedTargetID, id != selectedSourceID else { return }
     selectedTargetID = id
     persistPreferences(successMessage: "Import destination changed to \(targetName)")
-    updateCodexRunningStatus()
+    updateEndpointRunningStatus()
+    if id == "browserless" && !browserlessConfigured { showingBrowserlessSetup = true }
+    if id == "browserless" { refreshBrowserlessPreflight() }
   }
 
   func setCookiesEnabled(_ enabled: Bool) {
@@ -236,6 +307,34 @@ final class SyncModel: ObservableObject {
     persistPreferences(successMessage: enabled ? "History URL import enabled" : "History import disabled")
   }
 
+  func saveBrowserlessSettings(token: String, profileName: String, region: String, onlyDomains: String) {
+    let cleanedToken = token.trimmingCharacters(in: .whitespacesAndNewlines)
+    let cleanedName = profileName.trimmingCharacters(in: .whitespacesAndNewlines)
+    guard !cleanedName.isEmpty, !cleanedToken.isEmpty || BrowserlessCredentialStore.read() != nil else {
+      postNativeAlert(title: "Browserless connection incomplete", message: "Enter an API token and cloud profile name.", kind: .warning)
+      return
+    }
+    do {
+      if !cleanedToken.isEmpty { try BrowserlessCredentialStore.save(cleanedToken) }
+      browserlessConfigured = true
+      browserlessProfileName = cleanedName
+      browserlessRegion = region
+      browserlessOnlyDomains = onlyDomains
+      showingBrowserlessSetup = false
+      persistPreferences(successMessage: "Browserless connected — uploads remain manual")
+      refreshBrowserlessPreflight(force: true)
+    } catch {
+      postNativeAlert(title: "Could not save Browserless token", message: error.localizedDescription, kind: .error)
+    }
+  }
+
+  func disconnectBrowserless() {
+    BrowserlessCredentialStore.delete()
+    browserlessConfigured = false
+    showingBrowserlessSetup = false
+    updateEndpointRunningStatus()
+  }
+
   func setMenuBarEnabled(_ enabled: Bool) {
     menuBarEnabled = enabled
     NotificationCenter.default.post(name: .menuBarVisibilityChanged, object: enabled)
@@ -334,31 +433,67 @@ final class SyncModel: ObservableObject {
 
   func syncNow(showMenuBarAlert: Bool = false) {
     guard !isSyncing else {
+      if isBrowserlessTarget {
+        cancelSync()
+        return
+      }
       if showMenuBarAlert {
         postNativeAlert(title: "Sync already running", message: "Wait for the current transfer to finish.", kind: .information)
       }
       return
     }
-    updateCodexRunningStatus()
-    guard !codexBlocked else {
+    updateEndpointRunningStatus()
+    guard !syncBlocked else {
       if showMenuBarAlert {
         postNativeAlert(title: primaryStatus, message: secondaryStatus, kind: .warning)
       }
       return
     }
     isSyncing = true
+    uploadCanceling = false
     state = .syncing
-    primaryStatus = "Transferring selected data"
+    primaryStatus = isBrowserlessTarget ? "Uploading authenticated state" : "Transferring selected data"
     secondaryStatus = selectedTargetID == "codex"
       ? "Backing up Codex and merging \(selectedBrowser.name) locally…"
-      : "Waiting for \(selectedBrowser.name) and \(targetName)…"
-    runCLI(["sync", "--timeout", "300"]) { [weak self] success, output in
+      : isBrowserlessTarget
+        ? "Sending \(selectedBrowser.name) to Browserless \(browserlessRegion.uppercased()) only for this request…"
+        : "Waiting for \(selectedBrowser.name) and \(targetName)…"
+    var environment: [String: String] = [:]
+    var arguments = ["sync", "--timeout", isBrowserlessTarget ? "900" : "300"]
+    if isBrowserlessTarget {
+      guard let token = BrowserlessCredentialStore.read() else {
+        isSyncing = false
+        browserlessConfigured = false
+        updateEndpointRunningStatus()
+        return
+      }
+      environment["BROWSERLESS_TOKEN"] = token
+      arguments.append("--allow-cloud-upload")
+      beginUploadTracking()
+    }
+    activeSyncProcess = runCLI(arguments, environment: environment, onLine: { [weak self] line in
+      self?.handleBrowserlessProgress(line)
+    }) { [weak self] success, output in
       guard let self else { return }
+      self.activeSyncProcess = nil
       self.isSyncing = false
-      let partial = success && (output.contains("Partially synced:") || output.contains("with warnings"))
-      if success {
+      self.finishUploadTracking()
+      let partial = success && (
+        output.contains("Partially synced:")
+          || output.contains("with warnings")
+          || output.contains("omitted to fit")
+          || output.contains("could not be captured")
+      )
+      let canceled = output.contains("Browserless upload canceled") || output.contains("Temporary profile data was removed")
+      if canceled {
+        self.state = .canceled
+        self.primaryStatus = "Browserless upload canceled"
+        self.secondaryStatus = "No cloud profile was changed; temporary profile data was removed"
+      } else if success {
         self.state = partial ? .warning : .success
-        self.primaryStatus = self.selectedTargetID == "codex"
+        self.primaryStatus = self.isBrowserlessTarget
+          ? (partial ? "Browserless profile uploaded with omissions" : "Browserless profile uploaded")
+          : self.selectedTargetID == "codex"
           ? (partial ? "Codex sync completed with warnings" : "Codex sessions updated")
           : (partial ? "Partially synced" : "Transfer complete")
         self.secondaryStatus = self.lastMeaningfulLine(output) ?? "\(self.selectedBrowser.name) and \(self.targetName) are up to date"
@@ -367,20 +502,54 @@ final class SyncModel: ObservableObject {
         self.primaryStatus = "Sync did not finish"
         self.secondaryStatus = self.lastMeaningfulLine(output) ?? (self.selectedTargetID == "codex"
           ? "Quit Codex completely, then try again"
+          : self.isBrowserlessTarget
+            ? "Check the API token, close the source browser, and try again"
           : "Keep both browsers open and check the extensions")
       }
-      self.updateCodexRunningStatus()
+      self.updateEndpointRunningStatus()
       if showMenuBarAlert {
         self.postNativeAlert(
           title: self.primaryStatus,
           message: self.secondaryStatus,
-          kind: success ? (partial ? .warning : .information) : .error
+          kind: canceled ? .information : success ? (partial ? .warning : .information) : .error
         )
       }
     }
   }
 
+  func cancelSync() {
+    guard isBrowserlessTarget, isSyncing, !uploadCanceling else { return }
+    uploadCanceling = true
+    primaryStatus = "Canceling Browserless upload"
+    secondaryStatus = "Stopping the temporary browser and removing its isolated workspace…"
+    postSyncState()
+    activeSyncProcess?.terminate()
+  }
+
+  func refreshBrowserlessPreflight(force: Bool = false) {
+    guard isBrowserlessTarget, selectedSourceID != "comet", !isInspectingBrowserlessProfile else { return }
+    if !force, assessedBrowserID == selectedSourceID, browserlessAssessment != nil { return }
+    isInspectingBrowserlessProfile = true
+    let sourceAtStart = selectedSourceID
+    runCLI(["browserless-preflight"]) { [weak self] success, output in
+      guard let self else { return }
+      self.isInspectingBrowserlessProfile = false
+      guard self.selectedSourceID == sourceAtStart else { return }
+      if success, let assessment = self.decodeLastJSON(BrowserlessProfileAssessment.self, from: output) {
+        self.browserlessAssessment = assessment
+        self.assessedBrowserID = sourceAtStart
+      } else if force {
+        self.browserlessAssessment = nil
+        self.assessedBrowserID = nil
+      }
+    }
+  }
+
   func setDailyEnabled(_ enabled: Bool) {
+    guard !isBrowserlessTarget else {
+      postNativeAlert(title: "Cloud uploads are manual-only", message: "Browser Cookie Bridge will never schedule Browserless uploads in the background.", kind: .information)
+      return
+    }
     dailyEnabled = enabled
     applySchedule(enabled)
   }
@@ -390,6 +559,10 @@ final class SyncModel: ObservableObject {
   }
 
   func setLoginSyncEnabled(_ enabled: Bool) {
+    guard !isBrowserlessTarget else {
+      postNativeAlert(title: "Cloud uploads are manual-only", message: "Login sync does not send authenticated state to Browserless.", kind: .information)
+      return
+    }
     loginSyncEnabled = enabled
     isWorking = true
     runCLI([enabled ? "enable-login-sync" : "disable-login-sync"]) { [weak self] success, output in
@@ -453,7 +626,10 @@ final class SyncModel: ObservableObject {
       "--cookies", cookiesEnabled ? "on" : "off",
       "--history", historyEnabled ? "on" : "off",
       "--menu-bar", menuBarEnabled ? "on" : "off",
-      "--auto-check-updates", autoCheckUpdates ? "on" : "off"
+      "--auto-check-updates", autoCheckUpdates ? "on" : "off",
+      "--browserless-profile", browserlessProfileName,
+      "--browserless-region", browserlessRegion,
+      "--browserless-domains", browserlessOnlyDomains,
     ]
     runCLI(arguments) { [weak self] success, output in
       guard let self else { return }
@@ -461,7 +637,9 @@ final class SyncModel: ObservableObject {
       if success {
         self.state = .ready
         self.primaryStatus = successMessage
-        self.secondaryStatus = "This choice is saved for manual and daily syncs"
+        self.secondaryStatus = self.isBrowserlessTarget
+          ? "Cloud uploads run only after you click Upload"
+          : "This choice is saved for manual and daily syncs"
       } else {
         self.state = .error
         self.primaryStatus = "Could not save import settings"
@@ -471,7 +649,8 @@ final class SyncModel: ObservableObject {
       self.extensionsReady = self.requiredExtensionIDs.allSatisfy {
         FileManager.default.fileExists(atPath: self.support.appending(path: "extension-\($0)/manifest.json").path)
       }
-      self.updateCodexRunningStatus()
+      self.updateEndpointRunningStatus()
+      self.refreshBrowserlessPreflight()
     }
   }
 
@@ -500,26 +679,48 @@ final class SyncModel: ObservableObject {
     }
   }
 
-  private func runCLI(_ arguments: [String], completion: @escaping @MainActor (Bool, String) -> Void) {
+  @discardableResult
+  private func runCLI(
+    _ arguments: [String],
+    environment: [String: String] = [:],
+    onLine: (@MainActor (String) -> Void)? = nil,
+    completion: @escaping @MainActor (Bool, String) -> Void
+  ) -> Process? {
     guard let config = loadConfig() else {
       completion(false, "Configuration missing. Run install-app again.")
-      return
+      return nil
     }
     let process = Process()
     let output = Pipe()
+    let collector = ProcessOutputCollector()
     process.executableURL = URL(fileURLWithPath: config.nodePath)
     process.arguments = [runtimeCLI.path] + arguments
+    process.environment = ProcessInfo.processInfo.environment.merging(environment) { _, new in new }
     process.standardOutput = output
     process.standardError = output
+    output.fileHandleForReading.readabilityHandler = { handle in
+      let data = handle.availableData
+      guard !data.isEmpty else { return }
+      let lines = collector.append(data)
+      guard let onLine, !lines.isEmpty else { return }
+      Task { @MainActor in lines.forEach(onLine) }
+    }
     process.terminationHandler = { process in
-      let data = output.fileHandleForReading.readDataToEndOfFile()
-      let text = String(decoding: data, as: UTF8.self)
-      Task { @MainActor in completion(process.terminationStatus == 0, text) }
+      output.fileHandleForReading.readabilityHandler = nil
+      let remainder = output.fileHandleForReading.readDataToEndOfFile()
+      let lines = collector.append(remainder, finish: true)
+      let text = collector.text
+      Task { @MainActor in
+        if let onLine { lines.forEach(onLine) }
+        completion(process.terminationStatus == 0, text)
+      }
     }
     do {
       try process.run()
+      return process
     } catch {
       completion(false, error.localizedDescription)
+      return nil
     }
   }
 
@@ -546,28 +747,112 @@ final class SyncModel: ObservableObject {
     return line.hasPrefix("Error: ") ? String(line.dropFirst(7)) : line
   }
 
+  private func decodeLastJSON<T: Decodable>(_ type: T.Type, from output: String) -> T? {
+    for line in output.split(separator: "\n").reversed() {
+      guard let data = String(line).data(using: .utf8),
+            let value = try? JSONDecoder().decode(type, from: data) else { continue }
+      return value
+    }
+    return nil
+  }
+
+  private func beginUploadTracking() {
+    uploadProgress = 0.01
+    uploadElapsedSeconds = 0
+    uploadStartedAt = Date()
+    uploadTimer?.invalidate()
+    uploadTimer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] _ in
+      Task { @MainActor in
+        guard let self, let started = self.uploadStartedAt else { return }
+        self.uploadElapsedSeconds = max(0, Int(Date().timeIntervalSince(started)))
+      }
+    }
+    postSyncState()
+  }
+
+  private func finishUploadTracking() {
+    uploadTimer?.invalidate()
+    uploadTimer = nil
+    uploadStartedAt = nil
+    uploadCanceling = false
+    postSyncState()
+  }
+
+  private func handleBrowserlessProgress(_ line: String) {
+    guard line.hasPrefix("BCB_PROGRESS "),
+          let data = String(line.dropFirst("BCB_PROGRESS ".count)).data(using: .utf8),
+          let event = try? JSONDecoder().decode(BrowserlessProgressEvent.self, from: data) else { return }
+    if let fraction = event.fraction { uploadProgress = min(max(fraction, uploadProgress), 1) }
+    if let assessment = event.assessment {
+      browserlessAssessment = assessment
+      assessedBrowserID = selectedSourceID
+    }
+    guard !uploadCanceling else { return }
+    primaryStatus = switch event.phase {
+    case "preflight": "Inspecting the local profile"
+    case "preflight-complete": "Profile preflight complete"
+    case "validating": "Checking Browserless profile"
+    case "copying": "Preparing an isolated profile copy"
+    case "launching", "waiting": "Starting the temporary browser"
+    case "capturing": "Capturing authenticated state"
+    case "uploading": "Uploading fitted profile state"
+    case "verifying": "Verifying the Browserless profile"
+    case "complete": "Browserless profile uploaded"
+    default: "Uploading authenticated state"
+    }
+    if let detail = event.detail { secondaryStatus = detail }
+  }
+
+  private func postSyncState() {
+    NotificationCenter.default.post(
+      name: .syncStateChanged,
+      object: SyncMenuState(uploading: isBrowserlessTarget && isSyncing, canceling: uploadCanceling)
+    )
+  }
+
   private var formattedTime: String {
     scheduleTime.formatted(date: .omitted, time: .shortened)
   }
 
   private var requiredExtensionIDs: [String] {
-    selectedTargetID == "codex" ? [] : [selectedSourceID, selectedTargetID]
+    selectedTargetID == "codex" || selectedTargetID == "browserless" ? [] : [selectedSourceID, selectedTargetID]
   }
 
-  private func updateCodexRunningStatus() {
+  private func updateEndpointRunningStatus() {
     let wasRunning = codexRunning
     codexRunning = NSWorkspace.shared.runningApplications.contains {
       $0.bundleIdentifier == "com.openai.codex"
     }
-    guard selectedTargetID == "codex", !isSyncing else { return }
-    if codexRunning {
+    sourceBrowserRunning = NSWorkspace.shared.runningApplications.contains {
+      $0.bundleIdentifier == selectedBrowser.bundleIdentifier
+    }
+    guard !isSyncing else { return }
+    if selectedTargetID == "codex" && codexRunning {
       state = .warning
       primaryStatus = "Quit Codex before syncing"
       secondaryStatus = "Close ChatGPT Codex completely so its local cookie database can be updated safely"
-    } else if wasRunning && primaryStatus == "Quit Codex before syncing" {
+    } else if selectedTargetID == "codex" && wasRunning && primaryStatus == "Quit Codex before syncing" {
       state = .ready
       primaryStatus = "Ready to sync directly"
       secondaryStatus = "Codex is closed — a backup will be created before anything changes"
+    } else if isBrowserlessTarget {
+      if selectedSourceID == "comet" {
+        state = .warning
+        primaryStatus = "Comet capture is not supported"
+        secondaryStatus = "Choose Brave, Chrome, Edge, Arc, Vivaldi, or Opera for Browserless"
+      } else if !browserlessConfigured {
+        state = .warning
+        primaryStatus = "Connect Browserless"
+        secondaryStatus = "Your API token will be stored in macOS Keychain, never in the app configuration"
+      } else if sourceBrowserRunning {
+        state = .warning
+        primaryStatus = "Quit \(selectedBrowser.name) before uploading"
+        secondaryStatus = "Browserless captures a temporary copy of the closed profile, including local storage and IndexedDB"
+      } else {
+        state = .ready
+        primaryStatus = "Ready for an explicit cloud upload"
+        secondaryStatus = "Only this click sends authenticated state to Browserless \(browserlessRegion.uppercased())"
+      }
     }
   }
 
@@ -647,6 +932,7 @@ private struct AppConfig: Decodable {
   let targetBrowser: String?
   let imports: Imports?
   let ui: UISettings?
+  let browserless: BrowserlessSettings?
 
   struct Schedule: Decodable {
     let hour: Int
@@ -663,4 +949,84 @@ private struct AppConfig: Decodable {
     let openAtLogin: Bool?
     let autoCheckUpdates: Bool?
   }
+
+  struct BrowserlessSettings: Decodable {
+    let profileName: String?
+    let region: String?
+    let onlyDomains: [String]?
+  }
+}
+
+private enum BrowserlessCredentialStore {
+  private static let service = "com.apoorvdarshan.browser-cookie-bridge.browserless"
+  private static let account = "api-token"
+
+  static func save(_ token: String) throws {
+    let identity: [String: Any] = [
+      kSecClass as String: kSecClassGenericPassword,
+      kSecAttrService as String: service,
+      kSecAttrAccount as String: account,
+    ]
+    let update: [String: Any] = [kSecValueData as String: Data(token.utf8)]
+    let updateStatus = SecItemUpdate(identity as CFDictionary, update as CFDictionary)
+    if updateStatus == errSecSuccess { return }
+    guard updateStatus == errSecItemNotFound else {
+      throw NSError(domain: NSOSStatusErrorDomain, code: Int(updateStatus), userInfo: nil)
+    }
+    let item: [String: Any] = identity.merging([
+      kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly,
+      kSecValueData as String: Data(token.utf8),
+    ]) { _, new in new }
+    let status = SecItemAdd(item as CFDictionary, nil)
+    guard status == errSecSuccess else {
+      throw NSError(domain: NSOSStatusErrorDomain, code: Int(status), userInfo: nil)
+    }
+  }
+
+  static func read() -> String? {
+    let query: [String: Any] = [
+      kSecClass as String: kSecClassGenericPassword,
+      kSecAttrService as String: service,
+      kSecAttrAccount as String: account,
+      kSecReturnData as String: true,
+      kSecMatchLimit as String: kSecMatchLimitOne,
+    ]
+    var result: CFTypeRef?
+    guard SecItemCopyMatching(query as CFDictionary, &result) == errSecSuccess,
+          let data = result as? Data else { return nil }
+    return String(data: data, encoding: .utf8)
+  }
+
+  static func delete() {
+    let query: [String: Any] = [
+      kSecClass as String: kSecClassGenericPassword,
+      kSecAttrService as String: service,
+      kSecAttrAccount as String: account,
+    ]
+    SecItemDelete(query as CFDictionary)
+  }
+}
+
+private final class ProcessOutputCollector: @unchecked Sendable {
+  private let lock = NSLock()
+  private var bytes = Data()
+  private var pending = ""
+
+  var text: String {
+    lock.withLock { String(decoding: bytes, as: UTF8.self) }
+  }
+
+  func append(_ data: Data, finish: Bool = false) -> [String] {
+    lock.withLock {
+      bytes.append(data)
+      pending += String(decoding: data, as: UTF8.self)
+      var lines = pending.components(separatedBy: .newlines)
+      if finish {
+        pending = ""
+        return lines.filter { !$0.isEmpty }
+      }
+      pending = lines.popLast() ?? ""
+      return lines.filter { !$0.isEmpty }
+    }
+  }
 }