@hot-updater/react-native 1.0.0-rc.3 → 1.0.0-rc.30

package/android/src/oldarch/HotUpdaterModule.kt

@@ -26,6 +26,16 @@ class HotUpdaterModule internal constructor(
 
     override fun getName(): String = NAME
 
+    private fun readSafeInteger(
+        map: ReadableMap,
+        key: String,
+    ): Long? {
+        if (!map.hasKey(key) || map.isNull(key)) return null
+        val value = runCatching { map.getDouble(key) }.getOrNull() ?: return null
+        if (!value.isFinite() || value % 1.0 != 0.0) return null
+        return value.toLong().takeIf { it in 0..9_007_199_254_740_991L }
+    }
+
     override fun onCatalystInstanceDestroy() {
         super.onCatalystInstanceDestroy()
         // Cancel all ongoing coroutines when module is destroyed
@@ -37,12 +47,12 @@ class HotUpdaterModule internal constructor(
      */
     private fun getInstance(): HotUpdaterImpl = HotUpdater.getInstance(mReactApplicationContext)
 
-    private fun parseChangedAssets(params: ReadableMap): Map<String, ChangedAssetDescriptor>? {
-        if (!params.hasKey("changedAssets") || params.isNull("changedAssets")) {
+    private fun parseAssets(params: ReadableMap): Map<String, ChangedAssetDescriptor>? {
+        if (!params.hasKey("assets") || params.isNull("assets")) {
             return null
         }
 
-        val changedAssetsMap = params.getMap("changedAssets") ?: return null
+        val changedAssetsMap = params.getMap("assets") ?: return null
         val parsedAssets = linkedMapOf<String, ChangedAssetDescriptor>()
         val iterator = changedAssetsMap.keySetIterator()
 
@@ -58,6 +68,7 @@ class HotUpdaterModule internal constructor(
                     val baseFileHash = patchMap.getString("baseFileHash")
                     val patchFileHash = patchMap.getString("patchFileHash")
                     val patchUrl = patchMap.getString("patchUrl")
+                    val byteSize = readSafeInteger(patchMap, "byteSize")
 
                     if (
                         algorithm != null &&
@@ -72,6 +83,7 @@ class HotUpdaterModule internal constructor(
                             baseFileHash = baseFileHash,
                             patchFileHash = patchFileHash,
                             patchUrl = patchUrl,
+                            byteSize = byteSize,
                         )
                     } else {
                         null
@@ -166,90 +178,105 @@ class HotUpdaterModule internal constructor(
             try {
                 val bundleId = params.getString("bundleId")
                 if (bundleId == null || bundleId.isEmpty()) {
-                    promise.reject("MISSING_BUNDLE_ID", "Missing or empty 'bundleId'")
+                    promise.rejectUpdateBundle(HotUpdaterException.missingBundleId())
                     return@launch
                 }
 
-                val fileUrl = params.getString("fileUrl")
-
-                // Validate fileUrl format if provided
-                if (fileUrl != null && fileUrl.isNotEmpty()) {
+                val manifestUrl = params.getString("manifestUrl")
+                val manifestFileHash = params.getString("manifestFileHash")
+                val assets = parseAssets(params)
+                if (manifestUrl.isNullOrEmpty() || manifestFileHash.isNullOrEmpty() || assets == null) {
+                    promise.rejectUpdateBundle(HotUpdaterException.invalidManifestParams())
+                    return@launch
+                }
+                try {
+                    java.net.URL(manifestUrl)
+                } catch (e: java.net.MalformedURLException) {
+                    promise.rejectUpdateBundle(
+                        HotUpdaterException.invalidFileUrl("manifestUrl", manifestUrl, UpdateFailureResource.MANIFEST),
+                    )
+                    return@launch
+                }
+                val channel = params.getString("channel")
+                val archiveUrl =
+                    if (params.hasKey("archiveUrl") && !params.isNull("archiveUrl")) {
+                        params.getString("archiveUrl")
+                    } else {
+                        null
+                    }
+                if (archiveUrl != null) {
                     try {
-                        java.net.URL(fileUrl)
+                        java.net.URL(archiveUrl)
                     } catch (e: java.net.MalformedURLException) {
-                        promise.reject("INVALID_FILE_URL", "Invalid 'fileUrl' provided: $fileUrl")
+                        promise.rejectUpdateBundle(
+                            HotUpdaterException.invalidFileUrl("archiveUrl", archiveUrl, UpdateFailureResource.ARCHIVE),
+                        )
                         return@launch
                     }
                 }
-
-                val fileHash = params.getString("fileHash")
-                val manifestUrl = params.getString("manifestUrl")
-                val manifestFileHash = params.getString("manifestFileHash")
-                val changedAssets = parseChangedAssets(params)
-                val channel = params.getString("channel")
                 val selection = parseSelection(params)
 
                 val impl = getInstance()
 
-                impl.updateBundle(
-                    bundleId,
-                    fileUrl,
-                    fileHash,
-                    manifestUrl,
-                    manifestFileHash,
-                    changedAssets,
-                    channel,
-                    selection,
-                ) { progress ->
-                    // Post to Main thread for React Native event emission
-                    Handler(Looper.getMainLooper()).post {
-                        try {
-                            val progressParams =
-                                Arguments.createMap().apply {
-                                    putDouble("progress", progress.progress)
-                                    putString("artifactType", progress.artifactType)
-                                    progress.downloadedBytes?.let { putDouble("downloadedBytes", it.toDouble()) }
-                                    progress.totalBytes?.let { putDouble("totalBytes", it.toDouble()) }
-                                    progress.details?.let { details ->
-                                        val files = Arguments.createArray()
-                                        details.files.forEach { file ->
-                                            files.pushMap(
+                val result =
+                    impl.updateBundle(
+                        bundleId,
+                        manifestUrl,
+                        manifestFileHash,
+                        assets,
+                        channel,
+                        selection,
+                        archiveUrl,
+                    ) { progress ->
+                        // Post to Main thread for React Native event emission
+                        Handler(Looper.getMainLooper()).post {
+                            try {
+                                val progressParams =
+                                    Arguments.createMap().apply {
+                                        putDouble("progress", progress.progress)
+                                        putString("artifactType", progress.artifactType)
+                                        progress.details?.let { details ->
+                                            val files = Arguments.createArray()
+                                            details.files.forEach { file ->
+                                                files.pushMap(
+                                                    Arguments.createMap().apply {
+                                                        putString("path", file.path)
+                                                        putString("downloadPath", file.downloadPath)
+                                                        putString("status", file.status)
+                                                        putDouble("progress", file.progress)
+                                                        putInt("order", file.order)
+                                                        file.downloadedBytes?.let { putDouble("downloadedBytes", it.toDouble()) }
+                                                        file.totalBytes?.let { putDouble("totalBytes", it.toDouble()) }
+                                                    },
+                                                )
+                                            }
+
+                                            putMap(
+                                                "details",
                                                 Arguments.createMap().apply {
-                                                    putString("path", file.path)
-                                                    putString("downloadPath", file.downloadPath)
-                                                    putString("status", file.status)
-                                                    putDouble("progress", file.progress)
-                                                    putInt("order", file.order)
-                                                    file.downloadedBytes?.let { putDouble("downloadedBytes", it.toDouble()) }
-                                                    file.totalBytes?.let { putDouble("totalBytes", it.toDouble()) }
+                                                    putInt("totalFilesCount", details.totalFilesCount)
+                                                    putInt("completedFilesCount", details.completedFilesCount)
+                                                    putArray("files", files)
                                                 },
                                             )
                                         }
-
-                                        putMap(
-                                            "details",
-                                            Arguments.createMap().apply {
-                                                putInt("totalFilesCount", details.totalFilesCount)
-                                                putInt("completedFilesCount", details.completedFilesCount)
-                                                putArray("files", files)
-                                            },
-                                        )
                                     }
-                                }
-
-                            this@HotUpdaterModule
-                                .mReactApplicationContext
-                                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                                ?.emit("onProgress", progressParams)
-                        } catch (e: Exception) {
-                            Log.w("HotUpdater", "Failed to emit progress (bridge may be unavailable): ${e.message}")
+
+                                this@HotUpdaterModule
+                                    .mReactApplicationContext
+                                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                                    ?.emit("onProgress", progressParams)
+                            } catch (e: Exception) {
+                                Log.w("HotUpdater", "Failed to emit progress (bridge may be unavailable): ${e.message}")
+                            }
                         }
                     }
-                }
-                promise.resolve(true)
+                promise.resolve(result.toWritableMap())
             } catch (e: HotUpdaterException) {
-                promise.reject(e.code, e.message)
+                promise.rejectUpdateBundle(e)
             } catch (e: Exception) {
+                // Not an update failure (a stale Release selection, for example),
+                // so the rejection carries no classification.
                 promise.reject("UNKNOWN_ERROR", e.message ?: "An unknown error occurred")
             }
         }
@@ -414,17 +441,14 @@ class HotUpdaterModule internal constructor(
     override fun getInstallId(): String = getInstance().getInstallId()
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun getUserId(): String? = getInstance().getUserId()
-
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun getUsername(): String? = getInstance().getUsername()
+    override fun getStorageItem(key: String): String? = getInstance().getStorageItem(key)
 
     @ReactMethod
-    override fun setUser(
-        userId: String?,
-        username: String?,
+    override fun setStorageItem(
+        key: String,
+        value: String?,
     ) {
-        getInstance().setUser(userId, username)
+        getInstance().setStorageItem(key, value)
     }
 
     @ReactMethod

package/android/src/oldarch/HotUpdaterSpec.kt

@@ -62,13 +62,11 @@ abstract class HotUpdaterSpec internal constructor(
 
     abstract fun getInstallId(): String
 
-    abstract fun getUserId(): String?
+    abstract fun getStorageItem(key: String): String?
 
-    abstract fun getUsername(): String?
-
-    abstract fun setUser(
-        userId: String?,
-        username: String?,
+    abstract fun setStorageItem(
+        key: String,
+        value: String?,
     )
 
     abstract fun resetChannel(promise: Promise)

package/ios/HotUpdater/Internal/BrotliFileDecompressor.swift

@@ -0,0 +1,167 @@
+import Compression
+import Foundation
+
+enum BrotliFileDecompressor {
+    private static let bufferSize = 64 * 1024
+
+    static func decompress(
+        from sourcePath: String,
+        to outputPath: String,
+        expectedOutputByteSize: Int64? = nil
+    ) throws {
+        if let expectedOutputByteSize, expectedOutputByteSize < 0 {
+            throw error(6, "Invalid expected Brotli output size")
+        }
+        let fileManager = FileManager.default
+        let parentDirectory = (outputPath as NSString).deletingLastPathComponent
+        try fileManager.createDirectory(
+            atPath: parentDirectory,
+            withIntermediateDirectories: true
+        )
+        if fileManager.fileExists(atPath: outputPath) {
+            try fileManager.removeItem(atPath: outputPath)
+        }
+        guard fileManager.createFile(atPath: outputPath, contents: nil) else {
+            throw error(1, "Failed to create Brotli output file")
+        }
+
+        let input = try FileHandle(forReadingFrom: URL(fileURLWithPath: sourcePath))
+        let output = try FileHandle(forWritingTo: URL(fileURLWithPath: outputPath))
+        defer {
+            try? input.close()
+            try? output.close()
+        }
+
+        var stream = compression_stream(
+            dst_ptr: UnsafeMutablePointer<UInt8>(bitPattern: 1)!,
+            dst_size: 0,
+            src_ptr: UnsafePointer<UInt8>(bitPattern: 1)!,
+            src_size: 0,
+            state: nil
+        )
+        guard compression_stream_init(
+            &stream,
+            COMPRESSION_STREAM_DECODE,
+            COMPRESSION_BROTLI
+        ) == COMPRESSION_STATUS_OK else {
+            throw error(2, "Failed to initialize Brotli decompression")
+        }
+        defer { compression_stream_destroy(&stream) }
+
+        let outputBuffer = UnsafeMutablePointer<UInt8>.allocate(
+            capacity: bufferSize
+        )
+        defer { outputBuffer.deallocate() }
+
+        var reachedEnd = false
+        var totalOutputByteSize: UInt64 = 0
+        let maximumOutputByteSize = expectedOutputByteSize.map(UInt64.init)
+        while !reachedEnd {
+            let chunk = try FileUtilities.readUpToCount(
+                from: input,
+                count: bufferSize
+            ) ?? Data()
+            let status: compression_status
+            if chunk.isEmpty {
+                stream.src_ptr = UnsafePointer<UInt8>(bitPattern: 1)!
+                stream.src_size = 0
+                status = try process(
+                    &stream,
+                    output: output,
+                    outputBuffer: outputBuffer,
+                    finalize: true,
+                    totalOutputByteSize: &totalOutputByteSize,
+                    maximumOutputByteSize: maximumOutputByteSize
+                )
+            } else {
+                status = try chunk.withUnsafeBytes { bytes in
+                    guard let source = bytes.baseAddress?
+                        .assumingMemoryBound(to: UInt8.self) else {
+                        return COMPRESSION_STATUS_OK
+                    }
+                    stream.src_ptr = source
+                    stream.src_size = chunk.count
+                    return try process(
+                        &stream,
+                        output: output,
+                        outputBuffer: outputBuffer,
+                        finalize: false,
+                        totalOutputByteSize: &totalOutputByteSize,
+                        maximumOutputByteSize: maximumOutputByteSize
+                    )
+                }
+            }
+
+            if status == COMPRESSION_STATUS_END {
+                guard stream.src_size == 0 else {
+                    throw error(7, "Brotli stream contains trailing compressed bytes")
+                }
+                let trailing = try FileUtilities.readUpToCount(from: input, count: 1)
+                guard trailing?.isEmpty != false else {
+                    throw error(7, "Brotli stream contains trailing compressed bytes")
+                }
+                reachedEnd = true
+            } else if chunk.isEmpty {
+                throw error(3, "Brotli input ended before the stream completed")
+            }
+        }
+
+        if let maximumOutputByteSize,
+           totalOutputByteSize != maximumOutputByteSize {
+            throw error(
+                8,
+                "Brotli output size mismatch: expected \(maximumOutputByteSize), got \(totalOutputByteSize)"
+            )
+        }
+    }
+
+    private static func process(
+        _ stream: inout compression_stream,
+        output: FileHandle,
+        outputBuffer: UnsafeMutablePointer<UInt8>,
+        finalize: Bool,
+        totalOutputByteSize: inout UInt64,
+        maximumOutputByteSize: UInt64?
+    ) throws -> compression_status {
+        let flags = finalize ? Int32(COMPRESSION_STREAM_FINALIZE.rawValue) : 0
+        var status = COMPRESSION_STATUS_OK
+        repeat {
+            let previousSourceSize = stream.src_size
+            stream.dst_ptr = outputBuffer
+            stream.dst_size = bufferSize
+            status = compression_stream_process(&stream, flags)
+
+            guard status == COMPRESSION_STATUS_OK ||
+                    status == COMPRESSION_STATUS_END else {
+                throw error(4, "Brotli decompression failed")
+            }
+            let produced = bufferSize - stream.dst_size
+            if produced > 0 {
+                let (nextOutputByteSize, overflowed) = totalOutputByteSize
+                    .addingReportingOverflow(UInt64(produced))
+                guard !overflowed,
+                      maximumOutputByteSize.map({ nextOutputByteSize <= $0 }) ?? true else {
+                    throw error(6, "Brotli output exceeds expected size")
+                }
+                output.write(Data(bytes: outputBuffer, count: produced))
+                totalOutputByteSize = nextOutputByteSize
+            }
+            if finalize,
+               status == COMPRESSION_STATUS_OK,
+               produced == 0,
+               previousSourceSize == stream.src_size {
+                throw error(5, "Brotli decompression stalled")
+            }
+        } while stream.src_size > 0 || stream.dst_size == 0 ||
+            (finalize && status == COMPRESSION_STATUS_OK)
+        return status
+    }
+
+    private static func error(_ code: Int, _ message: String) -> NSError {
+        NSError(
+            domain: "BrotliFileDecompressor",
+            code: code,
+            userInfo: [NSLocalizedDescriptionKey: message]
+        )
+    }
+}

package/ios/HotUpdater/Internal/BuiltInAssetResolver.swift

@@ -0,0 +1,196 @@
+import Foundation
+
+protocol BuiltInAssetResolver: AnyObject {
+    func use(bundle: Bundle)
+    func copyIfMatches(assetPath: String, expectedHash: String, destination: String) -> Bool
+}
+
+final class IOSBuiltInAssetResolver: BuiltInAssetResolver {
+    private struct CachedIndex: Codable {
+        let schemaVersion: Int
+        let packageIdentity: String
+        var locators: [String: String]
+    }
+
+    private let cacheURL: URL
+    private let lock = NSLock()
+    private var bundle: Bundle = .main
+
+    init(cacheURL: URL) {
+        self.cacheURL = cacheURL
+    }
+
+    func use(bundle: Bundle) {
+        lock.lock()
+        self.bundle = bundle
+        lock.unlock()
+    }
+
+    func copyIfMatches(
+        assetPath: String,
+        expectedHash: String,
+        destination: String
+    ) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+
+        guard FileUtilities.normalizedRelativePath(from: assetPath) == assetPath else {
+            return false
+        }
+        let packageIdentity = packageIdentity(for: bundle)
+        var index = readIndex(packageIdentity: packageIdentity)
+
+        if let cachedLocator = index.locators[assetPath],
+           copyLocatorIfMatches(
+            cachedLocator,
+            expectedHash: expectedHash,
+            destination: destination
+           ) {
+            return true
+        }
+
+        guard let locator = resolveLocator(assetPath: assetPath),
+              copyLocatorIfMatches(
+                locator,
+                expectedHash: expectedHash,
+                destination: destination
+              ) else {
+            return false
+        }
+
+        index.locators[assetPath] = locator
+        writeIndex(index)
+        return true
+    }
+
+    private func resolveLocator(assetPath: String) -> String? {
+        if assetPath == "index.ios.bundle" {
+            guard let bundleURL = bundle.url(forResource: "main", withExtension: "jsbundle"),
+                  let relativePath = relativePath(of: bundleURL, inside: bundle.bundleURL) else {
+                return nil
+            }
+            return "bundle:\(relativePath)"
+        }
+
+        guard let resourceURL = bundle.resourceURL else { return nil }
+        let sourceURL = resourceURL.appendingPathComponent(assetPath).standardizedFileURL
+        guard relativePath(of: sourceURL, inside: resourceURL) == assetPath,
+              isRegularFile(sourceURL) else {
+            return nil
+        }
+        return "resource:\(assetPath)"
+    }
+
+    private func copyLocatorIfMatches(
+        _ locator: String,
+        expectedHash: String,
+        destination: String
+    ) -> Bool {
+        guard let sourceURL = sourceURL(for: locator), isRegularFile(sourceURL) else {
+            return false
+        }
+        let destinationURL = URL(fileURLWithPath: destination)
+        let temporaryURL = destinationURL
+            .deletingLastPathComponent()
+            .appendingPathComponent("\(destinationURL.lastPathComponent).builtin.tmp")
+        do {
+            try FileManager.default.createDirectory(
+                at: destinationURL.deletingLastPathComponent(),
+                withIntermediateDirectories: true
+            )
+            try? FileManager.default.removeItem(at: temporaryURL)
+            try FileManager.default.copyItem(at: sourceURL, to: temporaryURL)
+            guard HashUtils.verifyHash(fileURL: temporaryURL, expectedHash: expectedHash) else {
+                try? FileManager.default.removeItem(at: temporaryURL)
+                return false
+            }
+            try? FileManager.default.removeItem(at: destinationURL)
+            try FileManager.default.moveItem(at: temporaryURL, to: destinationURL)
+            return true
+        } catch {
+            try? FileManager.default.removeItem(at: temporaryURL)
+            return false
+        }
+    }
+
+    private func sourceURL(for locator: String) -> URL? {
+        if locator.hasPrefix("bundle:") {
+            let relativePath = String(locator.dropFirst("bundle:".count))
+            let sourceURL = bundle.bundleURL.appendingPathComponent(relativePath).standardizedFileURL
+            return self.relativePath(of: sourceURL, inside: bundle.bundleURL) == relativePath
+                ? sourceURL
+                : nil
+        }
+        if locator.hasPrefix("resource:"), let resourceURL = bundle.resourceURL {
+            let relativePath = String(locator.dropFirst("resource:".count))
+            let sourceURL = resourceURL.appendingPathComponent(relativePath).standardizedFileURL
+            return self.relativePath(of: sourceURL, inside: resourceURL) == relativePath
+                ? sourceURL
+                : nil
+        }
+        return nil
+    }
+
+    private func relativePath(of fileURL: URL, inside directoryURL: URL) -> String? {
+        let directory = directoryURL.standardizedFileURL.resolvingSymlinksInPath().path
+        let file = fileURL.standardizedFileURL.resolvingSymlinksInPath().path
+        let prefix = directory.hasSuffix("/") ? directory : "\(directory)/"
+        guard file.hasPrefix(prefix) else { return nil }
+        return String(file.dropFirst(prefix.count))
+    }
+
+    private func isRegularFile(_ url: URL) -> Bool {
+        (try? url.resourceValues(forKeys: [.isRegularFileKey]).isRegularFile) == true
+    }
+
+    private func packageIdentity(for bundle: Bundle) -> String {
+        let values = try? bundle.bundleURL.resourceValues(forKeys: [.contentModificationDateKey, .fileSizeKey])
+        let bundleIdentifier = bundle.bundleIdentifier ?? ""
+        let shortVersion = bundle.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String ?? ""
+        let bundleVersion = bundle.object(forInfoDictionaryKey: "CFBundleVersion") as? String ?? ""
+        let bundlePath = bundle.bundleURL.standardizedFileURL.path
+        let fileSize = String(values?.fileSize ?? -1)
+        let modificationTime = String(values?.contentModificationDate?.timeIntervalSince1970 ?? -1)
+
+        return [
+            bundleIdentifier,
+            shortVersion,
+            bundleVersion,
+            bundlePath,
+            fileSize,
+            modificationTime,
+        ].joined(separator: "|")
+    }
+
+    private func readIndex(packageIdentity: String) -> CachedIndex {
+        if let data = try? Data(contentsOf: cacheURL),
+           let index = try? JSONDecoder().decode(CachedIndex.self, from: data),
+           index.schemaVersion == Self.schemaVersion,
+           index.packageIdentity == packageIdentity {
+            return index
+        }
+        return CachedIndex(
+            schemaVersion: Self.schemaVersion,
+            packageIdentity: packageIdentity,
+            locators: [:]
+        )
+    }
+
+    private func writeIndex(_ index: CachedIndex) {
+        do {
+            try FileManager.default.createDirectory(
+                at: cacheURL.deletingLastPathComponent(),
+                withIntermediateDirectories: true
+            )
+            let temporaryURL = cacheURL.appendingPathExtension("tmp")
+            let data = try JSONEncoder().encode(index)
+            try data.write(to: temporaryURL, options: .atomic)
+            try? FileManager.default.removeItem(at: cacheURL)
+            try FileManager.default.moveItem(at: temporaryURL, to: cacheURL)
+        } catch {
+            // Cache persistence must never block a valid install.
+        }
+    }
+
+    private static let schemaVersion = 1
+}