pulse-updates 1.0.0

package/ios/PulseUpdates/AppLauncher/PulseAppLauncher.swift

@@ -0,0 +1,551 @@
+// PulseUpdates App Launcher
+// Based on expo-updates AppLauncherWithDatabase
+// Handles launching updates with asset fallback support
+
+import Foundation
+
+// MARK: - Launcher Protocol
+
+protocol PulseAppLauncherDelegate: AnyObject {
+    func appLauncher(_ launcher: PulseAppLauncher, didFinishWithSuccess success: Bool, error: Error?)
+}
+
+// MARK: - App Launcher
+
+final class PulseAppLauncher {
+
+    // MARK: - Public Properties
+
+    weak var delegate: PulseAppLauncherDelegate?
+
+    /// The update that was selected to launch
+    private(set) var launchedUpdate: PulseUpdate?
+
+    /// URL to the launch asset (JS bundle)
+    private(set) var launchAssetUrl: URL?
+
+    /// Map of asset keys to local file URLs (for expo-asset compatibility)
+    private(set) var assetFilesMap: [String: String] = [:]
+
+    /// Whether using embedded assets only (no downloaded assets)
+    var isUsingEmbeddedAssets: Bool {
+        return launchedUpdate?.isEmbedded ?? true
+    }
+
+    // MARK: - Private Properties
+
+    private let database: PulseDatabase
+    private let directory: URL
+    private let selectionPolicy: PulseSelectionPolicy
+    private let runtimeVersion: String
+
+    private let launcherQueue = DispatchQueue(label: "app.pulse.launcher")
+    private var completedAssets = 0
+    private var launchError: Error?
+
+    // Embedded manifest cache
+    private var embeddedManifest: PulseEmbeddedManifest?
+
+    // MARK: - Initialization
+
+    init(
+        database: PulseDatabase,
+        directory: URL,
+        selectionPolicy: PulseSelectionPolicy,
+        runtimeVersion: String
+    ) {
+        self.database = database
+        self.directory = directory
+        self.selectionPolicy = selectionPolicy
+        self.runtimeVersion = runtimeVersion
+    }
+
+    // MARK: - Public Methods
+
+    /// Launch the best available update
+    func launch(completion: @escaping (Bool, Error?) -> Void) {
+        // Select update to launch
+        do {
+            let updates = try database.launchableUpdates(forRuntimeVersion: runtimeVersion)
+
+            guard let selectedUpdate = selectionPolicy.selectUpdateToLaunch(from: updates) else {
+                completion(false, PulseLauncherError.noLaunchableUpdate)
+                return
+            }
+
+            launchedUpdate = selectedUpdate
+            launchUpdate(selectedUpdate, completion: completion)
+        } catch {
+            completion(false, error)
+        }
+    }
+
+    /// Launch a specific update
+    func launch(update: PulseUpdate, completion: @escaping (Bool, Error?) -> Void) {
+        launchedUpdate = update
+        launchUpdate(update, completion: completion)
+    }
+
+    // MARK: - Private Methods
+
+    private func launchUpdate(_ update: PulseUpdate, completion: @escaping (Bool, Error?) -> Void) {
+        // Mark update as accessed
+        try? database.markUpdateAccessed(update.updateId)
+
+        // Handle embedded updates
+        if update.status == .embedded {
+            launchEmbeddedUpdate(update, completion: completion)
+            return
+        }
+
+        // Handle development updates (no assets to verify)
+        if update.status == .development {
+            completion(true, nil)
+            return
+        }
+
+        // Handle regular updates - ensure all assets exist
+        ensureAllAssetsExist(for: update, completion: completion)
+    }
+
+    private func launchEmbeddedUpdate(_ update: PulseUpdate, completion: @escaping (Bool, Error?) -> Void) {
+        // For embedded updates, use the bundle directly
+        if let bundleUrl = Bundle.main.url(forResource: "main", withExtension: "jsbundle") {
+            launchAssetUrl = bundleUrl
+
+            // Build asset map from embedded manifest
+            buildEmbeddedAssetFilesMap()
+
+            completion(true, nil)
+        } else {
+            completion(false, PulseLauncherError.embeddedBundleNotFound)
+        }
+    }
+
+    private func ensureAllAssetsExist(for update: PulseUpdate, completion: @escaping (Bool, Error?) -> Void) {
+        do {
+            let assets = try database.assets(forUpdateId: update.updateId)
+
+            if assets.isEmpty {
+                // No assets to verify, just find the bundle
+                if let bundleHash = update.bundleHash {
+                    launchAssetUrl = bundleStorePath(hash: bundleHash)
+                }
+                completion(launchAssetUrl != nil, launchAssetUrl == nil ? PulseLauncherError.bundleNotFound : nil)
+                return
+            }
+
+            // Initialize asset map with embedded assets (fallback)
+            assetFilesMap = buildEmbeddedAssetsMap()
+
+            completedAssets = 0
+            launchError = nil
+
+            let totalAssets = assets.count
+
+            for asset in assets {
+                let localUrl = assetStorePath(hash: asset.hash)
+
+                ensureAssetExists(asset: asset, localUrl: localUrl) { [weak self] exists in
+                    guard let self = self else { return }
+
+                    self.launcherQueue.async {
+                        self.completedAssets += 1
+
+                        if exists {
+                            if asset.isLaunchAsset {
+                                self.launchAssetUrl = localUrl
+                            } else if let key = asset.key {
+                                self.assetFilesMap[key] = localUrl.absoluteString
+                            }
+                        }
+
+                        if self.completedAssets == totalAssets {
+                            DispatchQueue.main.async {
+                                let success = self.launchAssetUrl != nil
+                                completion(success, success ? nil : self.launchError ?? PulseLauncherError.launchAssetMissing)
+                            }
+                        }
+                    }
+                }
+            }
+        } catch {
+            completion(false, error)
+        }
+    }
+
+    /// Ensures an asset exists locally, copying from bundle or downloading if needed
+    private func ensureAssetExists(asset: PulseAsset, localUrl: URL, completion: @escaping (Bool) -> Void) {
+        // Step 1: Check if asset exists at expected location
+        checkAssetExists(at: localUrl) { [weak self] exists in
+            if exists {
+                completion(true)
+                return
+            }
+
+            // Step 2: Try to copy from main bundle
+            self?.maybeCopyAssetFromBundle(asset: asset, toUrl: localUrl) { success in
+                if success {
+                    completion(true)
+                    return
+                }
+
+                // Step 3: Try to download the asset
+                self?.downloadAsset(asset: asset, toUrl: localUrl) { downloadSuccess, error in
+                    if let error = error, asset.isLaunchAsset {
+                        self?.launchError = error
+                    }
+                    completion(downloadSuccess)
+                }
+            }
+        }
+    }
+
+    private func checkAssetExists(at url: URL, completion: @escaping (Bool) -> Void) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            let exists = FileManager.default.fileExists(atPath: url.path)
+            self.launcherQueue.async {
+                completion(exists)
+            }
+        }
+    }
+
+    /// Try to copy asset from the main bundle (embedded assets)
+    private func maybeCopyAssetFromBundle(asset: PulseAsset, toUrl localUrl: URL, completion: @escaping (Bool) -> Void) {
+        // Load embedded manifest if not cached
+        if embeddedManifest == nil {
+            embeddedManifest = loadEmbeddedManifest()
+        }
+
+        guard let embedded = embeddedManifest else {
+            completion(false)
+            return
+        }
+
+        // Find matching embedded asset by key or hash
+        let matchingAsset = embedded.assets.first { embeddedAsset in
+            (asset.key != nil && embeddedAsset.key == asset.key) ||
+            embeddedAsset.hash.lowercased() == asset.hash.lowercased()
+        }
+
+        guard let match = matchingAsset,
+              let bundleFilename = match.nsBundleFilename else {
+            completion(false)
+            return
+        }
+
+        // Get bundle path
+        DispatchQueue.global(qos: .userInitiated).async {
+            let bundlePath: String?
+
+            if let bundleDir = match.nsBundleDir, !bundleDir.isEmpty {
+                bundlePath = Bundle.main.path(forResource: bundleFilename, ofType: nil, inDirectory: bundleDir)
+            } else {
+                bundlePath = Bundle.main.path(forResource: bundleFilename, ofType: nil)
+            }
+
+            guard let sourcePath = bundlePath else {
+                self.launcherQueue.async {
+                    completion(false)
+                }
+                return
+            }
+
+            // Copy to local URL
+            do {
+                // Ensure parent directory exists
+                try FileManager.default.createDirectory(
+                    at: localUrl.deletingLastPathComponent(),
+                    withIntermediateDirectories: true
+                )
+
+                // Copy file
+                try FileManager.default.copyItem(atPath: sourcePath, toPath: localUrl.path)
+
+                self.launcherQueue.async {
+                    completion(true)
+                }
+            } catch {
+                print("[PulseUpdates] Failed to copy asset from bundle: \(error)")
+                self.launcherQueue.async {
+                    completion(false)
+                }
+            }
+        }
+    }
+
+    /// Download asset from remote URL
+    private func downloadAsset(asset: PulseAsset, toUrl localUrl: URL, completion: @escaping (Bool, Error?) -> Void) {
+        guard let remoteUrl = asset.url else {
+            completion(false, PulseLauncherError.assetUrlMissing)
+            return
+        }
+
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                // Ensure parent directory exists
+                try FileManager.default.createDirectory(
+                    at: localUrl.deletingLastPathComponent(),
+                    withIntermediateDirectories: true
+                )
+
+                // Download file
+                let data = try Data(contentsOf: remoteUrl)
+
+                // Verify hash if expected
+                if let expectedHash = asset.expectedHash {
+                    let actualHash = PulseCrypto.sha256Base64(data)
+                    if actualHash != expectedHash {
+                        self.launcherQueue.async {
+                            completion(false, PulseLauncherError.hashMismatch(expected: expectedHash, actual: actualHash))
+                        }
+                        return
+                    }
+                }
+
+                // Write to file
+                try data.write(to: localUrl)
+
+                self.launcherQueue.async {
+                    completion(true, nil)
+                }
+            } catch {
+                print("[PulseUpdates] Failed to download asset: \(error)")
+                self.launcherQueue.async {
+                    completion(false, error)
+                }
+            }
+        }
+    }
+
+    // MARK: - Asset Path Helpers
+
+    private func assetStorePath(hash: String) -> URL {
+        return directory
+            .appendingPathComponent("assets")
+            .appendingPathComponent("sha256")
+            .appendingPathComponent(hash.lowercased())
+    }
+
+    private func bundleStorePath(hash: String) -> URL {
+        // Bundle is stored in assets directory (same location as other assets)
+        return directory
+            .appendingPathComponent("assets")
+            .appendingPathComponent("sha256")
+            .appendingPathComponent(hash.lowercased())
+    }
+
+    // MARK: - Embedded Assets Map
+
+    /// Build map of embedded assets (key -> file URL)
+    private func buildEmbeddedAssetsMap() -> [String: String] {
+        guard let embedded = embeddedManifest ?? loadEmbeddedManifest() else {
+            return [:]
+        }
+
+        var map: [String: String] = [:]
+
+        for asset in embedded.assets where !asset.isLaunchAsset {
+            guard let key = asset.key,
+                  let filename = asset.nsBundleFilename else {
+                continue
+            }
+
+            let bundlePath: String?
+            if let dir = asset.nsBundleDir, !dir.isEmpty {
+                bundlePath = Bundle.main.path(forResource: filename, ofType: nil, inDirectory: dir)
+            } else {
+                bundlePath = Bundle.main.path(forResource: filename, ofType: nil)
+            }
+
+            if let path = bundlePath {
+                map[key] = URL(fileURLWithPath: path).absoluteString
+            }
+        }
+
+        return map
+    }
+
+    private func buildEmbeddedAssetFilesMap() {
+        assetFilesMap = buildEmbeddedAssetsMap()
+    }
+
+    // MARK: - Embedded Manifest
+
+    private func loadEmbeddedManifest() -> PulseEmbeddedManifest? {
+        guard let url = Bundle.main.url(forResource: "embedded-manifest", withExtension: "json"),
+              let data = try? Data(contentsOf: url),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            return nil
+        }
+
+        return PulseEmbeddedManifest(json: json)
+    }
+}
+
+// MARK: - Launcher Errors
+
+enum PulseLauncherError: Error, LocalizedError {
+    case noLaunchableUpdate
+    case embeddedBundleNotFound
+    case bundleNotFound
+    case launchAssetMissing
+    case assetUrlMissing
+    case hashMismatch(expected: String, actual: String)
+
+    var errorDescription: String? {
+        switch self {
+        case .noLaunchableUpdate:
+            return "No launchable update found"
+        case .embeddedBundleNotFound:
+            return "Embedded bundle not found in main bundle"
+        case .bundleNotFound:
+            return "Bundle not found in cache"
+        case .launchAssetMissing:
+            return "Launch asset is missing"
+        case .assetUrlMissing:
+            return "Asset URL is missing"
+        case .hashMismatch(let expected, let actual):
+            return "Asset hash mismatch: expected \(expected), got \(actual)"
+        }
+    }
+}
+
+// MARK: - Embedded Manifest Model
+
+struct PulseEmbeddedManifest {
+    let updateId: String
+    let runtimeVersion: String
+    let commitTime: Date
+    let assets: [PulseEmbeddedAsset]
+
+    init?(json: [String: Any]) {
+        guard let manifest = json["manifest"] as? [String: Any],
+              let updateId = manifest["updateId"] as? String,
+              let runtimeVersion = manifest["runtimeVersion"] as? String else {
+            return nil
+        }
+
+        self.updateId = updateId
+        self.runtimeVersion = runtimeVersion
+
+        if let commitTimeMs = manifest["commitTime"] as? Double {
+            self.commitTime = Date(timeIntervalSince1970: commitTimeMs / 1000)
+        } else {
+            self.commitTime = Date()
+        }
+
+        var parsedAssets: [PulseEmbeddedAsset] = []
+
+        // Parse assets array
+        if let assetsJson = manifest["assets"] as? [[String: Any]] {
+            for assetJson in assetsJson {
+                if let asset = PulseEmbeddedAsset(json: assetJson) {
+                    parsedAssets.append(asset)
+                }
+            }
+        }
+
+        // Parse launch asset
+        if let launchAssetJson = manifest["launchAsset"] as? [String: Any],
+           var launchAsset = PulseEmbeddedAsset(json: launchAssetJson) {
+            launchAsset.isLaunchAsset = true
+            parsedAssets.append(launchAsset)
+        }
+
+        self.assets = parsedAssets
+    }
+}
+
+struct PulseEmbeddedAsset {
+    let key: String?
+    let hash: String
+    let type: String?
+    let nsBundleDir: String?
+    let nsBundleFilename: String?
+    var isLaunchAsset: Bool = false
+
+    init?(json: [String: Any]) {
+        guard let hash = json["hash"] as? String else {
+            return nil
+        }
+
+        self.hash = hash
+        self.key = json["key"] as? String
+        self.type = json["type"] as? String ?? json["contentType"] as? String
+        self.nsBundleDir = json["nsBundleDir"] as? String
+        self.nsBundleFilename = json["nsBundleFilename"] as? String
+    }
+}
+
+// MARK: - Selection Policy Protocol
+
+protocol PulseSelectionPolicy {
+    /// Select which update to launch from available updates
+    func selectUpdateToLaunch(from updates: [PulseUpdate]) -> PulseUpdate?
+
+    /// Select which updates to delete (for reaper)
+    func selectUpdatesToDelete(launchedUpdate: PulseUpdateInfo, allUpdates: [PulseUpdateInfo]) -> [PulseUpdateInfo]
+}
+
+// MARK: - Default Selection Policy
+
+struct PulseDefaultSelectionPolicy: PulseSelectionPolicy {
+
+    /// Select the newest ready or embedded update by commit time
+    func selectUpdateToLaunch(from updates: [PulseUpdate]) -> PulseUpdate? {
+        return updates
+            .filter { $0.status == .ready || $0.status == .embedded }
+            .sorted { $0.commitTime > $1.commitTime }
+            .first
+    }
+
+    /// Select updates to delete - keeps launched update and one backup
+    /// Based on Expo's SelectionPolicyFilterAwareLoader
+    func selectUpdatesToDelete(launchedUpdate: PulseUpdateInfo, allUpdates: [PulseUpdateInfo]) -> [PulseUpdateInfo] {
+        var toDelete: [PulseUpdateInfo] = []
+        var newestBackup: PulseUpdateInfo?
+
+        for update in allUpdates {
+            // Never delete the currently launched update
+            if update.updateId == launchedUpdate.updateId {
+                continue
+            }
+
+            // Never delete embedded updates (handled by integrity check)
+            if update.isEmbedded {
+                continue
+            }
+
+            // Mark older updates for deletion, but track the newest as potential backup
+            if update.commitTime < launchedUpdate.commitTime {
+                toDelete.append(update)
+
+                if newestBackup == nil || update.commitTime > newestBackup!.commitTime {
+                    newestBackup = update
+                }
+            }
+        }
+
+        // Keep one backup (the newest older update) for rollback capability
+        if let backup = newestBackup {
+            toDelete.removeAll { $0.updateId == backup.updateId }
+        }
+
+        return toDelete
+    }
+}
+
+// MARK: - Crypto Helper
+
+struct PulseCrypto {
+    static func sha256Base64(_ data: Data) -> String {
+        var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+        data.withUnsafeBytes {
+            _ = CC_SHA256($0.baseAddress, CC_LONG(data.count), &hash)
+        }
+        return Data(hash).base64EncodedString()
+    }
+}
+
+import CommonCrypto