@otakit/capacitor-updater 2.3.2 → 3.0.0

package/ios/Sources/UpdaterPlugin/UpdaterPlugin.swift

@@ -1,5 +1,4 @@
 import Capacitor
-import CryptoKit
 import Foundation
 import UIKit
 
@@ -55,7 +54,9 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
   private var runtimeVersion: String?
   private var manifestKeys: [(kid: String, key: Data)] = []
   private var bundleKeys: [(kid: String, key: Data)] = []
-  private var trialTimeoutWorkItem: DispatchWorkItem?
+  private lazy var updateOwner = UpdateOwner(isAvailable: { [weak self] in self?.bridge?.webView != nil })
+  private let documentReadyBridge = DocumentReadyBridge()
+  private let trialDeadline = ForegroundDeadline()
   private var checkIntervalMs: Int = 600_000
   private var foregroundObserver: NSObjectProtocol?
   private static let defaultIngestURL = "https://ingest.otakit.app/v1"
@@ -65,6 +66,13 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
   private static let defaultRuntimeKey = "__default__"
 
   public override func load() {
+    DeviceEventClient.resume()
+    trialDeadline.observe(
+      center: .default,
+      active: UIApplication.didBecomeActiveNotification,
+      inactive: UIApplication.willResignActiveNotification,
+      initiallyActive: UIApplication.shared.applicationState == .active
+    )
     let envIngestUrl = ProcessInfo.processInfo.environment["OTAKIT_INGEST_URL"]
     let envCdnUrl = ProcessInfo.processInfo.environment["OTAKIT_CDN_URL"]
     ingestUrl = resolveIngestUrl(
@@ -87,22 +95,7 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     appReadyTimeoutMs = max(1000, getConfig().getInt("appReadyTimeout", 10_000))
     checkIntervalMs = getConfig().getInt("checkInterval", 600_000)
 
-    let rawKeysValue = getConfig().getArray("manifestKeys")
-    if let rawKeys = rawKeysValue as? [[String: String]] {
-      manifestKeys = rawKeys.compactMap { entry in
-        guard let kid = entry["kid"],
-              let keyBase64 = entry["key"],
-              let keyData = Data(base64Encoded: keyBase64) else { return nil }
-        return (kid: kid, key: keyData)
-      }
-      if manifestKeys.isEmpty && !rawKeys.isEmpty {
-        print("[OtaKit] ERROR: manifestKeys configured but all entries are invalid. Manifest verification will reject all updates.")
-        manifestKeys = [(kid: "_invalid_", key: Data())]
-      }
-    } else if rawKeysValue != nil {
-      print("[OtaKit] ERROR: manifestKeys has wrong format (expected array of {kid, key}). Manifest verification will reject all updates.")
-      manifestKeys = [(kid: "_invalid_", key: Data())]
-    }
+    manifestKeys = ManifestKeyConfig.parse(getConfig().getConfigJSON())
 
     if manifestKeys.isEmpty && HostedManifestKeys.matchesManagedManifestURL(cdnUrl) {
       manifestKeys = HostedManifestKeys.defaults
@@ -124,40 +117,48 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
       print("[OtaKit] ERROR: bundleKeys has wrong format (expected array of {kid, key}). Encrypted bundles cannot be decrypted.")
     }
 
-    pruneIncompatibleBundles()
-
-    let startup = coordinator.normalizeStartupState(
-      isBundleUsable: isBundleUsable
-    )
-    coordinator.cleanupBundles(startup.cleanupBundleIds)
+    let startup: UpdaterCoordinator.StartupPreparation
+    do {
+      try pruneIncompatibleBundles()
+      startup = try coordinator.normalizeStartupState(isBundleUsable: isBundleUsable)
+    } catch {
+      print("[OtaKit] Cannot persist startup recovery: \(error.localizedDescription)")
+      try? applyServerBasePathSynchronously(nil)
+      return
+    }
+    cleanupInBackground(startup.cleanupBundleIds)
 
     do {
+      if let trial = startup.trial { try installReadinessBridge(for: trial) }
       try applyServerBasePathSynchronously(startup.activationPath)
     } catch {
       print("[OtaKit] startup activation failed: \(error.localizedDescription)")
+      if let trial = startup.trial {
+        rollbackCurrentBundle(expectedTrial: trial, reason: "activation_failed", shouldReload: true)
+        return
+      }
     }
 
     if let eventPayload = startup.eventPayload {
       sendDeviceEvent(eventPayload)
     }
 
-    if let trialBundleId = startup.trialBundleId {
-      scheduleTrialTimeout(for: trialBundleId)
+    if let trial = startup.trial {
+      scheduleTrialTimeout(for: trial)
     } else {
       cancelTrialTimeout()
     }
 
     dispatchColdStart()
 
-    if resumePolicy != .off {
-      foregroundObserver = NotificationCenter.default.addObserver(
+    foregroundObserver = NotificationCenter.default.addObserver(
         forName: UIApplication.willEnterForegroundNotification,
         object: nil,
         queue: .main
       ) { [weak self] _ in
-        self?.handleAppWillEnterForeground()
+        DeviceEventClient.resume()
+        if self?.resumePolicy != .off { self?.handleAppWillEnterForeground() }
       }
-    }
   }
 
   deinit {
@@ -322,7 +323,10 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     Task {
       defer { coordinator.endOperation() }
       do {
+        try ensureOwnerActive()
         try await operation()
+      } catch is CancellationError {
+        // The owning bridge went away; this is not a failed update attempt.
       } catch {
         print("[OtaKit] \(label) failed: \(error.localizedDescription)")
       }
@@ -445,17 +449,23 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
   }
 
   @objc func notifyAppReady(_ call: CAPPluginCall) {
-    cancelTrialTimeout()
-    let preparation = coordinator.prepareNotifyAppReady()
-    coordinator.cleanupBundles(preparation.cleanupBundleIds)
-    if let eventPayload = preparation.eventPayload {
-      sendDeviceEvent(eventPayload)
-      // eventPayload is non-nil only on a genuine trial -> success transition,
-      // so repeat notifyAppReady() calls never double-emit.
-      emitEvent("updateApplied", ["bundle": store.getCurrentBundle().toDictionary()])
+    DispatchQueue.main.async { [weak self] in
+      guard let self else { call.reject("Updater is unavailable"); return }
+      do {
+        let preparation = try self.updateOwner.run {
+          try self.coordinator.prepareNotifyAppReady(activationId: call.getString("_otakitActivationId"))
+        }
+        self.cleanupInBackground(preparation.cleanupBundleIds)
+        if let eventPayload = preparation.eventPayload {
+          self.cancelTrialTimeout()
+          self.sendDeviceEvent(eventPayload)
+          self.emitEvent("updateApplied", ["bundle": self.store.getCurrentBundle().toDictionary()])
+        }
+        call.resolve()
+      } catch {
+        call.reject("Could not persist update readiness: \(error.localizedDescription)")
+      }
     }
-
-    call.resolve()
   }
 
   @objc func getLastFailure(_ call: CAPPluginCall) {
@@ -519,22 +529,27 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
       throw NSError(domain: "OtaKit", code: 1, userInfo: [NSLocalizedDescriptionKey: "Missing appId in plugin config"])
     }
 
-    return try await ManifestClient.fetchLatest(
-      cdnUrl: cdnUrl,
-      appId: appId,
-      channel: channel,
-      runtimeVersion: runtimeVersion,
-      allowInsecureUrls: allowInsecureUrls,
-      manifestKeys: manifestKeys.map {
-        ManifestKey(kid: $0.kid, derData: $0.key)
-      }
-    )
+    let checkId = "check-\(UUID().uuidString)"
+    return try await CheckFailure.observe({
+      let latest = try await ManifestClient.fetchLatest(
+        cdnUrl: self.cdnUrl, appId: appId, channel: channel,
+        runtimeVersion: self.runtimeVersion, allowInsecureUrls: self.allowInsecureUrls,
+        manifestKeys: self.manifestKeys.map { ManifestKey(kid: $0.kid, derData: $0.key) }
+      )
+      try self.ensureOwnerActive()
+      return latest
+    }, report: { failure in
+      try self.ensureOwnerActive()
+      self.sendDeviceEvent(action: .checkError, runtimeVersion: self.runtimeVersion, channel: channel,
+        detail: failure.detail, attemptId: checkId, phase: failure.phase)
+    })
   }
 
   private func checkLatest(
     respectInterval: Bool,
     channel: String?
   ) async throws -> CheckResolution {
+    try ensureOwnerActive()
     let targetChannel = resolveTargetChannel(channel)
     if respectInterval, shouldSkipCheckInterval() {
       print("[OtaKit] Skipping resume check: checkInterval has not elapsed")
@@ -579,7 +594,7 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
           targetChannel: targetChannel
         )
         return .staged(bundle, forceImmediate: manifest.forceImmediate)
-      } catch let error as NSError where isExpiredURLError(error) {
+      } catch where DownloadRetry.isExpiredURLFailure(error) {
         guard let refreshed = try await fetchLatest(channel: targetChannel) else {
           return .noUpdate
         }
@@ -605,6 +620,10 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     targetChannel: String?
   ) throws -> CheckResolution {
     guard isCompatibleRuntime(manifest.runtimeVersion) else {
+      try ensureOwnerActive()
+      sendDeviceEvent(action: .checkError, bundleVersion: manifest.version, runtimeVersion: runtimeVersion,
+        channel: targetChannel, releaseId: manifest.releaseId, detail: "runtime_mismatch",
+        attemptId: "check-\(UUID().uuidString)", phase: "check")
       throw NSError(
         domain: "OtaKit",
         code: 1,
@@ -664,15 +683,6 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     return false
   }
 
-  private func isExpiredURLError(_ error: NSError) -> Bool {
-    // HTTP 403 or 410 typically indicates an expired presigned URL
-    if error.domain == "Downloader" && (error.code == 403 || error.code == 410) {
-      return true
-    }
-    let desc = error.localizedDescription.lowercased()
-    return desc.contains("403") || desc.contains("410")
-  }
-
   private func downloadAndStage(
     url: URL,
     version: String,
@@ -683,6 +693,9 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     releaseId: String? = nil,
     encryption: ManifestEncryption? = nil
   ) async throws -> BundleInfo {
+    try ensureOwnerActive()
+    let installationId = BundleStore.newInstallationId()
+    var phase = "admission"
     // Check disk space before downloading
     if let size = expectedSize {
       // zip + extracted + buffer; encrypted bundles keep an extra decrypted
@@ -702,7 +715,7 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
           runtimeVersion: runtimeVersion,
           channel: channel,
           releaseId: releaseId,
-          detail: "insufficient_disk_space"
+          detail: "insufficient_disk_space", attemptId: installationId, phase: phase
         )
         emitEvent(
           "downloadFailed",
@@ -718,19 +731,21 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
       }
     }
 
+    phase = "transfer"
     let zipURL: URL
     do {
       zipURL = try await downloader.download(from: url)
     } catch {
       // Network failures must report like every other download-path failure
       // (Android's downloadZip already sits inside its try block).
+      if error is CancellationError { throw error }
       sendDeviceEvent(
         action: .downloadError,
         bundleVersion: version,
         runtimeVersion: runtimeVersion,
         channel: channel,
         releaseId: releaseId,
-        detail: error.localizedDescription
+        detail: error.localizedDescription, attemptId: installationId, phase: phase
       )
       emitEvent(
         "downloadFailed",
@@ -750,6 +765,7 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     let decryptedZipURL = fileManager.temporaryDirectory
       .appendingPathComponent("otakit-decrypted-\(UUID().uuidString).zip")
     defer {
+      coordinator.cleanupBundles([installationId])
       try? fileManager.removeItem(at: zipURL)
       try? fileManager.removeItem(at: decryptedZipURL)
       try? fileManager.removeItem(at: extractDirectory)
@@ -758,20 +774,17 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     do {
       // The manifest sha256 covers the downloaded object as-is — the
       // ciphertext when the bundle is encrypted.
-      let valid = try HashUtils.verify(
+      try ensureOwnerActive()
+      phase = "integrity"
+      try HashUtils.verifyDownload(
         fileURL: zipURL,
-        expectedSha256: expectedSha256
+        expectedSha256: expectedSha256,
+        expectedBytes: expectedSize.flatMap { $0 > 0 ? $0 : nil }, kind: "bundle"
       )
-      guard valid else {
-        throw NSError(
-          domain: "OtaKit",
-          code: 1,
-          userInfo: [NSLocalizedDescriptionKey: "Downloaded bundle hash mismatch"]
-        )
-      }
 
       var zipToExtract = zipURL
       if let encryption {
+        phase = "decrypt"
         guard let bundleKey = bundleKeys.first(where: { $0.kid == encryption.kid }) else {
           throw BundleCryptoError.noMatchingKey(encryption.kid)
         }
@@ -789,19 +802,15 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         zipToExtract = decryptedZipURL
       }
 
+      phase = "extract"
       try zipUtils.extractSecurely(zipURL: zipToExtract, to: extractDirectory)
       let bundleRoot = try resolveBundleRoot(extractedDirectory: extractDirectory)
 
-      let bundleId = buildBundleId(
-        version: version,
-        releaseId: releaseId,
-        sha256: expectedSha256
-      )
+      phase = "install"
+      let bundleId = installationId
       let destination = coordinator.bundleDirectory(for: bundleId)
 
-      if fileManager.fileExists(atPath: destination.path) {
-        try fileManager.removeItem(at: destination)
-      }
+      // moveItem fails if the destination exists; never replace an installation.
 
       if bundleRoot.path != destination.path {
         try fileManager.moveItem(at: bundleRoot, to: destination)
@@ -819,7 +828,8 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         releaseId: releaseId
       )
 
-      let cleanupBundleIds = try coordinator.stageDownloadedBundle(info)
+      phase = "stage"
+      let cleanupBundleIds = try stageOwnedBundle(info)
       coordinator.cleanupBundles(cleanupBundleIds)
 
       sendDeviceEvent(
@@ -827,18 +837,19 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         bundleVersion: version,
         runtimeVersion: runtimeVersion,
         channel: channel,
-        releaseId: releaseId
+        releaseId: releaseId, attemptId: installationId, phase: phase
       )
       emitEvent("updateStaged", ["bundle": info.toDictionary()])
       return info
     } catch {
+      if error is CancellationError { throw error }
       sendDeviceEvent(
         action: .downloadError,
         bundleVersion: version,
         runtimeVersion: runtimeVersion,
         channel: channel,
         releaseId: releaseId,
-        detail: error.localizedDescription
+        detail: error.localizedDescription, attemptId: installationId, phase: phase
       )
       emitEvent(
         "downloadFailed",
@@ -882,25 +893,59 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
 
   @discardableResult
   private func applyStaged(reloadAfterApply: Bool) throws -> Bool {
-    let preparation = coordinator.prepareApplyStaged(
+    try runOnMainSynchronously { [self] in
+      try updateOwner.run { try applyStagedOnMain(reloadAfterApply: reloadAfterApply) }
+    }
+  }
+
+  private func stageOwnedBundle(_ bundle: BundleInfo) throws -> [String] {
+    try runOnMainSynchronously { [self] in
+      try updateOwner.run { try coordinator.stageDownloadedBundle(bundle) }
+    }
+  }
+
+  private func ensureOwnerActive() throws {
+    try runOnMainSynchronously { [self] in try updateOwner.run {} }
+  }
+
+  private func cleanupInBackground(_ ids: [String]) {
+    guard !ids.isEmpty else { return }
+    let coordinator = self.coordinator
+    DispatchQueue.global(qos: .utility).async { coordinator.cleanupBundles(ids) }
+  }
+
+  private func installReadinessBridge(for trial: UpdaterCoordinator.Trial) throws {
+    guard let webView = bridge?.webView else {
+      throw NSError(domain: "OtaKit", code: 1, userInfo: [NSLocalizedDescriptionKey: "WebView unavailable"])
+    }
+    try documentReadyBridge.install(on: webView, activationId: trial.activationId)
+  }
+
+  private func applyStagedOnMain(reloadAfterApply: Bool) throws -> Bool {
+    let preparation = try coordinator.prepareApplyStaged(
       isCompatibleRuntime: isCompatibleRuntime,
       isBundleUsable: isBundleUsable
     )
-    coordinator.cleanupBundles(preparation.cleanupBundleIds)
+    cleanupInBackground(preparation.cleanupBundleIds)
 
     guard let activationPath = preparation.activationPath else {
       return false
     }
 
-    try applyServerBasePathSynchronously(activationPath)
-
-    if reloadAfterApply {
-      try reloadWebViewSynchronously()
+    do {
+      if let trial = preparation.trial { try installReadinessBridge(for: trial) }
+      try applyServerBasePathSynchronously(activationPath)
+      if reloadAfterApply { try reloadWebViewSynchronously() }
+    } catch {
+      if let trial = preparation.trial {
+        rollbackCurrentBundle(expectedTrial: trial, reason: "activation_failed", shouldReload: true)
+      }
+      throw error
     }
 
     cancelTrialTimeout()
-    if let trialBundleId = preparation.trialBundleId {
-      scheduleTrialTimeout(for: trialBundleId)
+    if let trial = preparation.trial {
+      scheduleTrialTimeout(for: trial)
     }
 
     return true
@@ -916,41 +961,38 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     }
   }
 
-  private func scheduleTrialTimeout(for bundleId: String) {
-    cancelTrialTimeout()
-
-    let workItem = DispatchWorkItem { [weak self] in
-      guard let self else {
-        return
-      }
-      if self.coordinator.isCurrentTrialBundle(bundleId) {
-        self.rollbackCurrentBundle(reason: "notify_timeout", shouldReload: true)
-      }
+  private func scheduleTrialTimeout(for trial: UpdaterCoordinator.Trial) {
+    trialDeadline.start(timeout: Double(appReadyTimeoutMs) / 1000) { [weak self] in
+      self?.rollbackCurrentBundle(expectedTrial: trial, reason: "notify_timeout", shouldReload: true)
     }
-    trialTimeoutWorkItem = workItem
-
-    DispatchQueue.main.asyncAfter(
-      deadline: .now() + .milliseconds(appReadyTimeoutMs),
-      execute: workItem
-    )
   }
 
-  private func cancelTrialTimeout() {
-    trialTimeoutWorkItem?.cancel()
-    trialTimeoutWorkItem = nil
-  }
+  private func cancelTrialTimeout() { trialDeadline.cancel() }
 
-  private func rollbackCurrentBundle(reason: String, shouldReload: Bool) {
-    cancelTrialTimeout()
-    let preparation = coordinator.prepareRollback(
-      reason: reason,
-      isBundleUsable: isBundleUsable
-    )
+  private func rollbackCurrentBundle(
+    expectedTrial: UpdaterCoordinator.Trial, reason: String, shouldReload: Bool
+  ) {
+    let preparation: UpdaterCoordinator.RollbackPreparation
+    do {
+      preparation = try updateOwner.run {
+        try coordinator.prepareRollback(
+          expectedTrial: expectedTrial, reason: reason, isBundleUsable: isBundleUsable
+        )
+      }
+    } catch is CancellationError {
+      cancelTrialTimeout()
+      return
+    } catch {
+      print("[OtaKit] Cannot persist rollback: \(error.localizedDescription)")
+      scheduleTrialTimeout(for: expectedTrial)
+      return
+    }
     guard preparation.didRollback else {
       return
     }
+    cancelTrialTimeout()
 
-    coordinator.cleanupBundles(preparation.cleanupBundleIds)
+    cleanupInBackground(preparation.cleanupBundleIds)
     if let eventPayload = preparation.eventPayload {
       sendDeviceEvent(eventPayload)
       emitEvent(
@@ -1008,31 +1050,9 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     }
   }
 
-  private func runOnMainSynchronously(_ work: @escaping () throws -> Void) throws {
-    if Thread.isMainThread {
-      try work()
-      return
-    }
-
-    let semaphore = DispatchSemaphore(value: 0)
-    final class FailureBox {
-      var error: Error?
-    }
-    let failure = FailureBox()
-
-    DispatchQueue.main.async {
-      defer { semaphore.signal() }
-      do {
-        try work()
-      } catch {
-        failure.error = error
-      }
-    }
-
-    semaphore.wait()
-    if let error = failure.error {
-      throw error
-    }
+  private func runOnMainSynchronously<T>(_ work: () throws -> T) rethrows -> T {
+    if Thread.isMainThread { return try work() }
+    return try DispatchQueue.main.sync(execute: work)
   }
 
   private func manifestToDictionary(
@@ -1091,6 +1111,9 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     manifest: LatestManifest,
     targetChannel: String?
   ) async throws -> BundleInfo {
+    try ensureOwnerActive()
+    let installationId = BundleStore.newInstallationId()
+    var phase = "admission"
     // Same conservative disk-space guard as the zip path.
     let requiredSpace = Int64(Double(manifest.size) * 2.5)
     if getFreeDiskSpace() < requiredSpace {
@@ -1100,7 +1123,7 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         runtimeVersion: manifest.runtimeVersion,
         channel: targetChannel,
         releaseId: manifest.releaseId,
-        detail: "insufficient_disk_space"
+        detail: "insufficient_disk_space", attemptId: installationId, phase: phase
       )
       emitEvent(
         "downloadFailed",
@@ -1122,10 +1145,12 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     let assembleDirectory = fileManager.temporaryDirectory
       .appendingPathComponent("otakit-assemble-\(UUID().uuidString)", isDirectory: true)
     defer {
+      coordinator.cleanupBundles([installationId])
       try? fileManager.removeItem(at: assembleDirectory)
     }
 
     do {
+      phase = "delta"
       guard let files = manifest.files, !files.isEmpty else {
         throw NSError(
           domain: "OtaKit",
@@ -1150,15 +1175,10 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
 
       try await assembler.assemble(entries: files, into: assembleDirectory)
 
-      let bundleId = buildBundleId(
-        version: manifest.version,
-        releaseId: manifest.releaseId,
-        sha256: manifest.sha256
-      )
+      phase = "install"
+      let bundleId = installationId
       let destination = coordinator.bundleDirectory(for: bundleId)
-      if fileManager.fileExists(atPath: destination.path) {
-        try fileManager.removeItem(at: destination)
-      }
+      // moveItem fails if the destination exists; never replace an installation.
       try fileManager.moveItem(at: assembleDirectory, to: destination)
 
       // Record this bundle's content hashes for cache pruning.
@@ -1182,7 +1202,8 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         releaseId: manifest.releaseId
       )
 
-      let cleanupBundleIds = try coordinator.stageDownloadedBundle(info)
+      phase = "stage"
+      let cleanupBundleIds = try stageOwnedBundle(info)
       coordinator.cleanupBundles(cleanupBundleIds)
 
       pruneDeltaCache(assembler: assembler)
@@ -1192,18 +1213,19 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         bundleVersion: manifest.version,
         runtimeVersion: manifest.runtimeVersion,
         channel: targetChannel,
-        releaseId: manifest.releaseId
+        releaseId: manifest.releaseId, attemptId: installationId, phase: phase
       )
       emitEvent("updateStaged", ["bundle": info.toDictionary()])
       return info
     } catch {
+      if error is CancellationError { throw error }
       sendDeviceEvent(
         action: .downloadError,
         bundleVersion: manifest.version,
         runtimeVersion: manifest.runtimeVersion,
         channel: targetChannel,
         releaseId: manifest.releaseId,
-        detail: error.localizedDescription
+        detail: error.localizedDescription, attemptId: installationId, phase: phase
       )
       emitEvent(
         "downloadFailed",
@@ -1240,8 +1262,8 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     assembler.pruneCache(referencedHashes: referenced)
   }
 
-  private func pruneIncompatibleBundles() {
-    let cleanupBundleIds = coordinator.pruneIncompatibleBundles(
+  private func pruneIncompatibleBundles() throws {
+    let cleanupBundleIds = try coordinator.pruneIncompatibleBundles(
       isCompatibleRuntime: isCompatibleRuntime
     )
     coordinator.cleanupBundles(cleanupBundleIds)
@@ -1255,45 +1277,6 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     isCompatibleRuntime(bundle.runtimeVersion)
   }
 
-  private func buildBundleId(
-    version: String,
-    releaseId: String?,
-    sha256: String?
-  ) -> String {
-    let trimmed = version.trimmingCharacters(in: .whitespacesAndNewlines)
-    let allowed = CharacterSet(
-      charactersIn: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._-"
-    )
-
-    var normalizedScalars = String.UnicodeScalarView()
-    for scalar in trimmed.unicodeScalars {
-      if allowed.contains(scalar) {
-        normalizedScalars.append(scalar)
-      } else {
-        normalizedScalars.append("-")
-      }
-    }
-
-    var normalized = String(normalizedScalars).replacingOccurrences(
-      of: "-{2,}",
-      with: "-",
-      options: .regularExpression
-    )
-    normalized = normalized.trimmingCharacters(in: CharacterSet(charactersIn: "-."))
-
-    if normalized.isEmpty {
-      normalized = "bundle"
-    }
-    if normalized.count > 64 {
-      normalized = String(normalized.prefix(64))
-    }
-
-    let identitySource = trimToNil(releaseId) ?? trimToNil(sha256) ?? trimmed
-    let digest = SHA256.hash(data: Data(identitySource.utf8))
-    let suffix = digest.map { String(format: "%02x", $0) }.joined().prefix(12)
-    return "\(normalized)-\(suffix)"
-  }
-
   /// Emit a JS lifecycle event. `notifyListeners` marshals to the bridge
   /// safely from any thread, so no manual dispatch is needed.
   private func emitEvent(_ name: String, _ data: [String: Any]) {
@@ -1347,7 +1330,9 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     runtimeVersion: String? = nil,
     channel: String? = nil,
     releaseId: String? = nil,
-    detail: String? = nil
+    detail: String? = nil,
+    attemptId: String? = nil,
+    phase: String? = nil
   ) {
     sendDeviceEvent(
       UpdaterCoordinator.DeviceEventPayload(
@@ -1356,7 +1341,9 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         runtimeVersion: runtimeVersion,
         channel: channel,
         releaseId: releaseId,
-        detail: detail
+        detail: detail,
+        attemptId: attemptId,
+        phase: phase
       )
     )
   }
@@ -1365,11 +1352,13 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     guard let appId else {
       return
     }
-    guard let bundleVersion = trimToNil(payload.bundleVersion) else {
+    let bundleVersion = trimToNil(payload.bundleVersion)
+    guard payload.action == .checkError || bundleVersion != nil else {
       print("[OtaKit] Skipping device event without bundleVersion")
       return
     }
-    guard let releaseId = trimToNil(payload.releaseId) else {
+    let releaseId = trimToNil(payload.releaseId)
+    guard payload.action == .checkError || releaseId != nil else {
       print("[OtaKit] Skipping device event without releaseId")
       return
     }
@@ -1383,15 +1372,30 @@ public class UpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
       appId: appId,
       platform: "ios",
       action: payload.action,
-      bundleVersion: bundleVersion,
+      bundleVersion: bundleVersion ?? "",
       channel: payload.channel,
       runtimeVersion: trimToNil(payload.runtimeVersion),
-      releaseId: releaseId,
+      releaseId: releaseId ?? "",
       nativeBuild: nativeBuild,
-      detail: payload.detail
+      detail: payload.detail,
+      attemptId: payload.attemptId,
+      phase: payload.phase,
+      lifecycle: nativeEventLifecycle()
     )
   }
 
+  private func nativeEventLifecycle() -> String {
+    let read = { () -> String in
+      switch UIApplication.shared.applicationState {
+      case .active: return "foreground"
+      case .background: return "background"
+      case .inactive: return "inactive"
+      @unknown default: return "unknown"
+      }
+    }
+    return Thread.isMainThread ? read() : DispatchQueue.main.sync(execute: read)
+  }
+
   private func isBundleUsable(_ bundle: BundleInfo) -> Bool {
     guard !bundle.isBuiltin else {
       return true