@hot-updater/react-native 0.19.4 → 0.19.6

package/android/src/main/java/com/hotupdater/BundleFileStorageService.kt

@@ -100,6 +100,15 @@ class BundleFileStorageService(
             bundleStoreDir.mkdirs()
         }
 
+        val currentBundleId =
+            getCachedBundleURL()?.let { cachedUrl ->
+                // Only consider cached bundles, not fallback bundles
+                if (!cachedUrl.startsWith("assets://")) {
+                    File(cachedUrl).parentFile?.name
+                } else {
+                    null
+                }
+            }
         val finalBundleDir = File(bundleStoreDir, bundleId)
         if (finalBundleDir.exists()) {
             Log.d("BundleStorage", "Bundle for bundleId $bundleId already exists. Using cached bundle.")
@@ -108,7 +117,7 @@ class BundleFileStorageService(
                 // Update last modified time and set the cached bundle URL
                 finalBundleDir.setLastModified(System.currentTimeMillis())
                 setBundleURL(existingIndexFile.absolutePath)
-                cleanupOldBundles(bundleStoreDir)
+                cleanupOldBundles(bundleStoreDir, currentBundleId, bundleId)
                 return true
             } else {
                 // If index.android.bundle is missing, delete and re-download
@@ -203,7 +212,7 @@ class BundleFileStorageService(
                     tempDir.deleteRecursively()
 
                     // 10) Remove old bundles
-                    cleanupOldBundles(bundleStoreDir)
+                    cleanupOldBundles(bundleStoreDir, currentBundleId, bundleId)
 
                     Log.d("BundleStorage", "Downloaded and activated bundle successfully.")
                     return@withContext true
@@ -213,25 +222,59 @@ class BundleFileStorageService(
     }
 
     /**
-     * Removes older bundles and any leftover .tmp directories
+     * Removes old bundles except for the specified bundle IDs, and any leftover .tmp directories
      */
-    private fun cleanupOldBundles(bundleStoreDir: File) {
-        // List only directories that are not .tmp
-        val bundles = bundleStoreDir.listFiles { file -> file.isDirectory && !file.name.endsWith(".tmp") }?.toList() ?: return
-        // Sort bundles by last modified (newest first)
-        val sortedBundles = bundles.sortedByDescending { it.lastModified() }
-        if (sortedBundles.size > 1) {
-            // Keep the most recent bundle, delete the rest
-            sortedBundles.drop(1).forEach { oldBundle ->
-                Log.d("BundleStorage", "Removing old bundle: ${oldBundle.name}")
-                oldBundle.deleteRecursively()
+    private fun cleanupOldBundles(
+        bundleStoreDir: File,
+        currentBundleId: String?,
+        bundleId: String,
+    ) {
+        try {
+            // List only directories that are not .tmp
+            val bundles =
+                bundleStoreDir
+                    .listFiles { file ->
+                        file.isDirectory && !file.name.endsWith(".tmp")
+                    }?.toList() ?: return
+
+            // Keep only the specified bundle IDs (filter out null values)
+            val bundleIdsToKeep = setOfNotNull(currentBundleId, bundleId).filter { it.isNotBlank() }
+
+            bundles.forEach { bundle ->
+                try {
+                    if (bundle.name !in bundleIdsToKeep) {
+                        Log.d("BundleStorage", "Removing old bundle: ${bundle.name}")
+                        if (bundle.deleteRecursively()) {
+                            Log.d("BundleStorage", "Successfully removed old bundle: ${bundle.name}")
+                        } else {
+                            Log.w("BundleStorage", "Failed to remove old bundle: ${bundle.name}")
+                        }
+                    } else {
+                        Log.d("BundleStorage", "Keeping bundle: ${bundle.name}")
+                    }
+                } catch (e: Exception) {
+                    Log.e("BundleStorage", "Error removing bundle ${bundle.name}: ${e.message}")
+                }
             }
-        }
 
-        // Remove any leftover .tmp directories
-        bundleStoreDir.listFiles { file -> file.isDirectory && file.name.endsWith(".tmp") }?.forEach { staleTmp ->
-            Log.d("BundleStorage", "Removing stale tmp directory: ${staleTmp.name}")
-            staleTmp.deleteRecursively()
+            // Remove any leftover .tmp directories
+            bundleStoreDir
+                .listFiles { file ->
+                    file.isDirectory && file.name.endsWith(".tmp")
+                }?.forEach { staleTmp ->
+                    try {
+                        Log.d("BundleStorage", "Removing stale tmp directory: ${staleTmp.name}")
+                        if (staleTmp.deleteRecursively()) {
+                            Log.d("BundleStorage", "Successfully removed tmp directory: ${staleTmp.name}")
+                        } else {
+                            Log.w("BundleStorage", "Failed to remove tmp directory: ${staleTmp.name}")
+                        }
+                    } catch (e: Exception) {
+                        Log.e("BundleStorage", "Error removing tmp directory ${staleTmp.name}: ${e.message}")
+                    }
+                }
+        } catch (e: Exception) {
+            Log.e("BundleStorage", "Error during cleanup: ${e.message}")
         }
     }
 }

package/ios/HotUpdater/Internal/BundleFileStorageService.swift

@@ -159,115 +159,67 @@ class BundleFileStorageService: BundleStorageService {
             return .failure(error)
         }
     }
-    
+        
     /**
-     * Cleans up old bundles, keeping only the current and latest bundles.
-     * Executes synchronously on the calling thread.
-     * @param currentBundleId ID of the current active bundle (optional)
-     * @return Result of operation
-     */
-    func cleanupOldBundles(currentBundleId: String?) -> Result<Void, Error> {
+    * Cleans up old bundles, keeping only the current and new bundles.
+    * 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> {
         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 {
-            var contents: [String]
-            do {
-                contents = try self.fileSystem.contentsOfDirectory(atPath: storeDir)
-            } catch let error {
-                NSLog("[BundleStorage] Failed to list contents of bundle store directory: \(storeDir)")
-                return .failure(BundleStorageError.fileSystemError(error))
-            }
-            
-            if contents.isEmpty {
-                NSLog("[BundleStorage] No bundles to clean up.")
-                return .success(())
-            }
-            
-            let currentBundlePath = currentBundleId != nil ?
-            (storeDir as NSString).appendingPathComponent(currentBundleId!) : nil
-            
-            var latestBundlePath: String? = nil
-            var latestModDate: Date = .distantPast
+            contents = try self.fileSystem.contentsOfDirectory(atPath: storeDir)
+        } catch let error {
+            NSLog("[BundleStorage] Failed to list contents of bundle store directory: \(storeDir)")
+            return .failure(BundleStorageError.fileSystemError(error))
+        }
+        
+        let bundles = contents.compactMap { item -> String? in
+            let fullPath = (storeDir as NSString).appendingPathComponent(item)
+            return (!item.hasSuffix(".tmp") && self.fileSystem.fileExists(atPath: fullPath)) ? fullPath : nil
+        }
+        
+        // Keep only the specified bundle IDs
+        let bundleIdsToKeep = Set([currentBundleId, bundleId].compactMap { $0 })
+        
+        bundles.forEach { bundlePath in
+            let bundleName = (bundlePath as NSString).lastPathComponent
             
-            for item in contents {
-                let fullPath = (storeDir as NSString).appendingPathComponent(item)
-                
-                // Skip .tmp directories
-                if item.hasSuffix(".tmp") {
-                    continue
-                }
-                
-                if let currentPath = currentBundlePath, fullPath == currentPath {
-                    continue
-                }
-                
-                if self.fileSystem.fileExists(atPath: fullPath) {
-                    do {
-                        let attributes = try self.fileSystem.attributesOfItem(atPath: fullPath)
-                        if let modDate = attributes[FileAttributeKey.modificationDate] as? Date {
-                            if modDate > latestModDate {
-                                latestModDate = modDate
-                                latestBundlePath = fullPath
-                            }
-                        }
-                    } catch {
-                        NSLog("[BundleStorage] Warning: Could not get attributes for \(fullPath): \(error)")
-                    }
+            if !bundleIdsToKeep.contains(bundleName) {
+                do {
+                    try self.fileSystem.removeItem(atPath: bundlePath)
+                    NSLog("[BundleStorage] Removing old bundle: \(bundleName)")
+                } catch {
+                    NSLog("[BundleStorage] Failed to remove old bundle at \(bundlePath): \(error)")
                 }
+            } else {
+                NSLog("[BundleStorage] Keeping bundle: \(bundleName)")
             }
-            
-            var bundlesToKeep = Set<String>()
-            
-            if let currentPath = currentBundlePath, self.fileSystem.fileExists(atPath: currentPath) {
-                bundlesToKeep.insert(currentPath)
-                NSLog("[BundleStorage] Keeping current bundle: \(currentBundleId!)")
-            }
-            
-            if let latestPath = latestBundlePath {
-                bundlesToKeep.insert(latestPath)
-                NSLog("[BundleStorage] Keeping latest bundle: \((latestPath as NSString).lastPathComponent)")
-            }
-            
-            var removedCount = 0
-            for item in contents {
+        }
+        
+        // Remove any leftover .tmp directories
+        contents.forEach { item in
+            if item.hasSuffix(".tmp") {
                 let fullPath = (storeDir as NSString).appendingPathComponent(item)
-                // Skip .tmp directories as well
-                if item.hasSuffix(".tmp") {
-                    // Clean up any stale .tmp directories
-                    do {
-                        try self.fileSystem.removeItem(atPath: fullPath)
-                        NSLog("[BundleStorage] Removed stale tmp directory: \(fullPath)")
-                    } catch {
-                        NSLog("[BundleStorage] Failed to remove stale tmp directory \(fullPath): \(error)")
-                    }
-                    continue
-                }
-                
-                if !bundlesToKeep.contains(fullPath) {
-                    do {
-                        try self.fileSystem.removeItem(atPath: fullPath)
-                        removedCount += 1
-                        NSLog("[BundleStorage] Removed old bundle: \(item)")
-                    } catch {
-                        NSLog("[BundleStorage] Failed to remove old bundle at \(fullPath): \(error)")
-                    }
+                do {
+                    try self.fileSystem.removeItem(atPath: fullPath)
+                    NSLog("[BundleStorage] Removing stale tmp directory: \(item)")
+                } catch {
+                    NSLog("[BundleStorage] Failed to remove stale tmp directory \(fullPath): \(error)")
                 }
             }
-            
-            if removedCount == 0 {
-                NSLog("[BundleStorage] No old bundles to remove.")
-            } else {
-                NSLog("[BundleStorage] Removed \(removedCount) old bundle(s).")
-            }
-            
-            return .success(())
-        } catch let error {
-            return .failure(error)
         }
+        
+        return .success(())
     }
     
     /**
@@ -324,6 +276,9 @@ class BundleFileStorageService: BundleStorageService {
      * @param completion Callback with result of the operation
      */
     func updateBundle(bundleId: String, fileUrl: URL?, completion: @escaping (Result<Bool, Error>) -> Void) {
+        // Get the current bundle ID from the cached bundle URL (exclude fallback bundles)
+        let currentBundleId = self.getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent
+        
         guard let validFileUrl = fileUrl else {
             NSLog("[BundleStorage] fileUrl is nil, resetting bundle URL.")
             // Dispatch the sequence to the file operation queue to ensure completion is called asynchronously
@@ -332,7 +287,7 @@ class BundleFileStorageService: BundleStorageService {
                 let setResult = self.setBundleURL(localPath: nil)
                 switch setResult {
                 case .success:
-                    let cleanupResult = self.cleanupOldBundles(currentBundleId: nil)
+                    let cleanupResult = self.cleanupOldBundles(currentBundleId: currentBundleId, bundleId: bundleId)
                     switch cleanupResult {
                     case .success:
                         completion(.success(true))
@@ -350,6 +305,7 @@ class BundleFileStorageService: BundleStorageService {
         
         // Start the bundle update process on a background queue
         fileOperationQueue.async {
+            
             let storeDirResult = self.bundleStoreDir()
             guard case .success(let storeDir) = storeDirResult else {
                 completion(.failure(storeDirResult.failureError ?? BundleStorageError.unknown(nil)))
@@ -368,7 +324,7 @@ class BundleFileStorageService: BundleStorageService {
                             let setResult = self.setBundleURL(localPath: bundlePath)
                             switch setResult {
                             case .success:
-                                let cleanupResult = self.cleanupOldBundles(currentBundleId: bundleId)
+                                let cleanupResult = self.cleanupOldBundles(currentBundleId: currentBundleId, bundleId: bundleId)
                                 switch cleanupResult {
                                 case .success:
                                     completion(.success(true))
@@ -478,7 +434,7 @@ class BundleFileStorageService: BundleStorageService {
     }
     
     /**
-     * Processes a downloaded bundle file using the “.tmp” rename approach.
+     * Processes a downloaded bundle file using the "tmp" rename approach.
      * This method is part of the asynchronous `updateBundle` flow and is expected to run on a background thread.
      * @param location URL of the downloaded file
      * @param tempZipFile Path to store the downloaded zip file
@@ -495,6 +451,7 @@ class BundleFileStorageService: BundleStorageService {
         tempDirectory: String,
         completion: @escaping (Result<Bool, Error>) -> Void
     ) {
+        let currentBundleId = self.getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent
         NSLog("[BundleStorage] Processing downloaded file atPath: \(location.path)")
         
         // 1) Ensure the ZIP file exists
@@ -556,7 +513,7 @@ class BundleFileStorageService: BundleStorageService {
                         self.cleanupTemporaryFiles([tempDirectory])
                         
                         // 13) Clean up old bundles, preserving current and latest
-                        let _ = self.cleanupOldBundles(currentBundleId: bundleId)
+                        let _ = self.cleanupOldBundles(currentBundleId: currentBundleId, bundleId: bundleId)
                         
                         // 14) Complete with success
                         completion(.success(true))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/react-native",
-  "version": "0.19.4",
+  "version": "0.19.6",
   "description": "React Native OTA solution for self-hosted",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -119,12 +119,12 @@
     "react-native": "0.79.1",
     "react-native-builder-bob": "^0.40.10",
     "typescript": "^5.8.3",
-    "hot-updater": "0.19.4"
+    "hot-updater": "0.19.6"
   },
   "dependencies": {
     "use-sync-external-store": "1.5.0",
-    "@hot-updater/js": "0.19.4",
-    "@hot-updater/core": "0.19.4"
+    "@hot-updater/js": "0.19.6",
+    "@hot-updater/core": "0.19.6"
   },
   "scripts": {
     "build": "bob build && tsc -p plugin/tsconfig.json",

package/plugin/build/withHotUpdater.js

@@ -50,7 +50,7 @@ var getFingerprint = function () { return __awaiter(void 0, void 0, void 0, func
                 if (fingerprintCache) {
                     return [2 /*return*/, fingerprintCache];
                 }
-                return [4 /*yield*/, (0, hot_updater_1.createFingerprintJson)()];
+                return [4 /*yield*/, (0, hot_updater_1.createAndInjectFingerprintFiles)()];
             case 1:
                 fingerprintCache = _a.sent();
                 return [2 /*return*/, fingerprintCache];