@hot-updater/react-native 0.36.6 → 1.0.0-rc.0

package/ios/HotUpdater/Internal/BundleFileStorageService.swift

@@ -1,4 +1,10 @@
 import Foundation
+import OSLog
+
+private let bundleStorageLog = OSLog(
+    subsystem: "com.hotupdater",
+    category: "BundleStorage"
+)
 
 @_silgen_name("HotUpdaterApplyBsdiffPatch")
 private func hotUpdaterApplyBsdiffPatchSymbol(
@@ -275,12 +281,21 @@ public protocol BundleStorageService {
 
     // Bundle update
     func updateBundle(bundleId: String, fileUrl: URL?, fileHash: String?, manifestUrl: URL?, manifestFileHash: String?, changedAssets: [String: ChangedAssetDescriptor]?, progressHandler: @escaping (UpdateProgressPayload) -> Void, completion: @escaping (Result<Bool, Error>) -> Void)
+    func stageReleaseSelection(_ selection: PersistedSelection) -> Bool
+    func acceptReleaseCatalog(catalogId: String, scopeKey: String, generation: Int64, catalogHash: String, channel: String, selectionContextHash: String) -> Bool
+    func getActiveUpdateState() -> [String: Any]
+    func isReleaseSelectionCurrent(catalogId: String, scopeKey: String, generation: Int64, catalogHash: String, channel: String, selectionContextHash: String) -> Bool
+    func commitReleaseSelection(_ selection: PersistedSelection) -> Bool
 
     // Rollback support
     func markLaunchCompleted(bundleId: String?)
     func notifyAppReady() -> [String: Any]
     func getCrashHistory() -> CrashedHistory
     func clearCrashHistory() -> Bool
+    func getInstallId() -> String
+    func getUserId() -> String?
+    func getUsername() -> String?
+    func setUser(userId: String?, username: String?)
     
     /**
      * Gets the base URL for the current active bundle directory
@@ -308,6 +323,14 @@ public protocol BundleStorageService {
     func resetChannel() -> Result<Bool, Error>
 }
 
+public extension BundleStorageService {
+    func stageReleaseSelection(_: PersistedSelection) -> Bool { false }
+    func acceptReleaseCatalog(catalogId _: String, scopeKey _: String, generation _: Int64, catalogHash _: String, channel _: String, selectionContextHash _: String) -> Bool { false }
+    func getActiveUpdateState() -> [String: Any] { [:] }
+    func isReleaseSelectionCurrent(catalogId _: String, scopeKey _: String, generation _: Int64, catalogHash _: String, channel _: String, selectionContextHash _: String) -> Bool { false }
+    func commitReleaseSelection(_: PersistedSelection) -> Bool { false }
+}
+
 class BundleFileStorageService: BundleStorageService {
     private struct ActiveBundleMetadataSnapshot {
         let activeBundleId: String
@@ -352,6 +375,29 @@ class BundleFileStorageService: BundleStorageService {
     private var currentLaunchReport: LaunchReport?
     private let activeBundleMetadataLock = NSLock()
     private var activeBundleMetadataSnapshot: ActiveBundleMetadataSnapshot?
+    private let builtInBundleIdProvider: () -> String
+    private let updateStrategyProvider: () -> UpdateStrategy
+    private let releaseStateLock = NSRecursiveLock()
+    private var pendingInstallSelections: [String: PersistedSelection] = [:]
+
+    private var currentInstallIdentity: InstallIdentity?
+    private var currentUserIdentity: UserIdentity?
+
+    private let protectedBundleStoreEntries: Set<String> = [
+        BundleMetadata.metadataFilename,
+        CrashedHistory.crashedHistoryFilename,
+        LaunchReport.launchReportFilename,
+        InstallIdentity.installIdentityFilename,
+        UserIdentity.userIdentityFilename,
+    ]
+
+    private func normalizeIdentityValue(_ value: String?) -> String? {
+        guard let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed
+    }
 
     private func emitArchiveProgress(
         progressHandler: @escaping (UpdateProgressPayload) -> Void,
@@ -654,7 +700,13 @@ class BundleFileStorageService: BundleStorageService {
                 return false
             }
 
-            NSLog("[BundleStorage] HotUpdaterBsdiffPatchApplied asset=\(assetPath) baseBundleId=\(patch.baseBundleId)")
+            os_log(
+                "HotUpdaterBsdiffPatchApplied asset=%{public}@ baseBundleId=%{public}@",
+                log: bundleStorageLog,
+                type: .default,
+                assetPath,
+                patch.baseBundleId
+            )
             return true
         case .failure:
             resetDiffProgressFile(
@@ -701,13 +753,21 @@ class BundleFileStorageService: BundleStorageService {
                 downloadService: DownloadService,
                 decompressService: DecompressService,
                 preferences: PreferencesService,
-                isolationKey: String) {
+                isolationKey: String,
+                builtInBundleIdProvider: @escaping () -> String = { "" },
+                updateStrategyProvider: @escaping () -> UpdateStrategy = {
+                    let fingerprintHash = HotUpdaterConfig.shared.fingerprintHash
+                        ?? Bundle.main.object(forInfoDictionaryKey: "HOT_UPDATER_FINGERPRINT_HASH") as? String
+                    return (fingerprintHash?.isEmpty == false) ? .fingerprint : .appVersion
+                }) {
 
         self.fileSystem = fileSystem
         self.downloadService = downloadService
         self.decompressService = decompressService
         self.preferences = preferences
         self.isolationKey = isolationKey
+        self.builtInBundleIdProvider = builtInBundleIdProvider
+        self.updateStrategyProvider = updateStrategyProvider
 
         // Create queue for file operations
         self.fileOperationQueue = DispatchQueue(label: "com.hotupdater.fileoperations",
@@ -744,6 +804,20 @@ class BundleFileStorageService: BundleStorageService {
         return URL(fileURLWithPath: storeDir).appendingPathComponent(LaunchReport.launchReportFilename)
     }
 
+    private func installIdentityFileURL() -> URL? {
+        guard case .success(let storeDir) = bundleStoreDir() else {
+            return nil
+        }
+        return URL(fileURLWithPath: storeDir).appendingPathComponent(InstallIdentity.installIdentityFilename)
+    }
+
+    private func userIdentityFileURL() -> URL? {
+        guard case .success(let storeDir) = bundleStoreDir() else {
+            return nil
+        }
+        return URL(fileURLWithPath: storeDir).appendingPathComponent(UserIdentity.userIdentityFilename)
+    }
+
     // MARK: - Metadata Operations
 
     private func loadMetadataOrNull() -> BundleMetadata? {
@@ -790,13 +864,87 @@ class BundleFileStorageService: BundleStorageService {
         _ = report.save(to: file)
     }
 
+    private func loadInstallIdentity() -> InstallIdentity? {
+        if let currentInstallIdentity {
+            return currentInstallIdentity
+        }
+        guard let file = installIdentityFileURL(),
+              let identity = InstallIdentity.load(from: file) else {
+            return nil
+        }
+        currentInstallIdentity = identity
+        return identity
+    }
+
+    private func saveInstallIdentity(_ identity: InstallIdentity) -> Bool {
+        currentInstallIdentity = identity
+        guard let file = installIdentityFileURL() else {
+            return false
+        }
+        return identity.save(to: file)
+    }
+
+    private func loadUserIdentity() -> UserIdentity? {
+        if let currentUserIdentity {
+            return currentUserIdentity
+        }
+        guard let file = userIdentityFileURL(),
+              let identity = UserIdentity.load(from: file) else {
+            return nil
+        }
+        currentUserIdentity = identity
+        return identity
+    }
+
+    private func saveUserIdentity(_ identity: UserIdentity?) -> Bool {
+        currentUserIdentity = identity
+        guard let file = userIdentityFileURL() else {
+            return false
+        }
+
+        guard let identity else {
+            if FileManager.default.fileExists(atPath: file.path) {
+                try? FileManager.default.removeItem(at: file)
+            }
+            return true
+        }
+
+        return identity.save(to: file)
+    }
+
+    private func resolveBuiltInBundleId() -> String? {
+        let bundleId = builtInBundleIdProvider().trimmingCharacters(in: .whitespacesAndNewlines)
+        return bundleId.isEmpty ? nil : bundleId
+    }
+
+    private func createPendingTransition(
+        fromBundleId: String,
+        toBundleId: String
+    ) -> PendingBundleTransition {
+        PendingBundleTransition(
+            fromBundleId: fromBundleId,
+            toBundleId: toBundleId,
+            updateStrategy: updateStrategyProvider()
+        )
+    }
+
+    private func launchReport(for status: LaunchReportStatus, transition: PendingBundleTransition?) -> LaunchReport {
+        LaunchReport(
+            status: status,
+            fromBundleId: transition?.fromBundleId,
+            toBundleId: transition?.toBundleId,
+            updateStrategy: transition?.updateStrategy
+        )
+    }
+
     private func createInitialMetadata() -> BundleMetadata {
         let currentBundleId = getCachedBundleId()
         return BundleMetadata(
             isolationKey: isolationKey,
             stableBundleId: nil,
             stagingBundleId: currentBundleId,
-            verificationPending: false
+            verificationPending: false,
+            pendingTransition: nil
         )
     }
 
@@ -804,7 +952,7 @@ class BundleFileStorageService: BundleStorageService {
         if let stagingBundleId = metadata.stagingBundleId, !metadata.verificationPending {
             return stagingBundleId
         }
-        return metadata.stableBundleId
+        return metadata.stableBundleId ?? resolveBuiltInBundleId()
     }
 
     private func getActiveBundleId() -> String? {
@@ -1076,8 +1224,7 @@ class BundleFileStorageService: BundleStorageService {
             for item in contents {
                 let fullPath = (storeDir as NSString).appendingPathComponent(item)
 
-                // Skip metadata files
-                if item == "metadata.json" || item == "crashed-history.json" {
+                if protectedBundleStoreEntries.contains(item) {
                     continue
                 }
 
@@ -1116,13 +1263,47 @@ class BundleFileStorageService: BundleStorageService {
         return metadata.verificationPending && metadata.stagingBundleId != nil
     }
 
-    private func prepareMetadataForNewStagingBundle(_ metadata: BundleMetadata, bundleId: String) -> BundleMetadata {
+    private func prepareMetadataForNewStagingBundle(_ metadata: BundleMetadata, bundleId: String) -> BundleMetadata? {
         let currentVerifiedBundleId = getCurrentVerifiedBundleId(metadata).flatMap { $0 == bundleId ? nil : $0 }
+        releaseStateLock.lock()
+        let incomingSelection = pendingInstallSelections.removeValue(forKey: bundleId)
+        releaseStateLock.unlock()
+        if let incomingSelection, !isSelectionCurrent(incomingSelection) {
+            return nil
+        }
+        let currentVerifiedSelection: PersistedSelection? = {
+            if metadata.stagingBundleId != nil, !metadata.verificationPending {
+                return metadata.stagingSelection
+            }
+            return metadata.stableSelection
+        }()?.bundleId == bundleId ? nil : ({
+            if metadata.stagingBundleId != nil, !metadata.verificationPending {
+                return metadata.stagingSelection
+            }
+            return metadata.stableSelection
+        }())
+        let stagingSelection = incomingSelection ?? PersistedSelection.legacyBundle(bundleId)
+        let fromSelection = currentVerifiedSelection
+            ?? PersistedSelection.legacyBundle(resolveBuiltInBundleId() ?? bundleId)
+        let pendingTransition = currentVerifiedBundleId.map {
+            createPendingTransition(fromBundleId: $0, toBundleId: bundleId)
+        }
         return BundleMetadata(
             isolationKey: isolationKey,
             stableBundleId: currentVerifiedBundleId,
             stagingBundleId: bundleId,
+            stableSelection: currentVerifiedSelection,
+            stagingSelection: stagingSelection,
             verificationPending: true,
+            pendingTransition: pendingTransition,
+            pendingSelectionTransition: PendingSelectionTransition(
+                fromReleaseId: fromSelection.releaseId,
+                fromBundleId: fromSelection.bundleId,
+                toReleaseId: stagingSelection.releaseId,
+                toBundleId: stagingSelection.bundleId
+            ),
+            highestSeenCatalogs: metadata.highestSeenCatalogs,
+            currentSelectionContexts: metadata.currentSelectionContexts,
             updatedAt: Date().timeIntervalSince1970 * 1000
         )
     }
@@ -1133,6 +1314,10 @@ class BundleFileStorageService: BundleStorageService {
             return false
         }
 
+        let pendingTransition = metadata.pendingTransition
+        let pendingSelectionTransition = metadata.pendingSelectionTransition
+        let stableSelection = metadata.stableSelection
+
         var crashedHistory = loadCrashedHistory()
         crashedHistory.addEntry(stagingId)
         let _ = saveCrashedHistory(crashedHistory)
@@ -1154,7 +1339,13 @@ class BundleFileStorageService: BundleStorageService {
             isolationKey: isolationKey,
             stableBundleId: nil,
             stagingBundleId: fallbackBundleId,
+            stableSelection: nil,
+            stagingSelection: stableSelection,
             verificationPending: false,
+            pendingTransition: nil,
+            pendingSelectionTransition: nil,
+            highestSeenCatalogs: metadata.highestSeenCatalogs,
+            currentSelectionContexts: metadata.currentSelectionContexts,
             updatedAt: Date().timeIntervalSince1970 * 1000
         )
 
@@ -1180,7 +1371,18 @@ class BundleFileStorageService: BundleStorageService {
             try? fileSystem.removeItem(atPath: stagingDir)
         }
 
-        saveLaunchReport(LaunchReport(status: "RECOVERED", crashedBundleId: stagingId))
+        saveLaunchReport(
+            LaunchReport(
+                status: .recovered,
+                fromReleaseId: pendingSelectionTransition?.toReleaseId,
+                fromBundleId: stagingId,
+                toReleaseId: stableSelection?.releaseId,
+                toBundleId: fallbackBundleId
+                    ?? pendingTransition?.fromBundleId
+                    ?? resolveBuiltInBundleId(),
+                updateStrategy: pendingTransition?.updateStrategy ?? updateStrategyProvider()
+            )
+        )
         return true
     }
 
@@ -1195,6 +1397,170 @@ class BundleFileStorageService: BundleStorageService {
 
         _ = rollbackPendingBundle(stagingBundleId)
     }
+
+    private func releaseScopeStateKey(catalogId: String, scopeKey: String) -> String {
+        "\(catalogId)|\(scopeKey)"
+    }
+
+    private func selectionContextValue(channel: String, selectionContextHash: String) -> String {
+        "\(channel)\n\(selectionContextHash)"
+    }
+
+    func acceptReleaseCatalog(
+        catalogId: String,
+        scopeKey: String,
+        generation: Int64,
+        catalogHash: String,
+        channel: String,
+        selectionContextHash: String
+    ) -> Bool {
+        releaseStateLock.lock()
+        defer { releaseStateLock.unlock() }
+        var metadata = loadMetadataOrNull() ?? createInitialMetadata()
+        let stateKey = releaseScopeStateKey(catalogId: catalogId, scopeKey: scopeKey)
+        if let highestSeen = metadata.highestSeenCatalogs[stateKey] {
+            if generation < highestSeen.generation { return false }
+            if generation == highestSeen.generation, catalogHash != highestSeen.catalogHash {
+                return false
+            }
+        }
+        metadata.highestSeenCatalogs[stateKey] = CatalogHighWater(
+            generation: generation,
+            catalogHash: catalogHash
+        )
+        metadata.currentSelectionContexts[stateKey] = selectionContextValue(
+            channel: channel,
+            selectionContextHash: selectionContextHash
+        )
+        metadata.updatedAt = Date().timeIntervalSince1970 * 1000
+        return saveMetadata(metadata)
+    }
+
+    private func activeSelection(_ metadata: BundleMetadata) -> PersistedSelection? {
+        metadata.stagingSelection
+            ?? metadata.stagingBundleId.map(PersistedSelection.legacyBundle)
+            ?? metadata.stableSelection
+            ?? metadata.stableBundleId.map(PersistedSelection.legacyBundle)
+    }
+
+    func getActiveUpdateState() -> [String: Any] {
+        releaseStateLock.lock()
+        defer { releaseStateLock.unlock() }
+        guard let metadata = loadMetadataOrNull() else {
+            return [
+                "activeSelection": NSNull(),
+                "stableSelection": NSNull(),
+                "verificationPending": false,
+                "highestSeenCatalogs": [:]
+            ]
+        }
+        let highWaters = metadata.highestSeenCatalogs.mapValues { highWater in
+            [
+                "generation": NSNumber(value: highWater.generation),
+                "catalogHash": highWater.catalogHash
+            ] as [String: Any]
+        }
+        return [
+            "activeSelection": activeSelection(metadata)?.dictionary ?? NSNull(),
+            "stableSelection": metadata.stableSelection?.dictionary ?? NSNull(),
+            "verificationPending": metadata.verificationPending,
+            "highestSeenCatalogs": highWaters
+        ]
+    }
+
+    func isReleaseSelectionCurrent(
+        catalogId: String,
+        scopeKey: String,
+        generation: Int64,
+        catalogHash: String,
+        channel: String,
+        selectionContextHash: String
+    ) -> Bool {
+        releaseStateLock.lock()
+        defer { releaseStateLock.unlock() }
+        guard let metadata = loadMetadataOrNull() else { return false }
+        let stateKey = releaseScopeStateKey(catalogId: catalogId, scopeKey: scopeKey)
+        return metadata.highestSeenCatalogs[stateKey] == CatalogHighWater(
+            generation: generation,
+            catalogHash: catalogHash
+        ) && metadata.currentSelectionContexts[stateKey] == selectionContextValue(
+            channel: channel,
+            selectionContextHash: selectionContextHash
+        )
+    }
+
+    private func isSelectionCurrent(_ selection: PersistedSelection) -> Bool {
+        guard let catalogId = selection.catalogId,
+              let scopeKey = selection.scopeKey,
+              let generation = selection.generation,
+              let catalogHash = selection.catalogHash,
+              let selectionContextHash = selection.selectionContextHash else {
+            return false
+        }
+        return isReleaseSelectionCurrent(
+            catalogId: catalogId,
+            scopeKey: scopeKey,
+            generation: generation,
+            catalogHash: catalogHash,
+            channel: selection.channel,
+            selectionContextHash: selectionContextHash
+        )
+    }
+
+    func stageReleaseSelection(_ selection: PersistedSelection) -> Bool {
+        releaseStateLock.lock()
+        defer { releaseStateLock.unlock() }
+        guard isSelectionCurrent(selection) else { return false }
+        pendingInstallSelections[selection.bundleId] = selection
+        return true
+    }
+
+    func commitReleaseSelection(_ selection: PersistedSelection) -> Bool {
+        releaseStateLock.lock()
+        defer { releaseStateLock.unlock() }
+        guard isSelectionCurrent(selection) else { return false }
+        var metadata = loadMetadataOrNull() ?? createInitialMetadata()
+        if selection.kind == "BUNDLE" {
+            if metadata.stagingSelection?.bundleId == selection.bundleId
+                || metadata.stagingBundleId == selection.bundleId {
+                metadata.stagingBundleId = selection.bundleId
+                metadata.stagingSelection = selection
+            } else if metadata.stableSelection?.bundleId == selection.bundleId
+                || metadata.stableBundleId == selection.bundleId {
+                metadata.stableBundleId = selection.bundleId
+                metadata.stableSelection = selection
+            } else {
+                return false
+            }
+        } else {
+            guard case .success = setBundleURL(localPath: nil) else { return false }
+            metadata.stableBundleId = nil
+            metadata.stableSelection = nil
+            metadata.stagingBundleId = nil
+            metadata.stagingSelection = selection
+            metadata.verificationPending = false
+            metadata.pendingTransition = nil
+            metadata.pendingSelectionTransition = nil
+        }
+        metadata.updatedAt = Date().timeIntervalSince1970 * 1000
+        guard saveMetadata(metadata) else { return false }
+        do {
+            try preferences.setItem(
+                selection.channel,
+                forKey: "HotUpdaterChannel"
+            )
+        } catch {
+            return false
+        }
+        if selection.kind != "BUNDLE", case .success(let storeDir) = bundleStoreDir() {
+            for item in (try? fileSystem.contentsOfDirectory(atPath: storeDir)) ?? [] {
+                guard !protectedBundleStoreEntries.contains(item) else { continue }
+                let path = (storeDir as NSString).appendingPathComponent(item)
+                try? fileSystem.removeItem(atPath: path)
+            }
+        }
+        return true
+    }
     
     // MARK: - Directory Management
     
@@ -1386,8 +1752,7 @@ class BundleFileStorageService: BundleStorageService {
         let bundles = contents.compactMap { item -> String? in
             let fullPath = (storeDir as NSString).appendingPathComponent(item)
 
-            // Skip metadata files - DO NOT delete
-            if item == "metadata.json" || item == "crashed-history.json" {
+            if protectedBundleStoreEntries.contains(item) {
                 return nil
             }
 
@@ -1608,6 +1973,10 @@ class BundleFileStorageService: BundleStorageService {
 
     func prepareLaunch(bundle: Bundle, pendingRecovery: PendingCrashRecovery?) -> LaunchSelection {
         saveLaunchReport(nil)
+        if loadInstallIdentity() == nil {
+            let identity = InstallIdentity()
+            _ = saveInstallIdentity(identity)
+        }
         applyPendingRecoveryIfNeeded(pendingRecovery)
         return selectLaunch(bundle: bundle)
     }
@@ -1642,7 +2011,11 @@ class BundleFileStorageService: BundleStorageService {
                 let setResult = self.setBundleURL(localPath: nil)
                 switch setResult {
                 case .success:
-                    let _ = self.saveMetadata(self.createInitialMetadata())
+                    let previousMetadata = self.loadMetadataOrNull()
+                    var resetMetadata = self.createInitialMetadata()
+                    resetMetadata.highestSeenCatalogs = previousMetadata?.highestSeenCatalogs ?? [:]
+                    resetMetadata.currentSelectionContexts = previousMetadata?.currentSelectionContexts ?? [:]
+                    let _ = self.saveMetadata(resetMetadata)
                     self.saveLaunchReport(nil)
                     let cleanupResult = self.cleanupOldBundles(currentBundleId: currentBundleId, bundleId: bundleId)
                     switch cleanupResult {
@@ -1680,11 +2053,18 @@ class BundleFileStorageService: BundleStorageService {
                 case .success(let existingBundlePath):
                     if let bundlePath = existingBundlePath {
                         NSLog("[BundleStorage] Using cached bundle at path: \(bundlePath)")
+                        let currentMetadata = self.loadMetadataOrNull() ?? self.createInitialMetadata()
+                        guard let updatedMetadata = self.prepareMetadataForNewStagingBundle(currentMetadata, bundleId: bundleId) else {
+                            completion(.failure(BundleStorageError.unknown(
+                                NSError(domain: "HotUpdater", code: 0, userInfo: [
+                                    NSLocalizedDescriptionKey: "Release catalog selection is stale"
+                                ])
+                            )))
+                            return
+                        }
                         let setResult = self.setBundleURL(localPath: bundlePath)
                         switch setResult {
                         case .success:
-                            let currentMetadata = self.loadMetadataOrNull() ?? self.createInitialMetadata()
-                            let updatedMetadata = self.prepareMetadataForNewStagingBundle(currentMetadata, bundleId: bundleId)
                             let _ = self.saveMetadata(updatedMetadata)
                             NSLog("[BundleStorage] Set staging bundle (cached): \(bundleId), verificationPending: true")
 
@@ -2113,10 +2493,18 @@ class BundleFileStorageService: BundleStorageService {
                     from: tmpDir,
                     to: realDir
                 )
+                let currentMetadata = self.loadMetadataOrNull() ?? self.createInitialMetadata()
+                guard let updatedMetadata = self.prepareMetadataForNewStagingBundle(currentMetadata, bundleId: bundleId) else {
+                    self.cleanupTemporaryFiles([tempDirectory])
+                    completion(.failure(BundleStorageError.unknown(
+                        NSError(domain: "HotUpdater", code: 0, userInfo: [
+                            NSLocalizedDescriptionKey: "Release catalog selection is stale"
+                        ])
+                    )))
+                    return
+                }
                 switch self.setBundleURL(localPath: finalBundlePath) {
                 case .success:
-                    let currentMetadata = self.loadMetadataOrNull() ?? self.createInitialMetadata()
-                    let updatedMetadata = self.prepareMetadataForNewStagingBundle(currentMetadata, bundleId: bundleId)
                     let _ = self.saveMetadata(updatedMetadata)
                     self.cleanupTemporaryFiles([tempDirectory])
                     self.scheduleCleanupOldBundles(
@@ -2447,14 +2835,22 @@ class BundleFileStorageService: BundleStorageService {
                     )
 
                     // 12) Set the bundle URL in preferences (for backwards compatibility)
+                    let currentMetadata = self.loadMetadataOrNull() ?? self.createInitialMetadata()
+                    guard let updatedMetadata = self.prepareMetadataForNewStagingBundle(currentMetadata, bundleId: bundleId) else {
+                        self.cleanupTemporaryFiles([tempDirectory])
+                        completion(.failure(BundleStorageError.unknown(
+                            NSError(domain: "HotUpdater", code: 0, userInfo: [
+                                NSLocalizedDescriptionKey: "Release catalog selection is stale"
+                            ])
+                        )))
+                        return
+                    }
                     let setResult = self.setBundleURL(localPath: finalBundlePath)
                     switch setResult {
                     case .success:
                         NSLog("[BundleStorage] Successfully set bundle URL: \(finalBundlePath)")
 
                         // 13) Set staging metadata for rollback support
-                        let currentMetadata = self.loadMetadataOrNull() ?? self.createInitialMetadata()
-                        let updatedMetadata = self.prepareMetadataForNewStagingBundle(currentMetadata, bundleId: bundleId)
                         let _ = self.saveMetadata(updatedMetadata)
                         NSLog("[BundleStorage] Set staging bundle: \(bundleId), verificationPending: true")
 
@@ -2534,19 +2930,52 @@ class BundleFileStorageService: BundleStorageService {
             return
         }
 
+        let pendingTransition = metadata.pendingTransition
+        let pendingSelectionTransition = metadata.pendingSelectionTransition
+        metadata.stableBundleId = nil
+        metadata.stableSelection = nil
         metadata.verificationPending = false
+        metadata.pendingTransition = nil
+        metadata.pendingSelectionTransition = nil
         metadata.updatedAt = Date().timeIntervalSince1970 * 1000
         let _ = saveMetadata(metadata)
+        saveLaunchReport(
+            LaunchReport(
+                status: .updateApplied,
+                fromReleaseId: pendingSelectionTransition?.fromReleaseId,
+                fromBundleId: pendingSelectionTransition?.fromBundleId ?? pendingTransition?.fromBundleId,
+                toReleaseId: pendingSelectionTransition?.toReleaseId,
+                toBundleId: pendingSelectionTransition?.toBundleId ?? pendingTransition?.toBundleId,
+                updateStrategy: pendingTransition?.updateStrategy
+            )
+        )
     }
 
     func notifyAppReady() -> [String: Any] {
         guard let report = loadLaunchReport() else {
-            return ["status": "STABLE"]
+            if let metadata = loadMetadataOrNull(),
+               metadata.verificationPending,
+               metadata.stagingBundleId != nil {
+                return ["status": "PENDING"]
+            }
+            return ["status": LaunchReportStatus.unchanged.rawValue]
         }
 
-        var result: [String: Any] = ["status": report.status]
-        if let crashedBundleId = report.crashedBundleId {
-            result["crashedBundleId"] = crashedBundleId
+        var result: [String: Any] = ["status": report.status.rawValue]
+        if let fromReleaseId = report.fromReleaseId {
+            result["fromReleaseId"] = fromReleaseId
+        }
+        if let fromBundleId = report.fromBundleId {
+            result["fromBundleId"] = fromBundleId
+        }
+        if let toBundleId = report.toBundleId {
+            result["toBundleId"] = toBundleId
+        }
+        if let toReleaseId = report.toReleaseId {
+            result["toReleaseId"] = toReleaseId
+        }
+        if let updateStrategy = report.updateStrategy {
+            result["updateStrategy"] = updateStrategy.rawValue
         }
         return result
     }
@@ -2569,6 +2998,37 @@ class BundleFileStorageService: BundleStorageService {
         return saveCrashedHistory(history)
     }
 
+    func getInstallId() -> String {
+        if let installId = loadInstallIdentity()?.installId {
+            return installId
+        }
+
+        let identity = InstallIdentity()
+        guard saveInstallIdentity(identity) else {
+            return identity.installId
+        }
+        return identity.installId
+    }
+
+    func getUserId() -> String? {
+        loadUserIdentity()?.userId
+    }
+
+    func getUsername() -> String? {
+        loadUserIdentity()?.username
+    }
+
+    func setUser(userId: String?, username: String?) {
+        let normalizedUserId = normalizeIdentityValue(userId)
+        let normalizedUsername = normalizeIdentityValue(username)
+        let identity = UserIdentity(userId: normalizedUserId, username: normalizedUsername)
+        if identity.isEmpty {
+            _ = saveUserIdentity(nil)
+            return
+        }
+        _ = saveUserIdentity(identity)
+    }
+
     /**
      * Gets the base URL for the current active bundle directory
      * Returns the file:// URL to the bundle directory without trailing slash
@@ -2618,12 +3078,15 @@ class BundleFileStorageService: BundleStorageService {
             return .failure(BundleStorageError.unknown(nil))
         }
 
-        let clearedMetadata = BundleMetadata(
-            isolationKey: isolationKey,
-            stableBundleId: nil,
-            stagingBundleId: nil,
-            verificationPending: false
-        )
+        var clearedMetadata = loadMetadataOrNull() ?? BundleMetadata(isolationKey: isolationKey)
+        clearedMetadata.stableBundleId = nil
+        clearedMetadata.stagingBundleId = nil
+        clearedMetadata.stableSelection = nil
+        clearedMetadata.stagingSelection = nil
+        clearedMetadata.verificationPending = false
+        clearedMetadata.pendingTransition = nil
+        clearedMetadata.pendingSelectionTransition = nil
+        clearedMetadata.updatedAt = Date().timeIntervalSince1970 * 1000
 
         guard saveMetadata(clearedMetadata) else {
             return .failure(BundleStorageError.unknown(nil))
@@ -2637,9 +3100,7 @@ class BundleFileStorageService: BundleStorageService {
 
         do {
             for item in try fileSystem.contentsOfDirectory(atPath: storeDir) {
-                if item == BundleMetadata.metadataFilename ||
-                    item == CrashedHistory.crashedHistoryFilename ||
-                    item == LaunchReport.launchReportFilename {
+                if protectedBundleStoreEntries.contains(item) {
                     continue
                 }