browser-cookie-bridge 1.2.0 → 1.4.0

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"),
@@ -51,6 +77,7 @@ final class SyncModel: ObservableObject {
   @Published var openAtLogin = false
   @Published var menuBarEnabled = true
   @Published var autoCheckUpdates = true
+  @Published var autoRestartCodex = false
   @Published var isCheckingForUpdates = false
   @Published var isInstallingUpdate = false
   @Published var availableUpdateVersion: String?
@@ -67,6 +94,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 +112,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]
@@ -93,11 +129,16 @@ final class SyncModel: ObservableObject {
   var targetName: String {
     isBrowserlessTarget ? "Browserless Cloud" : selectedTargetBrowser?.name ?? "ChatGPT Codex"
   }
-  var codexBlocked: Bool { selectedTargetID == "codex" && codexRunning }
+  var codexBlocked: Bool { selectedTargetID == "codex" && codexRunning && !autoRestartCodex }
   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 {
     isBrowserlessTarget ? browserlessIcon : selectedTargetBrowser.map(browserIcon) ?? codexIcon
@@ -141,6 +182,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() }
     }
@@ -220,6 +262,7 @@ final class SyncModel: ObservableObject {
       historyEnabled = config.imports?.history ?? false
       menuBarEnabled = config.ui?.menuBar ?? true
       autoCheckUpdates = config.ui?.autoCheckUpdates ?? true
+      autoRestartCodex = config.ui?.autoRestartCodex ?? false
       browserlessProfileName = config.browserless?.profileName ?? "browser-cookie-bridge"
       browserlessRegion = config.browserless?.region ?? "sfo"
       browserlessOnlyDomains = (config.browserless?.onlyDomains ?? []).joined(separator: ", ")
@@ -230,6 +273,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 +284,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 +296,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 +324,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)
     }
@@ -301,6 +349,11 @@ final class SyncModel: ObservableObject {
     if enabled { checkForUpdates() }
   }
 
+  func setAutoRestartCodex(_ enabled: Bool) {
+    autoRestartCodex = enabled
+    persistPreferences(successMessage: enabled ? "Automatic Codex restart enabled" : "Automatic Codex restart disabled")
+  }
+
   func checkForUpdates(showAlert: Bool = false) {
     guard !isCheckingForUpdates, !isInstallingUpdate else { return }
     guard let url = URL(string: "https://api.github.com/repos/apoorvdarshan/browser-cookie-bridge/releases/latest") else { return }
@@ -387,6 +440,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)
       }
@@ -399,7 +456,70 @@ final class SyncModel: ObservableObject {
       }
       return
     }
+    if selectedTargetID == "codex" && codexRunning && autoRestartCodex {
+      forceQuitCodexThenSync(showMenuBarAlert: showMenuBarAlert)
+      return
+    }
+    startSync(showMenuBarAlert: showMenuBarAlert, reopenCodexOnSuccess: false)
+  }
+
+  private func forceQuitCodexThenSync(showMenuBarAlert: Bool) {
+    isSyncing = true
+    uploadCanceling = false
+    state = .syncing
+    primaryStatus = "Closing Codex for sync"
+    secondaryStatus = "Force quitting ChatGPT Codex and waiting for its browser database to close…"
+    let applications = NSWorkspace.shared.runningApplications.filter {
+      $0.bundleIdentifier == "com.openai.codex"
+    }
+    guard !applications.isEmpty, applications.allSatisfy({ $0.forceTerminate() }) else {
+      finishCodexPreparationFailure(
+        message: "macOS could not force quit ChatGPT Codex. Quit it manually, then try again.",
+        showMenuBarAlert: showMenuBarAlert
+      )
+      return
+    }
+    waitForCodexToQuit(attemptsRemaining: 50, showMenuBarAlert: showMenuBarAlert)
+  }
+
+  private func waitForCodexToQuit(attemptsRemaining: Int, showMenuBarAlert: Bool) {
+    let stillRunning = NSWorkspace.shared.runningApplications.contains {
+      $0.bundleIdentifier == "com.openai.codex"
+    }
+    if !stillRunning {
+      codexRunning = false
+      secondaryStatus = "Codex is closed — waiting briefly for its database to be released…"
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) { [weak self] in
+        self?.startSync(showMenuBarAlert: showMenuBarAlert, reopenCodexOnSuccess: true)
+      }
+      return
+    }
+    guard attemptsRemaining > 0 else {
+      finishCodexPreparationFailure(
+        message: "ChatGPT Codex did not close within 10 seconds. Quit it manually, then try again.",
+        showMenuBarAlert: showMenuBarAlert
+      )
+      return
+    }
+    DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) { [weak self] in
+      self?.waitForCodexToQuit(attemptsRemaining: attemptsRemaining - 1, showMenuBarAlert: showMenuBarAlert)
+    }
+  }
+
+  private func finishCodexPreparationFailure(message: String, showMenuBarAlert: Bool) {
+    isSyncing = false
+    state = .error
+    primaryStatus = "Could not close Codex"
+    secondaryStatus = message
+    updateEndpointRunningStatus()
+    if showMenuBarAlert {
+      postNativeAlert(title: primaryStatus, message: secondaryStatus, kind: .error)
+    }
+  }
+
+  private func startSync(showMenuBarAlert: Bool, reopenCodexOnSuccess: Bool) {
     isSyncing = true
+    uploadCanceling = false
     state = .syncing
     primaryStatus = isBrowserlessTarget ? "Uploading authenticated state" : "Transferring selected data"
     secondaryStatus = selectedTargetID == "codex"
@@ -408,7 +528,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 +538,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")
@@ -441,16 +576,88 @@ final class SyncModel: ObservableObject {
           : "Keep both browsers open and check the extensions")
       }
       self.updateEndpointRunningStatus()
-      if showMenuBarAlert {
+      if success && reopenCodexOnSuccess {
+        self.reopenCodexAfterSuccessfulSync(
+          partial: partial,
+          syncSummary: self.secondaryStatus,
+          showMenuBarAlert: showMenuBarAlert
+        )
+      } else if showMenuBarAlert {
         self.postNativeAlert(
           title: self.primaryStatus,
           message: self.secondaryStatus,
-          kind: success ? (partial ? .warning : .information) : .error
+          kind: canceled ? .information : success ? (partial ? .warning : .information) : .error
         )
       }
     }
   }
 
+  private func reopenCodexAfterSuccessfulSync(partial: Bool, syncSummary: String, showMenuBarAlert: Bool) {
+    let transferResult = syncSummary.replacingOccurrences(
+      of: "Reopen Codex to use the updated sessions. ",
+      with: ""
+    )
+    guard let codexURL = NSWorkspace.shared.urlForApplication(withBundleIdentifier: "com.openai.codex") else {
+      state = .warning
+      primaryStatus = "Codex sessions updated, but Codex was not reopened"
+      secondaryStatus = "\(transferResult)\n\nCodex could not be found. Open it manually to use the updated sessions."
+      if showMenuBarAlert {
+        postNativeAlert(title: primaryStatus, message: secondaryStatus, kind: .warning)
+      }
+      return
+    }
+    NSWorkspace.shared.openApplication(at: codexURL, configuration: NSWorkspace.OpenConfiguration()) { [weak self] _, error in
+      Task { @MainActor in
+        guard let self else { return }
+        if let error {
+          self.state = .warning
+          self.primaryStatus = "Codex sessions updated, but Codex was not reopened"
+          self.secondaryStatus = "\(transferResult)\n\nCodex could not be reopened: \(error.localizedDescription)"
+        } else {
+          self.codexRunning = true
+          self.state = partial ? .warning : .success
+          self.primaryStatus = partial ? "Codex sync completed with warnings" : "Codex sessions updated"
+          self.secondaryStatus = "\(transferResult)\n\nChatGPT Codex reopened successfully."
+        }
+        if showMenuBarAlert {
+          self.postNativeAlert(
+            title: self.primaryStatus,
+            message: self.secondaryStatus,
+            kind: self.state == .success ? .information : .warning
+          )
+        }
+      }
+    }
+  }
+
+  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)
@@ -533,6 +740,7 @@ final class SyncModel: ObservableObject {
       "--history", historyEnabled ? "on" : "off",
       "--menu-bar", menuBarEnabled ? "on" : "off",
       "--auto-check-updates", autoCheckUpdates ? "on" : "off",
+      "--auto-restart-codex", autoRestartCodex ? "on" : "off",
       "--browserless-profile", browserlessProfileName,
       "--browserless-region", browserlessRegion,
       "--browserless-domains", browserlessOnlyDomains,
@@ -556,6 +764,7 @@ final class SyncModel: ObservableObject {
         FileManager.default.fileExists(atPath: self.support.appending(path: "extension-\($0)/manifest.json").path)
       }
       self.updateEndpointRunningStatus()
+      self.refreshBrowserlessPreflight()
     }
   }
 
@@ -584,27 +793,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 +861,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)
   }
@@ -648,7 +941,13 @@ final class SyncModel: ObservableObject {
       $0.bundleIdentifier == selectedBrowser.bundleIdentifier
     }
     guard !isSyncing else { return }
-    if selectedTargetID == "codex" && codexRunning {
+    if selectedTargetID == "codex" && codexRunning && autoRestartCodex {
+      if state == .ready || primaryStatus == "Quit Codex before syncing" {
+        state = .ready
+        primaryStatus = "Ready to sync and restart Codex"
+        secondaryStatus = "Sync will force quit Codex and reopen it only after a successful transfer"
+      }
+    } else 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"
@@ -769,6 +1068,7 @@ private struct AppConfig: Decodable {
     let menuBar: Bool?
     let openAtLogin: Bool?
     let autoCheckUpdates: Bool?
+    let autoRestartCodex: Bool?
   }
 
   struct BrowserlessSettings: Decodable {
@@ -827,3 +1127,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.4.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(" · ");
+}