@capgo/capacitor-updater 8.40.7 → 8.41.0

package/android/src/main/java/ee/forgr/capacitor_updater/CapacitorUpdaterPlugin.java

@@ -85,7 +85,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
     private static final String[] BREAKING_EVENT_NAMES = { "breakingAvailable", "majorAvailable" };
     private static final String LAST_FAILED_BUNDLE_PREF_KEY = "CapacitorUpdater.lastFailedBundle";
 
-    private final String pluginVersion = "8.40.7";
+    private final String pluginVersion = "8.41.0";
     private static final String DELAY_CONDITION_PREFERENCES = "";
 
     private SharedPreferences.Editor editor;

package/android/src/main/java/ee/forgr/capacitor_updater/CryptoCipher.java

@@ -357,8 +357,10 @@ public class CryptoCipher {
     }
 
     /**
-     * Get first 4 characters of the public key for identification.
-     * Returns 4-character string or empty string if key is invalid/empty.
+     * Get first 20 characters of the public key for identification.
+     * Returns 20-character string or empty string if key is invalid/empty.
+     * The first 12 chars are always "MIIBCgKCAQEA" for RSA 2048-bit keys,
+     * so the unique part starts at character 13.
      */
     public static String calcKeyId(String publicKey) {
         if (publicKey == null || publicKey.isEmpty()) {
@@ -371,7 +373,7 @@ public class CryptoCipher {
             .replace("-----BEGINRSAPUBLICKEY-----", "")
             .replace("-----ENDRSAPUBLICKEY-----", "");
 
-        // Return first 4 characters of the base64-encoded key
-        return cleanedKey.length() >= 4 ? cleanedKey.substring(0, 4) : cleanedKey;
+        // Return first 20 characters of the base64-encoded key
+        return cleanedKey.length() >= 20 ? cleanedKey.substring(0, 20) : cleanedKey;
     }
 }

package/android/src/main/java/ee/forgr/capacitor_updater/DownloadService.java

@@ -388,8 +388,9 @@ public class DownloadService extends Worker {
         sendStatsAsync("download_zip_start", version);
 
         File target = new File(documentsDir, dest);
-        File infoFile = new File(documentsDir, UPDATE_FILE);
-        File tempFile = new File(documentsDir, "temp" + ".tmp");
+        // Use bundle ID in temp file names to prevent collisions when multiple downloads run concurrently
+        File infoFile = new File(documentsDir, "update_" + id + ".dat");
+        File tempFile = new File(documentsDir, "temp_" + id + ".tmp");
 
         // Check available disk space before starting
         long availableSpace = target.getParentFile().getUsableSpace();
@@ -420,7 +421,7 @@ public class DownloadService extends Worker {
                     reader = new BufferedReader(new FileReader(infoFile));
                     String updateVersion = reader.readLine();
                     if (updateVersion != null && !updateVersion.equals(version)) {
-                        clearDownloadData(documentsDir);
+                        clearDownloadData(documentsDir, id);
                     } else {
                         downloadedBytes = tempFile.length();
                     }
@@ -432,7 +433,7 @@ public class DownloadService extends Worker {
                     }
                 }
             } else {
-                clearDownloadData(documentsDir);
+                clearDownloadData(documentsDir, id);
             }
 
             if (downloadedBytes > 0) {
@@ -544,9 +545,9 @@ public class DownloadService extends Worker {
         }
     }
 
-    private void clearDownloadData(String docDir) {
-        File tempFile = new File(docDir, "temp" + ".tmp");
-        File infoFile = new File(docDir, UPDATE_FILE);
+    private void clearDownloadData(String docDir, String id) {
+        File tempFile = new File(docDir, "temp_" + id + ".tmp");
+        File infoFile = new File(docDir, "update_" + id + ".dat");
         try {
             tempFile.delete();
             infoFile.delete();
@@ -824,12 +825,14 @@ public class DownloadService extends Worker {
     }
 
     /**
-     * Clean up old temporary files
+     * Clean up old temporary files (both .tmp and update_*.dat files)
      */
     private void cleanupOldTempFiles(File directory) {
         if (directory == null || !directory.exists()) return;
 
-        File[] tempFiles = directory.listFiles((dir, name) -> name.endsWith(".tmp"));
+        File[] tempFiles = directory.listFiles(
+            (dir, name) -> name.endsWith(".tmp") || (name.startsWith("update_") && name.endsWith(".dat"))
+        );
         if (tempFiles != null) {
             long oneHourAgo = System.currentTimeMillis() - 3600000;
             for (File tempFile : tempFiles) {

package/ios/Sources/CapacitorUpdaterPlugin/CapacitorUpdaterPlugin.swift

@@ -60,7 +60,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "completeFlexibleUpdate", returnType: CAPPluginReturnPromise)
     ]
     public var implementation = CapgoUpdater()
-    private let pluginVersion: String = "8.40.7"
+    private let pluginVersion: String = "8.41.0"
     static let updateUrlDefault = "https://plugin.capgo.app/updates"
     static let statsUrlDefault = "https://plugin.capgo.app/stats"
     static let channelUrlDefault = "https://plugin.capgo.app/channel_self"

package/ios/Sources/CapacitorUpdaterPlugin/CapgoUpdater.swift

@@ -104,6 +104,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
      */
@@ -417,13 +449,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 +471,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 +488,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 +509,87 @@ 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 cacheFileName = "\(finalFileHash)_\(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 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) {
+                        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 +608,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 +852,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 +898,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 +944,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
         }
 
@@ -872,7 +976,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 +984,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 +993,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 +1057,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 +1287,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 +1650,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 {

package/ios/Sources/CapacitorUpdaterPlugin/CryptoCipher.swift

@@ -278,8 +278,10 @@ public struct CryptoCipher {
         }
     }
 
-    /// Get first 4 characters of the public key for identification
-    /// Returns 4-character string or empty string if key is invalid/empty
+    /// Get first 20 characters of the public key for identification
+    /// Returns 20-character string or empty string if key is invalid/empty
+    /// The first 12 chars are always "MIIBCgKCAQEA" for RSA 2048-bit keys,
+    /// so the unique part starts at character 13
     public static func calcKeyId(publicKey: String) -> String {
         if publicKey.isEmpty {
             return ""
@@ -293,7 +295,7 @@ public struct CryptoCipher {
             .replacingOccurrences(of: "\r", with: "")
             .replacingOccurrences(of: " ", with: "")
 
-        // Return first 4 characters of the base64-encoded key
-        return String(cleanedKey.prefix(4))
+        // Return first 20 characters of the base64-encoded key
+        return String(cleanedKey.prefix(20))
     }
 }

package/ios/Sources/CapacitorUpdaterPlugin/InternalUtils.swift

@@ -263,6 +263,7 @@ enum CustomError: Error {
     case cannotDeleteDirectory
     case cannotDecryptSessionKey
     case invalidBase64
+    case insufficientDiskSpace
 
     // Throw in all other cases
     case unexpected(code: Int)
@@ -316,6 +317,53 @@ extension CustomError: LocalizedError {
                 "Decrypting the base64 failed",
                 comment: "Invalid checksum key"
             )
+        case .insufficientDiskSpace:
+            return NSLocalizedString(
+                "Insufficient disk space for download",
+                comment: "Not enough storage"
+            )
+        }
+    }
+}
+
+/// Thread-safe atomic counter for concurrent operations
+final class AtomicCounter {
+    private var value: Int = 0
+    private let lock = NSLock()
+
+    func increment() -> Int {
+        lock.lock()
+        defer { lock.unlock() }
+        value += 1
+        return value
+    }
+
+    var current: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return value
+    }
+}
+
+/// Thread-safe atomic boolean for concurrent operations
+final class AtomicBool {
+    private var _value: Bool
+    private let lock = NSLock()
+
+    init(initialValue: Bool = false) {
+        _value = initialValue
+    }
+
+    var value: Bool {
+        get {
+            lock.lock()
+            defer { lock.unlock() }
+            return _value
+        }
+        set {
+            lock.lock()
+            defer { lock.unlock() }
+            _value = newValue
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-updater",
-  "version": "8.40.7",
+  "version": "8.41.0",
   "license": "MPL-2.0",
   "description": "Live update for capacitor apps",
   "main": "dist/plugin.cjs.js",