browser-cookie-bridge 1.2.0 → 1.3.0

package/README.md

@@ -44,7 +44,7 @@
 
 ---
 
-> **Version 1.2.0 adds an optional Browserless Cloud destination.** It is destination-only, manual-only, and visually separated from local transfers. Importing into ChatGPT Codex remains an intentionally unsupported direct integration and requires Codex to be completely closed.
+> **Version 1.3.0 makes large Browserless uploads observable and recoverable.** The app measures the local profile and IndexedDB without reading their contents, streams capture progress and elapsed time, supports cancellation with deterministic temporary-data cleanup, reports auto-fit omissions, and verifies the cloud profile after upload.
 
 ## Why Browser Cookie Bridge
 
@@ -57,7 +57,7 @@ Browser Cookie Bridge gives those browser profiles a small, native control panel
 - 🍪 **Cookie and session transfer** — cookies are enabled by default, including supported domain, path, expiry, security, `SameSite`, and partition attributes.
 - 🌐 **Seven Chromium browsers** — Brave, Chrome, Edge, Arc, Vivaldi, Opera, and Perplexity Comet can be sources or destinations.
 - ✨ **ChatGPT Codex import** — merge selected local browser data into Codex's built-in browser; Codex is destination-only.
-- ☁️ **Optional Browserless upload** — create or refresh a Browserless authenticated profile with cookies, local storage, and IndexedDB; Browserless is destination-only and manual-only.
+- ☁️ **Optional Browserless upload** — create or refresh a Browserless authenticated profile with cookies, local storage, and IndexedDB; see a local size preflight, live progress, cancellation, and post-upload verification.
 - 🕘 **Background automation** — sync when you sign in, at a fixed daily time, or whenever you choose.
 - ◉ **Native menu-bar app** — closing the window removes the Dock icon while the helper continues running.
 - 🧯 **Backup and rollback** — Codex's database is backed up, modified on a separate copy, integrity-checked, and restored if replacement fails.
@@ -151,7 +151,11 @@ This path uses the official Browserless CLI and is deliberately separate from lo
 3. Quit the selected source browser so its profile can be copied consistently.
 4. Review the cloud warning and click **Upload now**.
 
-The upload creates the named Browserless profile the first time and refreshes it on later runs. It may contain cookies, local storage, and IndexedDB; history and saved passwords are excluded. Browserless uploads never run from Daily sync or Sync at login. Browser Cookie Bridge disables Browserless CLI telemetry for this integration. Comet is not currently supported by the Browserless capture CLI.
+The upload creates the named Browserless profile the first time and refreshes it on later runs. It may contain cookies, local storage, and IndexedDB; history and saved passwords are excluded. The app measures the profile, IndexedDB, local storage, and available disk space locally before capture. Progress and elapsed time remain visible, Cancel upload terminates the isolated capture process group, and the dedicated temporary workspace is removed after success, failure, timeout, or cancellation.
+
+Browserless currently caps the serialized authenticated-profile artifact at **2 MB**. A large on-disk IndexedDB does not mean all of it will be uploaded: the official CLI's `--auto-fit` behavior drops the heaviest origins until the artifact fits while keeping cookies. Browser Cookie Bridge reports those omissions in the final result and verifies that the named cloud profile can be read back after upload. Use the domain allowlist when you need specific sites or want a faster, smaller capture.
+
+Browserless uploads never run from Daily sync or Sync at login. Browser Cookie Bridge disables Browserless CLI telemetry for this integration. Comet is not currently supported by the Browserless capture CLI. The default cloud timeout is 15 minutes; `--timeout` can override it.
 
 The official CLI records the Browserless upload-disclaimer acceptance timestamp in `~/.browserless/config.json`. Browser Cookie Bridge does not store its API token there.
 
@@ -178,6 +182,7 @@ browser-cookie-bridge install-app [--no-open]
 browser-cookie-bridge setup [--hour 9] [--minute 0] [--no-schedule]
 browser-cookie-bridge preferences --source brave --target codex --cookies on --history off
 browser-cookie-bridge sync [--timeout 300] [--allow-cloud-upload]
+browser-cookie-bridge browserless-preflight
 browser-cookie-bridge doctor
 browser-cookie-bridge enable-login-sync
 browser-cookie-bridge disable-login-sync

package/bin/brave-codex-cookie-sync.js

@@ -2,7 +2,15 @@
 
 import { main } from "../src/cli.js";
 
-main(process.argv.slice(2)).catch((error) => {
+const controller = new AbortController();
+const cancel = () => controller.abort();
+process.once("SIGINT", cancel);
+process.once("SIGTERM", cancel);
+
+main(process.argv.slice(2), { signal: controller.signal }).catch((error) => {
   console.error(`Error: ${error.message}`);
-  process.exitCode = 1;
+  process.exitCode = controller.signal.aborted ? 130 : 1;
+}).finally(() => {
+  process.removeListener("SIGINT", cancel);
+  process.removeListener("SIGTERM", cancel);
 });

package/extension-template/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Browser Cookie Bridge",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Transfers selected browser data locally between supported browsers and into ChatGPT Codex.",
   "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA5o6lDkXzU/23Jm2QRk4mfuxNnr3VlEIjRHcZr93Gdo7PI7asHJQhigaMGT6UOz0lkaTn1F+TGIPlsJo9GNBSsxbCfxWoBSXcFQFrPolY5LEfKaMtZQQ6eb4UAnp+bbUwb1den4On0piWU47Yzl6i0Jcdg4EG5H1kCSF/6nJsbKgF7OTaR/3drULu40yRvflzSXRhly3UDO7c5mgHJsaMwVV+VILsxbcPOoRINjuo3zDC737HFs67dpf38xF3tjSVL0HURAWKKobMvfABiDfVEm5O0Lvf+57d1Ib12QLT2qtVXNDy3iYwX+w2S0wH2vIMsfvoFPlRdmeqft70kZOqXwIDAQAB",
   "permissions": ["alarms", "cookies", "history"],

package/macos-app/Info.plist

@@ -10,8 +10,8 @@
   <key>CFBundleInfoDictionaryVersion</key><string>6.0</string>
   <key>CFBundleName</key><string>Browser Cookie Bridge</string>
   <key>CFBundlePackageType</key><string>APPL</string>
-  <key>CFBundleShortVersionString</key><string>1.2.0</string>
-  <key>CFBundleVersion</key><string>26</string>
+  <key>CFBundleShortVersionString</key><string>1.3.0</string>
+  <key>CFBundleVersion</key><string>27</string>
   <key>LSMinimumSystemVersion</key><string>13.5</string>
   <key>NSHighResolutionCapable</key><true/>
 </dict>

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

@@ -35,6 +35,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
   weak var model: SyncModel?
   private weak var mainWindow: NSWindow?
   private var statusItem: NSStatusItem?
+  private var syncMenuItem: NSMenuItem?
   private var updateMenuItem: NSMenuItem?
 
   func applicationDidFinishLaunching(_ notification: Notification) {
@@ -56,6 +57,12 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
       name: .updateStateChanged,
       object: nil
     )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(syncStateChanged(_:)),
+      name: .syncStateChanged,
+      object: nil
+    )
   }
 
   func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { false }
@@ -94,7 +101,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
       item.button?.imageScaling = .scaleProportionallyDown
       let menu = NSMenu()
       menu.addItem(withTitle: "Show Browser Cookie Bridge", action: #selector(showMainWindowAction), keyEquivalent: "")
-      menu.addItem(withTitle: "Sync now", action: #selector(syncNowAction), keyEquivalent: "")
+      syncMenuItem = menu.addItem(withTitle: "Sync now", action: #selector(syncNowAction), keyEquivalent: "")
       let updateItem = menu.addItem(withTitle: "Check for Updates…", action: #selector(updateAction), keyEquivalent: "")
       updateMenuItem = updateItem
       addProjectLinks(to: menu)
@@ -106,6 +113,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
     } else if let statusItem {
       NSStatusBar.system.removeStatusItem(statusItem)
       self.statusItem = nil
+      syncMenuItem = nil
       updateMenuItem = nil
     }
   }
@@ -116,7 +124,10 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
   }
 
   @objc private func showMainWindowAction() { showMainWindow() }
-  @objc private func syncNowAction() { model?.syncNow(showMenuBarAlert: true) }
+  @objc private func syncNowAction() {
+    if model?.isBrowserlessTarget == true, model?.isSyncing == true { model?.cancelSync() }
+    else { model?.syncNow(showMenuBarAlert: true) }
+  }
   @objc private func updateAction() {
     if model?.availableUpdateVersion != nil { model?.installAvailableUpdate() }
     else { model?.checkForUpdates(showAlert: true) }
@@ -161,6 +172,20 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
     }
   }
 
+  @objc private func syncStateChanged(_ notification: Notification) {
+    guard let payload = notification.object as? SyncMenuState else { return }
+    if payload.canceling {
+      syncMenuItem?.title = "Canceling upload…"
+      syncMenuItem?.isEnabled = false
+    } else if payload.uploading {
+      syncMenuItem?.title = "Cancel upload"
+      syncMenuItem?.isEnabled = true
+    } else {
+      syncMenuItem?.title = "Sync now"
+      syncMenuItem?.isEnabled = true
+    }
+  }
+
   private func showMainWindow() {
     NSApp.setActivationPolicy(.regular)
     mainWindow?.makeKeyAndOrderFront(nil)
@@ -290,35 +315,57 @@ struct SyncPanel: View {
           TargetPicker()
         }
         Divider().opacity(0.65)
-        HStack(spacing: 12) {
-          VStack(alignment: .leading, spacing: 2) {
-            Text(model.primaryStatus)
-              .font(.system(size: 13, weight: .semibold))
-            Text(model.secondaryStatus)
-              .font(.system(size: 10.5))
-              .foregroundStyle(.secondary)
-              .lineLimit(2)
-              .help(model.secondaryStatus)
-          }
-          Spacer()
-          Button {
-            if model.isBrowserlessTarget && !model.browserlessConfigured {
-              model.showingBrowserlessSetup = true
-            } else {
-              model.syncNow()
+        VStack(spacing: 8) {
+          HStack(spacing: 12) {
+            VStack(alignment: .leading, spacing: 2) {
+              Text(model.primaryStatus)
+                .font(.system(size: 13, weight: .semibold))
+              Text(model.secondaryStatus)
+                .font(.system(size: 10.5))
+                .foregroundStyle(.secondary)
+                .lineLimit(2)
+                .help(model.secondaryStatus)
             }
-          } label: {
-            HStack(spacing: 7) {
-              if model.isSyncing { ProgressView().controlSize(.small) }
-              else { Image(systemName: syncButtonIcon) }
-              Text(syncButtonTitle)
+            Spacer()
+            Button {
+              if model.isBrowserlessTarget && model.isSyncing {
+                model.cancelSync()
+              } else if model.isBrowserlessTarget && !model.browserlessConfigured {
+                model.showingBrowserlessSetup = true
+              } else {
+                model.syncNow()
+              }
+            } label: {
+              HStack(spacing: 7) {
+                if model.isSyncing && !model.isBrowserlessTarget { ProgressView().controlSize(.small) }
+                else { Image(systemName: syncButtonIcon) }
+                Text(syncButtonTitle)
+              }
+              .frame(minWidth: model.syncBlocked ? 116 : 92)
             }
-            .frame(minWidth: model.syncBlocked ? 116 : 92)
+            .buttonStyle(.borderedProminent)
+            .tint(model.isBrowserlessTarget && model.isSyncing ? Theme.active : Theme.accent)
+            .disabled(
+              model.uploadCanceling
+                || (model.isSyncing && !model.isBrowserlessTarget)
+                || (!model.isSyncing && model.syncBlocked && !(model.isBrowserlessTarget && !model.browserlessConfigured))
+            )
+            .keyboardShortcut(.return, modifiers: .command)
+          }
+          if model.isBrowserlessTarget && model.isSyncing {
+            HStack(spacing: 9) {
+              ProgressView(value: model.uploadProgress, total: 1)
+                .progressViewStyle(.linear)
+                .tint(Theme.active)
+              Text(model.formattedUploadElapsed)
+                .font(.system(size: 9.5, weight: .semibold, design: .monospaced))
+                .foregroundStyle(.secondary)
+                .frame(width: 34, alignment: .trailing)
+            }
+            .accessibilityElement(children: .combine)
+            .accessibilityLabel("Browserless upload progress")
+            .accessibilityValue("\(Int(model.uploadProgress * 100)) percent, \(model.formattedUploadElapsed) elapsed")
           }
-          .buttonStyle(.borderedProminent)
-          .tint(Theme.accent)
-          .disabled(model.isSyncing || (model.syncBlocked && !(model.isBrowserlessTarget && !model.browserlessConfigured)))
-          .keyboardShortcut(.return, modifiers: .command)
         }
         .padding(model.syncBlocked ? 7 : 0)
         .background(
@@ -336,7 +383,9 @@ struct SyncPanel: View {
   }
 
   private var syncButtonTitle: String {
-    if model.isSyncing { return model.isBrowserlessTarget ? "Uploading…" : "Syncing…" }
+    if model.isBrowserlessTarget && model.uploadCanceling { return "Canceling…" }
+    if model.isBrowserlessTarget && model.isSyncing { return "Cancel upload" }
+    if model.isSyncing { return "Syncing…" }
     if model.codexBlocked { return "Close Codex first" }
     if model.isBrowserlessTarget && !model.browserlessConfigured { return "Connect Browserless" }
     if model.isBrowserlessTarget && model.selectedSourceID == "comet" { return "Choose another browser" }
@@ -345,6 +394,7 @@ struct SyncPanel: View {
   }
 
   private var syncButtonIcon: String {
+    if model.isBrowserlessTarget && model.isSyncing { return "xmark.circle.fill" }
     if model.syncBlocked { return model.isBrowserlessTarget && !model.browserlessConfigured ? "key.fill" : "xmark.circle.fill" }
     return model.isBrowserlessTarget ? "icloud.and.arrow.up.fill" : "arrow.triangle.2.circlepath"
   }
@@ -499,6 +549,21 @@ struct PreferencesPanel: View {
             }
             .controlSize(.small)
           }
+          RowDivider()
+          PreferenceRow(icon: "externaldrive.badge.magnifyingglass", color: Theme.accent, title: "Local profile preflight", detail: browserlessPreflightDetail) {
+            HStack(spacing: 7) {
+              ProfileSizeBadge(severity: model.browserlessAssessment?.severity, scanning: model.isInspectingBrowserlessProfile)
+              Button {
+                model.refreshBrowserlessPreflight(force: true)
+              } label: {
+                Image(systemName: "arrow.clockwise")
+              }
+              .buttonStyle(.plain)
+              .foregroundStyle(.secondary)
+              .disabled(model.isInspectingBrowserlessProfile || model.isSyncing)
+              .help("Rescan local profile size")
+            }
+          }
         } else {
           PreferenceRow(icon: "network", color: Theme.accent, title: "Cookies", detail: "Site sessions and sign-ins") {
             Toggle("", isOn: Binding(get: { model.cookiesEnabled }, set: { model.setCookiesEnabled($0) }))
@@ -579,6 +644,16 @@ struct PreferencesPanel: View {
       }
     }
   }
+
+  private var browserlessPreflightDetail: String {
+    if model.isInspectingBrowserlessProfile { return "Measuring profile, local storage, and IndexedDB without reading their contents" }
+    if let assessment = model.browserlessAssessment {
+      return assessment.temporarySpaceWarning
+        ? "\(assessment.summary) · free space may be too low for the temporary copy"
+        : assessment.summary
+    }
+    return "Calculated locally before upload; Browserless cloud artifacts are capped at 2 MB"
+  }
 }
 
 struct FixedBadge: View {
@@ -595,6 +670,40 @@ struct FixedBadge: View {
   }
 }
 
+struct ProfileSizeBadge: View {
+  let severity: String?
+  let scanning: Bool
+
+  var body: some View {
+    Text(label)
+      .font(.system(size: 9.5, weight: .semibold))
+      .foregroundStyle(color)
+      .padding(.horizontal, 8).padding(.vertical, 4)
+      .background(color.opacity(0.10), in: Capsule())
+  }
+
+  private var label: String {
+    if scanning { return "Scanning" }
+    switch severity {
+    case "elevated": return "Large"
+    case "high": return "Very large"
+    case "extreme": return "Extreme"
+    case "normal": return "Ready"
+    default: return "Not scanned"
+    }
+  }
+
+  private var color: Color {
+    if scanning { return .secondary }
+    switch severity {
+    case "elevated": return .orange
+    case "high", "extreme": return Theme.active
+    case "normal": return Theme.accent
+    default: return .secondary
+    }
+  }
+}
+
 struct BrowserlessSetupSheet: View {
   @EnvironmentObject private var model: SyncModel
   @Environment(\.dismiss) private var dismiss
@@ -904,11 +1013,11 @@ struct StatusIndicator: View {
   }
 
   private var label: String {
-    switch state { case .ready: "Ready"; case .syncing: "Syncing"; case .success: "Synced"; case .warning: "Partial"; case .error: "Needs action" }
+    switch state { case .ready: "Ready"; case .syncing: "Syncing"; case .success: "Synced"; case .canceled: "Canceled"; case .warning: "Partial"; case .error: "Needs action" }
   }
 
   private var color: Color {
-    switch state { case .ready, .syncing, .success: Theme.accent; case .warning: .orange; case .error: .red }
+    switch state { case .ready, .syncing, .success: Theme.accent; case .canceled: .secondary; case .warning: .orange; case .error: .red }
   }
 }
 

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

@@ -6,6 +6,7 @@ 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 {
@@ -21,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
@@ -31,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"),
@@ -67,6 +93,11 @@ final class SyncModel: ObservableObject {
   @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"
 
@@ -80,6 +111,10 @@ final class SyncModel: ObservableObject {
   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]
@@ -98,6 +133,11 @@ final class SyncModel: ObservableObject {
     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 {
     isBrowserlessTarget ? browserlessIcon : selectedTargetBrowser.map(browserIcon) ?? codexIcon
@@ -141,6 +181,7 @@ final class SyncModel: ObservableObject {
     let calendar = Calendar.current
     scheduleTime = calendar.date(bySettingHour: 9, minute: 0, second: 0, of: Date()) ?? Date()
     updateEndpointRunningStatus()
+    refreshBrowserlessPreflight()
     endpointStatusTimer = Timer.scheduledTimer(withTimeInterval: 2, repeats: true) { [weak self] _ in
       Task { @MainActor in self?.updateEndpointRunningStatus() }
     }
@@ -230,6 +271,7 @@ final class SyncModel: ObservableObject {
       FileManager.default.fileExists(atPath: support.appending(path: "extension-\($0)/manifest.json").path)
     }
     updateEndpointRunningStatus()
+    refreshBrowserlessPreflight()
     consumeUpdateResultIfNeeded()
     if autoCheckUpdates && !didCheckAfterLaunch {
       didCheckAfterLaunch = true
@@ -240,6 +282,8 @@ 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)")
   }
 
@@ -250,6 +294,7 @@ final class SyncModel: ObservableObject {
     persistPreferences(successMessage: "Import destination changed to \(targetName)")
     updateEndpointRunningStatus()
     if id == "browserless" && !browserlessConfigured { showingBrowserlessSetup = true }
+    if id == "browserless" { refreshBrowserlessPreflight() }
   }
 
   func setCookiesEnabled(_ enabled: Bool) {
@@ -277,6 +322,7 @@ final class SyncModel: ObservableObject {
       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)
     }
@@ -387,6 +433,10 @@ 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)
       }
@@ -400,6 +450,7 @@ final class SyncModel: ObservableObject {
       return
     }
     isSyncing = true
+    uploadCanceling = false
     state = .syncing
     primaryStatus = isBrowserlessTarget ? "Uploading authenticated state" : "Transferring selected data"
     secondaryStatus = selectedTargetID == "codex"
@@ -408,7 +459,7 @@ final class SyncModel: ObservableObject {
         ? "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", "300"]
+    var arguments = ["sync", "--timeout", isBrowserlessTarget ? "900" : "300"]
     if isBrowserlessTarget {
       guard let token = BrowserlessCredentialStore.read() else {
         isSyncing = false
@@ -418,15 +469,30 @@ final class SyncModel: ObservableObject {
       }
       environment["BROWSERLESS_TOKEN"] = token
       arguments.append("--allow-cloud-upload")
+      beginUploadTracking()
     }
-    runCLI(arguments, environment: environment) { [weak self] success, output in
+    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.isBrowserlessTarget
-          ? "Browserless profile uploaded"
+          ? (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")
@@ -445,12 +511,40 @@ final class SyncModel: ObservableObject {
         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)
@@ -556,6 +650,7 @@ final class SyncModel: ObservableObject {
         FileManager.default.fileExists(atPath: self.support.appending(path: "extension-\($0)/manifest.json").path)
       }
       self.updateEndpointRunningStatus()
+      self.refreshBrowserlessPreflight()
     }
   }
 
@@ -584,27 +679,48 @@ final class SyncModel: ObservableObject {
     }
   }
 
-  private func runCLI(_ arguments: [String], environment: [String: 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
     }
   }
 
@@ -631,6 +747,69 @@ 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)
   }
@@ -827,3 +1006,27 @@ private enum BrowserlessCredentialStore {
     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 }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-cookie-bridge",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Local-first cookie and session transfer for macOS with optional Browserless upload",
   "type": "module",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "test": "node --test test/*.test.js",
-    "check": "node --check bin/brave-codex-cookie-sync.js && node --check src/app-installer.js && node --check src/browserless.js && node --check src/browserless-runner.js && node --check src/broker.js && node --check src/chromium-reader.js && node --check src/cli.js && node --check src/codex-direct-import.js && node --check src/config.js && node --check src/paths.js && node --check src/scheduler.js && node --check src/updater.js && node --check scripts/build-dmg.js && node --check extension-template/background.js && node --check web/server.js && node --check web/script.js",
+    "check": "node --check bin/brave-codex-cookie-sync.js && node --check src/app-installer.js && node --check src/browserless.js && node --check src/browserless-preflight.js && node --check src/browserless-runner.js && node --check src/broker.js && node --check src/chromium-reader.js && node --check src/cli.js && node --check src/codex-direct-import.js && node --check src/config.js && node --check src/paths.js && node --check src/scheduler.js && node --check src/updater.js && node --check scripts/build-dmg.js && node --check extension-template/background.js && node --check web/server.js && node --check web/script.js",
     "release:check": "node scripts/check-release-version.js",
     "build:app": "node bin/brave-codex-cookie-sync.js install-app --no-open",
     "build:dmg": "node scripts/build-dmg.js",

package/src/browserless-preflight.js

@@ -0,0 +1,113 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const BROWSERLESS_SERVER_ARTIFACT_CAP_BYTES = 2 * 1024 * 1024;
+
+const MEBIBYTE = 1024 * 1024;
+const GIBIBYTE = 1024 * MEBIBYTE;
+
+export function inspectBrowserlessProfile({ profilePath } = {}) {
+  if (!profilePath || !fs.existsSync(profilePath)) {
+    throw new Error("The local browser profile could not be inspected.");
+  }
+
+  const profileBytes = directorySize(profilePath);
+  const indexedDBBytes = directorySize(path.join(profilePath, "IndexedDB"));
+  const localStorageBytes = directorySize(path.join(profilePath, "Local Storage"));
+  const freeBytes = availableBytes(profilePath);
+  const severity = sizeSeverity(indexedDBBytes);
+  const temporarySpaceWarning = Number.isFinite(freeBytes) && freeBytes < profileBytes + 256 * MEBIBYTE;
+
+  return {
+    profilePath,
+    profileBytes,
+    indexedDBBytes,
+    localStorageBytes,
+    freeBytes,
+    severity,
+    temporarySpaceWarning,
+    serverArtifactCapBytes: BROWSERLESS_SERVER_ARTIFACT_CAP_BYTES,
+    summary: profileSummary({
+      profileBytes,
+      indexedDBBytes,
+      localStorageBytes,
+      freeBytes,
+      severity,
+      temporarySpaceWarning,
+    }),
+  };
+}
+
+export function sizeSeverity(indexedDBBytes) {
+  if (indexedDBBytes >= GIBIBYTE) return "extreme";
+  if (indexedDBBytes >= 500 * MEBIBYTE) return "high";
+  if (indexedDBBytes >= 100 * MEBIBYTE) return "elevated";
+  return "normal";
+}
+
+export function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) return "unknown";
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let unit = -1;
+  do {
+    value /= 1024;
+    unit += 1;
+  } while (value >= 1024 && unit < units.length - 1);
+  const digits = value >= 100 ? 0 : value >= 10 ? 1 : 2;
+  return `${value.toFixed(digits)} ${units[unit]}`;
+}
+
+function directorySize(root) {
+  try {
+    if (fs.lstatSync(root).isSymbolicLink()) return 0;
+  } catch {
+    return 0;
+  }
+  let total = 0;
+  const pending = [root];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const candidate = path.join(current, entry.name);
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) {
+        pending.push(candidate);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      try {
+        total += fs.statSync(candidate).size;
+      } catch {}
+    }
+  }
+  return total;
+}
+
+function availableBytes(candidate) {
+  try {
+    const statistics = fs.statfsSync(candidate);
+    return Number(statistics.bavail) * Number(statistics.bsize);
+  } catch {
+    return Number.NaN;
+  }
+}
+
+function profileSummary({ profileBytes, indexedDBBytes, localStorageBytes, freeBytes, severity, temporarySpaceWarning }) {
+  const parts = [
+    `${formatBytes(profileBytes)} profile`,
+    `${formatBytes(indexedDBBytes)} IndexedDB`,
+    `${formatBytes(localStorageBytes)} local storage`,
+  ];
+  if (Number.isFinite(freeBytes)) parts.push(`${formatBytes(freeBytes)} free`);
+  if (temporarySpaceWarning) parts.push("low temporary disk space");
+  else if (severity !== "normal") parts.push(`${severity} IndexedDB load`);
+  return parts.join(" · ");
+}

package/src/browserless.js

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { projectRoot } from "./paths.js";
@@ -13,7 +15,10 @@ export async function uploadBrowserlessProfile({
   onlyDomains = [],
   token = process.env.BROWSERLESS_TOKEN,
   root = projectRoot(),
-  runner = runCLI,
+  runner = runBrowserlessCLI,
+  signal,
+  timeoutMs = 15 * 60 * 1000,
+  onProgress = () => {},
 } = {}) {
   if (!SUPPORTED_SOURCES.has(browser)) {
     throw new Error(`${browser === "comet" ? "Comet" : browser} is not supported by Browserless profile capture yet.`);
@@ -34,7 +39,15 @@ export async function uploadBrowserlessProfile({
     DO_NOT_TRACK: "1",
   };
   const client = ["--region", region, "--json"];
-  const shown = await runner(cliPath, ["profile", "show", profileName.trim(), ...client], environment, runnerPath);
+  onProgress({ phase: "validating", fraction: 0.10, detail: "Checking the destination profile…" });
+  const shown = await runner(
+    cliPath,
+    ["profile", "show", profileName.trim(), ...client],
+    environment,
+    runnerPath,
+    { signal, timeoutMs: Math.min(timeoutMs, 60_000) },
+  );
+  throwForInterruptedRun(shown, timeoutMs);
   const operation = shown.status === 0 ? "refresh" : isMissingProfile(shown.output) ? "upload" : null;
   if (!operation) throw new Error(lastLine(shown.output) || "Browserless could not validate the cloud profile.");
 
@@ -48,8 +61,28 @@ export async function uploadBrowserlessProfile({
     "--auto-fit",
   ];
   for (const domain of onlyDomains) capture.push("--only-domain", domain);
-  const result = await runner(cliPath, capture, environment, runnerPath);
-  if (result.status !== 0) throw new Error(lastLine(result.output) || "Browserless profile upload failed.");
+  const parseProgress = progressParser(onProgress);
+  const result = await runner(cliPath, capture, environment, runnerPath, {
+    signal,
+    timeoutMs,
+    onOutput: parseProgress,
+  });
+  parseProgress("\n");
+  throwForInterruptedRun(result, timeoutMs);
+  if (result.status !== 0) throw new Error(actionableFailure(result.output));
+
+  onProgress({ phase: "verifying", fraction: 0.97, detail: "Verifying the cloud profile…" });
+  const verified = await runner(
+    cliPath,
+    ["profile", "show", profileName.trim(), ...client],
+    environment,
+    runnerPath,
+    { signal, timeoutMs: Math.min(timeoutMs, 60_000) },
+  );
+  throwForInterruptedRun(verified, timeoutMs);
+  if (verified.status !== 0) {
+    throw new Error(`The upload finished, but Browserless could not verify the cloud profile: ${lastLine(verified.output) || "profile lookup failed"}`);
+  }
 
   const details = parseJSON(result.output);
   const cookies = details?.cookieCount;
@@ -59,28 +92,126 @@ export async function uploadBrowserlessProfile({
     : "";
   return {
     operation,
+    verified: true,
     profileName: details?.name || profileName.trim(),
     cookieCount: cookies,
     originCount: origins,
-    summary: `Browserless profile ${operation === "refresh" ? "updated" : "created"}: ${details?.name || profileName.trim()}${counts}`,
+    droppedOriginCount: droppedOrigins(result.output),
+    failedOriginCount: failedOrigins(result.output),
+    summary: uploadSummary({ operation, details, fallbackName: profileName.trim(), counts, output: result.output }),
   };
 }
 
-function runCLI(cliPath, args, environment, runnerPath) {
+export function runBrowserlessCLI(cliPath, args, environment, runnerPath, {
+  signal,
+  timeoutMs = 15 * 60 * 1000,
+  onOutput = () => {},
+} = {}) {
   return new Promise((resolve, reject) => {
+    const temporaryRoot = fs.mkdtempSync(path.join(os.tmpdir(), "browser-cookie-bridge-browserless-"));
+    fs.chmodSync(temporaryRoot, 0o700);
     const child = spawn(process.execPath, [runnerPath, cliPath, ...args], {
-      env: environment,
+      env: { ...environment, TMPDIR: temporaryRoot },
       stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
     });
     let stdout = "";
     let stderr = "";
-    child.stdout.on("data", (chunk) => { stdout += chunk; });
-    child.stderr.on("data", (chunk) => { stderr += chunk; });
-    child.on("error", reject);
-    child.on("close", (status) => resolve({ status: status ?? 1, output: `${stderr}${stdout}` }));
+    let interruption = null;
+    let settled = false;
+    const append = (target, chunk) => {
+      const text = String(chunk);
+      if (target === "stdout") stdout += text;
+      else stderr += text;
+      onOutput(text);
+    };
+    const terminate = (reason) => {
+      if (settled || interruption) return;
+      interruption = reason;
+      try {
+        if (process.platform !== "win32" && child.pid) process.kill(-child.pid, "SIGTERM");
+        else child.kill("SIGTERM");
+      } catch {}
+      setTimeout(() => {
+        if (child.exitCode !== null || child.signalCode !== null) return;
+        try {
+          if (process.platform !== "win32" && child.pid) process.kill(-child.pid, "SIGKILL");
+          else child.kill("SIGKILL");
+        } catch {}
+      }, 2_000).unref();
+    };
+    const abort = () => terminate("canceled");
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    const timer = setTimeout(() => terminate("timedOut"), timeoutMs);
+    timer.unref();
+    child.stdout.on("data", (chunk) => append("stdout", chunk));
+    child.stderr.on("data", (chunk) => append("stderr", chunk));
+    child.on("error", (error) => {
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      fs.rmSync(temporaryRoot, { recursive: true, force: true });
+      reject(error);
+    });
+    child.on("close", (status) => {
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      fs.rmSync(temporaryRoot, { recursive: true, force: true });
+      resolve({
+        status: interruption === "canceled" ? 130 : interruption === "timedOut" ? 124 : (status ?? 1),
+        output: `${stderr}${stdout}`,
+        canceled: interruption === "canceled",
+        timedOut: interruption === "timedOut",
+      });
+    });
   });
 }
 
+export function progressParser(onProgress) {
+  let pending = "";
+  let lastPhase = "";
+  return (chunk) => {
+    pending += chunk;
+    const lines = pending.split(/\r\n|\n|\r/);
+    pending = lines.pop() ?? "";
+    for (const raw of lines) {
+      const line = raw.trim();
+      let progress = null;
+      if (/copying profile data/i.test(line)) {
+        progress = { phase: "copying", fraction: 0.18, detail: "Copying profile data into an isolated workspace…" };
+      } else if (/launching headless browser/i.test(line)) {
+        progress = { phase: "launching", fraction: 0.30, detail: "Launching the temporary browser…" };
+      } else if (/waiting for browser to be ready/i.test(line)) {
+        progress = { phase: "waiting", fraction: 0.38, detail: "Waiting for the temporary browser…" };
+      } else if (/capturing per-origin storage/i.test(line)) {
+        progress = { phase: "capturing", fraction: 0.42, detail: "Capturing cookies, local storage, and IndexedDB…" };
+      } else if (/^\d+\/\d+\s+/.test(line)) {
+        const match = line.match(/^(\d+)\/(\d+)\s+(.+)$/);
+        if (match) {
+          const current = Number(match[1]);
+          const total = Number(match[2]);
+          progress = {
+            phase: "capturing",
+            fraction: total > 0 ? 0.42 + 0.42 * Math.min(current / total, 1) : 0.42,
+            current,
+            total,
+            detail: `Capturing ${match[3]}`,
+          };
+        }
+      } else if (/uploading to browserless/i.test(line)) {
+        progress = { phase: "uploading", fraction: 0.90, detail: "Uploading the fitted authenticated profile…" };
+      }
+      if (!progress) continue;
+      const identity = `${progress.phase}:${progress.current ?? ""}:${progress.total ?? ""}:${progress.detail}`;
+      if (identity === lastPhase) continue;
+      lastPhase = identity;
+      onProgress(progress);
+    }
+  };
+}
+
 function isMissingProfile(output) {
   return /(?:not found|does not exist|404)/i.test(output);
 }
@@ -106,3 +237,45 @@ function parseJSON(output) {
 function lastLine(output) {
   return output.split("\n").map((line) => line.trim()).filter(Boolean).at(-1)?.replace(/^Error:\s*/, "");
 }
+
+function throwForInterruptedRun(result, timeoutMs) {
+  if (result?.canceled || result?.status === 130) {
+    throw new Error("Browserless upload canceled. Temporary profile data was removed.");
+  }
+  if (result?.timedOut || result?.status === 124) {
+    const minutes = Math.max(1, Math.round(timeoutMs / 60_000));
+    throw new Error(`Browserless upload timed out after ${minutes} minute${minutes === 1 ? "" : "s"}. Check the connection, close the source browser, and try again with a smaller domain allowlist.`);
+  }
+}
+
+function droppedOrigins(output) {
+  return Number(output.match(/--auto-fit:\s*dropped\s+(\d+)\s+origin/i)?.[1] || 0);
+}
+
+function failedOrigins(output) {
+  return Number(output.match(/!\s+(\d+)\s+origin\(s\) failed to capture/i)?.[1] || 0);
+}
+
+function uploadSummary({ operation, details, fallbackName, counts, output }) {
+  const dropped = droppedOrigins(output);
+  const failed = failedOrigins(output);
+  const warnings = [];
+  if (dropped > 0) warnings.push(`${dropped} heavy origin${dropped === 1 ? "" : "s"} omitted to fit Browserless's 2 MB cap`);
+  if (failed > 0) warnings.push(`${failed} origin${failed === 1 ? "" : "s"} could not be captured`);
+  const warning = warnings.length > 0 ? `; ${warnings.join("; ")}` : "";
+  return `Browserless profile ${operation === "refresh" ? "updated" : "created"} and verified: ${details?.name || fallbackName}${counts}${warning}`;
+}
+
+function actionableFailure(output) {
+  const detail = lastLine(output) || "Browserless profile upload failed.";
+  if (/(?:failed to reach|enotfound|econnreset|econnrefused|network|socket hang up|fetch failed)/i.test(output)) {
+    return `Browserless could not be reached. Check your internet connection and region, then try again. ${detail}`;
+  }
+  if (/(?:profile busy|singletonlock|browser.*running|source browser must be closed)/i.test(output)) {
+    return `The source browser is still using this profile. Quit it completely, wait a few seconds, and try again. ${detail}`;
+  }
+  if (/(?:2 MB|too large|artifact.*cap|payload.*large)/i.test(output)) {
+    return `The captured state could not fit Browserless's 2 MB profile cap. Add a domain allowlist for the sites you need, then try again. ${detail}`;
+  }
+  return detail;
+}

package/src/cli.js

@@ -10,6 +10,7 @@ import {
 } from "./codex-direct-import.js";
 import { readChromiumProfile } from "./chromium-reader.js";
 import { uploadBrowserlessProfile } from "./browserless.js";
+import { inspectBrowserlessProfile } from "./browserless-preflight.js";
 import { installConfig, installRuntime, readConfig, updatePreferences } from "./config.js";
 import {
   braveCookiePaths,
@@ -46,6 +47,7 @@ Commands:
   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] [--allow-cloud-upload]
+  browserless-preflight
   doctor
   enable-login-sync
   disable-login-sync
@@ -55,13 +57,15 @@ Commands:
   help
 `;
 
-export async function main(argv) {
+export async function main(argv, { signal } = {}) {
   const [command = "help", ...args] = argv;
   switch (command) {
     case "setup":
       return setup(args);
     case "sync":
-      return sync(args);
+      return sync(args, { signal });
+    case "browserless-preflight":
+      return browserlessPreflight();
     case "install-app":
       return installDesktopApp(args);
     case "bootstrap-bundled":
@@ -259,11 +263,11 @@ function setup(args) {
     : "Cookie values are transferred in memory and are not written to logs or disk.");
 }
 
-async function sync(args) {
+async function sync(args, { signal } = {}) {
   assertMacOS();
-  const seconds = integerFlag(args, "--timeout", 300, 5, 3600);
   const config = readConfig();
   const target = config.targetBrowser || "codex";
+  const seconds = integerFlag(args, "--timeout", target === "browserless" ? 900 : 300, 5, 3600);
   const isCodexTarget = target === "codex";
   if (target === "browserless") {
     if (!args.includes("--allow-cloud-upload")) {
@@ -271,6 +275,15 @@ async function sync(args) {
     }
     const source = config.sourceBrowser || "brave";
     const local = readChromiumProfile({ browser: source, imports: { cookies: false, history: false } });
+    emitBrowserlessProgress({ phase: "preflight", fraction: 0.03, detail: "Inspecting the local profile…" });
+    const assessment = inspectBrowserlessProfile({ profilePath: local.profilePath });
+    emitBrowserlessProgress({
+      phase: "preflight-complete",
+      fraction: 0.06,
+      detail: assessment.summary,
+      assessment,
+    });
+    console.log(`Profile preflight: ${assessment.summary}`);
     console.log(`Preparing ${source} profile ${local.profileName} for an explicit Browserless cloud upload…`);
     const result = await uploadBrowserlessProfile({
       browser: source,
@@ -278,7 +291,11 @@ async function sync(args) {
       profileName: config.browserless?.profileName || "browser-cookie-bridge",
       region: config.browserless?.region || "sfo",
       onlyDomains: config.browserless?.onlyDomains || [],
+      timeoutMs: seconds * 1000,
+      signal,
+      onProgress: emitBrowserlessProgress,
     });
+    emitBrowserlessProgress({ phase: "complete", fraction: 1, detail: result.summary });
     console.log(result.summary);
     return result;
   }
@@ -322,6 +339,21 @@ async function sync(args) {
   return result;
 }
 
+function browserlessPreflight() {
+  assertMacOS();
+  const config = readConfig();
+  const source = config.sourceBrowser || "brave";
+  if (source === "comet") throw new Error("Comet is not supported by Browserless profile capture yet.");
+  const local = readChromiumProfile({ browser: source, imports: { cookies: false, history: false } });
+  const assessment = inspectBrowserlessProfile({ profilePath: local.profilePath });
+  console.log(JSON.stringify({ browser: source, profileName: local.profileName, ...assessment }));
+  return assessment;
+}
+
+function emitBrowserlessProgress(event) {
+  console.log(`BCB_PROGRESS ${JSON.stringify(event)}`);
+}
+
 export function directCodexSummary(result) {
   const imported = result.imported + result.historyImported;
   const skipped = result.skipped + result.historySkipped;