@capgo/capacitor-updater 6.14.26 → 6.14.33

package/ios/{Plugin/CryptoCipher.swift → Sources/CapacitorUpdaterPlugin/CryptoCipherV1.swift}

@@ -161,7 +161,14 @@ fileprivate extension SecKey {
     }
 }
 
-public struct CryptoCipher {
+// V1 Encryption - uses privateKey (deprecated but kept for backwards compatibility)
+public struct CryptoCipherV1 {
+    private static var logger: Logger?
+
+    public static func setLogger(_ newLogger: Logger) {
+        logger = newLogger
+    }
+
     public static func calcChecksum(filePath: URL) -> String {
         let bufferSize = 1024 * 1024 * 5 // 5 MB
         var checksum = uLong(0)
@@ -186,16 +193,16 @@ public struct CryptoCipher {
 
             return String(format: "%08X", checksum).lowercased()
         } catch {
-            print("\(CapacitorUpdater.TAG) Cannot get checksum: \(filePath.path)", error)
+            print("\("[Capacitor-updater]") Cannot get checksum: \(filePath.path)", error)
             return ""
         }
     }
     public static func decryptFile(filePath: URL, privateKey: String, sessionKey: String, version: String) throws {
         if privateKey.isEmpty {
-            print("\(CapacitorUpdater.TAG) Cannot found privateKey")
+            print("\("[Capacitor-updater]") Cannot found privateKey")
             return
         } else if sessionKey.isEmpty  || sessionKey.components(separatedBy: ":").count != 2 {
-            print("\(CapacitorUpdater.TAG) Cannot found sessionKey")
+            print("\("[Capacitor-updater]") Cannot found sessionKey")
             return
         }
         do {
@@ -218,7 +225,7 @@ public struct CryptoCipher {
                 throw NSError(domain: "Failed to decrypt session key data", code: 2, userInfo: nil)
             }
 
-            let aesPrivateKey = AES128Key(iv: ivData, aes128Key: sessionKeyDataDecrypted)
+            let aesPrivateKey = AES128Key(iv: ivData, aes128Key: sessionKeyDataDecrypted, logger: logger ?? Logger(withTag: "[Capacitor-updater]"))
 
             guard let encryptedData = try? Data(contentsOf: filePath) else {
                 throw NSError(domain: "Failed to read encrypted data", code: 3, userInfo: nil)
@@ -231,7 +238,7 @@ public struct CryptoCipher {
             try decryptedData.write(to: filePath)
 
         } catch {
-            print("\(CapacitorUpdater.TAG) Cannot decode: \(filePath.path)", error)
+            print("\("[Capacitor-updater]") Cannot decode: \(filePath.path)", error)
             throw CustomError.cannotDecode
         }
     }

package/ios/{Plugin → Sources/CapacitorUpdaterPlugin}/CryptoCipherV2.swift

@@ -8,37 +8,43 @@ import Foundation
 import CryptoKit
 import BigInt
 
+// V2 Encryption - uses publicKey (modern encryption from main branch)
 public struct CryptoCipherV2 {
+    private static var logger: Logger!
 
-    public static func decryptChecksum(checksum: String, publicKey: String, version: String) throws -> String {
+    public static func setLogger(_ logger: Logger) {
+        self.logger = logger
+    }
+
+    public static func decryptChecksum(checksum: String, publicKey: String) throws -> String {
         if publicKey.isEmpty {
-            print("\(CapacitorUpdater.TAG) The public key is empty")
+            logger.info("No encryption set (public key) ignored")
             return checksum
         }
         do {
             guard let checksumBytes = Data(base64Encoded: checksum) else {
-                print("\(CapacitorUpdater.TAG) Cannot decode checksum as base64: \(checksum)")
+                logger.error("Cannot decode checksum as base64: \(checksum)")
                 throw CustomError.cannotDecode
             }
 
             if checksumBytes.isEmpty {
-                print("\(CapacitorUpdater.TAG) Decoded checksum is empty")
+                logger.error("Decoded checksum is empty")
                 throw CustomError.cannotDecode
             }
 
             guard let rsaPublicKey = RSAPublicKey.load(rsaPublicKey: publicKey) else {
-                print("\(CapacitorUpdater.TAG) The public key is not a valid RSA Public key")
+                logger.error("The public key is not a valid RSA Public key")
                 throw CustomError.cannotDecode
             }
 
             guard let decryptedChecksum = rsaPublicKey.decrypt(data: checksumBytes) else {
-                print("\(CapacitorUpdater.TAG) decryptChecksum fail")
+                logger.error("decryptChecksum fail")
                 throw NSError(domain: "Failed to decrypt session key data", code: 2, userInfo: nil)
             }
 
             return decryptedChecksum.base64EncodedString()
         } catch {
-            print("\(CapacitorUpdater.TAG) decryptChecksum fail: \(error.localizedDescription)")
+            logger.error("decryptChecksum fail: \(error.localizedDescription)")
             throw CustomError.cannotDecode
         }
     }
@@ -51,7 +57,7 @@ public struct CryptoCipherV2 {
             do {
                 fileHandle = try FileHandle(forReadingFrom: filePath)
             } catch {
-                print("\(CapacitorUpdater.TAG) Cannot open file for checksum: \(filePath.path)", error)
+                logger.error("Cannot open file for checksum: \(filePath.path) \(error)")
                 return ""
             }
 
@@ -59,7 +65,7 @@ public struct CryptoCipherV2 {
                 do {
                     try fileHandle.close()
                 } catch {
-                    print("\(CapacitorUpdater.TAG) Error closing file: \(error)")
+                    logger.error("Error closing file: \(error)")
                 }
             }
 
@@ -72,7 +78,7 @@ public struct CryptoCipherV2 {
                         fileData = fileHandle.readData(ofLength: bufferSize)
                     }
                 } catch {
-                    print("\(CapacitorUpdater.TAG) Error reading file: \(error)")
+                    logger.error("Error reading file: \(error)")
                     return false
                 }
 
@@ -87,25 +93,25 @@ public struct CryptoCipherV2 {
             let digest = sha256.finalize()
             return digest.compactMap { String(format: "%02x", $0) }.joined()
         } catch {
-            print("\(CapacitorUpdater.TAG) Cannot get checksum: \(filePath.path)", error)
+            logger.error("Cannot get checksum: \(filePath.path) \(error)")
             return ""
         }
     }
 
     public static func decryptFile(filePath: URL, publicKey: String, sessionKey: String, version: String) throws {
         if publicKey.isEmpty || sessionKey.isEmpty || sessionKey.components(separatedBy: ":").count != 2 {
-            print("\(CapacitorUpdater.TAG) Cannot found public key or sessionKey")
+            logger.info("Encryption not set, no public key or seesion, ignored")
             return
         }
 
         if !publicKey.hasPrefix("-----BEGIN RSA PUBLIC KEY-----") {
-            print("\(CapacitorUpdater.TAG) The public key is not a valid RSA Public key")
+            logger.error("The public key is not a valid RSA Public key")
             return
         }
 
         do {
             guard let rsaPublicKey = RSAPublicKey.load(rsaPublicKey: publicKey) else {
-                print("\(CapacitorUpdater.TAG) The public key is not a valid RSA Public key")
+                logger.error("The public key is not a valid RSA Public key")
                 throw CustomError.cannotDecode
             }
 
@@ -114,68 +120,68 @@ public struct CryptoCipherV2 {
             let encryptedKeyBase64 = sessionKeyComponents[1]
 
             guard let ivData = Data(base64Encoded: ivBase64) else {
-                print("\(CapacitorUpdater.TAG) Cannot decode sessionKey IV", ivBase64)
+                logger.error("Cannot decode sessionKey IV \(ivBase64)")
                 throw CustomError.cannotDecode
             }
 
             if ivData.count != 16 {
-                print("\(CapacitorUpdater.TAG) IV data has invalid length: \(ivData.count), expected 16")
+                logger.error("IV data has invalid length: \(ivData.count), expected 16")
                 throw CustomError.cannotDecode
             }
 
             guard let sessionKeyDataEncrypted = Data(base64Encoded: encryptedKeyBase64) else {
-                print("\(CapacitorUpdater.TAG) Cannot decode sessionKey data", encryptedKeyBase64)
+                logger.error("Cannot decode sessionKey data \(encryptedKeyBase64)")
                 throw NSError(domain: "Invalid session key data", code: 1, userInfo: nil)
             }
 
             guard let sessionKeyDataDecrypted = rsaPublicKey.decrypt(data: sessionKeyDataEncrypted) else {
-                print("\(CapacitorUpdater.TAG) Failed to decrypt session key data")
+                logger.error("Failed to decrypt session key data")
                 throw NSError(domain: "Failed to decrypt session key data", code: 2, userInfo: nil)
             }
 
             if sessionKeyDataDecrypted.count != 16 {
-                print("\(CapacitorUpdater.TAG) Decrypted session key has invalid length: \(sessionKeyDataDecrypted.count), expected 16")
+                logger.error("Decrypted session key has invalid length: \(sessionKeyDataDecrypted.count), expected 16")
                 throw NSError(domain: "Invalid decrypted session key", code: 5, userInfo: nil)
             }
 
-            let aesPrivateKey = AES128Key(iv: ivData, aes128Key: sessionKeyDataDecrypted)
+            let aesPrivateKey = AES128Key(iv: ivData, aes128Key: sessionKeyDataDecrypted, logger: logger)
 
             let encryptedData: Data
             do {
                 encryptedData = try Data(contentsOf: filePath)
             } catch {
-                print("\(CapacitorUpdater.TAG) Failed to read encrypted data: \(error)")
+                logger.error("Failed to read encrypted data: \(error)")
                 throw NSError(domain: "Failed to read encrypted data", code: 3, userInfo: nil)
             }
 
             if encryptedData.isEmpty {
-                print("\(CapacitorUpdater.TAG) Encrypted file data is empty")
+                logger.error("Encrypted file data is empty")
                 throw NSError(domain: "Empty encrypted data", code: 6, userInfo: nil)
             }
 
             guard let decryptedData = aesPrivateKey.decrypt(data: encryptedData) else {
-                print("\(CapacitorUpdater.TAG) Failed to decrypt data")
+                logger.error("Failed to decrypt data")
                 throw NSError(domain: "Failed to decrypt data", code: 4, userInfo: nil)
             }
 
             if decryptedData.isEmpty {
-                print("\(CapacitorUpdater.TAG) Decrypted data is empty")
+                logger.error("Decrypted data is empty")
                 throw NSError(domain: "Empty decrypted data", code: 7, userInfo: nil)
             }
 
             do {
                 try decryptedData.write(to: filePath, options: .atomic)
                 if !FileManager.default.fileExists(atPath: filePath.path) {
-                    print("\(CapacitorUpdater.TAG) File was not created after write")
+                    logger.error("File was not created after write")
                     throw NSError(domain: "File write failed", code: 8, userInfo: nil)
                 }
             } catch {
-                print("\(CapacitorUpdater.TAG) Error writing decrypted file: \(error)")
+                logger.error("Error writing decrypted file: \(error)")
                 throw error
             }
 
         } catch {
-            print("\(CapacitorUpdater.TAG) decryptFile fail")
+            logger.error("decryptFile fail")
             throw CustomError.cannotDecode
         }
     }

package/ios/Sources/CapacitorUpdaterPlugin/DelayUpdateUtils.swift

@@ -0,0 +1,220 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+//
+//  DelayUpdateUtils.swift
+//  Plugin
+//
+//  Created by Auto-generated based on Android implementation
+//  Copyright © 2024 Capgo. All rights reserved.
+//
+
+import Foundation
+import Version
+
+public class DelayUpdateUtils {
+
+    static let DELAY_CONDITION_PREFERENCES = "DELAY_CONDITION_PREFERENCES_CAPGO"
+    static let BACKGROUND_TIMESTAMP_KEY = "BACKGROUND_TIMESTAMP_KEY_CAPGO"
+    private let logger: Logger
+
+    private let currentVersionNative: Version
+
+    public enum CancelDelaySource {
+        case killed
+        case background
+        case foreground
+
+        var description: String {
+            switch self {
+            case .killed: return "KILLED"
+            case .background: return "BACKGROUND"
+            case .foreground: return "FOREGROUND"
+            }
+        }
+    }
+
+    public init(currentVersionNative: Version, logger: Logger) {
+        self.currentVersionNative = currentVersionNative
+        self.logger = logger
+    }
+
+    public func checkCancelDelay(source: CancelDelaySource) {
+        let delayUpdatePreferences = UserDefaults.standard.string(forKey: DelayUpdateUtils.DELAY_CONDITION_PREFERENCES) ?? "[]"
+        let delayConditionList: [DelayCondition] = fromJsonArr(json: delayUpdatePreferences).map { obj -> DelayCondition in
+            let kind: String = obj.value(forKey: "kind") as! String
+            let value: String? = obj.value(forKey: "value") as? String
+            return DelayCondition(kind: kind, value: value)
+        }
+
+        var delayConditionListToKeep: [DelayCondition] = []
+        var index = 0
+
+        for condition in delayConditionList {
+            let kind = condition.getKind()
+            let value = condition.getValue()
+
+            switch kind {
+            case "background":
+                if source == .foreground {
+                    let backgroundedAt = getBackgroundTimestamp()
+                    let now = Int64(Date().timeIntervalSince1970 * 1000) // Convert to milliseconds
+                    let delta = max(0, now - backgroundedAt)
+
+                    var longValue: Int64 = 0
+                    if let value = value, !value.isEmpty {
+                        longValue = Int64(value) ?? 0
+                    }
+
+                    if delta > longValue {
+                        logger.info("Background condition (value: \(value ?? "")) deleted at index \(index). Delta: \(delta), longValue: \(longValue)")
+                    } else {
+                        delayConditionListToKeep.append(condition)
+                        logger.info("Background delay (value: \(value ?? "")) condition kept at index \(index) (source: \(source.description))")
+                    }
+                } else {
+                    delayConditionListToKeep.append(condition)
+                    logger.info("Background delay (value: \(value ?? "")) condition kept at index \(index) (source: \(source.description))")
+                }
+
+            case "kill":
+                if source == .killed {
+                    logger.info("Kill delay (value: \(value ?? "")) condition removed at index \(index) after app kill")
+                } else {
+                    delayConditionListToKeep.append(condition)
+                    logger.info("Kill delay (value: \(value ?? "")) condition kept at index \(index) (source: \(source.description))")
+                }
+
+            case "date":
+                if let value = value, !value.isEmpty {
+                    do {
+                        let dateFormatter = ISO8601DateFormatter()
+                        dateFormatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+
+                        if let date = dateFormatter.date(from: value) {
+                            if Date() > date {
+                                logger.info("Date delay (value: \(value)) condition removed due to expired date at index \(index)")
+                            } else {
+                                delayConditionListToKeep.append(condition)
+                                logger.info("Date delay (value: \(value)) condition kept at index \(index)")
+                            }
+                        } else {
+                            logger.error("Date delay (value: \(value)) condition removed due to parsing issue at index \(index)")
+                        }
+                    } catch {
+                        logger.error("Date delay (value: \(value)) condition removed due to parsing issue at index \(index): \(error)")
+                    }
+                } else {
+                    logger.error("Date delay (value: \(value ?? "")) condition removed due to empty value at index \(index)")
+                }
+
+            case "nativeVersion":
+                if let value = value, !value.isEmpty {
+                    do {
+                        let versionLimit = try Version(value)
+                        if currentVersionNative >= versionLimit {
+                            logger.info("Native version delay (value: \(value)) condition removed due to above limit at index \(index)")
+                        } else {
+                            delayConditionListToKeep.append(condition)
+                            logger.info("Native version delay (value: \(value)) condition kept at index \(index)")
+                        }
+                    } catch {
+                        logger.error("Native version delay (value: \(value)) condition removed due to parsing issue at index \(index): \(error)")
+                    }
+                } else {
+                    logger.error("Native version delay (value: \(value ?? "")) condition removed due to empty value at index \(index)")
+                }
+
+            default:
+                logger.error("Unknown delay condition kind: \(kind) at index \(index)")
+            }
+
+            index += 1
+        }
+
+        if !delayConditionListToKeep.isEmpty {
+            let json = toJson(object: delayConditionListToKeep.map { $0.toJSON() })
+            _ = setMultiDelay(delayConditions: json)
+        } else {
+            // Clear all delay conditions if none are left to keep
+            _ = cancelDelay(source: "checkCancelDelay")
+        }
+    }
+
+    public func setMultiDelay(delayConditions: String) -> Bool {
+        do {
+            UserDefaults.standard.set(delayConditions, forKey: DelayUpdateUtils.DELAY_CONDITION_PREFERENCES)
+            UserDefaults.standard.synchronize()
+            logger.info("Delay update saved")
+            return true
+        } catch {
+            logger.error("Failed to delay update, [Error calling 'setMultiDelay()']: \(error)")
+            return false
+        }
+    }
+
+    public func setBackgroundTimestamp(_ backgroundTimestamp: Int64) {
+        do {
+            UserDefaults.standard.set(backgroundTimestamp, forKey: DelayUpdateUtils.BACKGROUND_TIMESTAMP_KEY)
+            UserDefaults.standard.synchronize()
+            logger.info("Background timestamp saved")
+        } catch {
+            logger.error("Failed to save background timestamp, [Error calling 'setBackgroundTimestamp()']: \(error)")
+        }
+    }
+
+    public func unsetBackgroundTimestamp() {
+        do {
+            UserDefaults.standard.removeObject(forKey: DelayUpdateUtils.BACKGROUND_TIMESTAMP_KEY)
+            UserDefaults.standard.synchronize()
+            logger.info("Background timestamp removed")
+        } catch {
+            logger.error("Failed to remove background timestamp, [Error calling 'unsetBackgroundTimestamp()']: \(error)")
+        }
+    }
+
+    private func getBackgroundTimestamp() -> Int64 {
+        do {
+            let timestamp = UserDefaults.standard.object(forKey: DelayUpdateUtils.BACKGROUND_TIMESTAMP_KEY) as? Int64 ?? 0
+            return timestamp
+        } catch {
+            logger.error("Failed to get background timestamp, [Error calling 'getBackgroundTimestamp()']: \(error)")
+            return 0
+        }
+    }
+
+    public func cancelDelay(source: String) -> Bool {
+        do {
+            UserDefaults.standard.removeObject(forKey: DelayUpdateUtils.DELAY_CONDITION_PREFERENCES)
+            UserDefaults.standard.synchronize()
+            logger.info("All delays canceled from \(source)")
+            return true
+        } catch {
+            logger.error("Failed to cancel update delay: \(error)")
+            return false
+        }
+    }
+
+    // MARK: - Helper methods
+
+    private func toJson(object: Any) -> String {
+        guard let data = try? JSONSerialization.data(withJSONObject: object, options: []) else {
+            return ""
+        }
+        return String(data: data, encoding: String.Encoding.utf8) ?? ""
+    }
+
+    private func fromJsonArr(json: String) -> [NSObject] {
+        guard let jsonData = json.data(using: .utf8) else {
+            return []
+        }
+        let object = try? JSONSerialization.jsonObject(
+            with: jsonData,
+            options: .mutableContainers
+        ) as? [NSObject]
+        return object ?? []
+    }
+}

package/ios/Sources/CapacitorUpdaterPlugin/DeviceIdHelper.swift

@@ -0,0 +1,120 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import Foundation
+import Security
+
+/**
+ * Helper class to manage device ID persistence across app installations.
+ * Uses iOS Keychain to persist the device ID.
+ */
+class DeviceIdHelper {
+    private static let keychainService = "app.capgo.updater"
+    private static let keychainAccount = "deviceId"
+    private static let legacyDefaultsKey = "appUUID"
+
+    /**
+     * Gets or creates a device ID that persists across reinstalls.
+     *
+     * This method:
+     * 1. First checks for an existing ID in Keychain (persists across reinstalls)
+     * 2. Falls back to UserDefaults (for migration from older versions)
+     * 3. Generates a new UUID if neither exists
+     * 4. Stores the ID in Keychain for future use
+     *
+     * @return Device ID as a lowercase UUID string
+     */
+    static func getOrCreateDeviceId() -> String {
+        // Try to get device ID from Keychain first
+        if let keychainDeviceId = getDeviceIdFromKeychain() {
+            return keychainDeviceId.lowercased()
+        }
+
+        // Migration: Check UserDefaults for existing device ID
+        var deviceId = UserDefaults.standard.string(forKey: legacyDefaultsKey)
+
+        if deviceId == nil || deviceId!.isEmpty {
+            // Generate new device ID if none exists
+            deviceId = UUID().uuidString
+        }
+
+        // Ensure lowercase for consistency
+        deviceId = deviceId!.lowercased()
+
+        // Save to Keychain for persistence across reinstalls
+        saveDeviceIdToKeychain(deviceId: deviceId!)
+
+        return deviceId!
+    }
+
+    /**
+     * Retrieves the device ID from iOS Keychain.
+     *
+     * @return Device ID string or nil if not found
+     */
+    private static func getDeviceIdFromKeychain() -> String? {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: keychainService,
+            kSecAttrAccount as String: keychainAccount,
+            kSecReturnData as String: true,
+            kSecMatchLimit as String: kSecMatchLimitOne
+        ]
+
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+
+        guard status == errSecSuccess,
+              let data = result as? Data,
+              let deviceId = String(data: data, encoding: .utf8) else {
+            return nil
+        }
+
+        return deviceId
+    }
+
+    /**
+     * Saves the device ID to iOS Keychain with appropriate accessibility settings.
+     *
+     * Uses kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:
+     * - Data persists across reinstalls
+     * - Data is NOT synced to iCloud
+     * - Data is accessible after first device unlock
+     * - Data stays on this device only (privacy-friendly)
+     *
+     * @param deviceId The device ID to save
+     */
+    private static func saveDeviceIdToKeychain(deviceId: String) {
+        guard let data = deviceId.data(using: .utf8) else {
+            return
+        }
+
+        // Delete any existing entry first
+        let deleteQuery: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: keychainService,
+            kSecAttrAccount as String: keychainAccount
+        ]
+        SecItemDelete(deleteQuery as CFDictionary)
+
+        // Add new entry with appropriate accessibility
+        let addQuery: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: keychainService,
+            kSecAttrAccount as String: keychainAccount,
+            kSecValueData as String: data,
+            // This ensures data persists across reinstalls but stays on device (not synced)
+            kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+        ]
+
+        let status = SecItemAdd(addQuery as CFDictionary, nil)
+
+        if status != errSecSuccess {
+            // Log error but don't crash - we'll fall back to UserDefaults on next launch
+            print("Failed to save device ID to Keychain: \(status)")
+        }
+    }
+}

package/ios/{Plugin → Sources/CapacitorUpdaterPlugin}/InternalUtils.swift

@@ -67,6 +67,51 @@ extension GetChannel {
         return dict
     }
 }
+struct ChannelInfo: Codable {
+    let id: String?
+    let name: String?
+    let `public`: Bool?
+    let allow_self_set: Bool?
+}
+struct ListChannelsDec: Decodable {
+    let channels: [ChannelInfo]?
+    let error: String?
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+
+        if let channelsArray = try? container.decode([ChannelInfo].self) {
+            // Backend returns direct array
+            self.channels = channelsArray
+            self.error = nil
+        } else {
+            // Handle error response
+            let errorContainer = try decoder.container(keyedBy: CodingKeys.self)
+            self.channels = nil
+            self.error = try? errorContainer.decode(String.self, forKey: .error)
+        }
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case error
+    }
+}
+public class ListChannels: NSObject {
+    var channels: [[String: Any]] = []
+    var error: String = ""
+}
+extension ListChannels {
+    func toDict() -> [String: Any] {
+        var dict: [String: Any] = [String: Any]()
+        let otherSelf: Mirror = Mirror(reflecting: self)
+        for child: Mirror.Child in otherSelf.children {
+            if let key: String = child.label {
+                dict[key] = child.value
+            }
+        }
+        return dict
+    }
+}
 struct InfoObject: Codable {
     let platform: String?
     let device_id: String?
@@ -112,6 +157,7 @@ struct AppVersionDec: Decodable {
     let error: String?
     let session_key: String?
     let major: Bool?
+    let breaking: Bool?
     let data: [String: String]?
     let manifest: [ManifestEntry]?
 }
@@ -124,6 +170,7 @@ public class AppVersion: NSObject {
     var error: String?
     var sessionKey: String?
     var major: Bool?
+    var breaking: Bool?
     var data: [String: String]?
     var manifest: [ManifestEntry]?
 }