@capgo/capacitor-updater 5.35.0 → 5.39.0

package/ios/Sources/CapacitorUpdaterPlugin/CapacitorUpdaterPlugin.swift

@@ -51,10 +51,16 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "getNextBundle", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getFailedUpdate", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setShakeMenu", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "isShakeMenuEnabled", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "isShakeMenuEnabled", returnType: CAPPluginReturnPromise),
+        // App Store update methods
+        CAPPluginMethod(name: "getAppUpdateInfo", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "openAppStore", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "performImmediateUpdate", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startFlexibleUpdate", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "completeFlexibleUpdate", returnType: CAPPluginReturnPromise)
     ]
     public var implementation = CapgoUpdater()
-    private let pluginVersion: String = "5.35.0"
+    private let pluginVersion: String = "5.39.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"
@@ -92,6 +98,11 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     private var backgroundWork: DispatchWorkItem?
     private var taskRunning = false
     private var periodCheckDelay = 0
+
+    // Lock to ensure cleanup completes before downloads start
+    private let cleanupLock = NSLock()
+    private var cleanupComplete = false
+    private var cleanupThread: Thread?
     private var persistCustomId = false
     private var persistModifyUrl = false
     private var allowManualBundleError = false
@@ -185,7 +196,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             logger.info("Loaded persisted updateUrl")
         }
         autoUpdate = getConfig().getBoolean("autoUpdate", true)
-        appReadyTimeout = getConfig().getInt("appReadyTimeout", 10000)
+        appReadyTimeout = max(1000, getConfig().getInt("appReadyTimeout", 10000))  // Minimum 1 second
         implementation.timeout = Double(getConfig().getInt("responseTimeout", 20))
         resetWhenUpdate = getConfig().getBoolean("resetWhenUpdate", true)
         shakeMenuEnabled = getConfig().getBoolean("shakeMenu", false)
@@ -196,7 +207,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             periodCheckDelay = periodCheckDelayValue
         }
 
-        implementation.publicKey = getConfig().getString("publicKey", "")!
+        implementation.setPublicKey(getConfig().getString("publicKey") ?? "")
         implementation.notifyDownloadRaw = notifyDownload
         implementation.pluginVersion = self.pluginVersion
 
@@ -204,6 +215,11 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         implementation.setLogger(logger)
         CryptoCipher.setLogger(logger)
 
+        // Log public key prefix if encryption is enabled
+        if let keyId = implementation.getKeyId(), !keyId.isEmpty {
+            logger.info("Public key prefix: \(keyId)")
+        }
+
         // Initialize DelayUpdateUtils
         self.delayUpdateUtils = DelayUpdateUtils(currentVersionNative: currentVersionNative, logger: logger)
         let config = (self.bridge?.viewController as? CAPBridgeViewController)?.instanceDescriptor().legacyConfig
@@ -358,28 +374,74 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     private func cleanupObsoleteVersions() {
-        let previous = UserDefaults.standard.string(forKey: "LatestNativeBuildVersion") ?? UserDefaults.standard.string(forKey: "LatestVersionNative") ?? "0"
-        if previous != "0" && self.currentBuildVersion != previous {
-            _ = self._reset(toLastSuccessful: false)
-            let res = implementation.list()
-            res.forEach { version in
-                logger.info("Deleting obsolete bundle: \(version.getId())")
-                let res = implementation.delete(id: version.getId())
-                if !res {
-                    logger.error("Delete failed, id \(version.getId()) doesn't exist")
+        cleanupThread = Thread {
+            self.cleanupLock.lock()
+            defer {
+                self.cleanupComplete = true
+                self.cleanupLock.unlock()
+                self.logger.info("Cleanup complete")
+            }
+
+            let previous = UserDefaults.standard.string(forKey: "LatestNativeBuildVersion") ?? UserDefaults.standard.string(forKey: "LatestVersionNative") ?? "0"
+            if previous != "0" && self.currentBuildVersion != previous {
+                _ = self._reset(toLastSuccessful: false)
+                let res = self.implementation.list()
+                for version in res {
+                    // Check if thread was cancelled
+                    if Thread.current.isCancelled {
+                        self.logger.warn("Cleanup was cancelled, stopping")
+                        return
+                    }
+                    self.logger.info("Deleting obsolete bundle: \(version.getId())")
+                    let res = self.implementation.delete(id: version.getId())
+                    if !res {
+                        self.logger.error("Delete failed, id \(version.getId()) doesn't exist")
+                    }
+                }
+
+                let storedBundles = self.implementation.list(raw: true)
+                let allowedIds = Set(storedBundles.compactMap { info -> String? in
+                    let id = info.getId()
+                    return id.isEmpty ? nil : id
+                })
+                self.implementation.cleanupDownloadDirectories(allowedIds: allowedIds, threadToCheck: Thread.current)
+                self.implementation.cleanupOrphanedTempFolders(threadToCheck: Thread.current)
+
+                // Check again before the expensive delta cache cleanup
+                if Thread.current.isCancelled {
+                    self.logger.warn("Cleanup was cancelled before delta cache cleanup")
+                    return
                 }
+                self.implementation.cleanupDeltaCache(threadToCheck: Thread.current)
             }
+            UserDefaults.standard.set(self.currentBuildVersion, forKey: "LatestNativeBuildVersion")
+            UserDefaults.standard.synchronize()
+        }
+        cleanupThread?.start()
 
-            let storedBundles = implementation.list(raw: true)
-            let allowedIds = Set(storedBundles.compactMap { info -> String? in
-                let id = info.getId()
-                return id.isEmpty ? nil : id
-            })
-            implementation.cleanupDownloadDirectories(allowedIds: allowedIds)
-            implementation.cleanupDeltaCache()
+        // Start a timeout watchdog thread to cancel cleanup if it takes too long
+        let timeout = Double(self.appReadyTimeout / 2) / 1000.0
+        Thread.detachNewThread {
+            Thread.sleep(forTimeInterval: timeout)
+            if let thread = self.cleanupThread, !thread.isFinished && !self.cleanupComplete {
+                self.logger.warn("Cleanup timeout exceeded (\(timeout)s), cancelling cleanup thread")
+                thread.cancel()
+            }
         }
-        UserDefaults.standard.set(self.currentBuildVersion, forKey: "LatestNativeBuildVersion")
-        UserDefaults.standard.synchronize()
+    }
+
+    private func waitForCleanupIfNeeded() {
+        if cleanupComplete {
+            return  // Already done, no need to wait
+        }
+
+        logger.info("Waiting for cleanup to complete before starting download...")
+
+        // Wait for cleanup to complete - blocks until lock is released
+        cleanupLock.lock()
+        cleanupLock.unlock()
+
+        logger.info("Cleanup finished, proceeding with download")
     }
 
     @objc func notifyDownload(id: String, percent: Int, ignoreMultipleOfTen: Bool = false, bundle: BundleInfo? = nil) {
@@ -1272,6 +1334,8 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             return
         }
         DispatchQueue.global(qos: .background).async {
+            // Wait for cleanup to complete before starting download
+            self.waitForCleanupIfNeeded()
             self.backgroundTaskID = UIApplication.shared.beginBackgroundTask(withName: "Finish Download Tasks") {
                 // End the task if time expires.
                 self.endBackGroundTask()
@@ -1602,4 +1666,208 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         implementation.appId = appId
         call.resolve()
     }
+
+    // MARK: - App Store Update Methods
+
+    /// AppUpdateAvailability enum values matching TypeScript definitions
+    private enum AppUpdateAvailability: Int {
+        case unknown = 0
+        case updateNotAvailable = 1
+        case updateAvailable = 2
+        case updateInProgress = 3
+    }
+
+    @objc func getAppUpdateInfo(_ call: CAPPluginCall) {
+        let country = call.getString("country", "US")
+        let bundleId = implementation.appId
+
+        logger.info("Getting App Store update info for \(bundleId) in country \(country)")
+
+        DispatchQueue.global(qos: .background).async {
+            let urlString = "https://itunes.apple.com/lookup?bundleId=\(bundleId)&country=\(country)"
+            guard let url = URL(string: urlString) else {
+                call.reject("Invalid URL for App Store lookup")
+                return
+            }
+
+            let task = URLSession.shared.dataTask(with: url) { data, response, error in
+                if let error = error {
+                    self.logger.error("App Store lookup failed: \(error.localizedDescription)")
+                    call.reject("App Store lookup failed: \(error.localizedDescription)")
+                    return
+                }
+
+                guard let data = data else {
+                    call.reject("No data received from App Store")
+                    return
+                }
+
+                do {
+                    guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+                          let resultCount = json["resultCount"] as? Int else {
+                        call.reject("Invalid response from App Store")
+                        return
+                    }
+
+                    let currentVersionName = Bundle.main.versionName ?? "0.0.0"
+                    let currentVersionCode = Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "0"
+
+                    var result: [String: Any] = [
+                        "currentVersionName": currentVersionName,
+                        "currentVersionCode": currentVersionCode,
+                        "updateAvailability": AppUpdateAvailability.unknown.rawValue
+                    ]
+
+                    if resultCount > 0,
+                       let results = json["results"] as? [[String: Any]],
+                       let appInfo = results.first {
+
+                        let availableVersion = appInfo["version"] as? String
+                        let releaseDate = appInfo["currentVersionReleaseDate"] as? String
+                        let minimumOsVersion = appInfo["minimumOsVersion"] as? String
+
+                        result["availableVersionName"] = availableVersion
+                        result["availableVersionCode"] = availableVersion // iOS doesn't have separate version code
+                        result["availableVersionReleaseDate"] = releaseDate
+                        result["minimumOsVersion"] = minimumOsVersion
+
+                        // Determine update availability by comparing versions
+                        if let availableVersion = availableVersion {
+                            do {
+                                let currentVer = try Version(currentVersionName)
+                                let availableVer = try Version(availableVersion)
+                                if availableVer > currentVer {
+                                    result["updateAvailability"] = AppUpdateAvailability.updateAvailable.rawValue
+                                } else {
+                                    result["updateAvailability"] = AppUpdateAvailability.updateNotAvailable.rawValue
+                                }
+                            } catch {
+                                // If version parsing fails, do string comparison
+                                if availableVersion != currentVersionName {
+                                    result["updateAvailability"] = AppUpdateAvailability.updateAvailable.rawValue
+                                } else {
+                                    result["updateAvailability"] = AppUpdateAvailability.updateNotAvailable.rawValue
+                                }
+                            }
+                        } else {
+                            result["updateAvailability"] = AppUpdateAvailability.updateNotAvailable.rawValue
+                        }
+
+                        // iOS doesn't support in-app updates like Android
+                        result["immediateUpdateAllowed"] = false
+                        result["flexibleUpdateAllowed"] = false
+                    } else {
+                        // App not found in App Store (maybe not published yet)
+                        result["updateAvailability"] = AppUpdateAvailability.updateNotAvailable.rawValue
+                        self.logger.info("App not found in App Store for bundleId: \(bundleId)")
+                    }
+
+                    call.resolve(result)
+                } catch {
+                    self.logger.error("Failed to parse App Store response: \(error.localizedDescription)")
+                    call.reject("Failed to parse App Store response: \(error.localizedDescription)")
+                }
+            }
+            task.resume()
+        }
+    }
+
+    @objc func openAppStore(_ call: CAPPluginCall) {
+        let appId = call.getString("appId")
+
+        if let appId = appId {
+            // Open App Store with provided app ID
+            let urlString = "https://apps.apple.com/app/id\(appId)"
+            guard let url = URL(string: urlString) else {
+                call.reject("Invalid App Store URL")
+                return
+            }
+            DispatchQueue.main.async {
+                UIApplication.shared.open(url) { success in
+                    if success {
+                        call.resolve()
+                    } else {
+                        call.reject("Failed to open App Store")
+                    }
+                }
+            }
+        } else {
+            // Look up app ID using bundle identifier
+            let bundleId = implementation.appId
+            let lookupUrl = "https://itunes.apple.com/lookup?bundleId=\(bundleId)"
+
+            DispatchQueue.global(qos: .background).async {
+                guard let url = URL(string: lookupUrl) else {
+                    call.reject("Invalid lookup URL")
+                    return
+                }
+
+                let task = URLSession.shared.dataTask(with: url) { data, _, error in
+                    if let error = error {
+                        call.reject("Failed to lookup app: \(error.localizedDescription)")
+                        return
+                    }
+
+                    guard let data = data,
+                          let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+                          let results = json["results"] as? [[String: Any]],
+                          let appInfo = results.first,
+                          let trackId = appInfo["trackId"] as? Int else {
+                        // If lookup fails, try opening the generic App Store app page using bundle ID
+                        let fallbackUrlString = "https://apps.apple.com/app/\(bundleId)"
+                        guard let fallbackUrl = URL(string: fallbackUrlString) else {
+                            call.reject("Failed to find app in App Store and fallback URL is invalid")
+                            return
+                        }
+                        DispatchQueue.main.async {
+                            UIApplication.shared.open(fallbackUrl) { success in
+                                if success {
+                                    call.resolve()
+                                } else {
+                                    call.reject("Failed to open App Store")
+                                }
+                            }
+                        }
+                        return
+                    }
+
+                    let appStoreUrl = "https://apps.apple.com/app/id\(trackId)"
+                    guard let url = URL(string: appStoreUrl) else {
+                        call.reject("Invalid App Store URL")
+                        return
+                    }
+
+                    DispatchQueue.main.async {
+                        UIApplication.shared.open(url) { success in
+                            if success {
+                                call.resolve()
+                            } else {
+                                call.reject("Failed to open App Store")
+                            }
+                        }
+                    }
+                }
+                task.resume()
+            }
+        }
+    }
+
+    @objc func performImmediateUpdate(_ call: CAPPluginCall) {
+        // iOS doesn't support in-app updates like Android's Play Store
+        // Redirect users to the App Store instead
+        logger.warn("performImmediateUpdate is not supported on iOS. Use openAppStore() instead.")
+        call.reject("In-app updates are not supported on iOS. Use openAppStore() to direct users to the App Store.", "NOT_SUPPORTED")
+    }
+
+    @objc func startFlexibleUpdate(_ call: CAPPluginCall) {
+        // iOS doesn't support flexible in-app updates
+        logger.warn("startFlexibleUpdate is not supported on iOS. Use openAppStore() instead.")
+        call.reject("Flexible updates are not supported on iOS. Use openAppStore() to direct users to the App Store.", "NOT_SUPPORTED")
+    }
+
+    @objc func completeFlexibleUpdate(_ call: CAPPluginCall) {
+        // iOS doesn't support flexible in-app updates
+        logger.warn("completeFlexibleUpdate is not supported on iOS.")
+        call.reject("Flexible updates are not supported on iOS.", "NOT_SUPPORTED")
+    }
 }

package/ios/Sources/CapacitorUpdaterPlugin/CapgoUpdater.swift

@@ -26,6 +26,7 @@ import UIKit
     private let FALLBACK_VERSION: String = "pastVersion"
     private let NEXT_VERSION: String = "nextVersion"
     private var unzipPercent = 0
+    private let TEMP_UNZIP_PREFIX: String = "capgo_unzip_"
 
     // Add this line to declare cacheFolder
     private let cacheFolder: URL = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!.appendingPathComponent("capgo_downloads")
@@ -42,6 +43,9 @@ import UIKit
     public var deviceID = ""
     public var publicKey: String = ""
 
+    // Cached key ID calculated once from publicKey
+    private var cachedKeyId: String?
+
     // Flag to track if we received a 429 response - stops requests until app restart
     private static var rateLimitExceeded = false
 
@@ -79,6 +83,19 @@ import UIKit
         return String((0..<length).map { _ in letters.randomElement()! })
     }
 
+    public func setPublicKey(_ publicKey: String) {
+        self.publicKey = publicKey
+        if !publicKey.isEmpty {
+            self.cachedKeyId = CryptoCipher.calcKeyId(publicKey: publicKey)
+        } else {
+            self.cachedKeyId = nil
+        }
+    }
+
+    public func getKeyId() -> String? {
+        return self.cachedKeyId
+    }
+
     private var isDevEnvironment: Bool {
         #if DEBUG
         return true
@@ -258,7 +275,7 @@ import UIKit
     private func saveDownloaded(sourceZip: URL, id: String, base: URL, notify: Bool) throws {
         try prepareFolder(source: base)
         let destPersist: URL = base.appendingPathComponent(id)
-        let destUnZip: URL = libraryDir.appendingPathComponent(randomString(length: 10))
+        let destUnZip: URL = libraryDir.appendingPathComponent(TEMP_UNZIP_PREFIX + randomString(length: 10))
 
         self.unzipPercent = 0
         self.notifyDownload(id: id, percent: 75)
@@ -324,7 +341,8 @@ import UIKit
             is_prod: self.isProd(),
             action: nil,
             channel: nil,
-            defaultChannel: self.defaultChannel
+            defaultChannel: self.defaultChannel,
+            key_id: self.cachedKeyId
         )
     }
 
@@ -479,16 +497,11 @@ import UIKit
                     logger.error("Failed to copy builtin file \(fileName): \(error.localizedDescription)")
                 }
                 dispatchGroup.leave()
-            } else if FileManager.default.fileExists(atPath: cacheFilePath.path) && verifyChecksum(file: cacheFilePath, expectedHash: fileHash) {
-                do {
-                    try FileManager.default.copyItem(at: cacheFilePath, to: destFilePath)
-                    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))
-                } catch {
-                    downloadError = error
-                    logger.error("Failed to copy cached file \(fileName): \(error.localizedDescription)")
-                }
+            } 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
@@ -588,6 +601,30 @@ import UIKit
         return updatedBundle
     }
 
+    /// 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 {
+        // First quick check - if file doesn't exist, don't bother
+        guard FileManager.default.fileExists(atPath: source.path) else {
+            return false
+        }
+
+        // Verify checksum before copy
+        guard verifyChecksum(file: source, expectedHash: expectedHash) else {
+            return false
+        }
+
+        // Try to copy - if it fails (file deleted by OS between check and copy), return false
+        do {
+            try FileManager.default.copyItem(at: source, to: destination)
+            return true
+        } catch {
+            // File was deleted between check and copy, or other IO error - caller should download instead
+            logger.debug("Cache copy failed (likely OS eviction): \(error.localizedDescription)")
+            return false
+        }
+    }
+
     private func decompressBrotli(data: Data, fileName: String) -> Data? {
         // Handle empty files
         if data.count == 0 {
@@ -999,6 +1036,16 @@ import UIKit
     }
 
     public func cleanupDeltaCache() {
+        cleanupDeltaCache(threadToCheck: nil)
+    }
+
+    public func cleanupDeltaCache(threadToCheck: Thread?) {
+        // Check if thread was cancelled
+        if let thread = threadToCheck, thread.isCancelled {
+            logger.warn("cleanupDeltaCache was cancelled before starting")
+            return
+        }
+
         let fileManager = FileManager.default
         guard fileManager.fileExists(atPath: cacheFolder.path) else {
             return
@@ -1012,6 +1059,10 @@ import UIKit
     }
 
     public func cleanupDownloadDirectories(allowedIds: Set<String>) {
+        cleanupDownloadDirectories(allowedIds: allowedIds, threadToCheck: nil)
+    }
+
+    public func cleanupDownloadDirectories(allowedIds: Set<String>, threadToCheck: Thread?) {
         let bundleRoot = libraryDir.appendingPathComponent(bundleDirectory)
         let fileManager = FileManager.default
 
@@ -1023,6 +1074,12 @@ import UIKit
             let contents = try fileManager.contentsOfDirectory(at: bundleRoot, includingPropertiesForKeys: [.isDirectoryKey], options: [.skipsHiddenFiles])
 
             for url in contents {
+                // Check if thread was cancelled
+                if let thread = threadToCheck, thread.isCancelled {
+                    logger.warn("cleanupDownloadDirectories was cancelled")
+                    return
+                }
+
                 let resourceValues = try url.resourceValues(forKeys: [.isDirectoryKey])
                 if resourceValues.isDirectory != true {
                     continue
@@ -1047,6 +1104,43 @@ import UIKit
         }
     }
 
+    public func cleanupOrphanedTempFolders(threadToCheck: Thread?) {
+        let fileManager = FileManager.default
+
+        do {
+            let contents = try fileManager.contentsOfDirectory(at: libraryDir, includingPropertiesForKeys: [.isDirectoryKey], options: [.skipsHiddenFiles])
+
+            for url in contents {
+                // Check if thread was cancelled
+                if let thread = threadToCheck, thread.isCancelled {
+                    logger.warn("cleanupOrphanedTempFolders was cancelled")
+                    return
+                }
+
+                let resourceValues = try url.resourceValues(forKeys: [.isDirectoryKey])
+                if resourceValues.isDirectory != true {
+                    continue
+                }
+
+                let folderName = url.lastPathComponent
+
+                // Only delete folders with the temp unzip prefix
+                if !folderName.hasPrefix(TEMP_UNZIP_PREFIX) {
+                    continue
+                }
+
+                do {
+                    try fileManager.removeItem(at: url)
+                    logger.info("Deleted orphaned temp unzip folder: \(folderName)")
+                } catch {
+                    logger.error("Failed to delete orphaned temp folder: \(folderName) \(error.localizedDescription)")
+                }
+            }
+        } catch {
+            logger.error("Failed to enumerate library directory for temp folder cleanup: \(error.localizedDescription)")
+        }
+    }
+
     public func getBundleDirectory(id: String) -> URL {
         return libraryDir.appendingPathComponent(self.bundleDirectory).appendingPathComponent(id)
     }

package/ios/Sources/CapacitorUpdaterPlugin/CryptoCipher.swift

@@ -264,4 +264,23 @@ public struct CryptoCipher {
             throw CustomError.cannotDecode
         }
     }
+
+    /// Get first 4 characters of the public key for identification
+    /// Returns 4-character string or empty string if key is invalid/empty
+    public static func calcKeyId(publicKey: String) -> String {
+        if publicKey.isEmpty {
+            return ""
+        }
+
+        // Remove PEM headers and whitespace to get the raw key data
+        let cleanedKey = publicKey
+            .replacingOccurrences(of: "-----BEGIN RSA PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "-----END RSA PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "\n", with: "")
+            .replacingOccurrences(of: "\r", with: "")
+            .replacingOccurrences(of: " ", with: "")
+
+        // Return first 4 characters of the base64-encoded key
+        return String(cleanedKey.prefix(4))
+    }
 }

package/ios/Sources/CapacitorUpdaterPlugin/InternalUtils.swift

@@ -128,6 +128,7 @@ struct InfoObject: Codable {
     var action: String?
     var channel: String?
     var defaultChannel: String?
+    var key_id: String?
 }
 
 public struct ManifestEntry: Codable {

package/package.json

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