@hot-updater/react-native 0.29.2 → 0.29.4

package/HotUpdater.podspec

@@ -23,10 +23,6 @@ Pod::Spec.new do |s|
     "OTHER_SWIFT_FLAGS" => "-enable-experimental-feature AccessLevelOnImport"
   }
 
-  # SWCompression dependency for ZIP/TAR/GZIP/Brotli extraction support
-  # Native Compression framework is used for GZIP and Brotli decompression
-  s.dependency "SWCompression", "~> 4.8.0"
-
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
   # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
   if respond_to?(:install_modules_dependencies, true)

package/android/src/oldarch/HotUpdaterModule.kt

@@ -7,7 +7,6 @@ import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.WritableNativeArray
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import kotlinx.coroutines.CoroutineScope
@@ -153,10 +152,16 @@ class HotUpdaterModule internal constructor(
     }
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun notifyAppReady(): WritableNativeMap = getInstance().notifyAppReady().toWritableNativeMap()
+    override fun notifyAppReady(): String {
+        val result = getInstance().notifyAppReady()
+        return org.json.JSONObject(result).toString()
+    }
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun getCrashHistory(): WritableNativeArray = getInstance().getCrashHistory().toWritableNativeArray()
+    override fun getCrashHistory(): String {
+        val history = getInstance().getCrashHistory()
+        return org.json.JSONArray(history).toString()
+    }
 
     @ReactMethod(isBlockingSynchronousMethod = true)
     override fun clearCrashHistory(): Boolean {
@@ -177,7 +182,10 @@ class HotUpdaterModule internal constructor(
     }
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun getManifest(): WritableNativeMap = getInstance().getManifest().toWritableNativeMap()
+    override fun getManifest(): String {
+        val result = getInstance().getManifest()
+        return org.json.JSONObject(result).toString()
+    }
 
     @ReactMethod
     override fun setCohort(cohort: String) {

package/android/src/oldarch/HotUpdaterSpec.kt

@@ -4,8 +4,6 @@ import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.WritableArray
-import com.facebook.react.bridge.WritableMap
 
 abstract class HotUpdaterSpec internal constructor(
     context: ReactApplicationContext,
@@ -19,9 +17,9 @@ abstract class HotUpdaterSpec internal constructor(
 
     abstract fun reloadProcess(promise: Promise)
 
-    abstract fun notifyAppReady(): WritableMap
+    abstract fun notifyAppReady(): String
 
-    abstract fun getCrashHistory(): WritableArray
+    abstract fun getCrashHistory(): String
 
     abstract fun clearCrashHistory(): Boolean
 
@@ -33,7 +31,7 @@ abstract class HotUpdaterSpec internal constructor(
 
     abstract fun getBundleId(): String?
 
-    abstract fun getManifest(): WritableMap
+    abstract fun getManifest(): String
 
     abstract fun resetChannel(promise: Promise)
 }

package/ios/HotUpdater/Internal/ArchiveExtractionUtilities.swift

@@ -0,0 +1,178 @@
+import Foundation
+
+enum ArchiveExtractionUtilities {
+    static let bufferSize = 64 * 1024
+
+    static func readUpToCount(from handle: FileHandle, count: Int) throws -> Data? {
+        guard count >= 0 else {
+            throw NSError(
+                domain: "ArchiveExtractionUtilities",
+                code: 5,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid read size: \(count)"]
+            )
+        }
+
+        if count == 0 {
+            return Data()
+        }
+
+        if #available(macOS 10.15.4, iOS 13.4, watchOS 6.2, tvOS 13.4, *) {
+            return try handle.read(upToCount: count)
+        }
+
+        return handle.readData(ofLength: count)
+    }
+
+    static func readExactly(from handle: FileHandle, count: Int) throws -> Data {
+        guard count >= 0 else {
+            throw NSError(
+                domain: "ArchiveExtractionUtilities",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid read size: \(count)"]
+            )
+        }
+
+        if count == 0 {
+            return Data()
+        }
+
+        guard let data = try readUpToCount(from: handle, count: count), data.count == count else {
+            throw NSError(
+                domain: "ArchiveExtractionUtilities",
+                code: 2,
+                userInfo: [NSLocalizedDescriptionKey: "Unexpected end of archive while reading \(count) bytes"]
+            )
+        }
+
+        return data
+    }
+
+    static func currentOffset(for handle: FileHandle) -> UInt64 {
+        if #available(macOS 10.15.4, iOS 13.4, watchOS 6.2, tvOS 13.4, *) {
+            return (try? handle.offset()) ?? 0
+        }
+
+        return handle.offsetInFile
+    }
+
+    static func seek(_ handle: FileHandle, to offset: UInt64) throws {
+        if #available(macOS 10.15.4, iOS 13.4, watchOS 6.2, tvOS 13.4, *) {
+            try handle.seek(toOffset: offset)
+            return
+        }
+
+        handle.seek(toFileOffset: offset)
+    }
+
+    static func skipBytes(_ byteCount: UInt64, in handle: FileHandle) throws {
+        guard byteCount > 0 else {
+            return
+        }
+
+        let offset = currentOffset(for: handle)
+        let (targetOffset, overflowed) = offset.addingReportingOverflow(byteCount)
+
+        guard !overflowed else {
+            throw NSError(
+                domain: "ArchiveExtractionUtilities",
+                code: 6,
+                userInfo: [NSLocalizedDescriptionKey: "Archive offset overflow while skipping \(byteCount) bytes from offset \(offset)"]
+            )
+        }
+
+        try seek(handle, to: targetOffset)
+    }
+
+    static func normalizedRelativePath(from rawPath: String) -> String? {
+        var candidate = rawPath
+            .replacingOccurrences(of: "\\", with: "/")
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+
+        while candidate.hasPrefix("/") {
+            candidate.removeFirst()
+        }
+
+        while candidate.hasPrefix("./") {
+            candidate.removeFirst(2)
+        }
+
+        let components = candidate
+            .split(separator: "/")
+            .map(String.init)
+
+        guard !components.isEmpty else {
+            return nil
+        }
+
+        guard !components.contains(".."), !components.contains(".") else {
+            return nil
+        }
+
+        return components.joined(separator: "/")
+    }
+
+    static func extractionURL(for relativePath: String, destinationRoot: String) throws -> URL {
+        let rootURL = URL(fileURLWithPath: destinationRoot, isDirectory: true)
+        let targetURL = rootURL.appendingPathComponent(relativePath)
+        let standardizedRoot = rootURL.standardizedFileURL.path
+        let standardizedTarget = targetURL.standardizedFileURL.path
+
+        guard standardizedTarget == standardizedRoot ||
+                standardizedTarget.hasPrefix(standardizedRoot + "/") else {
+            throw NSError(
+                domain: "ArchiveExtractionUtilities",
+                code: 3,
+                userInfo: [NSLocalizedDescriptionKey: "Path traversal attempt detected: \(relativePath)"]
+            )
+        }
+
+        return targetURL
+    }
+
+    static func ensureDirectory(at url: URL, fileManager: FileManager = .default) throws {
+        var isDirectory = ObjCBool(false)
+        if fileManager.fileExists(atPath: url.path, isDirectory: &isDirectory) {
+            if isDirectory.boolValue {
+                return
+            }
+
+            try fileManager.removeItem(at: url)
+        }
+
+        try fileManager.createDirectory(at: url, withIntermediateDirectories: true, attributes: nil)
+    }
+
+    static func createOutputFile(at url: URL, fileManager: FileManager = .default) throws -> FileHandle {
+        try ensureDirectory(at: url.deletingLastPathComponent(), fileManager: fileManager)
+
+        if fileManager.fileExists(atPath: url.path) {
+            try fileManager.removeItem(at: url)
+        }
+
+        guard fileManager.createFile(atPath: url.path, contents: nil) else {
+            throw NSError(
+                domain: "ArchiveExtractionUtilities",
+                code: 4,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to create output file at \(url.path)"]
+            )
+        }
+
+        return try FileHandle(forWritingTo: url)
+    }
+}
+
+extension Data {
+    func archiveUInt16LE(at offset: Int) -> UInt16 {
+        let byte0 = UInt16(self[offset])
+        let byte1 = UInt16(self[offset + 1]) << 8
+        return byte0 | byte1
+    }
+
+    func archiveUInt32LE(at offset: Int) -> UInt32 {
+        let byte0 = UInt32(self[offset])
+        let byte1 = UInt32(self[offset + 1]) << 8
+        let byte2 = UInt32(self[offset + 2]) << 16
+        let byte3 = UInt32(self[offset + 3]) << 24
+        return byte0 | byte1 | byte2 | byte3
+    }
+}

package/ios/HotUpdater/Internal/BundleFileStorageService.swift

@@ -147,6 +147,17 @@ class BundleFileStorageService: BundleStorageService {
         let manifest: ManifestAssets
     }
 
+    private enum UpdateProgress {
+        static let downloadEnd = 0.7
+        static let verificationStart = 0.72
+        static let verificationEnd = 0.82
+        static let extractionStart = 0.82
+        static let extractionEnd = 0.97
+        static let bundleValidation = 0.98
+        static let activationReady = 0.99
+        static let complete = 1.0
+    }
+
     private let fileSystem: FileSystemService
     private let downloadService: DownloadService
     private let decompressService: DecompressService
@@ -178,7 +189,7 @@ class BundleFileStorageService: BundleStorageService {
 
         // Create queue for file operations
         self.fileOperationQueue = DispatchQueue(label: "com.hotupdater.fileoperations",
-                                               qos: .utility,
+                                               qos: .userInitiated,
                                                attributes: .concurrent)
 
         // Ensure bundle store directory exists
@@ -623,26 +634,23 @@ class BundleFileStorageService: BundleStorageService {
      */
     func findBundleFile(in directoryPath: String) -> Result<String?, Error> {
         NSLog("[BundleStorage] Searching for bundle file in directory: \(directoryPath)")
-        
-        // Check directory contents
+
+        let iosBundlePath = (directoryPath as NSString).appendingPathComponent("index.ios.bundle")
+        if self.fileSystem.fileExists(atPath: iosBundlePath) {
+            NSLog("[BundleStorage] Found iOS bundle atPath: \(iosBundlePath)")
+            return .success(iosBundlePath)
+        }
+
+        let mainBundlePath = (directoryPath as NSString).appendingPathComponent("main.jsbundle")
+        if self.fileSystem.fileExists(atPath: mainBundlePath) {
+            NSLog("[BundleStorage] Found main bundle atPath: \(mainBundlePath)")
+            return .success(mainBundlePath)
+        }
+
         do {
             let contents = try self.fileSystem.contentsOfDirectory(atPath: directoryPath)
             NSLog("[BundleStorage] Directory contents: \(contents)")
-            
-            // Check for iOS bundle file directly
-            let iosBundlePath = (directoryPath as NSString).appendingPathComponent("index.ios.bundle")
-            if self.fileSystem.fileExists(atPath: iosBundlePath) {
-                NSLog("[BundleStorage] Found iOS bundle atPath: \(iosBundlePath)")
-                return .success(iosBundlePath)
-            }
-            
-            // Check for main bundle file
-            let mainBundlePath = (directoryPath as NSString).appendingPathComponent("main.jsbundle")
-            if self.fileSystem.fileExists(atPath: mainBundlePath) {
-                NSLog("[BundleStorage] Found main bundle atPath: \(mainBundlePath)")
-                return .success(mainBundlePath)
-            }
-            
+
             // Additional search: check all .bundle files
             for file in contents {
                 if file.hasSuffix(".bundle") {
@@ -662,19 +670,23 @@ class BundleFileStorageService: BundleStorageService {
     }
         
     /**
-    * Cleans up old bundles, keeping only the current and new bundles.
+    * Cleans up old bundles, keeping only the requested bundle IDs.
     * Executes synchronously on the calling thread.
     * @param currentBundleId ID of the current active bundle (optional)
     * @param bundleId ID of the new bundle to keep (optional)
     * @return Result of operation
     */
     func cleanupOldBundles(currentBundleId: String?, bundleId: String?) -> Result<Void, Error> {
+        cleanupOldBundles(bundleIdsToKeep: [currentBundleId, bundleId].compactMap { $0 })
+    }
+
+    private func cleanupOldBundles(bundleIdsToKeep: [String]) -> Result<Void, Error> {
         let storeDirResult = bundleStoreDir()
-        
+
         guard case .success(let storeDir) = storeDirResult else {
             return .failure(storeDirResult.failureError ?? BundleStorageError.unknown(nil))
         }
-        
+
         // List only directories that are not .tmp
         let contents: [String]
         do {
@@ -694,14 +706,12 @@ class BundleFileStorageService: BundleStorageService {
 
             return (!item.hasSuffix(".tmp") && self.fileSystem.fileExists(atPath: fullPath)) ? fullPath : nil
         }
-        
-        // Keep only the specified bundle IDs
-        let bundleIdsToKeep = Set([currentBundleId, bundleId].compactMap { $0 })
-        
+        let bundleIdsToKeepSet = Set(bundleIdsToKeep)
+
         bundles.forEach { bundlePath in
             let bundleName = (bundlePath as NSString).lastPathComponent
-            
-            if !bundleIdsToKeep.contains(bundleName) {
+
+            if !bundleIdsToKeepSet.contains(bundleName) {
                 do {
                     try self.fileSystem.removeItem(atPath: bundlePath)
                     NSLog("[BundleStorage] Removing old bundle: \(bundleName)")
@@ -712,7 +722,7 @@ class BundleFileStorageService: BundleStorageService {
                 NSLog("[BundleStorage] Keeping bundle: \(bundleName)")
             }
         }
-        
+
         // Remove any leftover .tmp directories
         contents.forEach { item in
             if item.hasSuffix(".tmp") {
@@ -725,9 +735,23 @@ class BundleFileStorageService: BundleStorageService {
                 }
             }
         }
-        
+
         return .success(())
     }
+
+    private func scheduleCleanupOldBundles(bundleIdsToKeep: [String]) {
+        let uniqueBundleIdsToKeep = Array(Set(bundleIdsToKeep.filter { !$0.isEmpty }))
+        guard !uniqueBundleIdsToKeep.isEmpty else {
+            return
+        }
+
+        self.fileOperationQueue.async(flags: .barrier) {
+            let cleanupResult = self.cleanupOldBundles(bundleIdsToKeep: uniqueBundleIdsToKeep)
+            if case .failure(let error) = cleanupResult {
+                NSLog("[BundleStorage] Error during deferred cleanup: \(error)")
+            }
+        }
+    }
     
     /**
      * Sets the current bundle URL in preferences.
@@ -895,12 +919,10 @@ class BundleFileStorageService: BundleStorageService {
                             let _ = self.saveMetadata(updatedMetadata)
                             NSLog("[BundleStorage] Set staging bundle (cached): \(bundleId), verificationPending: true")
 
-                            // Clean up old bundles, preserving the fallback and new staging bundle.
-                            let bundleIdsToKeep = [updatedMetadata.stableBundleId, bundleId].compactMap { $0 }
-                            if bundleIdsToKeep.count > 0 {
-                                let _ = self.cleanupOldBundles(currentBundleId: bundleIdsToKeep.first, bundleId: bundleIdsToKeep.count > 1 ? bundleIdsToKeep[1] : nil)
-                            }
-
+                            progressHandler(UpdateProgress.complete)
+                            self.scheduleCleanupOldBundles(
+                                bundleIdsToKeep: [currentBundleId, updatedMetadata.stableBundleId, bundleId].compactMap { $0 }
+                            )
                             completion(.success(true))
                         case .failure(let error):
                             completion(.failure(error))
@@ -997,8 +1019,7 @@ class BundleFileStorageService: BundleStorageService {
                 }
             },
             progressHandler: { downloadProgress in
-                // Map download progress to 0.0 - 0.8
-                progressHandler(downloadProgress * 0.8)
+                progressHandler(Self.mapProgress(downloadProgress, start: 0, end: UpdateProgress.downloadEnd))
             },
             completion: { [weak self] result in
             guard let self = self else {
@@ -1084,7 +1105,7 @@ class BundleFileStorageService: BundleStorageService {
      * @param storeDir Path to the bundle-store directory
      * @param bundleId ID of the bundle being processed
      * @param tempDirectory Temporary directory for processing
-     * @param progressHandler Callback for extraction progress (0.8 to 1.0)
+     * @param progressHandler Callback for download/apply progress (0.0 to 1.0)
      * @param completion Callback with result of the operation
      */
     private func processDownloadedFileWithTmp(
@@ -1124,17 +1145,21 @@ class BundleFileStorageService: BundleStorageService {
             }
 
             // 4) Create tmpDir
-            try self.fileSystem.createDirectory(atPath: tmpDir)
+            guard self.fileSystem.createDirectory(atPath: tmpDir) else {
+                throw BundleStorageError.directoryCreationFailed
+            }
             NSLog("[BundleStorage] Created tmpDir: \(tmpDir)")
             logFileSystemDiagnostics(path: tmpDir, context: "TmpDir Created")
 
             // 5) Verify bundle integrity (hash or signature based on fileHash format)
             NSLog("[BundleStorage] Verifying bundle integrity...")
+            progressHandler(UpdateProgress.verificationStart)
             let tempBundleURL = URL(fileURLWithPath: tempBundleFile)
             let verificationResult = SignatureVerifier.verifyBundle(fileURL: tempBundleURL, fileHash: fileHash)
             switch verificationResult {
             case .success:
                 NSLog("[BundleStorage] Bundle verification completed successfully")
+                progressHandler(UpdateProgress.verificationEnd)
             case .failure(let error):
                 NSLog("[BundleStorage] Bundle verification failed: \(error)")
                 try? self.fileSystem.removeItem(atPath: tmpDir)
@@ -1148,8 +1173,12 @@ class BundleFileStorageService: BundleStorageService {
             logFileSystemDiagnostics(path: tempBundleFile, context: "Before Extraction")
             do {
                 try self.decompressService.unzip(file: tempBundleFile, to: tmpDir, progressHandler: { unzipProgress in
-                    // Map unzip progress (0.0 - 1.0) to overall progress (0.8 - 1.0)
-                    progressHandler(0.8 + (unzipProgress * 0.2))
+                    let progress = Self.mapProgress(
+                        unzipProgress,
+                        start: UpdateProgress.extractionStart,
+                        end: UpdateProgress.extractionEnd
+                    )
+                    progressHandler(progress)
                 })
                 NSLog("[BundleStorage] Extraction complete at \(tmpDir)")
                 logFileSystemDiagnostics(path: tmpDir, context: "After Extraction")
@@ -1167,6 +1196,7 @@ class BundleFileStorageService: BundleStorageService {
             try? self.fileSystem.removeItem(atPath: tempBundleFile)
 
             // 8) Verify that a valid bundle file exists inside tmpDir
+            progressHandler(UpdateProgress.bundleValidation)
             switch self.findBundleFile(in: tmpDir) {
             case .success(let maybeBundlePath):
                 if let bundlePathInTmp = maybeBundlePath {
@@ -1210,13 +1240,13 @@ class BundleFileStorageService: BundleStorageService {
                         // 14) Clean up the temporary directory
                         self.cleanupTemporaryFiles([tempDirectory])
 
-                        // 15) Clean up old bundles, preserving the fallback and new staging bundle.
-                        let bundleIdsToKeep = [updatedMetadata.stableBundleId, bundleId].compactMap { $0 }
-                        if bundleIdsToKeep.count > 0 {
-                            let _ = self.cleanupOldBundles(currentBundleId: bundleIdsToKeep.first, bundleId: bundleIdsToKeep.count > 1 ? bundleIdsToKeep[1] : nil)
-                        }
+                        progressHandler(UpdateProgress.activationReady)
+                        self.scheduleCleanupOldBundles(
+                            bundleIdsToKeep: [currentBundleId, updatedMetadata.stableBundleId, bundleId].compactMap { $0 }
+                        )
 
-                        // 16) Complete with success
+                        // 15) Complete with success
+                        progressHandler(UpdateProgress.complete)
                         completion(.success(true))
                     case .failure(let err):
                         let nsError = err as NSError
@@ -1259,6 +1289,11 @@ class BundleFileStorageService: BundleStorageService {
         }
     }
 
+    private static func mapProgress(_ value: Double, start: Double, end: Double) -> Double {
+        let clampedValue = min(max(value, 0), 1)
+        return start + (clampedValue * (end - start))
+    }
+
     // MARK: - Rollback Support
 
     /**