@hot-updater/react-native 0.25.0 → 0.25.2

package/LICENSE

@@ -19,3 +19,15 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+---
+
+ADDITIONAL DISCLAIMER
+
+The authors of this software shall not be held responsible for any legal issues,
+regulatory violations, policy violations, or disputes arising from the use,
+distribution, or integration of this software.
+
+Users are solely responsible for ensuring compliance with all applicable laws,
+regulations, and third-party policies (including but not limited to app store
+policies).

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

@@ -93,6 +93,14 @@ class BundleFileStorageService(
         private const val TAG = "BundleStorage"
     }
 
+    init {
+        // Ensure bundle store directory exists
+        getBundleStoreDir().mkdirs()
+
+        // Clean up old bundles if isolationKey format changed
+        checkAndCleanupIfIsolationKeyChanged()
+    }
+
     // Session-only rollback tracking (in-memory)
     private var sessionRollbackBundleId: String? = null
 
@@ -134,6 +142,67 @@ class BundleFileStorageService(
         return regex.find(currentUrl)?.groupValues?.get(1)
     }
 
+    /**
+     * Checks if isolationKey has changed and cleans up old bundles if needed.
+     * This handles migration when isolationKey format changes.
+     */
+    private fun checkAndCleanupIfIsolationKeyChanged() {
+        val metadataFile = getMetadataFile()
+
+        if (!metadataFile.exists()) {
+            // First launch - no cleanup needed
+            return
+        }
+
+        try {
+            // Read metadata without validation to get stored isolationKey
+            val jsonString = metadataFile.readText()
+            val json = org.json.JSONObject(jsonString)
+            val storedIsolationKey = json.optString("isolationKey", null)
+
+            if (storedIsolationKey != null && storedIsolationKey != isolationKey) {
+                // isolationKey changed - migration needed
+                Log.d(TAG, "isolationKey changed: $storedIsolationKey -> $isolationKey")
+                Log.d(TAG, "Cleaning up old bundles for migration")
+                cleanupAllBundlesForMigration()
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error checking isolationKey: ${e.message}")
+        }
+    }
+
+    /**
+     * Removes all bundle directories during migration.
+     * Called when isolationKey format changes.
+     */
+    private fun cleanupAllBundlesForMigration() {
+        val bundleStoreDir = getBundleStoreDir()
+
+        if (!bundleStoreDir.exists()) {
+            return
+        }
+
+        try {
+            var cleanedCount = 0
+            bundleStoreDir.listFiles()?.forEach { file ->
+                if (file.isDirectory) {
+                    try {
+                        if (file.deleteRecursively()) {
+                            cleanedCount++
+                            Log.d(TAG, "Migration: removed old bundle ${file.name}")
+                        }
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Error removing bundle ${file.name}: ${e.message}")
+                    }
+                }
+            }
+
+            Log.d(TAG, "Migration cleanup complete: removed $cleanedCount bundles")
+        } catch (e: Exception) {
+            Log.e(TAG, "Error during migration cleanup: ${e.message}")
+        }
+    }
+
     // MARK: - State Machine
 
     private fun isVerificationPending(metadata: BundleMetadata): Boolean = metadata.verificationPending && metadata.stagingBundleId != null
@@ -493,34 +562,48 @@ class BundleFileStorageService(
                 }
             val tempBundleFile = File(tempDir, bundleFileName)
 
-            // Check file size before downloading
-            val fileSize = downloadService.getFileSize(downloadUrl)
-            if (fileSize > 0 && baseDir != null) {
-                // Check available disk space
-                val stat = StatFs(baseDir.absolutePath)
-                val availableBytes = stat.availableBlocksLong * stat.blockSizeLong
-                val requiredSpace = fileSize * 2 // ZIP + extracted files
-
-                Log.d("BundleStorage", "File size: $fileSize bytes, Available: $availableBytes bytes, Required: $requiredSpace bytes")
-
-                if (availableBytes < requiredSpace) {
-                    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")
-            }
-
             // Download the file (0% - 80%)
+            // Disk space check will be performed in fileSizeCallback
+            var diskSpaceError: HotUpdaterException? = null
+
             val downloadResult =
                 downloadService.downloadFile(
                     downloadUrl,
                     tempBundleFile,
+                    fileSizeCallback = { fileSize ->
+                        // Perform disk space check when file size is known
+                        if (baseDir != null) {
+                            val stat = StatFs(baseDir.absolutePath)
+                            val availableBytes = stat.availableBlocksLong * stat.blockSizeLong
+                            val requiredSpace = fileSize * 2 // ZIP + extracted files
+
+                            Log.d(
+                                "BundleStorage",
+                                "File size: $fileSize bytes, Available: $availableBytes bytes, Required: $requiredSpace bytes",
+                            )
+
+                            if (availableBytes < requiredSpace) {
+                                Log.d(
+                                    TAG,
+                                    "Insufficient disk space detected: need $requiredSpace bytes, available $availableBytes bytes",
+                                )
+                                // Store error to be thrown after download completes/cancels
+                                diskSpaceError = HotUpdaterException.insufficientDiskSpace(requiredSpace, availableBytes)
+                            }
+                        }
+                    },
                 ) { downloadProgress ->
                     // Map download progress to 0.0 - 0.8
                     progressCallback(downloadProgress * 0.8)
                 }
 
+            // Check for disk space error first before processing download result
+            diskSpaceError?.let {
+                Log.d(TAG, "Throwing disk space error")
+                tempDir.deleteRecursively()
+                throw it
+            }
+
             when (downloadResult) {
                 is DownloadResult.Error -> {
                     Log.d("BundleStorage", "Download failed: ${downloadResult.exception.message}")

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

@@ -112,8 +112,13 @@ class HotUpdaterImpl {
             val appVersion = getAppVersion(context) ?: "unknown"
             val appChannel = getChannel(context)
 
-            // Use fingerprint if available, otherwise use app version
-            val baseKey = if (!fingerprintHash.isNullOrEmpty()) fingerprintHash else appVersion
+            // Include both fingerprint hash and app version for complete isolation
+            val baseKey =
+                if (!fingerprintHash.isNullOrEmpty()) {
+                    "${fingerprintHash}_$appVersion"
+                } else {
+                    appVersion
+                }
 
             return "HotUpdaterPrefs_${baseKey}_$appChannel"
         }

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

@@ -45,23 +45,18 @@ sealed class DownloadResult {
  * Interface for download operations
  */
 interface DownloadService {
-    /**
-     * Gets the file size from the URL without downloading
-     * @param fileUrl The URL to check
-     * @return File size in bytes, or -1 if unavailable
-     */
-    suspend fun getFileSize(fileUrl: URL): Long
-
     /**
      * Downloads a file from a URL
      * @param fileUrl The URL to download from
      * @param destination The local file to save to
+     * @param fileSizeCallback Optional callback called when file size is known
      * @param progressCallback Callback for download progress updates
      * @return Result indicating success or failure
      */
     suspend fun downloadFile(
         fileUrl: URL,
         destination: File,
+        fileSizeCallback: ((Long) -> Unit)? = null,
         progressCallback: (Double) -> Unit,
     ): DownloadResult
 }
@@ -128,34 +123,10 @@ class OkHttpDownloadService : DownloadService {
             .writeTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
             .build()
 
-    override suspend fun getFileSize(fileUrl: URL): Long =
-        withContext(Dispatchers.IO) {
-            try {
-                val request =
-                    Request
-                        .Builder()
-                        .url(fileUrl)
-                        .head()
-                        .build()
-                client.newCall(request).execute().use { response ->
-                    if (response.isSuccessful) {
-                        val contentLength = response.header("Content-Length")?.toLongOrNull() ?: -1L
-                        Log.d(TAG, "File size from HEAD request: $contentLength bytes")
-                        contentLength
-                    } else {
-                        Log.d(TAG, "HEAD request failed: ${response.code}")
-                        -1L
-                    }
-                }
-            } catch (e: Exception) {
-                Log.d(TAG, "Failed to get file size: ${e.message}")
-                -1L
-            }
-        }
-
     override suspend fun downloadFile(
         fileUrl: URL,
         destination: File,
+        fileSizeCallback: ((Long) -> Unit)?,
         progressCallback: (Double) -> Unit,
     ): DownloadResult =
         withContext(Dispatchers.IO) {
@@ -167,6 +138,7 @@ class OkHttpDownloadService : DownloadService {
                     return@withContext attemptDownload(
                         fileUrl,
                         destination,
+                        fileSizeCallback,
                         progressCallback,
                     )
                 } catch (e: Exception) {
@@ -193,6 +165,7 @@ class OkHttpDownloadService : DownloadService {
     private suspend fun attemptDownload(
         fileUrl: URL,
         destination: File,
+        fileSizeCallback: ((Long) -> Unit)?,
         progressCallback: (Double) -> Unit,
     ): DownloadResult =
         withContext(Dispatchers.IO) {
@@ -231,14 +204,14 @@ class OkHttpDownloadService : DownloadService {
             // Get total file size
             val totalSize = body.contentLength()
 
-            if (totalSize <= 0) {
-                Log.d(TAG, "Invalid content length: $totalSize")
-                response.close()
-                return@withContext DownloadResult.Error(Exception("Invalid content length: $totalSize"))
+            if (totalSize > 0) {
+                // Notify file size to caller for disk space check
+                fileSizeCallback?.invoke(totalSize)
+                Log.d(TAG, "Starting download: $totalSize bytes")
+            } else {
+                Log.d(TAG, "Content-Length not available ($totalSize), proceeding without disk space check")
             }
 
-            Log.d(TAG, "Starting download: $totalSize bytes")
-
             try {
                 // Wrap response body with progress tracking
                 val progressBody =

package/ios/HotUpdater/Internal/BundleFileStorageService.swift

@@ -153,6 +153,12 @@ class BundleFileStorageService: BundleStorageService {
         self.fileOperationQueue = DispatchQueue(label: "com.hotupdater.fileoperations",
                                                qos: .utility,
                                                attributes: .concurrent)
+
+        // Ensure bundle store directory exists
+        _ = bundleStoreDir()
+
+        // Clean up old bundles if isolationKey format changed
+        checkAndCleanupIfIsolationKeyChanged()
     }
 
     // MARK: - Metadata File Paths
@@ -189,6 +195,73 @@ class BundleFileStorageService: BundleStorageService {
         return updatedMetadata.save(to: file)
     }
 
+    /**
+     * Checks if isolationKey has changed and cleans up old bundles if needed.
+     * This handles migration when isolationKey format changes.
+     */
+    private func checkAndCleanupIfIsolationKeyChanged() {
+        guard let metadataURL = metadataFileURL() else {
+            return
+        }
+
+        let metadataPath = metadataURL.path
+
+        guard fileSystem.fileExists(atPath: metadataPath) else {
+            // First launch - no cleanup needed
+            return
+        }
+
+        do {
+            let jsonString = try String(contentsOf: metadataURL, encoding: .utf8)
+            if let jsonData = jsonString.data(using: .utf8),
+               let json = try JSONSerialization.jsonObject(with: jsonData) as? [String: Any],
+               let storedKey = json["isolationKey"] as? String {
+
+                if storedKey != isolationKey {
+                    NSLog("[BundleStorage] isolationKey changed: \(storedKey) -> \(isolationKey)")
+                    NSLog("[BundleStorage] Cleaning up old bundles for migration")
+                    cleanupAllBundlesForMigration()
+                }
+            }
+        } catch {
+            NSLog("[BundleStorage] Error checking isolationKey: \(error.localizedDescription)")
+        }
+    }
+
+    /**
+     * Removes all bundle directories during migration.
+     * Called when isolationKey format changes.
+     */
+    private func cleanupAllBundlesForMigration() {
+        guard case .success(let storeDir) = bundleStoreDir() else {
+            return
+        }
+
+        do {
+            let contents = try fileSystem.contentsOfDirectory(atPath: storeDir)
+            var cleanedCount = 0
+
+            for item in contents {
+                let fullPath = (storeDir as NSString).appendingPathComponent(item)
+
+                // Skip metadata files
+                if item == "metadata.json" || item == "crashed-history.json" {
+                    continue
+                }
+
+                if fileSystem.fileExists(atPath: fullPath) {
+                    try fileSystem.removeItem(atPath: fullPath)
+                    cleanedCount += 1
+                    NSLog("[BundleStorage] Migration: removed old bundle \(item)")
+                }
+            }
+
+            NSLog("[BundleStorage] Migration cleanup complete: removed \(cleanedCount) bundles")
+        } catch {
+            NSLog("[BundleStorage] Error during migration cleanup: \(error.localizedDescription)")
+        }
+    }
+
     // MARK: - Crashed History Operations
 
     private func loadCrashedHistory() -> CrashedHistory {
@@ -728,47 +801,43 @@ class BundleFileStorageService: BundleStorageService {
         let bundleFileName = fileUrl.lastPathComponent.isEmpty ? "bundle.zip" : fileUrl.lastPathComponent
         let tempBundleFile = (tempDirectory as NSString).appendingPathComponent(bundleFileName)
 
-        NSLog("[BundleStorage] Checking file size and disk space...")
+        NSLog("[BundleStorage] Starting download from \(fileUrl)")
+
+        // Download with integrated disk space check
+        var diskSpaceError: BundleStorageError? = nil
+
+        _ = self.downloadService.downloadFile(
+            from: fileUrl,
+            to: tempBundleFile,
+            fileSizeHandler: { [weak self] fileSize in
+                // This will be called when Content-Length is received
+                guard let self = self else { return }
 
-        // 5) Check file size and disk space before download
-        self.downloadService.getFileSize(from: fileUrl) { [weak self] sizeResult in
-            guard let self = self else { return }
+                NSLog("[BundleStorage] File size received: \(fileSize) bytes")
 
-            if case .success(let fileSize) = sizeResult {
                 // Check available disk space
                 do {
                     let attributes = try FileManager.default.attributesOfFileSystem(forPath: NSHomeDirectory())
                     if let freeSize = attributes[.systemFreeSize] as? Int64 {
                         let requiredSpace = fileSize * 2  // ZIP + extracted files
 
-                        NSLog("[BundleStorage] File size: \(fileSize) bytes, Available: \(freeSize) bytes, Required: \(requiredSpace) bytes")
+                        NSLog("[BundleStorage] Available: \(freeSize) bytes, Required: \(requiredSpace) bytes")
 
                         if freeSize < requiredSpace {
-                            NSLog("[BundleStorage] Insufficient disk space")
-                            self.cleanupTemporaryFiles([tempDirectory])
-                            completion(.failure(BundleStorageError.insufficientDiskSpace))
-                            return
+                            NSLog("[BundleStorage] Insufficient disk space detected: need \(requiredSpace) bytes, available \(freeSize) bytes")
+                            // Store error to be returned in completion handler
+                            diskSpaceError = .insufficientDiskSpace
                         }
                     }
                 } catch {
                     NSLog("[BundleStorage] Failed to check disk space: \(error.localizedDescription)")
-                    // Continue with download despite disk check failure
                 }
-            } else {
-                NSLog("[BundleStorage] Unable to determine file size, proceeding with download")
-            }
-
-            NSLog("[BundleStorage] Starting download from \(fileUrl)")
-
-            // 6) DownloadService handles its own threading for the download task.
-            // The completion handler for downloadService.downloadFile is then dispatched to fileOperationQueue.
-            let task = self.downloadService.downloadFile(from: fileUrl,
-                                                         to: tempBundleFile,
-                                                         progressHandler: { downloadProgress in
-                                                             // Map download progress to 0.0 - 0.8
-                                                             progressHandler(downloadProgress * 0.8)
-                                                         },
-                                                         completion: { [weak self] result in
+            },
+            progressHandler: { downloadProgress in
+                // Map download progress to 0.0 - 0.8
+                progressHandler(downloadProgress * 0.8)
+            },
+            completion: { [weak self] result in
             guard let self = self else {
                 let error = NSError(domain: "HotUpdaterError", code: 998,
                                     userInfo: [NSLocalizedDescriptionKey: "Self deallocated during download"])
@@ -776,6 +845,14 @@ class BundleFileStorageService: BundleStorageService {
                 return
             }
 
+            // Check for disk space error first before processing download result
+            if let diskError = diskSpaceError {
+                NSLog("[BundleStorage] Throwing disk space error")
+                self.cleanupTemporaryFiles([tempDirectory])
+                completion(.failure(diskError))
+                return
+            }
+
             // Dispatch the processing of the downloaded file to the file operation queue
             let workItem = DispatchWorkItem {
                 switch result {
@@ -802,12 +879,8 @@ class BundleFileStorageService: BundleStorageService {
                 }
             }
             self.fileOperationQueue.async(execute: workItem)
-        })
-
-            if let task = task {
-                self.activeTasks.append(task) // Manage active tasks
-            }
         }
+        )
     }
     
     /**

package/ios/HotUpdater/Internal/HotUpdaterImpl.swift

@@ -73,8 +73,13 @@ import React
         let appVersion = self.appVersion ?? "unknown"
         let appChannel = self.appChannel
 
-        // Use fingerprint if available, otherwise use app version
-        let baseKey = (fingerprintHash != nil && !fingerprintHash!.isEmpty) ? fingerprintHash! : appVersion
+        // Include both fingerprint hash and app version for complete isolation
+        let baseKey: String
+        if let hash = fingerprintHash, !hash.isEmpty {
+            baseKey = "\(hash)_\(appVersion)"
+        } else {
+            baseKey = appVersion
+        }
 
         return "hotupdater_\(baseKey)_\(appChannel)_"
     }

package/ios/HotUpdater/Internal/URLSessionDownloadService.swift

@@ -4,22 +4,16 @@ import UIKit
 #endif
 
 protocol DownloadService {
-    /**
-     * Gets the file size from the URL without downloading.
-     * @param url The URL to check
-     * @param completion Callback with file size or error
-     */
-    func getFileSize(from url: URL, completion: @escaping (Result<Int64, Error>) -> Void)
-
     /**
      * Downloads a file from a URL.
      * @param url The URL to download from
      * @param destination The local path to save to
+     * @param fileSizeHandler Optional callback called when file size is known
      * @param progressHandler Callback for download progress updates
      * @param completion Callback with downloaded file URL or error
      * @return The download task (optional)
      */
-    func downloadFile(from url: URL, to destination: String, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask?
+    func downloadFile(from url: URL, to destination: String, fileSizeHandler: ((Int64) -> Void)?, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask?
 }
 
 
@@ -42,6 +36,7 @@ class URLSessionDownloadService: NSObject, DownloadService {
     private var progressHandlers: [URLSessionTask: (Double) -> Void] = [:]
     private var completionHandlers: [URLSessionTask: (Result<URL, Error>) -> Void] = [:]
     private var destinations: [URLSessionTask: String] = [:]
+    private var fileSizeHandlers: [URLSessionTask: (Int64) -> Void] = [:]
     private var taskStates: [Int: TaskState] = [:]
 
     override init() {
@@ -94,35 +89,7 @@ class URLSessionDownloadService: NSObject, DownloadService {
         }
     }
 
-    func getFileSize(from url: URL, completion: @escaping (Result<Int64, Error>) -> Void) {
-        var request = URLRequest(url: url)
-        request.httpMethod = "HEAD"
-
-        let task = session.dataTask(with: request) { _, response, error in
-            if let error = error {
-                NSLog("[DownloadService] HEAD request failed: \(error.localizedDescription)")
-                completion(.failure(error))
-                return
-            }
-
-            guard let httpResponse = response as? HTTPURLResponse else {
-                completion(.failure(DownloadError.invalidContentLength))
-                return
-            }
-
-            let contentLength = httpResponse.expectedContentLength
-            if contentLength > 0 {
-                NSLog("[DownloadService] File size from HEAD request: \(contentLength) bytes")
-                completion(.success(contentLength))
-            } else {
-                NSLog("[DownloadService] Invalid content length: \(contentLength)")
-                completion(.failure(DownloadError.invalidContentLength))
-            }
-        }
-        task.resume()
-    }
-
-    func downloadFile(from url: URL, to destination: String, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask? {
+    func downloadFile(from url: URL, to destination: String, fileSizeHandler: ((Int64) -> Void)?, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask? {
         // Determine if we should use background session
         #if !os(macOS)
         let appState = UIApplication.shared.applicationState
@@ -141,6 +108,9 @@ class URLSessionDownloadService: NSObject, DownloadService {
         progressHandlers[task] = progressHandler
         completionHandlers[task] = completion
         destinations[task] = destination
+        if let handler = fileSizeHandler {
+            fileSizeHandlers[task] = handler
+        }
 
         // Extract bundleId from destination path (e.g., "bundle-store/{bundleId}/bundle.zip")
         let bundleId = (destination as NSString).pathComponents
@@ -170,6 +140,7 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
             progressHandlers.removeValue(forKey: downloadTask)
             completionHandlers.removeValue(forKey: downloadTask)
             destinations.removeValue(forKey: downloadTask)
+            fileSizeHandlers.removeValue(forKey: downloadTask)
             removeTaskState(downloadTask.taskIdentifier)
 
             // 다운로드 완료 알림
@@ -223,6 +194,7 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
             progressHandlers.removeValue(forKey: task)
             completionHandlers.removeValue(forKey: task)
             destinations.removeValue(forKey: task)
+            fileSizeHandlers.removeValue(forKey: task)
             removeTaskState(task.taskIdentifier)
 
             NotificationCenter.default.post(name: .downloadDidFinish, object: task)
@@ -235,11 +207,23 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
     
     func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {
         let progressHandler = progressHandlers[downloadTask]
-        
+
+        // Call file size handler on first callback when size is known
+        if totalBytesWritten == bytesWritten && bytesWritten > 0 {
+            if let fileSizeHandler = fileSizeHandlers[downloadTask] {
+                if totalBytesExpectedToWrite > 0 {
+                    fileSizeHandler(totalBytesExpectedToWrite)
+                } else {
+                    NSLog("[DownloadService] Content-Length not available, proceeding without disk space check")
+                }
+                fileSizeHandlers.removeValue(forKey: downloadTask)
+            }
+        }
+
         if totalBytesExpectedToWrite > 0 {
             let progress = Double(totalBytesWritten) / Double(totalBytesExpectedToWrite)
             progressHandler?(progress)
-            
+
             let progressInfo: [String: Any] = [
                 "progress": progress,
                 "totalBytesReceived": totalBytesWritten,
@@ -248,7 +232,7 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
             NotificationCenter.default.post(name: .downloadProgressUpdate, object: downloadTask, userInfo: progressInfo)
         } else {
             progressHandler?(0)
-            
+
             NotificationCenter.default.post(name: .downloadProgressUpdate, object: downloadTask, userInfo: ["progress": 0.0, "totalBytesReceived": 0, "totalBytesExpected": 0])
         }
     }

package/package.json

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

package/plugin/build/withHotUpdater.js

@@ -39,6 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+var promises_1 = require("node:fs/promises");
 var cli_tools_1 = require("@hot-updater/cli-tools");
 var config_plugins_1 = require("expo/config-plugins");
 var hot_updater_1 = require("hot-updater");
@@ -64,32 +65,81 @@ var getFingerprint = function () { return __awaiter(void 0, void 0, void 0, func
     });
 }); };
 /**
- * Extract public key from private key in signing config
+ * Extract public key for embedding in native configs.
+ * Supports multiple sources with priority order:
+ * 1. HOT_UPDATER_PRIVATE_KEY environment variable
+ * 2. Private key file (extract public key)
+ * 3. Public key file (derived from privateKeyPath)
+ * 4. Skip with warning (graceful fallback)
  */
 var getPublicKeyFromConfig = function (signingConfig) { return __awaiter(void 0, void 0, void 0, function () {
-    var privateKeyPath, privateKeyPEM, publicKeyPEM, error_1;
+    var envPrivateKey, publicKeyPEM, privateKeyPath, publicKeyPath, privateKeyPEM, publicKeyPEM, _privateKeyError_1, publicKeyPEM, _publicKeyError_1;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                if (!(signingConfig === null || signingConfig === void 0 ? void 0 : signingConfig.enabled) || !(signingConfig === null || signingConfig === void 0 ? void 0 : signingConfig.privateKeyPath)) {
+                // If signing not enabled, no public key needed
+                if (!(signingConfig === null || signingConfig === void 0 ? void 0 : signingConfig.enabled)) {
+                    return [2 /*return*/, null];
+                }
+                envPrivateKey = process.env.HOT_UPDATER_PRIVATE_KEY;
+                if (envPrivateKey) {
+                    try {
+                        publicKeyPEM = (0, hot_updater_1.getPublicKeyFromPrivate)(envPrivateKey);
+                        console.log("[hot-updater] Using public key extracted from HOT_UPDATER_PRIVATE_KEY environment variable");
+                        return [2 /*return*/, publicKeyPEM.trim()];
+                    }
+                    catch (error) {
+                        console.warn("[hot-updater] WARNING: Failed to extract public key from HOT_UPDATER_PRIVATE_KEY:\n" +
+                            "".concat(error instanceof Error ? error.message : String(error), "\n"));
+                        // Continue to try other methods
+                    }
+                }
+                // If no privateKeyPath configured, can't proceed with file-based methods
+                if (!signingConfig.privateKeyPath) {
+                    console.warn("[hot-updater] WARNING: signing.enabled is true but no privateKeyPath configured.\n" +
+                        "Public key will not be embedded. Set HOT_UPDATER_PRIVATE_KEY environment variable or configure privateKeyPath.");
                     return [2 /*return*/, null];
                 }
-                _a.label = 1;
-            case 1:
-                _a.trys.push([1, 3, , 4]);
                 privateKeyPath = path_1.default.isAbsolute(signingConfig.privateKeyPath)
                     ? signingConfig.privateKeyPath
                     : path_1.default.resolve(process.cwd(), signingConfig.privateKeyPath);
+                publicKeyPath = privateKeyPath.replace(/private-key\.pem$/, "public-key.pem");
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 8]);
                 return [4 /*yield*/, (0, hot_updater_1.loadPrivateKey)(privateKeyPath)];
             case 2:
                 privateKeyPEM = _a.sent();
                 publicKeyPEM = (0, hot_updater_1.getPublicKeyFromPrivate)(privateKeyPEM);
+                console.log("[hot-updater] Extracted public key from ".concat(privateKeyPath));
                 return [2 /*return*/, publicKeyPEM.trim()];
             case 3:
-                error_1 = _a.sent();
-                throw new Error("[hot-updater] Failed to extract public key: ".concat(error_1 instanceof Error ? error_1.message : String(error_1), "\n") +
-                    "Run 'npx hot-updater keys generate' to create signing keys");
-            case 4: return [2 /*return*/];
+                _privateKeyError_1 = _a.sent();
+                _a.label = 4;
+            case 4:
+                _a.trys.push([4, 6, , 7]);
+                return [4 /*yield*/, (0, promises_1.readFile)(publicKeyPath, "utf-8")];
+            case 5:
+                publicKeyPEM = _a.sent();
+                console.log("[hot-updater] Using public key from ".concat(publicKeyPath));
+                return [2 /*return*/, publicKeyPEM.trim()];
+            case 6:
+                _publicKeyError_1 = _a.sent();
+                // Priority 4: All sources failed - throw error
+                throw new Error("[hot-updater] Failed to load public key for bundle signing.\n\n" +
+                    "Signing is enabled (signing.enabled: true) but no public key sources found.\n\n" +
+                    "For EAS builds, use EAS Secrets:\n" +
+                    '  eas env:create --name HOT_UPDATER_PRIVATE_KEY --value "$(cat keys/private-key.pem)"\n\n' +
+                    "Or add to eas.json:\n" +
+                    '  "env": { "HOT_UPDATER_PRIVATE_KEY": "-----BEGIN PRIVATE KEY-----\\n..." }\n\n' +
+                    "For local development:\n" +
+                    "  npx hot-updater keys generate\n\n" +
+                    "Searched locations:\n" +
+                    "  - HOT_UPDATER_PRIVATE_KEY environment variable\n" +
+                    "  - Private key file: ".concat(privateKeyPath, "\n") +
+                    "  - Public key file: ".concat(publicKeyPath, "\n"));
+            case 7: return [3 /*break*/, 8];
+            case 8: return [2 /*return*/];
         }
     });
 }); };