@capgo/capacitor-updater 5.40.5 → 5.42.3

package/ios/Sources/CapacitorUpdaterPlugin/CapgoUpdater.swift

@@ -48,6 +48,12 @@ import UIKit
     // Flag to track if we've already sent the rate limit statistic - prevents infinite loop
     private static var rateLimitStatisticSent = false
 
+    // Stats batching - queue events and send max once per second
+    private var statsQueue: [StatsEvent] = []
+    private let statsQueueLock = NSLock()
+    private var statsFlushTimer: Timer?
+    private static let statsFlushInterval: TimeInterval = 1.0
+
     private var userAgent: String {
         let safePluginVersion = pluginVersion.isEmpty ? "unknown" : pluginVersion
         let safeAppId = appId.isEmpty ? "unknown" : appId
@@ -70,6 +76,15 @@ import UIKit
         self.logger = logger
     }
 
+    deinit {
+        // Invalidate the stats timer to prevent memory leaks
+        statsFlushTimer?.invalidate()
+        statsFlushTimer = nil
+
+        // Flush any remaining stats before deallocation
+        flushStatsQueue()
+    }
+
     private func calcTotalPercent(percent: Int, min: Int, max: Int) -> Int {
         return (percent * (max - min)) / 100 + min
     }
@@ -80,12 +95,20 @@ import UIKit
     }
 
     public func setPublicKey(_ publicKey: String) {
-        self.publicKey = publicKey
-        if !publicKey.isEmpty {
-            self.cachedKeyId = CryptoCipher.calcKeyId(publicKey: publicKey)
-        } else {
+        // Empty string means no encryption - proceed normally
+        if publicKey.isEmpty {
+            self.publicKey = ""
             self.cachedKeyId = nil
+            return
+        }
+
+        // Non-empty: must be a valid RSA key or crash
+        guard RSAPublicKey.load(rsaPublicKey: publicKey) != nil else {
+            fatalError("Invalid public key in capacitor.config.json: failed to parse RSA key. Remove the key or provide a valid PEM-formatted RSA public key.")
         }
+
+        self.publicKey = publicKey
+        self.cachedKeyId = CryptoCipher.calcKeyId(publicKey: publicKey)
     }
 
     public func getKeyId() -> String? {
@@ -104,6 +127,38 @@ import UIKit
         return !self.isDevEnvironment && !self.isAppStoreReceiptSandbox() && !self.hasEmbeddedMobileProvision()
     }
 
+    /**
+     * Checks if there is sufficient disk space for a download.
+     * Matches Android behavior: 2x safety margin, throws "insufficient_disk_space"
+     * - Parameter estimatedSize: The estimated size of the download in bytes. Defaults to 50MB.
+     */
+    private func checkDiskSpace(estimatedSize: Int64 = 50 * 1024 * 1024) throws {
+        let fileManager = FileManager.default
+        guard let documentDirectory = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first else {
+            return
+        }
+
+        do {
+            let attributes = try fileManager.attributesOfFileSystem(forPath: documentDirectory.path)
+            guard let freeSpace = attributes[.systemFreeSize] as? Int64 else {
+                logger.warn("Could not determine free disk space, proceeding with download")
+                return
+            }
+
+            let requiredSpace = estimatedSize * 2 // 2x safety margin like Android
+
+            if freeSpace < requiredSpace {
+                logger.error("Insufficient disk space. Available: \(freeSpace), Required: \(requiredSpace)")
+                self.sendStats(action: "insufficient_disk_space")
+                throw CustomError.insufficientDiskSpace
+            }
+        } catch let error as CustomError {
+            throw error
+        } catch {
+            logger.warn("Error checking disk space: \(error.localizedDescription)")
+        }
+    }
+
     /**
      * Check if a 429 (Too Many Requests) response was received and set the flag
      */
@@ -328,6 +383,56 @@ import UIKit
         }
     }
 
+    private func populateDeltaCacheAsync(for id: String) {
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            self?.populateDeltaCache(for: id)
+        }
+    }
+
+    private func populateDeltaCache(for id: String) {
+        let bundleDir = self.getBundleDirectory(id: id)
+        let fileManager = FileManager.default
+
+        guard fileManager.fileExists(atPath: bundleDir.path) else {
+            logger.debug("Skip delta cache population: bundle dir missing")
+            return
+        }
+
+        do {
+            try fileManager.createDirectory(at: cacheFolder, withIntermediateDirectories: true, attributes: nil)
+        } catch {
+            logger.debug("Skip delta cache population: failed to create cache dir")
+            return
+        }
+
+        guard let enumerator = fileManager.enumerator(at: bundleDir, includingPropertiesForKeys: [.isDirectoryKey], options: [.skipsHiddenFiles]) else {
+            return
+        }
+
+        for case let fileURL as URL in enumerator {
+            let resourceValues = try? fileURL.resourceValues(forKeys: [.isDirectoryKey])
+            if resourceValues?.isDirectory == true {
+                continue
+            }
+
+            let checksum = CryptoCipher.calcChecksum(filePath: fileURL)
+            if checksum.isEmpty {
+                continue
+            }
+
+            let cacheFile = cacheFolder.appendingPathComponent("\(checksum)_\(fileURL.lastPathComponent)")
+            if fileManager.fileExists(atPath: cacheFile.path) {
+                continue
+            }
+
+            do {
+                try fileManager.copyItem(at: fileURL, to: cacheFile)
+            } catch {
+                logger.debug("Delta cache copy failed: \(fileURL.path)")
+            }
+        }
+    }
+
     private func createInfoObject() -> InfoObject {
         return InfoObject(
             platform: "ios",
@@ -417,13 +522,15 @@ import UIKit
         logger.info("Current bundle set to: \((bundle ).isEmpty ? BundleInfo.ID_BUILTIN : bundle)")
     }
 
-    private var tempDataPath: URL {
-        return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!.appendingPathComponent("package.tmp")
+    // Per-download temp file paths to prevent collisions when multiple downloads run concurrently
+    private func tempDataPath(for id: String) -> URL {
+        return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!.appendingPathComponent("package_\(id).tmp")
     }
 
-    private var updateInfo: URL {
-        return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!.appendingPathComponent("update.dat")
+    private func updateInfoPath(for id: String) -> URL {
+        return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!.appendingPathComponent("update_\(id).dat")
     }
+
     private var tempData = Data()
 
     private func verifyChecksum(file: URL, expectedHash: String) -> Bool {
@@ -437,6 +544,10 @@ import UIKit
         let destFolder = self.getBundleDirectory(id: id)
         let builtinFolder = Bundle.main.bundleURL.appendingPathComponent("public")
 
+        // Check disk space before starting manifest download (estimate 100KB per file, minimum 50MB)
+        let estimatedSize = Int64(max(manifest.count * 100 * 1024, 50 * 1024 * 1024))
+        try checkDiskSpace(estimatedSize: estimatedSize)
+
         try FileManager.default.createDirectory(at: cacheFolder, withIntermediateDirectories: true, attributes: nil)
         try FileManager.default.createDirectory(at: destFolder, withIntermediateDirectories: true, attributes: nil)
 
@@ -450,11 +561,19 @@ import UIKit
         // Notify the start of the download process
         self.notifyDownload(id: id, percent: 0, ignoreMultipleOfTen: true)
 
-        let dispatchGroup = DispatchGroup()
+        let totalFiles = manifest.count
+
+        // Configure concurrent operation count similar to Android: min(64, max(32, totalFiles))
+        manifestDownloadQueue.maxConcurrentOperationCount = min(64, max(32, totalFiles))
+
+        // Thread-safe counters for concurrent operations
+        let completedFiles = AtomicCounter()
+        let hasError = AtomicBool(initialValue: false)
         var downloadError: Error?
+        let errorLock = NSLock()
 
-        let totalFiles = manifest.count
-        var completedFiles = 0
+        // Create operations for each file
+        var operations: [Operation] = []
 
         for entry in manifest {
             guard let fileName = entry.file_name,
@@ -463,134 +582,90 @@ import UIKit
                 continue
             }
 
+            // Decrypt checksum if needed (done before creating operation)
             if !self.publicKey.isEmpty && !sessionKey.isEmpty {
                 do {
                     fileHash = try CryptoCipher.decryptChecksum(checksum: fileHash, publicKey: self.publicKey)
                 } catch {
+                    errorLock.lock()
                     downloadError = error
+                    errorLock.unlock()
+                    hasError.value = true
                     logger.error("Checksum decryption failed")
                     logger.debug("Bundle: \(id), File: \(fileName), Error: \(error)")
+                    continue
                 }
             }
 
-            // Check if file has .br extension for Brotli decompression
+            let finalFileHash = fileHash
             let fileNameWithoutPath = (fileName as NSString).lastPathComponent
-            let cacheFileName = "\(fileHash)_\(fileNameWithoutPath)"
-            let cacheFilePath = cacheFolder.appendingPathComponent(cacheFileName)
-
-            // Check if file is Brotli compressed and remove .br extension from destination
             let isBrotli = fileName.hasSuffix(".br")
-            let destFileName = isBrotli ? String(fileName.dropLast(3)) : fileName
+            let cacheBaseName = isBrotli ? String(fileNameWithoutPath.dropLast(3)) : fileNameWithoutPath
+            let cacheFilePath = cacheFolder.appendingPathComponent("\(finalFileHash)_\(cacheBaseName)")
+            let legacyCacheFilePath: URL? = isBrotli ? cacheFolder.appendingPathComponent("\(finalFileHash)_\(fileNameWithoutPath)") : nil
 
+            let destFileName = isBrotli ? String(fileName.dropLast(3)) : fileName
             let destFilePath = destFolder.appendingPathComponent(destFileName)
             let builtinFilePath = builtinFolder.appendingPathComponent(fileName)
 
-            // Create necessary subdirectories in the destination folder
-            try FileManager.default.createDirectory(at: destFilePath.deletingLastPathComponent(), withIntermediateDirectories: true, attributes: nil)
+            // Create parent directories synchronously (before operations start)
+            try? FileManager.default.createDirectory(at: destFilePath.deletingLastPathComponent(), withIntermediateDirectories: true, attributes: nil)
 
-            dispatchGroup.enter()
+            let operation = BlockOperation { [weak self] in
+                guard let self = self else { return }
+                guard !hasError.value else { return } // Skip if error already occurred
 
-            if FileManager.default.fileExists(atPath: builtinFilePath.path) && verifyChecksum(file: builtinFilePath, expectedHash: fileHash) {
                 do {
-                    try FileManager.default.copyItem(at: builtinFilePath, to: destFilePath)
-                    logger.info("downloadManifest \(fileName) using builtin file \(id)")
-                    completedFiles += 1
-                    self.notifyDownload(id: id, percent: self.calcTotalPercent(percent: Int((Double(completedFiles) / Double(totalFiles)) * 100), min: 10, max: 70))
-                } catch {
-                    downloadError = error
-                    logger.error("Failed to copy builtin file")
-                    logger.debug("File: \(fileName), Error: \(error.localizedDescription)")
-                }
-                dispatchGroup.leave()
-            } else if self.tryCopyFromCache(from: cacheFilePath, to: destFilePath, expectedHash: fileHash) {
-                // Successfully copied from cache
-                logger.info("downloadManifest \(fileName) copy from cache \(id)")
-                completedFiles += 1
-                self.notifyDownload(id: id, percent: self.calcTotalPercent(percent: Int((Double(completedFiles) / Double(totalFiles)) * 100), min: 10, max: 70))
-                dispatchGroup.leave()
-            } else {
-                // File not in cache, download, decompress, and save to both cache and destination
-                self.alamofireSession.download(downloadUrl).responseData { response in
-                    defer { dispatchGroup.leave() }
+                    // Try builtin first
+                    if FileManager.default.fileExists(atPath: builtinFilePath.path) && self.verifyChecksum(file: builtinFilePath, expectedHash: finalFileHash) {
+                        try FileManager.default.copyItem(at: builtinFilePath, to: destFilePath)
+                        self.logger.info("downloadManifest \(fileName) using builtin file \(id)")
+                    }
+                    // Try cache
+                    else if
+                        self.tryCopyFromCache(from: cacheFilePath, to: destFilePath, expectedHash: finalFileHash) ||
+                            (legacyCacheFilePath != nil && self.tryCopyFromCache(from: legacyCacheFilePath!, to: destFilePath, expectedHash: finalFileHash)) {
+                        self.logger.info("downloadManifest \(fileName) copy from cache \(id)")
+                    }
+                    // Download
+                    else {
+                        try self.downloadManifestFile(
+                            downloadUrl: downloadUrl,
+                            destFilePath: destFilePath,
+                            cacheFilePath: cacheFilePath,
+                            fileHash: finalFileHash,
+                            fileName: fileName,
+                            destFileName: destFileName,
+                            isBrotli: isBrotli,
+                            sessionKey: sessionKey,
+                            version: version,
+                            bundleId: id
+                        )
+                    }
 
-                    switch response.result {
-                    case .success(let data):
-                        do {
-                            let statusCode = response.response?.statusCode ?? 200
-                            if statusCode < 200 || statusCode >= 300 {
-                                self.sendStats(action: "download_manifest_file_fail", versionName: "\(version):\(fileName)")
-                                if let stringData = String(data: data, encoding: .utf8) {
-                                    throw NSError(domain: "StatusCodeError", code: 2, userInfo: [NSLocalizedDescriptionKey: "Failed to fetch. Status code (\(statusCode)) invalid. Data: \(stringData) for file \(fileName) at url \(downloadUrl)"])
-                                } else {
-                                    throw NSError(domain: "StatusCodeError", code: 2, userInfo: [NSLocalizedDescriptionKey: "Failed to fetch. Status code (\(statusCode)) invalid for file \(fileName) at url \(downloadUrl)"])
-                                }
-                            }
-
-                            // Add decryption step if public key is set and sessionKey is provided
-                            var finalData = data
-                            if !self.publicKey.isEmpty && !sessionKey.isEmpty {
-                                let tempFile = self.cacheFolder.appendingPathComponent("temp_\(UUID().uuidString)")
-                                try finalData.write(to: tempFile)
-                                do {
-                                    try CryptoCipher.decryptFile(filePath: tempFile, publicKey: self.publicKey, sessionKey: sessionKey, version: version)
-                                } catch {
-                                    self.sendStats(action: "decrypt_fail", versionName: version)
-                                    throw error
-                                }
-                                // TODO: try and do             self.sendStats(action: "decrypt_fail", versionName: version) if fail
-                                finalData = try Data(contentsOf: tempFile)
-                                try FileManager.default.removeItem(at: tempFile)
-                            }
-
-                            // Use the isBrotli and destFilePath already computed above
-                            if isBrotli {
-                                // Decompress the Brotli data
-                                guard let decompressedData = self.decompressBrotli(data: finalData, fileName: fileName) else {
-                                    self.sendStats(action: "download_manifest_brotli_fail", versionName: "\(version):\(destFileName)")
-                                    throw NSError(domain: "BrotliDecompressionError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Failed to decompress Brotli data for file \(fileName) at url \(downloadUrl)"])
-                                }
-                                finalData = decompressedData
-                            }
-
-                            try finalData.write(to: destFilePath)
-                            if !self.publicKey.isEmpty && !sessionKey.isEmpty {
-                                // assume that calcChecksum != null
-                                let calculatedChecksum = CryptoCipher.calcChecksum(filePath: destFilePath)
-                                CryptoCipher.logChecksumInfo(label: "Calculated checksum", hexChecksum: calculatedChecksum)
-                                CryptoCipher.logChecksumInfo(label: "Expected checksum", hexChecksum: fileHash)
-                                if calculatedChecksum != fileHash {
-                                    // Delete the corrupt file before throwing error
-                                    try? FileManager.default.removeItem(at: destFilePath)
-                                    self.sendStats(action: "download_manifest_checksum_fail", versionName: "\(version):\(destFileName)")
-                                    throw NSError(domain: "ChecksumError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Computed checksum is not equal to required checksum (\(calculatedChecksum) != \(fileHash)) for file \(fileName) at url \(downloadUrl)"])
-                                }
-                            }
-
-                            // Save decrypted data to cache and destination
-                            try finalData.write(to: cacheFilePath)
-
-                            completedFiles += 1
-                            self.notifyDownload(id: id, percent: self.calcTotalPercent(percent: Int((Double(completedFiles) / Double(totalFiles)) * 100), min: 10, max: 70))
-                            self.logger.info("Manifest file downloaded and cached")
-                            self.logger.debug("Bundle: \(id), File: \(fileName), Brotli: \(isBrotli), Encrypted: \(!self.publicKey.isEmpty && !sessionKey.isEmpty)")
-                        } catch {
-                            downloadError = error
-                            self.logger.error("Manifest file download failed")
-                            self.logger.debug("Bundle: \(id), File: \(fileName), Error: \(error.localizedDescription)")
-                        }
-                    case .failure(let error):
+                    let completed = completedFiles.increment()
+                    let percent = self.calcTotalPercent(percent: Int((Double(completed) / Double(totalFiles)) * 100), min: 10, max: 70)
+                    self.notifyDownload(id: id, percent: percent)
+
+                } catch {
+                    errorLock.lock()
+                    if downloadError == nil {
                         downloadError = error
-                        self.sendStats(action: "download_manifest_file_fail", versionName: "\(version):\(fileName)")
-                        self.logger.error("Manifest file download network error")
-                        self.logger.debug("Bundle: \(id), File: \(fileName), Error: \(error.localizedDescription), Response: \(response.debugDescription)")
                     }
+                    errorLock.unlock()
+                    hasError.value = true
+                    self.logger.error("Manifest file download failed: \(fileName)")
+                    self.logger.debug("Bundle: \(id), File: \(fileName), Error: \(error.localizedDescription)")
                 }
             }
+
+            operations.append(operation)
         }
 
-        dispatchGroup.wait()
+        // Execute all operations concurrently and wait for completion
+        manifestDownloadQueue.addOperations(operations, waitUntilFinished: true)
 
-        if let error = downloadError {
+        if hasError.value, let error = downloadError {
             // Update bundle status to ERROR if download failed
             let errorBundle = bundleInfo.setStatus(status: BundleStatus.ERROR.localizedString)
             self.saveBundleInfo(id: id, bundle: errorBundle)
@@ -609,6 +684,105 @@ import UIKit
         return updatedBundle
     }
 
+    /// Downloads a single manifest file synchronously
+    /// Used by downloadManifest for concurrent file downloads
+    private func downloadManifestFile(
+        downloadUrl: String,
+        destFilePath: URL,
+        cacheFilePath: URL,
+        fileHash: String,
+        fileName: String,
+        destFileName: String,
+        isBrotli: Bool,
+        sessionKey: String,
+        version: String,
+        bundleId: String
+    ) throws {
+        let semaphore = DispatchSemaphore(value: 0)
+        var downloadError: Error?
+
+        self.alamofireSession.download(downloadUrl).responseData { response in
+            defer { semaphore.signal() }
+
+            switch response.result {
+            case .success(let data):
+                do {
+                    let statusCode = response.response?.statusCode ?? 200
+                    if statusCode < 200 || statusCode >= 300 {
+                        self.sendStats(action: "download_manifest_file_fail", versionName: "\(version):\(fileName)")
+                        if let stringData = String(data: data, encoding: .utf8) {
+                            throw NSError(domain: "StatusCodeError", code: statusCode, userInfo: [NSLocalizedDescriptionKey: "Failed to fetch. Status code (\(statusCode)) invalid. Data: \(stringData) for file \(fileName) at url \(downloadUrl)"])
+                        } else {
+                            throw NSError(domain: "StatusCodeError", code: statusCode, userInfo: [NSLocalizedDescriptionKey: "Failed to fetch. Status code (\(statusCode)) invalid for file \(fileName) at url \(downloadUrl)"])
+                        }
+                    }
+
+                    // Add decryption step if public key is set and sessionKey is provided
+                    var finalData = data
+                    if !self.publicKey.isEmpty && !sessionKey.isEmpty {
+                        let tempFile = self.cacheFolder.appendingPathComponent("temp_\(UUID().uuidString)")
+                        try finalData.write(to: tempFile)
+                        do {
+                            try CryptoCipher.decryptFile(filePath: tempFile, publicKey: self.publicKey, sessionKey: sessionKey, version: version)
+                        } catch {
+                            self.sendStats(action: "decrypt_fail", versionName: version)
+                            throw error
+                        }
+                        finalData = try Data(contentsOf: tempFile)
+                        try FileManager.default.removeItem(at: tempFile)
+                    }
+
+                    // Decompress Brotli if needed
+                    if isBrotli {
+                        guard let decompressedData = self.decompressBrotli(data: finalData, fileName: fileName) else {
+                            self.sendStats(action: "download_manifest_brotli_fail", versionName: "\(version):\(destFileName)")
+                            throw NSError(domain: "BrotliDecompressionError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Failed to decompress Brotli data for file \(fileName) at url \(downloadUrl)"])
+                        }
+                        finalData = decompressedData
+                    }
+
+                    // Write to destination
+                    try finalData.write(to: destFilePath)
+
+                    // Verify checksum if encryption is enabled
+                    if !self.publicKey.isEmpty && !sessionKey.isEmpty {
+                        let calculatedChecksum = CryptoCipher.calcChecksum(filePath: destFilePath)
+                        CryptoCipher.logChecksumInfo(label: "Calculated checksum", hexChecksum: calculatedChecksum)
+                        CryptoCipher.logChecksumInfo(label: "Expected checksum", hexChecksum: fileHash)
+                        if calculatedChecksum != fileHash {
+                            try? FileManager.default.removeItem(at: destFilePath)
+                            self.sendStats(action: "download_manifest_checksum_fail", versionName: "\(version):\(destFileName)")
+                            throw NSError(domain: "ChecksumError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Computed checksum is not equal to required checksum (\(calculatedChecksum) != \(fileHash)) for file \(fileName) at url \(downloadUrl)"])
+                        }
+                    }
+
+                    // Save to cache
+                    try finalData.write(to: cacheFilePath)
+
+                    self.logger.info("Manifest file downloaded and cached")
+                    self.logger.debug("Bundle: \(bundleId), File: \(fileName), Brotli: \(isBrotli), Encrypted: \(!self.publicKey.isEmpty && !sessionKey.isEmpty)")
+
+                } catch {
+                    downloadError = error
+                    self.logger.error("Manifest file download failed")
+                    self.logger.debug("Bundle: \(bundleId), File: \(fileName), Error: \(error.localizedDescription)")
+                }
+
+            case .failure(let error):
+                downloadError = error
+                self.sendStats(action: "download_manifest_file_fail", versionName: "\(version):\(fileName)")
+                self.logger.error("Manifest file download network error")
+                self.logger.debug("Bundle: \(bundleId), File: \(fileName), Error: \(error.localizedDescription), Response: \(response.debugDescription)")
+            }
+        }
+
+        semaphore.wait()
+
+        if let error = downloadError {
+            throw error
+        }
+    }
+
     /// Atomically try to copy a file from cache - returns true if successful, false if file doesn't exist or copy failed
     /// This handles the race condition where OS can delete cache files between exists() check and copy
     private func tryCopyFromCache(from source: URL, to destination: URL, expectedHash: String) -> Bool {
@@ -754,15 +928,20 @@ import UIKit
     public func download(url: URL, version: String, sessionKey: String, link: String? = nil, comment: String? = nil) throws -> BundleInfo {
         let id: String = self.randomString(length: 10)
         let semaphore = DispatchSemaphore(value: 0)
-        if version != getLocalUpdateVersion() {
-            cleanDownloadData()
+        // Each download uses its own temp files keyed by bundle ID to prevent collisions
+        if version != getLocalUpdateVersion(for: id) {
+            cleanDownloadData(for: id)
         }
-        ensureResumableFilesExist()
-        saveDownloadInfo(version)
+        ensureResumableFilesExist(for: id)
+        saveDownloadInfo(version, for: id)
+
+        // Check disk space before starting download (matches Android behavior)
+        try checkDiskSpace()
+
         var checksum = ""
         var targetSize = -1
         var lastSentProgress = 0
-        var totalReceivedBytes: Int64 = loadDownloadProgress() // Retrieving the amount of already downloaded data if exist, defined at 0 otherwise
+        var totalReceivedBytes: Int64 = loadDownloadProgress(for: id) // Retrieving the amount of already downloaded data if exist, defined at 0 otherwise
         let requestHeaders: HTTPHeaders = ["Range": "bytes=\(totalReceivedBytes)-"]
 
         // Send stats for zip download start
@@ -795,7 +974,7 @@ import UIKit
                 if case .success(let data) = result {
                     self.tempData.append(data)
 
-                    self.savePartialData(startingAt: UInt64(totalReceivedBytes)) // Saving the received data in the package.tmp file
+                    self.savePartialData(startingAt: UInt64(totalReceivedBytes), for: id) // Saving the received data in the package_<id>.tmp file
                     totalReceivedBytes += Int64(data.count)
 
                     let percent = max(10, Int((Double(totalReceivedBytes) / Double(targetSize)) * 70.0))
@@ -841,15 +1020,16 @@ import UIKit
             throw mainError!
         }
 
-        let finalPath = tempDataPath.deletingLastPathComponent().appendingPathComponent("\(id)")
+        let tempPath = tempDataPath(for: id)
+        let finalPath = tempPath.deletingLastPathComponent().appendingPathComponent("\(id)")
         do {
-            try CryptoCipher.decryptFile(filePath: tempDataPath, publicKey: self.publicKey, sessionKey: sessionKey, version: version)
-            try FileManager.default.moveItem(at: tempDataPath, to: finalPath)
+            try CryptoCipher.decryptFile(filePath: tempPath, publicKey: self.publicKey, sessionKey: sessionKey, version: version)
+            try FileManager.default.moveItem(at: tempPath, to: finalPath)
         } catch {
             logger.error("Failed to decrypt file")
             logger.debug("Error: \(error)")
             self.saveBundleInfo(id: id, bundle: BundleInfo(id: id, version: version, status: BundleStatus.ERROR, downloaded: Date(), checksum: checksum, link: link, comment: comment))
-            cleanDownloadData()
+            cleanDownloadData(for: id)
             throw error
         }
 
@@ -858,6 +1038,7 @@ import UIKit
             CryptoCipher.logChecksumInfo(label: "Calculated bundle checksum", hexChecksum: checksum)
             logger.info("Downloading: 80% (unzipping)")
             try self.saveDownloaded(sourceZip: finalPath, id: id, base: self.libraryDir.appendingPathComponent(self.bundleDirectory), notify: true)
+            self.populateDeltaCacheAsync(for: id)
 
         } catch {
             logger.error("Failed to unzip file")
@@ -872,7 +1053,7 @@ import UIKit
                 logger.error("Could not delete failed zip")
                 logger.debug("Path: \(finalPath.path), Error: \(error)")
             }
-            cleanDownloadData()
+            cleanDownloadData(for: id)
             throw error
         }
 
@@ -880,7 +1061,7 @@ import UIKit
         logger.info("Downloading: 90% (wrapping up)")
         let info = BundleInfo(id: id, version: version, status: BundleStatus.PENDING, downloaded: Date(), checksum: checksum, link: link, comment: comment)
         self.saveBundleInfo(id: id, bundle: info)
-        self.cleanDownloadData()
+        self.cleanDownloadData(for: id)
 
         // Send stats for zip download complete
         self.sendStats(action: "download_zip_complete", versionName: version)
@@ -889,54 +1070,59 @@ import UIKit
         logger.info("Downloading: 100% (complete)")
         return info
     }
-    private func ensureResumableFilesExist() {
+    private func ensureResumableFilesExist(for id: String) {
         let fileManager = FileManager.default
-        if !fileManager.fileExists(atPath: tempDataPath.path) {
-            if !fileManager.createFile(atPath: tempDataPath.path, contents: Data()) {
+        let tempPath = tempDataPath(for: id)
+        let infoPath = updateInfoPath(for: id)
+        if !fileManager.fileExists(atPath: tempPath.path) {
+            if !fileManager.createFile(atPath: tempPath.path, contents: Data()) {
                 logger.error("Cannot ensure temp data file exists")
-                logger.debug("Path: \(tempDataPath.path)")
+                logger.debug("Path: \(tempPath.path)")
             }
         }
 
-        if !fileManager.fileExists(atPath: updateInfo.path) {
-            if !fileManager.createFile(atPath: updateInfo.path, contents: Data()) {
+        if !fileManager.fileExists(atPath: infoPath.path) {
+            if !fileManager.createFile(atPath: infoPath.path, contents: Data()) {
                 logger.error("Cannot ensure update info file exists")
-                logger.debug("Path: \(updateInfo.path)")
+                logger.debug("Path: \(infoPath.path)")
             }
         }
     }
 
-    private func cleanDownloadData() {
-        // Deleting package.tmp
+    private func cleanDownloadData(for id: String) {
         let fileManager = FileManager.default
-        if fileManager.fileExists(atPath: tempDataPath.path) {
+        let tempPath = tempDataPath(for: id)
+        let infoPath = updateInfoPath(for: id)
+        // Deleting package_<id>.tmp
+        if fileManager.fileExists(atPath: tempPath.path) {
             do {
-                try fileManager.removeItem(at: tempDataPath)
+                try fileManager.removeItem(at: tempPath)
             } catch {
                 logger.error("Could not delete temp data file")
-                logger.debug("Path: \(tempDataPath), Error: \(error)")
+                logger.debug("Path: \(tempPath), Error: \(error)")
             }
         }
-        // Deleting update.dat
-        if fileManager.fileExists(atPath: updateInfo.path) {
+        // Deleting update_<id>.dat
+        if fileManager.fileExists(atPath: infoPath.path) {
             do {
-                try fileManager.removeItem(at: updateInfo)
+                try fileManager.removeItem(at: infoPath)
             } catch {
                 logger.error("Could not delete update info file")
-                logger.debug("Path: \(updateInfo), Error: \(error)")
+                logger.debug("Path: \(infoPath), Error: \(error)")
             }
         }
     }
 
-    private func savePartialData(startingAt byteOffset: UInt64) {
+    private func savePartialData(startingAt byteOffset: UInt64, for id: String) {
         let fileManager = FileManager.default
+        let tempPath = tempDataPath(for: id)
         do {
-            // Check if package.tmp exist
-            if !fileManager.fileExists(atPath: tempDataPath.path) {
-                try self.tempData.write(to: tempDataPath, options: .atomicWrite)
+            // Check if package_<id>.tmp exist
+            if !fileManager.fileExists(atPath: tempPath.path) {
+                try self.tempData.write(to: tempPath, options: .atomicWrite)
             } else {
                 // If yes, it start writing on it
-                let fileHandle = try FileHandle(forWritingTo: tempDataPath)
+                let fileHandle = try FileHandle(forWritingTo: tempPath)
                 fileHandle.seek(toFileOffset: byteOffset) // Moving at the specified position to start writing
                 fileHandle.write(self.tempData)
                 fileHandle.closeFile()
@@ -948,29 +1134,33 @@ import UIKit
         self.tempData.removeAll() // Clearing tempData to avoid writing the same data multiple times
     }
 
-    private func saveDownloadInfo(_ version: String) {
+    private func saveDownloadInfo(_ version: String, for id: String) {
+        let infoPath = updateInfoPath(for: id)
         do {
-            try "\(version)".write(to: updateInfo, atomically: true, encoding: .utf8)
+            try "\(version)".write(to: infoPath, atomically: true, encoding: .utf8)
         } catch {
             logger.error("Failed to save download progress")
             logger.debug("Error: \(error)")
         }
     }
-    private func getLocalUpdateVersion() -> String { // Return the version that was tried to be downloaded on last download attempt
-        if !FileManager.default.fileExists(atPath: updateInfo.path) {
+
+    private func getLocalUpdateVersion(for id: String) -> String { // Return the version that was tried to be downloaded on last download attempt
+        let infoPath = updateInfoPath(for: id)
+        if !FileManager.default.fileExists(atPath: infoPath.path) {
             return "nil"
         }
-        guard let versionString = try? String(contentsOf: updateInfo),
+        guard let versionString = try? String(contentsOf: infoPath),
               let version = Optional(versionString) else {
             return "nil"
         }
         return version
     }
-    private func loadDownloadProgress() -> Int64 {
 
+    private func loadDownloadProgress(for id: String) -> Int64 {
         let fileManager = FileManager.default
+        let tempPath = tempDataPath(for: id)
         do {
-            let attributes = try fileManager.attributesOfItem(atPath: tempDataPath.path)
+            let attributes = try fileManager.attributesOfItem(atPath: tempPath.path)
             if let fileSize = attributes[.size] as? NSNumber {
                 return fileSize.int64Value
             }
@@ -1174,6 +1364,44 @@ import UIKit
             logger.error("Failed to enumerate library directory for temp folder cleanup")
             logger.debug("Error: \(error.localizedDescription)")
         }
+
+        // Also cleanup old download temp files (package_*.tmp and update_*.dat)
+        cleanupOldDownloadTempFiles()
+    }
+
+    private func cleanupOldDownloadTempFiles() {
+        let fileManager = FileManager.default
+        guard let documentsDir = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first else {
+            return
+        }
+
+        do {
+            let contents = try fileManager.contentsOfDirectory(at: documentsDir, includingPropertiesForKeys: [.contentModificationDateKey], options: [.skipsHiddenFiles])
+            let oneHourAgo = Date().addingTimeInterval(-3600)
+
+            for url in contents {
+                let fileName = url.lastPathComponent
+                // Only cleanup package_*.tmp and update_*.dat files
+                let isDownloadTemp = (fileName.hasPrefix("package_") && fileName.hasSuffix(".tmp")) ||
+                    (fileName.hasPrefix("update_") && fileName.hasSuffix(".dat"))
+                if !isDownloadTemp {
+                    continue
+                }
+
+                // Only delete files older than 1 hour
+                if let modDate = try? url.resourceValues(forKeys: [.contentModificationDateKey]).contentModificationDate,
+                   modDate < oneHourAgo {
+                    do {
+                        try fileManager.removeItem(at: url)
+                        logger.debug("Deleted old download temp file: \(fileName)")
+                    } catch {
+                        logger.debug("Failed to delete old download temp file: \(fileName), Error: \(error.localizedDescription)")
+                    }
+                }
+            }
+        } catch {
+            logger.debug("Failed to enumerate documents directory for temp file cleanup: \(error.localizedDescription)")
+        }
     }
 
     public func getBundleDirectory(id: String) -> URL {
@@ -1499,6 +1727,13 @@ import UIKit
 
     private let operationQueue = OperationQueue()
 
+    private let manifestDownloadQueue: OperationQueue = {
+        let queue = OperationQueue()
+        queue.name = "com.capgo.manifestDownload"
+        queue.qualityOfService = .userInitiated
+        return queue
+    }()
+
     func sendStats(action: String, versionName: String? = nil, oldVersionName: String? = "") {
         // Check if rate limit was exceeded
         if CapgoUpdater.rateLimitExceeded {
@@ -1509,21 +1744,70 @@ import UIKit
         guard !statsUrl.isEmpty else {
             return
         }
-        operationQueue.maxConcurrentOperationCount = 1
 
-        let versionName = versionName ?? getCurrentBundle().getVersionName()
+        let resolvedVersionName = versionName ?? getCurrentBundle().getVersionName()
+        let info = createInfoObject()
+
+        let event = StatsEvent(
+            platform: info.platform,
+            device_id: info.device_id,
+            app_id: info.app_id,
+            custom_id: info.custom_id,
+            version_build: info.version_build,
+            version_code: info.version_code,
+            version_os: info.version_os,
+            version_name: resolvedVersionName,
+            old_version_name: oldVersionName ?? "",
+            plugin_version: info.plugin_version,
+            is_emulator: info.is_emulator,
+            is_prod: info.is_prod,
+            action: action,
+            channel: info.channel,
+            defaultChannel: info.defaultChannel,
+            key_id: info.key_id,
+            timestamp: Int64(Date().timeIntervalSince1970 * 1000)
+        )
+
+        statsQueueLock.lock()
+        statsQueue.append(event)
+        statsQueueLock.unlock()
 
-        var parameters = createInfoObject()
-        parameters.action = action
-        parameters.version_name = versionName
-        parameters.old_version_name = oldVersionName ?? ""
+        ensureStatsTimerStarted()
+    }
+
+    private func ensureStatsTimerStarted() {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            if self.statsFlushTimer == nil || !self.statsFlushTimer!.isValid {
+                // Use closure-based timer to avoid strong reference cycle
+                self.statsFlushTimer = Timer.scheduledTimer(
+                    withTimeInterval: CapgoUpdater.statsFlushInterval,
+                    repeats: true
+                ) { [weak self] _ in
+                    self?.flushStatsQueue()
+                }
+            }
+        }
+    }
+
+    private func flushStatsQueue() {
+        statsQueueLock.lock()
+        guard !statsQueue.isEmpty else {
+            statsQueueLock.unlock()
+            return
+        }
+        let eventsToSend = statsQueue
+        statsQueue.removeAll()
+        statsQueueLock.unlock()
+
+        operationQueue.maxConcurrentOperationCount = 1
 
         let operation = BlockOperation {
             let semaphore = DispatchSemaphore(value: 0)
             self.alamofireSession.request(
                 self.statsUrl,
                 method: .post,
-                parameters: parameters,
+                parameters: eventsToSend,
                 encoder: JSONParameterEncoder.default,
                 requestModifier: { $0.timeoutInterval = self.timeout }
             ).responseData { response in
@@ -1535,10 +1819,10 @@ import UIKit
 
                 switch response.result {
                 case .success:
-                    self.logger.info("Stats sent successfully")
-                    self.logger.debug("Action: \(action), Version: \(versionName)")
+                    self.logger.info("Stats batch sent successfully")
+                    self.logger.debug("Sent \(eventsToSend.count) events")
                 case let .failure(error):
-                    self.logger.error("Error sending stats")
+                    self.logger.error("Error sending stats batch")
                     self.logger.debug("Response: \(response.value?.debugDescription ?? "nil"), Error: \(error.localizedDescription)")
                 }
                 semaphore.signal()
@@ -1546,7 +1830,6 @@ import UIKit
             semaphore.wait()
         }
         operationQueue.addOperation(operation)
-
     }
 
     public func getBundleInfo(id: String?) -> BundleInfo {