@hot-updater/react-native 0.36.4 → 0.36.6

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

@@ -547,34 +547,28 @@ class BundleFileStorageService(
         return regex.find(currentUrl)?.groupValues?.get(1)
     }
 
-    private fun resolveBundleFile(bundleDir: File): File? {
-        val manifest = readManifestFromBundleDir(bundleDir)
-        val manifestBundlePath =
-            (manifest?.get("assets") as? Map<*, *>)
-                ?.keys
-                ?.mapNotNull { key ->
-                    (key as? String)
-                        ?.trim()
-                        ?.takeIf { it.isNotEmpty() }
-                        ?.takeIf { File(it).name.endsWith(".android.bundle") }
-                }?.singleOrNull()
-
-        if (manifestBundlePath != null) {
-            try {
-                val canonicalBundleDir = bundleDir.canonicalFile
-                val canonicalBundleFile = File(bundleDir, manifestBundlePath).canonicalFile
-                val canonicalBundleDirPath = canonicalBundleDir.path
-                val canonicalBundleFilePath = canonicalBundleFile.path
-                val isWithinBundleDir =
-                    canonicalBundleFilePath == canonicalBundleDirPath ||
-                        canonicalBundleFilePath.startsWith("$canonicalBundleDirPath${File.separator}")
-
-                if (isWithinBundleDir && canonicalBundleFile.isFile) {
-                    return canonicalBundleFile
-                }
-            } catch (e: Exception) {
-                Log.w(TAG, "Failed to resolve manifest bundle file from ${bundleDir.absolutePath}: ${e.message}")
+    private fun resolveBundleFile(
+        bundleDir: File,
+        expectedBundleId: String? = null,
+    ): File? {
+        val manifestFile = File(bundleDir, "manifest.json")
+        if (manifestFile.exists()) {
+            val manifest = parseBundleManifestFromFile(manifestFile) ?: return null
+            if (expectedBundleId != null && manifest.bundleId != expectedBundleId) {
+                return null
             }
+
+            val resolvedAssets =
+                manifest.assets.keys.associateWith { assetPath ->
+                    RelativePathResolver
+                        .resolveInside(bundleDir, assetPath)
+                        ?.takeIf { it.isFile }
+                        ?: return null
+                }
+            return resolvedAssets
+                .filterKeys { assetPath -> File(assetPath).name.endsWith(".android.bundle") }
+                .values
+                .singleOrNull()
         }
 
         return File(bundleDir, "index.android.bundle").absoluteFile.takeIf { it.isFile }
@@ -582,7 +576,7 @@ class BundleFileStorageService(
 
     private fun findBundleFile(bundleId: String): File? {
         val bundleDir = File(getBundleStoreDir(), bundleId)
-        return resolveBundleFile(bundleDir)
+        return resolveBundleFile(bundleDir, bundleId)
     }
 
     private fun getBundleUrlForId(bundleId: String): String? = findBundleFile(bundleId)?.absolutePath
@@ -1090,15 +1084,21 @@ class BundleFileStorageService(
             return null
         }
 
-        val file = File(urlString)
-        val exists = file.exists()
-        Log.d(TAG, "getCachedBundleURL: file exists = $exists at path: $urlString")
-        if (!exists) {
+        val cachedBundleId = extractBundleIdFromCurrentURL()
+        val resolvedBundle = cachedBundleId?.let(::findBundleFile)
+        val isValid =
+            if (cachedBundleId == null) {
+                File(urlString).isFile
+            } else {
+                resolvedBundle != null
+            }
+        Log.d(TAG, "getCachedBundleURL: cached bundle valid = $isValid at path: $urlString")
+        if (!isValid) {
             preferences.setItem("HotUpdaterBundleURL", null)
-            Log.d(TAG, "getCachedBundleURL: file doesn't exist, cleared preference")
+            Log.d(TAG, "getCachedBundleURL: cached bundle is invalid, cleared preference")
             return null
         }
-        return urlString
+        return resolvedBundle?.absolutePath ?: urlString
     }
 
     override fun getFallbackBundleURL(): String = "assets://index.android.bundle"
@@ -1180,7 +1180,7 @@ class BundleFileStorageService(
         val finalBundleDir = File(bundleStoreDir, bundleId)
         if (finalBundleDir.exists()) {
             Log.d(TAG, "Bundle for bundleId $bundleId already exists. Using cached bundle.")
-            val existingBundleFile = resolveBundleFile(finalBundleDir)
+            val existingBundleFile = resolveBundleFile(finalBundleDir, bundleId)
             if (existingBundleFile != null) {
                 // Update last modified time
                 finalBundleDir.setLastModified(System.currentTimeMillis())
@@ -1364,7 +1364,7 @@ class BundleFileStorageService(
                     }
 
                     // 4) Resolve the extracted Android bundle file.
-                    val extractedBundleFile = resolveBundleFile(tmpDir)
+                    val extractedBundleFile = resolveBundleFile(tmpDir, bundleId)
                     if (extractedBundleFile == null) {
                         Log.d("BundleStorage", "Android bundle file could not be resolved in tmpDir.")
                         tempDir.deleteRecursively()
@@ -1403,7 +1403,7 @@ class BundleFileStorageService(
                     }
 
                     // 8) Verify the Android bundle file exists inside finalBundleDir.
-                    val finalBundleFile = resolveBundleFile(finalBundleDir)
+                    val finalBundleFile = resolveBundleFile(finalBundleDir, bundleId)
                     if (finalBundleFile == null) {
                         Log.d("BundleStorage", "Android bundle file could not be resolved in realDir.")
                         tempDir.deleteRecursively()

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

@@ -12,7 +12,8 @@ internal object RelativePathResolver {
             return null
         }
 
-        val components = path.split("/")
+        // Archive directory entries conventionally end with one slash.
+        val components = path.removeSuffix("/").split("/")
         if (components.any { it.isEmpty() || it == "." || it == ".." }) {
             return null
         }

package/android/src/test/java/com/hotupdater/BundleFileStorageServiceTest.kt

@@ -48,29 +48,29 @@ class BundleFileStorageServiceTest {
     }
 
     @Test
-    fun `resolveBundleFile falls back to root index when manifest has no android bundle candidate`() {
+    fun `resolveBundleFile rejects a manifest with missing assets even when root index exists`() {
         val rootDir = temporaryFolder.newFolder("no-android-candidate")
         val service = createService(rootDir)
         val bundleDir = createBundleDir(rootDir, "bundle-no-candidate")
-        val fallbackBundleFile = writeFile(bundleDir, "index.android.bundle")
+        writeFile(bundleDir, "index.android.bundle")
 
         writeManifest(bundleDir, listOf("index.ios.bundle", "assets/image.png"))
 
-        assertResolvedBundlePath(service, bundleDir, fallbackBundleFile)
+        assertNull(invokeResolveBundleFile(service, bundleDir))
     }
 
     @Test
-    fun `resolveBundleFile falls back to root index when manifest has multiple android bundle candidates`() {
+    fun `resolveBundleFile rejects a manifest with multiple android bundle candidates`() {
         val rootDir = temporaryFolder.newFolder("multiple-android-candidates")
         val service = createService(rootDir)
         val bundleDir = createBundleDir(rootDir, "bundle-multiple-candidates")
-        val fallbackBundleFile = writeFile(bundleDir, "index.android.bundle")
+        writeFile(bundleDir, "index.android.bundle")
 
         writeFile(bundleDir, "foo.android.bundle")
         writeFile(bundleDir, "dist/bar.android.bundle")
         writeManifest(bundleDir, listOf("foo.android.bundle", "dist/bar.android.bundle"))
 
-        assertResolvedBundlePath(service, bundleDir, fallbackBundleFile)
+        assertNull(invokeResolveBundleFile(service, bundleDir))
     }
 
     @Test
@@ -122,7 +122,14 @@ class BundleFileStorageServiceTest {
         val service = createService(rootDir, preferences)
 
         val stagingDir = createBundleDir(rootDir, "staging-bundle")
-        writeManifest(stagingDir, listOf("dist/missing.android.bundle"))
+        writeFile(stagingDir, "dist/staging.android.bundle")
+        writeManifest(
+            stagingDir,
+            listOf(
+                "dist/staging.android.bundle",
+                "assets/missing.png",
+            ),
+        )
 
         val stableDir = createBundleDir(rootDir, "stable-bundle")
         val stableBundleFile = writeFile(stableDir, "dist/stable.android.bundle")
@@ -141,7 +148,7 @@ class BundleFileStorageServiceTest {
         val selection = service.prepareLaunch(null)
         val report = service.notifyAppReady()
 
-        assertEquals(stableBundleFile.canonicalFile.absolutePath, selection.bundleUrl)
+        assertEquals(stableBundleFile.absolutePath, selection.bundleUrl)
         assertEquals(stableDir.name, selection.launchedBundleId)
         assertFalse(selection.shouldRollbackOnCrash)
         assertFalse(stagingDir.exists())
@@ -153,7 +160,7 @@ class BundleFileStorageServiceTest {
         assertEquals(stableDir.name, metadata?.stagingBundleId)
         assertNull(metadata?.stableBundleId)
         assertFalse(metadata?.verificationPending ?: true)
-        assertEquals(stableBundleFile.canonicalFile.absolutePath, preferences.getItem("HotUpdaterBundleURL"))
+        assertEquals(stableBundleFile.absolutePath, preferences.getItem("HotUpdaterBundleURL"))
     }
 
     @Test
@@ -416,9 +423,10 @@ class BundleFileStorageServiceTest {
             BundleFileStorageService::class.java.getDeclaredMethod(
                 "resolveBundleFile",
                 File::class.java,
+                String::class.java,
             )
         method.isAccessible = true
-        return method.invoke(service, bundleDir) as File?
+        return method.invoke(service, bundleDir, bundleDir.name) as File?
     }
 
     private fun invokeCanUseManifestDrivenInstall(service: BundleFileStorageService): Boolean {

package/android/src/test/java/com/hotupdater/RelativePathResolverTest.kt

@@ -0,0 +1,41 @@
+package com.hotupdater
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+class RelativePathResolverTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
+    @Test
+    fun `resolves a standard archive directory entry ending in a slash`() {
+        val root = temporaryFolder.root
+
+        val resolved = RelativePathResolver.resolveInside(root, "drawable-mdpi/")
+
+        assertEquals(
+            File(root, "drawable-mdpi").canonicalFile,
+            resolved?.canonicalFile,
+        )
+    }
+
+    @Test
+    fun `rejects unsafe archive directory paths ending in a slash`() {
+        val root = temporaryFolder.root
+        val unsafePaths =
+            listOf(
+                "/",
+                "../",
+                "drawable-mdpi/../",
+                "drawable-mdpi//",
+            )
+
+        unsafePaths.forEach { path ->
+            assertNull(path, RelativePathResolver.resolveInside(root, path))
+        }
+    }
+}

package/ios/HotUpdater/Internal/BundleFileStorageService.swift

@@ -791,7 +791,7 @@ class BundleFileStorageService: BundleStorageService {
     }
 
     private func createInitialMetadata() -> BundleMetadata {
-        let currentBundleId = getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent
+        let currentBundleId = getCachedBundleId()
         return BundleMetadata(
             isolationKey: isolationKey,
             stableBundleId: nil,
@@ -808,7 +808,7 @@ class BundleFileStorageService: BundleStorageService {
     }
 
     private func getActiveBundleId() -> String? {
-        if let cachedBundleId = getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent {
+        if let cachedBundleId = getCachedBundleId() {
             return cachedBundleId
         }
 
@@ -870,12 +870,11 @@ class BundleFileStorageService: BundleStorageService {
     }
 
     func canUseManifestDrivenInstall() -> Bool {
-        guard let currentBundleURL = getCachedBundleURL(),
+        guard let currentBundleId = getCachedBundleId(),
               case .success(let storeDir) = bundleStoreDir() else {
             return false
         }
 
-        let currentBundleId = currentBundleURL.deletingLastPathComponent().lastPathComponent
         let currentBundleDir = (storeDir as NSString).appendingPathComponent(currentBundleId)
         guard fileSystem.fileExists(atPath: currentBundleDir),
               let snapshot = getActiveBundleMetadataSnapshot(),
@@ -1141,7 +1140,10 @@ class BundleFileStorageService: BundleStorageService {
         let fallbackBundleId = metadata.stableBundleId.flatMap { candidate in
             if case .success(let storeDir) = bundleStoreDir() {
                 let stableBundleDir = (storeDir as NSString).appendingPathComponent(candidate)
-                if case .success(let bundlePath) = findBundleFile(in: stableBundleDir), bundlePath != nil {
+                if case .success(let bundlePath) = findBundleFile(
+                    in: stableBundleDir,
+                    expectedBundleId: candidate
+                ), bundlePath != nil {
                     return candidate
                 }
             }
@@ -1163,7 +1165,10 @@ class BundleFileStorageService: BundleStorageService {
         if let fallbackBundleId,
            case .success(let storeDir) = bundleStoreDir() {
             let fallbackBundleDir = (storeDir as NSString).appendingPathComponent(fallbackBundleId)
-            if case .success(let bundlePath) = findBundleFile(in: fallbackBundleDir), let bundlePath {
+            if case .success(let bundlePath) = findBundleFile(
+                in: fallbackBundleDir,
+                expectedBundleId: fallbackBundleId
+            ), let bundlePath {
                 let _ = setBundleURL(localPath: bundlePath)
             }
         } else {
@@ -1278,9 +1283,45 @@ class BundleFileStorageService: BundleStorageService {
      * @param directoryPath Directory to search in
      * @return Result with path to bundle file or error
      */
-    func findBundleFile(in directoryPath: String) -> Result<String?, Error> {
+    func findBundleFile(
+        in directoryPath: String,
+        expectedBundleId: String? = nil
+    ) -> Result<String?, Error> {
         NSLog("[BundleStorage] Searching for bundle file in directory: \(directoryPath)")
 
+        let manifestPath = (directoryPath as NSString).appendingPathComponent("manifest.json")
+        if fileSystem.fileExists(atPath: manifestPath) {
+            guard let manifest = readManifest(in: directoryPath),
+                  let parsedManifest = parseBundleManifest(from: manifest),
+                  expectedBundleId == nil || parsedManifest.bundleId == expectedBundleId else {
+                return .success(nil)
+            }
+
+            do {
+                var bundlePaths: [String] = []
+                for assetPath in parsedManifest.assets.keys {
+                    let assetURL = try ArchiveExtractionUtilities.extractionURL(
+                        for: assetPath,
+                        destinationRoot: directoryPath
+                    )
+                    guard fileSystem.fileExists(atPath: assetURL.path),
+                          let attributes = try? fileSystem.attributesOfItem(atPath: assetURL.path),
+                          attributes[.type] as? FileAttributeType == .typeRegular else {
+                        return .success(nil)
+                    }
+
+                    let fileName = assetURL.lastPathComponent
+                    if fileName.hasSuffix(".bundle") || fileName == "main.jsbundle" {
+                        bundlePaths.append(assetURL.path)
+                    }
+                }
+
+                return .success(bundlePaths.count == 1 ? bundlePaths[0] : nil)
+            } catch {
+                return .failure(error)
+            }
+        }
+
         let iosBundlePath = (directoryPath as NSString).appendingPathComponent("index.ios.bundle")
         if self.fileSystem.fileExists(atPath: iosBundlePath) {
             NSLog("[BundleStorage] Found iOS bundle atPath: \(iosBundlePath)")
@@ -1415,18 +1456,91 @@ class BundleFileStorageService: BundleStorageService {
             return .failure(error)
         }
     }
+
+    private func bundleId(for bundleURL: URL, storeDir: String) -> String? {
+        let storeURL = URL(fileURLWithPath: storeDir, isDirectory: true).standardizedFileURL
+        let bundleURL = bundleURL.standardizedFileURL
+        let storePrefix = storeURL.path + "/"
+
+        guard bundleURL.path.hasPrefix(storePrefix) else {
+            return nil
+        }
+
+        return bundleURL.path
+            .dropFirst(storePrefix.count)
+            .split(separator: "/")
+            .first
+            .map(String.init)
+    }
+
+    private func getCachedBundleId() -> String? {
+        guard let bundleURL = getCachedBundleURL(),
+              case .success(let storeDir) = bundleStoreDir() else {
+            return nil
+        }
+
+        return bundleId(for: bundleURL, storeDir: storeDir)
+    }
+
+    func resolveBundlePathAfterMove(
+        _ bundlePath: String,
+        from sourceDirectory: String,
+        to destinationDirectory: String
+    ) throws -> String {
+        let sourceURL = URL(
+            fileURLWithPath: sourceDirectory,
+            isDirectory: true
+        ).standardizedFileURL
+        let bundleURL = URL(fileURLWithPath: bundlePath).standardizedFileURL
+        let sourcePrefix = sourceURL.path + "/"
+
+        guard bundleURL.path.hasPrefix(sourcePrefix) else {
+            throw BundleStorageError.invalidBundle
+        }
+
+        let relativePath = String(bundleURL.path.dropFirst(sourcePrefix.count))
+        guard ArchiveExtractionUtilities.normalizedRelativePath(from: relativePath) == relativePath else {
+            throw BundleStorageError.invalidBundle
+        }
+
+        return try ArchiveExtractionUtilities.extractionURL(
+            for: relativePath,
+            destinationRoot: destinationDirectory
+        ).path
+    }
     
     /**
      * Gets the URL to the cached bundle file if it exists.
      */
     func getCachedBundleURL() -> URL? {
         do {
-            guard let savedURLString = try self.preferences.getItem(forKey: "HotUpdaterBundleURL"),
-                  let bundleURL = URL(string: savedURLString),
-                  self.fileSystem.fileExists(atPath: bundleURL.path) else {
+            guard let savedURLString = try self.preferences.getItem(forKey: "HotUpdaterBundleURL") else {
                 return nil
             }
-            return bundleURL
+
+            let savedURL = URL(string: savedURLString)
+            let bundleURL = (
+                (savedURL?.isFileURL == true ? savedURL : nil)
+                    ?? URL(fileURLWithPath: savedURLString)
+            ).standardizedFileURL
+            guard self.fileSystem.fileExists(atPath: bundleURL.path),
+                  case .success(let storeDir) = bundleStoreDir() else {
+                return nil
+            }
+
+            let storeURL = URL(fileURLWithPath: storeDir, isDirectory: true).standardizedFileURL
+            guard let bundleId = bundleId(for: bundleURL, storeDir: storeDir) else {
+                return nil
+            }
+
+            let bundleDirectory = storeURL.appendingPathComponent(bundleId).path
+            guard case .success(let resolvedBundlePath) = findBundleFile(
+                in: bundleDirectory,
+                expectedBundleId: bundleId
+            ), let resolvedBundlePath else {
+                return nil
+            }
+            return URL(fileURLWithPath: resolvedBundlePath)
         } catch {
             NSLog("[BundleStorage] Error getting cached bundle URL: \(error.localizedDescription)")
             return nil
@@ -1446,7 +1560,7 @@ class BundleFileStorageService: BundleStorageService {
         guard let metadata = loadMetadataOrNull() else {
             return LaunchSelection(
                 bundleURL: getCachedBundleURL() ?? getFallbackBundleURL(bundle: bundle),
-                launchedBundleId: getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent,
+                launchedBundleId: getCachedBundleId(),
                 shouldRollbackOnCrash: false
             )
         }
@@ -1454,7 +1568,10 @@ class BundleFileStorageService: BundleStorageService {
         if let stagingId = metadata.stagingBundleId,
            case .success(let storeDir) = bundleStoreDir() {
             let stagingBundleDir = (storeDir as NSString).appendingPathComponent(stagingId)
-            if case .success(let bundlePath) = findBundleFile(in: stagingBundleDir), let bundlePath {
+            if case .success(let bundlePath) = findBundleFile(
+                in: stagingBundleDir,
+                expectedBundleId: stagingId
+            ), let bundlePath {
                 return LaunchSelection(
                     bundleURL: URL(fileURLWithPath: bundlePath),
                     launchedBundleId: stagingId,
@@ -1470,7 +1587,10 @@ class BundleFileStorageService: BundleStorageService {
         if let stableId = metadata.stableBundleId,
            case .success(let storeDir) = bundleStoreDir() {
             let stableBundleDir = (storeDir as NSString).appendingPathComponent(stableId)
-            if case .success(let bundlePath) = findBundleFile(in: stableBundleDir), let bundlePath {
+            if case .success(let bundlePath) = findBundleFile(
+                in: stableBundleDir,
+                expectedBundleId: stableId
+            ), let bundlePath {
                 return LaunchSelection(
                     bundleURL: URL(fileURLWithPath: bundlePath),
                     launchedBundleId: stableId,
@@ -1512,7 +1632,7 @@ class BundleFileStorageService: BundleStorageService {
         }
 
         // Get the current bundle ID from the cached bundle URL (exclude fallback bundles)
-        let currentBundleId = self.getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent
+        let currentBundleId = self.getCachedBundleId()
 
         guard let validFileUrl = fileUrl else {
             NSLog("[BundleStorage] fileUrl is nil, resetting bundle URL.")
@@ -1552,7 +1672,10 @@ class BundleFileStorageService: BundleStorageService {
             let finalBundleDir = (storeDir as NSString).appendingPathComponent(bundleId)
             
             if self.fileSystem.fileExists(atPath: finalBundleDir) {
-                let findResult = self.findBundleFile(in: finalBundleDir)
+                let findResult = self.findBundleFile(
+                    in: finalBundleDir,
+                    expectedBundleId: bundleId
+                )
                 switch findResult {
                 case .success(let existingBundlePath):
                     if let bundlePath = existingBundlePath {
@@ -1670,7 +1793,7 @@ class BundleFileStorageService: BundleStorageService {
             return
         }
 
-        let currentBundleId = self.getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent
+        let currentBundleId = self.getCachedBundleId()
         let currentBundleDir = currentBundleId.map {
             (storeDir as NSString).appendingPathComponent($0)
         }
@@ -1969,7 +2092,7 @@ class BundleFileStorageService: BundleStorageService {
             let manifestDestination = (tmpDir as NSString).appendingPathComponent("manifest.json")
             try writeManifestFile(targetManifest, to: manifestDestination)
 
-            switch self.findBundleFile(in: tmpDir) {
+            switch self.findBundleFile(in: tmpDir, expectedBundleId: bundleId) {
             case .success(let maybeBundlePath):
                 guard let bundlePathInTmp = maybeBundlePath else {
                     throw BundleStorageError.invalidBundle
@@ -1985,8 +2108,10 @@ class BundleFileStorageService: BundleStorageService {
                     throw BundleStorageError.moveOperationFailed(error)
                 }
 
-                let finalBundlePath = (realDir as NSString).appendingPathComponent(
-                    (bundlePathInTmp as NSString).lastPathComponent
+                let finalBundlePath = try resolveBundlePathAfterMove(
+                    bundlePathInTmp,
+                    from: tmpDir,
+                    to: realDir
                 )
                 switch self.setBundleURL(localPath: finalBundlePath) {
                 case .success:
@@ -2199,7 +2324,7 @@ class BundleFileStorageService: BundleStorageService {
         progressHandler: @escaping (UpdateProgressPayload) -> Void,
         completion: @escaping (Result<Bool, Error>) -> Void
     ) {
-        let currentBundleId = self.getCachedBundleURL()?.deletingLastPathComponent().lastPathComponent
+        let currentBundleId = self.getCachedBundleId()
         NSLog("[BundleStorage] Processing downloaded file atPath: \(location.path)")
 
         // 1) Ensure the bundle file exists
@@ -2289,7 +2414,7 @@ class BundleFileStorageService: BundleStorageService {
                 progressHandler: progressHandler,
                 progress: UpdateProgress.bundleValidation
             )
-            switch self.findBundleFile(in: tmpDir) {
+            switch self.findBundleFile(in: tmpDir, expectedBundleId: bundleId) {
             case .success(let maybeBundlePath):
                 if let bundlePathInTmp = maybeBundlePath {
                     NSLog("[BundleStorage] Found valid bundle in tmpDir: \(bundlePathInTmp)")
@@ -2315,7 +2440,11 @@ class BundleFileStorageService: BundleStorageService {
                     }
 
                     // 11) Construct final bundlePath for preferences
-                    let finalBundlePath = (realDir as NSString).appendingPathComponent((bundlePathInTmp as NSString).lastPathComponent)
+                    let finalBundlePath = try resolveBundlePathAfterMove(
+                        bundlePathInTmp,
+                        from: tmpDir,
+                        to: realDir
+                    )
 
                     // 12) Set the bundle URL in preferences (for backwards compatibility)
                     let setResult = self.setBundleURL(localPath: finalBundlePath)

package/lib/commonjs/sdkVersion.js

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.HOT_UPDATER_SDK_VERSION = void 0;
-const HOT_UPDATER_SDK_VERSION = exports.HOT_UPDATER_SDK_VERSION = "0.36.4";
+const HOT_UPDATER_SDK_VERSION = exports.HOT_UPDATER_SDK_VERSION = "0.36.6";
 //# sourceMappingURL=sdkVersion.js.map

package/lib/module/sdkVersion.js

@@ -1,4 +1,4 @@
 "use strict";
 
-export const HOT_UPDATER_SDK_VERSION = "0.36.4";
+export const HOT_UPDATER_SDK_VERSION = "0.36.6";
 //# sourceMappingURL=sdkVersion.js.map

package/lib/typescript/commonjs/sdkVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const HOT_UPDATER_SDK_VERSION = "0.36.4";
+export declare const HOT_UPDATER_SDK_VERSION = "0.36.6";
 //# sourceMappingURL=sdkVersion.d.ts.map

package/lib/typescript/module/sdkVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const HOT_UPDATER_SDK_VERSION = "0.36.4";
+export declare const HOT_UPDATER_SDK_VERSION = "0.36.6";
 //# sourceMappingURL=sdkVersion.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/react-native",
-  "version": "0.36.4",
+  "version": "0.36.6",
   "description": "React Native OTA solution for self-hosted",
   "source": "./src/index.ts",
   "main": "./lib/commonjs/index.js",
@@ -131,14 +131,14 @@
     "react-native-builder-bob": "0.41.0",
     "@typescript/native": "npm:typescript@^7.0.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "hot-updater": "0.36.4"
+    "hot-updater": "0.36.6"
   },
   "dependencies": {
     "use-sync-external-store": "1.5.0",
-    "@hot-updater/cli-tools": "0.36.4",
-    "@hot-updater/core": "0.36.4",
-    "@hot-updater/js": "0.36.4",
-    "@hot-updater/plugin-core": "0.36.4"
+    "@hot-updater/cli-tools": "0.36.6",
+    "@hot-updater/core": "0.36.6",
+    "@hot-updater/js": "0.36.6",
+    "@hot-updater/plugin-core": "0.36.6"
   },
   "scripts": {
     "build": "node ./scripts/sync-sdk-version.mjs run -- bob build && tsc -p plugin/tsconfig.build.json",

package/src/sdkVersion.ts

@@ -1 +1 @@
-export const HOT_UPDATER_SDK_VERSION = "0.36.4";
+export const HOT_UPDATER_SDK_VERSION = "0.36.6";