@capgo/capacitor-updater 8.0.0 → 8.1.0

package/ios/Sources/CapacitorUpdaterPlugin/RSA.swift

@@ -0,0 +1,274 @@
+import BigInt
+import Foundation
+import CommonCrypto
+import CryptoKit
+
+///
+/// Constants
+///
+private enum RSAConstants {
+    static let rsaKeySizeInBits: NSNumber = 2048
+    static let rsaAlgorithm: SecKeyAlgorithm = .rsaEncryptionOAEPSHA256
+}
+
+// We do all this stuff because ios is shit and open source libraries allow to do decryption with public key
+// So we have to do it manually, while in nodejs or Java it's ok and done at language level.
+
+///
+/// The RSA public key.
+///
+public struct RSAPublicKey {
+    private let manualKey: ManualRSAPublicKey
+
+    fileprivate init(manualKey: ManualRSAPublicKey) {
+        self.manualKey = manualKey
+    }
+
+    ///
+    /// Takes the data and uses the public key to decrypt it.
+    /// Returns the decrypted data.
+    ///
+    public func decrypt(data: Data) -> Data? {
+        return manualKey.decrypt(data)
+    }
+
+    ///
+    /// Allows you to load an RSA public key (i.e. one downloaded from the net).
+    ///
+    public static func load(rsaPublicKey: String) -> RSAPublicKey? {
+        // Clean up the key string
+        var pubKey: String = rsaPublicKey
+        pubKey = pubKey.replacingOccurrences(of: "-----BEGIN RSA PUBLIC KEY-----", with: "")
+        pubKey = pubKey.replacingOccurrences(of: "-----END RSA PUBLIC KEY-----", with: "")
+        pubKey = pubKey.replacingOccurrences(of: "-----BEGIN PUBLIC KEY-----", with: "")
+        pubKey = pubKey.replacingOccurrences(of: "-----END PUBLIC KEY-----", with: "")
+        pubKey = pubKey.replacingOccurrences(of: "\\n+", with: "", options: .regularExpression)
+        pubKey = pubKey.replacingOccurrences(of: "\n", with: "")
+        pubKey = pubKey.trimmingCharacters(in: .whitespacesAndNewlines)
+
+        do {
+            guard let rsaPublicKeyData: Data = Data(base64Encoded: String(pubKey)) else {
+                throw CustomError.cannotDecode
+            }
+
+            // Try parsing as PKCS#1
+            if let manualKey = ManualRSAPublicKey.fromPKCS1(rsaPublicKeyData) {
+                return RSAPublicKey(manualKey: manualKey)
+            }
+
+            // Most common public exponent is 65537 (0x010001)
+            let commonExponent = Data([0x01, 0x00, 0x01]) // 65537 in big-endian
+
+            // Assume the entire key data is the modulus
+            let lastResortKey = ManualRSAPublicKey(modulus: rsaPublicKeyData, exponent: commonExponent)
+            return RSAPublicKey(manualKey: lastResortKey)
+        } catch {
+            return nil
+        }
+    }
+}
+
+// Manual RSA Public Key Implementation using the BigInt library
+struct ManualRSAPublicKey {
+    let modulus: BigInt
+    let exponent: BigInt
+
+    init(modulus: Data, exponent: Data) {
+        // Create positive BigInts from Data
+        let modulusBytes = [UInt8](modulus)
+        var modulusValue = BigUInt(0)
+        for byte in modulusBytes {
+            modulusValue = (modulusValue << 8) | BigUInt(byte)
+        }
+        self.modulus = BigInt(modulusValue)
+        let exponentBytes = [UInt8](exponent)
+        var exponentValue = BigUInt(0)
+        for byte in exponentBytes {
+            exponentValue = (exponentValue << 8) | BigUInt(byte)
+        }
+        self.exponent = BigInt(exponentValue)
+    }
+
+    // Parse PKCS#1 format public key
+    static func fromPKCS1(_ publicKeyData: Data) -> ManualRSAPublicKey? {
+        // Parse ASN.1 DER encoded RSA public key
+        // Format: RSAPublicKey ::= SEQUENCE { modulus INTEGER, publicExponent INTEGER }
+
+        guard publicKeyData.count > 0 else {
+            return nil
+        }
+
+        let bytes = [UInt8](publicKeyData)
+
+        // Check for sequence tag (0x30)
+        guard bytes[0] == 0x30 else {
+            // Try direct modulus/exponent approach as fallback
+            if publicKeyData.count >= 3 {
+                // Assume this is a raw RSA public key with modulus + exponent
+                // Most common: modulus is 256 bytes (2048 bits), exponent is 3 bytes (0x010001 = 65537)
+                let modulusSize = publicKeyData.count - 3
+                if modulusSize > 0 {
+                    let modulusData = publicKeyData.prefix(modulusSize)
+                    let exponentData = publicKeyData.suffix(3)
+                    return ManualRSAPublicKey(modulus: modulusData, exponent: exponentData)
+                }
+            }
+
+            return nil
+        }
+
+        var index = 1
+
+        // Skip length
+        if bytes[index] & 0x80 != 0 {
+            let lenBytes = Int(bytes[index] & 0x7F)
+            if (index + 1 + lenBytes) >= bytes.count {
+                return nil
+            }
+            index += 1 + lenBytes
+        } else {
+            index += 1
+        }
+
+        // Check for INTEGER tag for modulus (0x02)
+        if index >= bytes.count {
+            return nil
+        }
+
+        guard bytes[index] == 0x02 else {
+            return nil
+        }
+        index += 1
+
+        // Get modulus length
+        if index >= bytes.count {
+            return nil
+        }
+
+        var modulusLength = 0
+        if bytes[index] & 0x80 != 0 {
+            let lenBytes = Int(bytes[index] & 0x7F)
+            if (index + 1 + lenBytes) >= bytes.count {
+                return nil
+            }
+            index += 1
+            for i in 0..<lenBytes {
+                modulusLength = (modulusLength << 8) | Int(bytes[index + i])
+            }
+            index += lenBytes
+        } else {
+            modulusLength = Int(bytes[index])
+            index += 1
+        }
+
+        // Skip any leading zero in modulus (for unsigned integer)
+        if index < bytes.count && bytes[index] == 0x00 {
+            index += 1
+            modulusLength -= 1
+        }
+
+        // Extract modulus
+        if (index + modulusLength) > bytes.count {
+            return nil
+        }
+
+        let modulusData = Data(bytes[index..<(index + modulusLength)])
+        index += modulusLength
+
+        // Check for INTEGER tag for exponent
+        if index >= bytes.count {
+            return nil
+        }
+
+        guard bytes[index] == 0x02 else {
+            return nil
+        }
+        index += 1
+
+        // Get exponent length
+        if index >= bytes.count {
+            return nil
+        }
+
+        var exponentLength = 0
+        if bytes[index] & 0x80 != 0 {
+            let lenBytes = Int(bytes[index] & 0x7F)
+            if (index + 1 + lenBytes) >= bytes.count {
+                return nil
+            }
+            index += 1
+            for i in 0..<lenBytes {
+                exponentLength = (exponentLength << 8) | Int(bytes[index + i])
+            }
+            index += lenBytes
+        } else {
+            exponentLength = Int(bytes[index])
+            index += 1
+        }
+
+        // Extract exponent
+        if (index + exponentLength) > bytes.count {
+            return nil
+        }
+
+        let exponentData = Data(bytes[index..<(index + exponentLength)])
+        return ManualRSAPublicKey(modulus: modulusData, exponent: exponentData)
+    }
+
+    // Decrypt data using raw RSA operation (c^d mod n)
+    func decrypt(_ encryptedData: Data) -> Data? {
+        // Create positive BigInt from encrypted data
+        let encryptedBytes = [UInt8](encryptedData)
+        var encryptedValue = BigUInt(0)
+        for byte in encryptedBytes {
+            encryptedValue = (encryptedValue << 8) | BigUInt(byte)
+        }
+        let encrypted = BigInt(encryptedValue)
+
+        // In Node.js:
+        // privateEncrypt uses the private key (d) to encrypt
+        // publicDecrypt uses the public key (e) to decrypt
+        // The operation we want is: ciphertext^e mod n
+
+        // RSA operation: c^e mod n
+        let decrypted = encrypted.manualPower(exponent, modulus: modulus)
+
+        // Convert to bytes with proper padding
+        guard let bigUIntValue = decrypted.magnitude as? BigUInt else {
+            return nil
+        }
+
+        // Convert BigUInt to bytes with padding
+        var resultBytes = [UInt8]()
+        var tempValue = bigUIntValue
+        while tempValue > 0 {
+            let byte = UInt8(tempValue & 0xFF)
+            resultBytes.insert(byte, at: 0)  // Prepend to get big-endian
+            tempValue >>= 8
+        }
+
+        // Ensure we have at least 256 bytes (2048 bits) with leading zeros
+        let paddedBytes = [UInt8](repeating: 0, count: max(0, 256 - resultBytes.count)) + resultBytes
+
+        // For PKCS1 padding from Node.js privateEncrypt, the format is:
+        // 0x00 || 0x01 || PS || 0x00 || actual data
+        // where PS is a string of 0xFF bytes
+
+        // Check for privateEncrypt padding format (0x00 || 0x01 || PS || 0x00)
+        var startIndex = 0
+        if paddedBytes.count > 2 && paddedBytes[0] == 0x00 && paddedBytes[1] == 0x01 {
+            for i in 2..<paddedBytes.count {
+                if paddedBytes[i] == 0x00 {
+                    startIndex = i + 1
+                    break
+                }
+            }
+        }
+        if startIndex < paddedBytes.count {
+            let result = Data(paddedBytes[startIndex...])
+            return result
+        } else {
+            return Data(paddedBytes)
+        }
+    }
+}

package/ios/Sources/CapacitorUpdaterPlugin/ShakeMenu.swift

@@ -0,0 +1,112 @@
+/*
+ * 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 UIKit
+import Capacitor
+
+extension UIApplication {
+    public class func topViewController(_ base: UIViewController? = UIApplication.shared.windows.first?.rootViewController) -> UIViewController? {
+        if let nav = base as? UINavigationController {
+            return topViewController(nav.visibleViewController)
+        }
+        if let tab = base as? UITabBarController, let selected = tab.selectedViewController {
+            return topViewController(selected)
+        }
+        if let presented = base?.presentedViewController {
+            return topViewController(presented)
+        }
+        return base
+    }
+}
+
+extension UIWindow {
+    override open func motionEnded(_ motion: UIEvent.EventSubtype, with event: UIEvent?) {
+        if motion == .motionShake {
+            // Find the CapacitorUpdaterPlugin instance
+            guard let bridge = (rootViewController as? CAPBridgeProtocol),
+                  let plugin = bridge.plugin(withName: "CapacitorUpdaterPlugin") as? CapacitorUpdaterPlugin else {
+                return
+            }
+
+            // Check if shake menu is enabled
+            if !plugin.shakeMenuEnabled {
+                return
+            }
+
+            showShakeMenu(plugin: plugin, bridge: bridge)
+        }
+    }
+
+    private func showShakeMenu(plugin: CapacitorUpdaterPlugin, bridge: CAPBridgeProtocol) {
+        // Prevent multiple alerts from showing
+        if let topVC = UIApplication.topViewController(),
+           topVC.isKind(of: UIAlertController.self) {
+            plugin.logger.info("UIAlertController is already presented")
+            return
+        }
+
+        let appName = Bundle.main.infoDictionary?["CFBundleDisplayName"] as? String ?? "App"
+        let title = "Preview \(appName) Menu"
+        let message = "What would you like to do?"
+        let okButtonTitle = "Go Home"
+        let reloadButtonTitle = "Reload app"
+        let cancelButtonTitle = "Close menu"
+
+        let updater = plugin.implementation
+
+        func resetBuiltin() {
+            updater.reset()
+            bridge.setServerBasePath("")
+            DispatchQueue.main.async {
+                if let vc = (self.rootViewController as? CAPBridgeViewController) {
+                    vc.loadView()
+                    vc.viewDidLoad()
+                }
+                _ = updater.delete(id: updater.getCurrentBundleId())
+                plugin.logger.info("Reset to builtin version")
+            }
+        }
+
+        let bundleId = updater.getCurrentBundleId()
+        if let vc = (self.rootViewController as? CAPBridgeViewController) {
+            plugin.logger.info("getServerBasePath: \(vc.getServerBasePath())")
+        }
+        plugin.logger.info("bundleId: \(bundleId)")
+
+        let alertShake = UIAlertController(title: title, message: message, preferredStyle: .alert)
+
+        alertShake.addAction(UIAlertAction(title: okButtonTitle, style: .default) { _ in
+            guard let next = updater.getNextBundle() else {
+                resetBuiltin()
+                return
+            }
+            if !next.isBuiltin() {
+                plugin.logger.info("Resetting to: \(next.toString())")
+                _ = updater.set(bundle: next)
+                let destHot = updater.getBundleDirectory(id: next.getId())
+                plugin.logger.info("Reloading \(next.toString())")
+                bridge.setServerBasePath(destHot.path)
+            } else {
+                resetBuiltin()
+            }
+            plugin.logger.info("Reload app done")
+        })
+
+        alertShake.addAction(UIAlertAction(title: cancelButtonTitle, style: .default))
+
+        alertShake.addAction(UIAlertAction(title: reloadButtonTitle, style: .default) { _ in
+            DispatchQueue.main.async {
+                bridge.webView?.reload()
+            }
+        })
+
+        DispatchQueue.main.async {
+            if let topVC = UIApplication.topViewController() {
+                topVC.present(alertShake, animated: true)
+            }
+        }
+    }
+}

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

@@ -34,9 +34,7 @@ extension UserDefaults: ObjectSavable {
     }
 
     func getObj<Object>(forKey: String, castTo type: Object.Type) throws -> Object where Object: Decodable {
-        // print("forKey", forKey)
         guard let data: Data = data(forKey: forKey) else { throw ObjectSavableError.noValue }
-        // print("data", data)
         let decoder: JSONDecoder = JSONDecoder()
         do {
             let object: Object = try decoder.decode(type, from: data)

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@capgo/capacitor-updater",
-  "version": "8.0.0",
-  "packageManager": "pnpm@8.5.1",
+  "version": "8.1.0",
   "license": "MPL-2.0",
   "description": "Live update for capacitor apps",
   "main": "dist/plugin.cjs.js",
@@ -10,12 +9,14 @@
   "unpkg": "dist/plugin.js",
   "files": [
     "android/src/main/",
+    "android/proguard-rules.pro",
     "android/build.gradle",
     "dist/",
-    "ios/Plugin/",
-    "CapgoCapacitorUpdater.podspec"
+    "ios/Sources/",
+    "CapgoCapacitorUpdater.podspec",
+    "Package.swift"
   ],
-  "author": "Martin Donadieu",
+  "author": "Martin Donadieu <martin@capgo.app>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Cap-go/capacitor-updater.git"
@@ -25,56 +26,61 @@
   },
   "keywords": [
     "capacitor",
-    "plugin",
-    "OTA",
-    "manual update",
+    "live updates",
     "live update",
+    "updates",
     "auto update",
+    "manual update",
+    "capgo",
+    "plugin",
+    "OTA",
     "ionic",
     "appflow alternative",
-    "capgo",
+    "capawesome alternative",
+    "@capawesome/capacitor-live-update",
     "native"
   ],
   "scripts": {
     "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
-    "verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin && cd ..",
+    "verify:ios": "xcodebuild -scheme CapgoCapacitorUpdater -destination generic/platform=iOS",
     "verify:android": "cd android && ./gradlew clean build test && cd ..",
     "verify:web": "npm run build",
+    "test": "npm run test:ios && npm run test:android",
+    "test:ios": "./scripts/test-ios.sh",
+    "test:android": "cd android && ./gradlew test && cd ..",
     "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
-    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --autocorrect --format",
-    "eslint": "eslint . --ext ts",
-    "prettier": "prettier --config .prettierrc.js \"**/*.{css,html,ts,js,java}\"",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext .ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
     "swiftlint": "node-swiftlint",
-    "docgen": "docgen --api CapacitorUpdaterPlugin --output-readme README.md --output-json dist/docs.json",
-    "docgen:api": "docgen --api CapacitorUpdaterPlugin --output-readme api.md --output-json dist/docs.json && awk '{sub(/###/,\"##\")}1' api.md > temp.txt && mv temp.txt api.md",
+    "docgen": "node scripts/generate-docs.js",
     "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
     "clean": "rimraf ./dist",
     "watch": "tsc --watch",
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
-    "@capacitor/android": "^5.0.3",
-    "@capacitor/cli": "^5.0.3",
-    "@capacitor/core": "^5.0.3",
-    "@capacitor/docgen": "^0.2.1",
-    "@capacitor/ios": "^5.0.3",
-    "@ionic/eslint-config": "^0.3.0",
-    "@ionic/prettier-config": "^3.0.0",
-    "@ionic/swiftlint-config": "^1.1.2",
-    "@types/node": "^20.2.3",
-    "@typescript-eslint/eslint-plugin": "^5.59.7",
-    "@typescript-eslint/parser": "^5.59.7",
-    "eslint": "^8.41.0",
-    "eslint-plugin-import": "^2.27.5",
-    "prettier": "^2.8.8",
-    "prettier-plugin-java": "^2.1.0",
-    "rimraf": "^5.0.1",
-    "rollup": "^3.23.0",
-    "swiftlint": "^1.0.2",
-    "typescript": "^5.0.4"
+    "@capacitor/android": "^8.0.0",
+    "@capacitor/cli": "^8.0.0",
+    "@capacitor/core": "^8.0.0",
+    "@capacitor/docgen": "^0.3.0",
+    "@capacitor/ios": "^8.0.0",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "@types/node": "^24.3.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-import": "^2.32.0",
+    "husky": "^9.1.7",
+    "prettier": "^3.6.2",
+    "prettier-plugin-java": "^2.7.4",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.50.0",
+    "swiftlint": "^2.0.0",
+    "typescript": "^5.9.2"
   },
   "peerDependencies": {
-    "@capacitor/core": "^5.0.0"
+    "@capacitor/core": "^8.0.0"
   },
   "prettier": "@ionic/prettier-config",
   "swiftlint": "@ionic/swiftlint-config",