@hot-updater/react-native 0.23.0 → 0.24.0

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

@@ -32,6 +32,7 @@ interface BundleStorageService {
 
     /**
      * Gets the URL to the bundle file (cached or fallback)
+     * With rollback support: checks for crashed staging bundles
      * @return The path to the bundle file
      */
     fun getBundleURL(): String
@@ -42,14 +43,33 @@ interface BundleStorageService {
      * @param fileUrl URL of the bundle file to download (or null to reset)
      * @param fileHash Combined hash string for verification (sig:<signature> or <hex_hash>)
      * @param progressCallback Callback for download progress updates
-     * @return true if the update was successful
+     * @throws HotUpdaterException if the update fails
      */
     suspend fun updateBundle(
         bundleId: String,
         fileUrl: String?,
         fileHash: String?,
         progressCallback: (Double) -> Unit,
-    ): Boolean
+    )
+
+    /**
+     * Notifies that the app has started successfully with the current bundle
+     * @param currentBundleId The bundle ID that JS reports as currently loaded
+     * @return Map containing status and optional crashedBundleId
+     */
+    fun notifyAppReady(currentBundleId: String?): Map<String, Any?>
+
+    /**
+     * Gets the crashed bundle history
+     * @return CrashedHistory containing crashed bundles
+     */
+    fun getCrashHistory(): CrashedHistory
+
+    /**
+     * Clears the crashed bundle history
+     * @return true if clearing was successful
+     */
+    fun clearCrashHistory(): Boolean
 }
 
 /**
@@ -62,20 +82,219 @@ class BundleFileStorageService(
     private val decompressService: DecompressService,
     private val preferences: PreferencesService,
 ) : BundleStorageService {
+    companion object {
+        private const val TAG = "BundleStorage"
+    }
+
+    // Session-only rollback tracking (in-memory)
+    private var sessionRollbackBundleId: String? = null
+
+    // MARK: - Bundle Store Directory
+
+    private fun getBundleStoreDir(): File {
+        val baseDir = fileSystem.getExternalFilesDir()
+        return File(baseDir, "bundle-store")
+    }
+
+    private fun getMetadataFile(): File = File(getBundleStoreDir(), BundleMetadata.METADATA_FILENAME)
+
+    private fun getCrashedHistoryFile(): File = File(getBundleStoreDir(), CrashedHistory.CRASHED_HISTORY_FILENAME)
+
+    // MARK: - Metadata Operations
+
+    private fun loadMetadataOrNull(): BundleMetadata? = BundleMetadata.loadFromFile(getMetadataFile())
+
+    private fun saveMetadata(metadata: BundleMetadata): Boolean = metadata.saveToFile(getMetadataFile())
+
+    private fun createInitialMetadata(): BundleMetadata {
+        val currentBundleId = extractBundleIdFromCurrentURL()
+        Log.d(TAG, "Creating initial metadata with stableBundleId: $currentBundleId")
+        return BundleMetadata(
+            stableBundleId = currentBundleId,
+            stagingBundleId = null,
+            verificationPending = false,
+            verificationAttemptedAt = null,
+        )
+    }
+
+    private fun extractBundleIdFromCurrentURL(): String? {
+        val currentUrl = preferences.getItem("HotUpdaterBundleURL") ?: return null
+        // "bundle-store/abc123/index.android.bundle" -> "abc123"
+        val regex = Regex("bundle-store/([^/]+)/")
+        return regex.find(currentUrl)?.groupValues?.get(1)
+    }
+
+    // MARK: - State Machine
+
+    private fun isVerificationPending(metadata: BundleMetadata): Boolean = metadata.verificationPending && metadata.stagingBundleId != null
+
+    private fun wasVerificationAttempted(metadata: BundleMetadata): Boolean = metadata.verificationAttemptedAt != null
+
+    private fun markVerificationAttempted() {
+        val metadata = loadMetadataOrNull() ?: return
+        val updatedMetadata =
+            metadata.copy(
+                verificationAttemptedAt = System.currentTimeMillis(),
+                updatedAt = System.currentTimeMillis(),
+            )
+        saveMetadata(updatedMetadata)
+        Log.d(TAG, "Marked verification attempted at ${updatedMetadata.verificationAttemptedAt}")
+    }
+
+    private fun promoteStagingToStable() {
+        val metadata = loadMetadataOrNull() ?: return
+        val stagingBundleId = metadata.stagingBundleId ?: return
+
+        Log.d(TAG, "Promoting staging bundle $stagingBundleId to stable")
+
+        val updatedMetadata =
+            metadata.copy(
+                stableBundleId = stagingBundleId,
+                stagingBundleId = null,
+                verificationPending = false,
+                verificationAttemptedAt = null,
+                updatedAt = System.currentTimeMillis(),
+            )
+        saveMetadata(updatedMetadata)
+
+        // Update HotUpdaterBundleURL preference to point to stable bundle
+        val bundleStoreDir = getBundleStoreDir()
+        val stableBundleDir = File(bundleStoreDir, stagingBundleId)
+        val bundleFile = stableBundleDir.walk().find { it.name == "index.android.bundle" }
+        if (bundleFile != null) {
+            preferences.setItem("HotUpdaterBundleURL", bundleFile.absolutePath)
+        }
+
+        // Cleanup old bundles (keep only the new stable)
+        cleanupOldBundles(bundleStoreDir, null, stagingBundleId)
+    }
+
+    private fun rollbackToStable() {
+        val metadata = loadMetadataOrNull() ?: return
+        val stagingBundleId = metadata.stagingBundleId ?: return
+
+        Log.w(TAG, "Rolling back: adding $stagingBundleId to crashed history")
+
+        // Add to crashed history
+        val crashedHistory = loadCrashedHistory()
+        crashedHistory.addEntry(stagingBundleId)
+        saveCrashedHistory(crashedHistory)
+
+        // Save rollback info to session variable (memory only)
+        sessionRollbackBundleId = stagingBundleId
+
+        // Clear staging pointer
+        val updatedMetadata =
+            metadata.copy(
+                stagingBundleId = null,
+                verificationPending = false,
+                verificationAttemptedAt = null,
+                stagingExecutionCount = null,
+                updatedAt = System.currentTimeMillis(),
+            )
+        saveMetadata(updatedMetadata)
+
+        // Update bundle URL to point to stable bundle
+        val stableBundleId = updatedMetadata.stableBundleId
+        if (stableBundleId != null) {
+            val bundleStoreDir = getBundleStoreDir()
+            val stableBundleDir = File(bundleStoreDir, stableBundleId)
+            val bundleFile = stableBundleDir.walk().find { it.name == "index.android.bundle" }
+            if (bundleFile != null && bundleFile.exists()) {
+                setBundleURL(bundleFile.absolutePath)
+                Log.d(TAG, "Updated bundle URL to stable: $stableBundleId")
+            }
+        } else {
+            // No stable bundle available, clear bundle URL (fallback to assets)
+            setBundleURL(null)
+            Log.d(TAG, "Cleared bundle URL (no stable bundle)")
+        }
+
+        // Remove staging bundle directory
+        val bundleStoreDir = getBundleStoreDir()
+        val stagingBundleDir = File(bundleStoreDir, stagingBundleId)
+        if (stagingBundleDir.exists()) {
+            stagingBundleDir.deleteRecursively()
+            Log.d(TAG, "Deleted crashed staging bundle directory: $stagingBundleId")
+        }
+    }
+
+    // MARK: - Crashed History
+
+    private fun loadCrashedHistory(): CrashedHistory = CrashedHistory.loadFromFile(getCrashedHistoryFile())
+
+    private fun saveCrashedHistory(history: CrashedHistory): Boolean = history.saveToFile(getCrashedHistoryFile())
+
+    private fun isBundleInCrashedHistory(bundleId: String): Boolean = loadCrashedHistory().contains(bundleId)
+
+    override fun getCrashHistory(): CrashedHistory = loadCrashedHistory()
+
+    override fun clearCrashHistory(): Boolean {
+        val history = CrashedHistory()
+        saveCrashedHistory(history)
+        Log.d(TAG, "Cleared crash history")
+        return true
+    }
+
+    // MARK: - notifyAppReady
+
+    override fun notifyAppReady(currentBundleId: String?): Map<String, Any?> {
+        val metadata =
+            loadMetadataOrNull()
+                ?: return mapOf("status" to "STABLE")
+
+        // Check if there was a recent rollback (session variable)
+        sessionRollbackBundleId?.let { crashedBundleId ->
+            // Clear rollback info (one-time read)
+            sessionRollbackBundleId = null
+
+            Log.d(TAG, "notifyAppReady: recovered from rollback (crashed bundle: $crashedBundleId)")
+            return mapOf(
+                "status" to "RECOVERED",
+                "crashedBundleId" to crashedBundleId,
+            )
+        }
+
+        // Check for promotion
+        if (isVerificationPending(metadata)) {
+            val stagingBundleId = metadata.stagingBundleId
+            if (stagingBundleId != null && stagingBundleId == currentBundleId) {
+                Log.d(TAG, "App started successfully with staging bundle $currentBundleId, promoting to stable")
+                promoteStagingToStable()
+                return mapOf("status" to "PROMOTED")
+            } else {
+                Log.d(TAG, "notifyAppReady: bundleId mismatch (staging=$stagingBundleId, current=$currentBundleId)")
+            }
+        } else {
+            Log.d(TAG, "notifyAppReady: no verification pending")
+        }
+
+        // No changes
+        return mapOf("status" to "STABLE")
+    }
+
+    // MARK: - Bundle URL Operations
+
     override fun setBundleURL(localPath: String?): Boolean {
+        Log.d(TAG, "setBundleURL: $localPath")
         preferences.setItem("HotUpdaterBundleURL", localPath)
         return true
     }
 
     override fun getCachedBundleURL(): String? {
         val urlString = preferences.getItem("HotUpdaterBundleURL")
+        Log.d(TAG, "getCachedBundleURL: read from prefs = $urlString")
         if (urlString.isNullOrEmpty()) {
+            Log.d(TAG, "getCachedBundleURL: urlString is null or empty")
             return null
         }
 
         val file = File(urlString)
-        if (!file.exists()) {
+        val exists = file.exists()
+        Log.d(TAG, "getCachedBundleURL: file exists = $exists at path: $urlString")
+        if (!exists) {
             preferences.setItem("HotUpdaterBundleURL", null)
+            Log.d(TAG, "getCachedBundleURL: file doesn't exist, cleared preference")
             return null
         }
         return urlString
@@ -83,63 +302,154 @@ class BundleFileStorageService(
 
     override fun getFallbackBundleURL(): String = "assets://index.android.bundle"
 
-    override fun getBundleURL(): String = getCachedBundleURL() ?: getFallbackBundleURL()
+    // Track if crash detection has already run in this process
+    private var crashDetectionCompleted = false
+
+    override fun getBundleURL(): String {
+        val metadata = loadMetadataOrNull()
+
+        if (metadata == null) {
+            // Legacy mode: no metadata.json exists, use existing behavior
+            val cached = getCachedBundleURL()
+            val result = cached ?: getFallbackBundleURL()
+            Log.d(TAG, "getBundleURL (legacy): returning $result")
+            return result
+        }
+
+        // New rollback-aware mode - only run crash detection ONCE per process
+        if (isVerificationPending(metadata) && !crashDetectionCompleted) {
+            crashDetectionCompleted = true
+
+            if (wasVerificationAttempted(metadata)) {
+                // Already executed once but didn't call notifyAppReady → crash!
+                Log.w(TAG, "Crash detected: staging bundle executed but didn't call notifyAppReady")
+                rollbackToStable()
+            } else {
+                // First execution - mark verification attempted and give it a chance
+                Log.d(TAG, "First execution of staging bundle, marking verification attempted")
+                markVerificationAttempted()
+            }
+        }
+
+        // Reload metadata after potential rollback
+        val currentMetadata = loadMetadataOrNull()
+
+        // Return staging bundle if verification pending
+        if (currentMetadata != null && isVerificationPending(currentMetadata)) {
+            val stagingId = currentMetadata.stagingBundleId
+            if (stagingId != null) {
+                val bundleStoreDir = getBundleStoreDir()
+                val stagingBundleDir = File(bundleStoreDir, stagingId)
+                val bundleFile = stagingBundleDir.walk().find { it.name == "index.android.bundle" }
+                if (bundleFile != null && bundleFile.exists()) {
+                    Log.d(TAG, "getBundleURL: returning STAGING bundle $stagingId")
+                    return bundleFile.absolutePath
+                } else {
+                    Log.w(TAG, "getBundleURL: staging bundle file not found for $stagingId")
+                    // Staging bundle file missing, rollback to stable
+                    rollbackToStable()
+                }
+            }
+        }
+
+        // Return stable bundle URL
+        val stableBundleId = currentMetadata?.stableBundleId
+        if (stableBundleId != null) {
+            val bundleStoreDir = getBundleStoreDir()
+            val stableBundleDir = File(bundleStoreDir, stableBundleId)
+            val bundleFile = stableBundleDir.walk().find { it.name == "index.android.bundle" }
+            if (bundleFile != null && bundleFile.exists()) {
+                Log.d(TAG, "getBundleURL: returning stable bundle $stableBundleId")
+                return bundleFile.absolutePath
+            }
+        }
+
+        // Fallback
+        val cached = getCachedBundleURL()
+        val result = cached ?: getFallbackBundleURL()
+        Log.d(TAG, "getBundleURL: returning $result (cached=$cached)")
+        return result
+    }
 
     override suspend fun updateBundle(
         bundleId: String,
         fileUrl: String?,
         fileHash: String?,
         progressCallback: (Double) -> Unit,
-    ): Boolean {
+    ) {
         Log.d(
-            "BundleStorage",
+            TAG,
             "updateBundle bundleId $bundleId fileUrl $fileUrl fileHash $fileHash",
         )
 
         // If no URL is provided, reset to fallback
         if (fileUrl.isNullOrEmpty()) {
             setBundleURL(null)
-            return true
+            return
+        }
+
+        // Check if bundle is in crashed history
+        if (isBundleInCrashedHistory(bundleId)) {
+            Log.w(TAG, "Bundle $bundleId is in crashed history, rejecting update")
+            throw HotUpdaterException.bundleInCrashedHistory(bundleId)
         }
 
+        // Initialize metadata if it doesn't exist (lazy initialization)
+        val existingMetadata = loadMetadataOrNull()
+        val metadata =
+            existingMetadata ?: createInitialMetadata().also {
+                saveMetadata(it)
+                Log.d(TAG, "Created initial metadata during updateBundle")
+            }
+
         val baseDir = fileSystem.getExternalFilesDir()
-        val bundleStoreDir = File(baseDir, "bundle-store")
+        val bundleStoreDir = getBundleStoreDir()
         if (!bundleStoreDir.exists()) {
             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.")
+            Log.d(TAG, "Bundle for bundleId $bundleId already exists. Using cached bundle.")
             val existingIndexFile = finalBundleDir.walk().find { it.name == "index.android.bundle" }
             if (existingIndexFile != null) {
-                // Update last modified time and set the cached bundle URL
+                // Update last modified time
                 finalBundleDir.setLastModified(System.currentTimeMillis())
+
+                // Update metadata: set as staging
+                val currentMetadata = loadMetadataOrNull() ?: createInitialMetadata()
+                val updatedMetadata =
+                    currentMetadata.copy(
+                        stagingBundleId = bundleId,
+                        verificationPending = true,
+                        verificationAttemptedAt = null,
+                        updatedAt = System.currentTimeMillis(),
+                    )
+                saveMetadata(updatedMetadata)
+
+                // Set bundle URL for backwards compatibility
                 setBundleURL(existingIndexFile.absolutePath)
-                cleanupOldBundles(bundleStoreDir, currentBundleId, bundleId)
-                return true
+
+                // Keep both stable and staging bundles
+                val stableBundleId = currentMetadata.stableBundleId
+                cleanupOldBundles(bundleStoreDir, stableBundleId, bundleId)
+
+                Log.d(TAG, "Existing bundle set as staging, will be promoted after notifyAppReady")
+                return
             } else {
                 // If index.android.bundle is missing, delete and re-download
                 finalBundleDir.deleteRecursively()
             }
         }
 
-        val tempDir = File(baseDir, "bundle-temp")
+        val tempDirName = "bundle-temp"
+        val tempDir = File(baseDir, tempDirName)
         if (tempDir.exists()) {
             tempDir.deleteRecursively()
         }
         tempDir.mkdirs()
 
-        return withContext(Dispatchers.IO) {
+        withContext(Dispatchers.IO) {
             val downloadUrl = URL(fileUrl)
 
             // Determine bundle filename from URL
@@ -162,9 +472,8 @@ class BundleFileStorageService(
                 Log.d("BundleStorage", "File size: $fileSize bytes, Available: $availableBytes bytes, Required: $requiredSpace bytes")
 
                 if (availableBytes < requiredSpace) {
-                    val errorMsg = "Insufficient disk space: need $requiredSpace bytes, available $availableBytes bytes"
-                    Log.d("BundleStorage", errorMsg)
-                    return@withContext false
+                    Log.d("BundleStorage", "Insufficient disk space: need $requiredSpace bytes, available $availableBytes bytes")
+                    throw HotUpdaterException.insufficientDiskSpace(requiredSpace, availableBytes)
                 }
             } else {
                 Log.d("BundleStorage", "Unable to determine file size, proceeding with download")
@@ -184,7 +493,17 @@ class BundleFileStorageService(
                 is DownloadResult.Error -> {
                     Log.d("BundleStorage", "Download failed: ${downloadResult.exception.message}")
                     tempDir.deleteRecursively()
-                    return@withContext false
+
+                    // Check if this is an incomplete download error
+                    if (downloadResult.exception is IncompleteDownloadException) {
+                        val incompleteEx = downloadResult.exception as IncompleteDownloadException
+                        throw HotUpdaterException.incompleteDownload(
+                            incompleteEx.expectedSize,
+                            incompleteEx.actualSize,
+                        )
+                    } else {
+                        throw HotUpdaterException.downloadFailed(downloadResult.exception)
+                    }
                 }
 
                 is DownloadResult.Success -> {
@@ -198,7 +517,7 @@ class BundleFileStorageService(
                         Log.e("BundleStorage", "Bundle verification failed", e)
                         tempDir.deleteRecursively()
                         tempBundleFile.delete()
-                        return@withContext false
+                        throw HotUpdaterException.signatureVerificationFailed(e)
                     }
 
                     // 2) Create a .tmp directory under bundle-store (to avoid colliding with an existing bundleId folder)
@@ -221,7 +540,7 @@ class BundleFileStorageService(
                         Log.d("BundleStorage", "Failed to extract archive into tmpDir.")
                         tempDir.deleteRecursively()
                         tmpDir.deleteRecursively()
-                        return@withContext false
+                        throw HotUpdaterException.extractionFormatError()
                     }
 
                     // 4) Find index.android.bundle inside tmpDir
@@ -230,7 +549,7 @@ class BundleFileStorageService(
                         Log.d("BundleStorage", "index.android.bundle not found in tmpDir.")
                         tempDir.deleteRecursively()
                         tmpDir.deleteRecursively()
-                        return@withContext false
+                        throw HotUpdaterException.invalidBundle()
                     }
 
                     // 5) Log extracted bundle file size
@@ -245,9 +564,20 @@ class BundleFileStorageService(
                     // 7) Attempt to rename tmpDir → finalBundleDir (atomic within the same parent folder)
                     val renamed = tmpDir.renameTo(finalBundleDir)
                     if (!renamed) {
-                        // If rename fails, use moveItem or copyItem
+                        // If rename fails, use moveItem as fallback
                         if (!fileSystem.moveItem(tmpDir.absolutePath, finalBundleDir.absolutePath)) {
-                            fileSystem.copyItem(tmpDir.absolutePath, finalBundleDir.absolutePath)
+                            // If move also fails, try copy + delete as last resort
+                            if (!fileSystem.copyItem(tmpDir.absolutePath, finalBundleDir.absolutePath)) {
+                                // All strategies failed
+                                Log.e(
+                                    "BundleStorage",
+                                    "Failed to move bundle from tmpDir to finalBundleDir (rename, move, and copy all failed)",
+                                )
+                                tempDir.deleteRecursively()
+                                tmpDir.deleteRecursively()
+                                throw HotUpdaterException.moveOperationFailed()
+                            }
+                            // Copy succeeded, clean up tmpDir
                             tmpDir.deleteRecursively()
                         }
                     }
@@ -258,26 +588,40 @@ class BundleFileStorageService(
                         Log.d("BundleStorage", "index.android.bundle not found in realDir.")
                         tempDir.deleteRecursively()
                         finalBundleDir.deleteRecursively()
-                        return@withContext false
+                        throw HotUpdaterException.invalidBundle()
                     }
 
                     // 9) Update finalBundleDir's last modified time
                     finalBundleDir.setLastModified(System.currentTimeMillis())
 
-                    // 10) Save the new bundle path in Preferences
+                    // 10) Save the new bundle as STAGING with verification pending
                     val bundlePath = finalIndexFile.absolutePath
-                    Log.d("BundleStorage", "Setting bundle URL: $bundlePath")
+                    Log.d(TAG, "Setting bundle as staging: $bundlePath")
+
+                    // Update metadata: set new bundle as staging
+                    val currentMetadata = loadMetadataOrNull() ?: createInitialMetadata()
+                    val updatedMetadata =
+                        currentMetadata.copy(
+                            stagingBundleId = bundleId,
+                            verificationPending = true,
+                            verificationAttemptedAt = null,
+                            updatedAt = System.currentTimeMillis(),
+                        )
+                    saveMetadata(updatedMetadata)
+
+                    // Also update HotUpdaterBundleURL for backwards compatibility
+                    // This will point to the staging bundle that will be loaded
                     setBundleURL(bundlePath)
 
                     // 11) Clean up temporary and download folders
                     tempDir.deleteRecursively()
 
-                    // 12) Remove old bundles
-                    cleanupOldBundles(bundleStoreDir, currentBundleId, bundleId)
+                    // 12) Keep both stable and staging bundles
+                    val stableBundleId = currentMetadata.stableBundleId
+                    cleanupOldBundles(bundleStoreDir, stableBundleId, bundleId)
 
-                    Log.d("BundleStorage", "Downloaded and activated bundle successfully.")
+                    Log.d(TAG, "Downloaded and set bundle as staging successfully. Will be promoted after notifyAppReady.")
                     // Progress already at 1.0 from unzip completion
-                    return@withContext true
                 }
             }
         }
@@ -305,17 +649,17 @@ class BundleFileStorageService(
             bundles.forEach { bundle ->
                 try {
                     if (bundle.name !in bundleIdsToKeep) {
-                        Log.d("BundleStorage", "Removing old bundle: ${bundle.name}")
+                        Log.d(TAG, "Removing old bundle: ${bundle.name}")
                         if (bundle.deleteRecursively()) {
-                            Log.d("BundleStorage", "Successfully removed old bundle: ${bundle.name}")
+                            Log.d(TAG, "Successfully removed old bundle: ${bundle.name}")
                         } else {
-                            Log.w("BundleStorage", "Failed to remove old bundle: ${bundle.name}")
+                            Log.w(TAG, "Failed to remove old bundle: ${bundle.name}")
                         }
                     } else {
-                        Log.d("BundleStorage", "Keeping bundle: ${bundle.name}")
+                        Log.d(TAG, "Keeping bundle: ${bundle.name}")
                     }
                 } catch (e: Exception) {
-                    Log.e("BundleStorage", "Error removing bundle ${bundle.name}: ${e.message}")
+                    Log.e(TAG, "Error removing bundle ${bundle.name}: ${e.message}")
                 }
             }
 
@@ -325,18 +669,18 @@ class BundleFileStorageService(
                     file.isDirectory && file.name.endsWith(".tmp")
                 }?.forEach { staleTmp ->
                     try {
-                        Log.d("BundleStorage", "Removing stale tmp directory: ${staleTmp.name}")
+                        Log.d(TAG, "Removing stale tmp directory: ${staleTmp.name}")
                         if (staleTmp.deleteRecursively()) {
-                            Log.d("BundleStorage", "Successfully removed tmp directory: ${staleTmp.name}")
+                            Log.d(TAG, "Successfully removed tmp directory: ${staleTmp.name}")
                         } else {
-                            Log.w("BundleStorage", "Failed to remove tmp directory: ${staleTmp.name}")
+                            Log.w(TAG, "Failed to remove tmp directory: ${staleTmp.name}")
                         }
                     } catch (e: Exception) {
-                        Log.e("BundleStorage", "Error removing tmp directory ${staleTmp.name}: ${e.message}")
+                        Log.e(TAG, "Error removing tmp directory ${staleTmp.name}: ${e.message}")
                     }
                 }
         } catch (e: Exception) {
-            Log.e("BundleStorage", "Error during cleanup: ${e.message}")
+            Log.e(TAG, "Error during cleanup: ${e.message}")
         }
     }
 }