@hot-updater/react-native 1.0.0-rc.4 → 1.0.0-rc.41

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/android/src/oldarch/JavaScriptExceptionHooks.kt

@@ -0,0 +1,71 @@
+package com.hotupdater
+
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSExceptionHandler
+import com.facebook.react.bridge.ReactContext
+
+/**
+ * Routes JavaScript errors of the running React instance to crash recovery.
+ * The old architecture reaches the instance through ReactNativeHost, which only
+ * an old architecture build compiles.
+ */
+internal object JavaScriptExceptionHooks {
+    private val patchedInstanceManagerIds = mutableSetOf<Int>()
+    private val patchedCatalystInstanceIds = mutableSetOf<Int>()
+
+    fun install(application: ReactApplication) {
+        val instanceManager = application.reactNativeHost.reactInstanceManager
+        val managerIdentity = System.identityHashCode(instanceManager)
+        if (patchedInstanceManagerIds.add(managerIdentity)) {
+            val exceptionHandlerField =
+                HotUpdaterRecoveryManager.findField(instanceManager.javaClass, "mJSExceptionHandler")
+            if (exceptionHandlerField == null) {
+                patchedInstanceManagerIds.remove(managerIdentity)
+                return
+            }
+
+            exceptionHandlerField.isAccessible = true
+            val previousHandler = exceptionHandlerField.get(instanceManager) as? JSExceptionHandler
+            exceptionHandlerField.set(
+                instanceManager,
+                HotUpdaterRecoveryManager.RecoveryJSExceptionHandler(previousHandler),
+            )
+        }
+
+        instanceManager.currentReactContext?.let { reactContext ->
+            HotUpdaterRecoveryManager.patchReactContextExceptionHandler(reactContext)
+            patchCatalystInstanceExceptionHandler(reactContext)
+        }
+    }
+
+    private fun patchCatalystInstanceExceptionHandler(reactContext: ReactContext) {
+        val catalystInstance =
+            try {
+                reactContext.catalystInstance
+            } catch (_: Exception) {
+                null
+            } ?: return
+
+        val catalystIdentity = System.identityHashCode(catalystInstance)
+        if (!patchedCatalystInstanceIds.add(catalystIdentity)) {
+            return
+        }
+
+        val exceptionHandlerField =
+            HotUpdaterRecoveryManager.findField(catalystInstance.javaClass, "mJSExceptionHandler")
+        if (exceptionHandlerField == null) {
+            patchedCatalystInstanceIds.remove(catalystIdentity)
+            return
+        }
+
+        exceptionHandlerField.isAccessible = true
+        val previousHandler = exceptionHandlerField.get(catalystInstance) as? JSExceptionHandler
+        if (previousHandler is HotUpdaterRecoveryManager.RecoveryJSExceptionHandler) {
+            return
+        }
+        exceptionHandlerField.set(
+            catalystInstance,
+            HotUpdaterRecoveryManager.RecoveryJSExceptionHandler(previousHandler),
+        )
+    }
+}

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]
+        )
+    }
+}