pulse-updates 1.0.0

package/android/src/main/java/app/pulse/updates/errorrecovery/PulseErrorRecoveryHandler.kt

@@ -0,0 +1,159 @@
+package app.pulse.updates.errorrecovery
+
+import android.os.Handler
+import android.os.Looper
+import android.os.Message
+import app.pulse.updates.pulseLog
+import app.pulse.updates.pulseLogError
+
+/**
+ * Keeps track of and executes tasks in the error recovery pipeline. The pipeline allows us to
+ * predictably and serially respond to unpredictably ordered events.
+ *
+ * This error recovery flow is intended to be lightweight and is *not* a full safety net whose
+ * purpose is to avoid crashes at all costs. Rather, its primary purpose is to prevent bad updates
+ * from "bricking" an app by causing crashes before there is ever a chance to download a fix.
+ *
+ * When an error is caught, the pipeline is started and executes the following tasks serially:
+ * (a) check for a new update and start downloading if there is one
+ * (b) if there is a new update, reload and launch the new update
+ * (c) if not, or if another error occurs, fall back to an older working update (if one exists)
+ * (d) crash.
+ */
+internal class PulseErrorRecoveryHandler(
+    looper: Looper,
+    private val delegate: PulseErrorRecoveryDelegate
+) : Handler(looper) {
+
+    private val pipeline = arrayListOf(
+        Task.WAIT_FOR_REMOTE_UPDATE,
+        Task.LAUNCH_NEW_UPDATE,
+        Task.LAUNCH_CACHED_UPDATE,
+        Task.CRASH
+    )
+    private var isPipelineRunning = false
+    private var isWaitingForRemoteUpdate = false
+    private var hasContentAppeared = false
+    private val encounteredErrors = ArrayList<Exception>()
+
+    object MessageType {
+        const val EXCEPTION_ENCOUNTERED = 0
+        const val CONTENT_APPEARED = 1
+        const val REMOTE_LOAD_STATUS_CHANGED = 2
+    }
+
+    private enum class Task {
+        WAIT_FOR_REMOTE_UPDATE,
+        LAUNCH_NEW_UPDATE,
+        LAUNCH_CACHED_UPDATE,
+        CRASH
+    }
+
+    override fun handleMessage(msg: Message) {
+        when (msg.what) {
+            MessageType.EXCEPTION_ENCOUNTERED -> maybeStartPipeline(msg.obj as Exception)
+            MessageType.CONTENT_APPEARED -> handleContentAppeared()
+            MessageType.REMOTE_LOAD_STATUS_CHANGED -> handleRemoteLoadStatusChanged(msg.obj as PulseErrorRecoveryDelegate.RemoteLoadStatus)
+            else -> throw RuntimeException("PulseErrorRecoveryHandler cannot handle message " + msg.what)
+        }
+    }
+
+    private fun handleContentAppeared() {
+        hasContentAppeared = true
+        // the launch now counts as "successful" so we don't want to roll back;
+        // remove any extraneous tasks from the pipeline as such
+        pipeline.retainAll(setOf(Task.WAIT_FOR_REMOTE_UPDATE, Task.CRASH))
+        delegate.markSuccessfulLaunchForLaunchedUpdate()
+    }
+
+    private fun handleRemoteLoadStatusChanged(newStatus: PulseErrorRecoveryDelegate.RemoteLoadStatus) {
+        if (!isWaitingForRemoteUpdate) {
+            return
+        }
+        isWaitingForRemoteUpdate = false
+        if (newStatus != PulseErrorRecoveryDelegate.RemoteLoadStatus.NEW_UPDATE_LOADED) {
+            pipeline.remove(Task.LAUNCH_NEW_UPDATE)
+        }
+        runNextTask()
+    }
+
+    private fun runNextTask() {
+        when (pipeline.removeAt(0)) {
+            Task.WAIT_FOR_REMOTE_UPDATE -> {
+                pulseLog(TAG, "ErrorRecovery: attempting to fetch a new update, waiting")
+                waitForRemoteUpdate()
+            }
+            Task.LAUNCH_NEW_UPDATE -> {
+                pulseLog(TAG, "ErrorRecovery: launching new update")
+                tryRelaunchFromCache()
+            }
+            Task.LAUNCH_CACHED_UPDATE -> {
+                pulseLog(TAG, "ErrorRecovery: falling back to older update")
+                tryRelaunchFromCache()
+            }
+            Task.CRASH -> {
+                pulseLogError(TAG, "ErrorRecovery: could not recover from error, crashing")
+                crash()
+            }
+        }
+    }
+
+    private fun maybeStartPipeline(exception: Exception) {
+        encounteredErrors.add(exception)
+        if (delegate.getLaunchedUpdateSuccessfulLaunchCount() > 0) {
+            pipeline.remove(Task.LAUNCH_CACHED_UPDATE)
+        } else if (!hasContentAppeared) {
+            delegate.markFailedLaunchForLaunchedUpdate()
+        }
+
+        if (!isPipelineRunning) {
+            isPipelineRunning = true
+            runNextTask()
+        }
+    }
+
+    private fun waitForRemoteUpdate() {
+        val remoteLoadStatus = delegate.getRemoteLoadStatus()
+        if (remoteLoadStatus == PulseErrorRecoveryDelegate.RemoteLoadStatus.NEW_UPDATE_LOADED) {
+            runNextTask()
+        } else if (remoteLoadStatus == PulseErrorRecoveryDelegate.RemoteLoadStatus.NEW_UPDATE_LOADING ||
+            delegate.getCheckOnLaunchConfiguration().uppercase() != "NEVER"
+        ) {
+            isWaitingForRemoteUpdate = true
+            if (delegate.getRemoteLoadStatus() != PulseErrorRecoveryDelegate.RemoteLoadStatus.NEW_UPDATE_LOADING) {
+                delegate.loadRemoteUpdate()
+            }
+            postDelayed({ handleRemoteLoadStatusChanged(PulseErrorRecoveryDelegate.RemoteLoadStatus.IDLE) }, REMOTE_LOAD_TIMEOUT_MS)
+        } else {
+            pipeline.remove(Task.LAUNCH_NEW_UPDATE)
+            runNextTask()
+        }
+    }
+
+    private fun tryRelaunchFromCache() {
+        delegate.relaunch(object : PulseErrorRecoveryDelegate.LauncherCallback {
+            override fun onFailure(e: Exception) {
+                post {
+                    encounteredErrors.add(e)
+                    pipeline.removeAll(setOf(Task.LAUNCH_NEW_UPDATE, Task.LAUNCH_CACHED_UPDATE))
+                    runNextTask()
+                }
+            }
+
+            override fun onSuccess() {
+                post {
+                    isPipelineRunning = false
+                }
+            }
+        })
+    }
+
+    private fun crash() {
+        delegate.throwException(encounteredErrors[0])
+    }
+
+    companion object {
+        private const val TAG = "PulseErrorRecoveryHandler"
+        const val REMOTE_LOAD_TIMEOUT_MS = 5000L
+    }
+}

package/android/src/main/java/app/pulse/updates/launcher/PulseAppLauncher.kt

@@ -0,0 +1,472 @@
+package app.pulse.updates.launcher
+
+import android.content.Context
+import app.pulse.updates.pulseLog
+import app.pulse.updates.pulseLogWarn
+import app.pulse.updates.pulseLogError
+import app.pulse.updates.database.PulseAsset
+import app.pulse.updates.database.PulseDatabase
+import app.pulse.updates.database.PulseUpdate
+import app.pulse.updates.database.PulseUpdateStatus
+import java.io.File
+import java.io.FileOutputStream
+import java.io.InputStream
+import java.net.URL
+import java.security.MessageDigest
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * PulseUpdates App Launcher
+ * Based on expo-updates AppLauncherWithDatabase
+ * Handles launching updates with 3-step asset fallback support
+ */
+class PulseAppLauncher(
+    private val context: Context,
+    private val database: PulseDatabase,
+    private val directory: File,
+    private val selectionPolicy: PulseSelectionPolicy,
+    private val runtimeVersion: String
+) {
+    companion object {
+        private const val TAG = "PulseAppLauncher"
+    }
+
+    // Public properties
+    var launchedUpdate: PulseUpdate? = null
+        private set
+
+    var launchAssetFile: File? = null
+        private set
+
+    var assetFilesMap: Map<String, String> = emptyMap()
+        private set
+
+    val isUsingEmbeddedAssets: Boolean
+        get() = launchedUpdate?.isEmbedded == true
+
+    // Private state
+    private var embeddedManifest: EmbeddedManifest? = null
+
+    /**
+     * Launch the best available update
+     */
+    fun launch(callback: (success: Boolean, error: Exception?) -> Unit) {
+        try {
+            val updates = database.launchableUpdates(runtimeVersion)
+            val selectedUpdate = selectionPolicy.selectUpdateToLaunch(updates)
+
+            if (selectedUpdate == null) {
+                callback(false, LauncherException("No launchable update found"))
+                return
+            }
+
+            launchedUpdate = selectedUpdate
+            launchUpdate(selectedUpdate, callback)
+        } catch (e: Exception) {
+            callback(false, e)
+        }
+    }
+
+    /**
+     * Launch a specific update
+     */
+    fun launch(update: PulseUpdate, callback: (success: Boolean, error: Exception?) -> Unit) {
+        launchedUpdate = update
+        launchUpdate(update, callback)
+    }
+
+    private fun launchUpdate(update: PulseUpdate, callback: (success: Boolean, error: Exception?) -> Unit) {
+        // Mark update as accessed
+        try {
+            database.markUpdateAccessed(update.updateId)
+        } catch (e: Exception) {
+            pulseLogWarn(TAG, "Failed to mark update accessed: ${e.message}")
+        }
+
+        // Handle embedded updates
+        if (update.status == PulseUpdateStatus.EMBEDDED) {
+            launchEmbeddedUpdate(update, callback)
+            return
+        }
+
+        // Handle development updates (no assets to verify)
+        if (update.status == PulseUpdateStatus.DEVELOPMENT) {
+            callback(true, null)
+            return
+        }
+
+        // Handle regular updates - ensure all assets exist
+        ensureAllAssetsExist(update, callback)
+    }
+
+    private fun launchEmbeddedUpdate(update: PulseUpdate, callback: (success: Boolean, error: Exception?) -> Unit) {
+        // For embedded updates, DON'T set launchAssetFile
+        // Let React Native use its default bundle loading mechanism
+        // This ensures images from drawable folders are resolved correctly
+        launchAssetFile = null
+        assetFilesMap = emptyMap()
+        callback(true, null)
+    }
+
+    private fun ensureAllAssetsExist(update: PulseUpdate, callback: (success: Boolean, error: Exception?) -> Unit) {
+        try {
+            val assets = database.assetsForUpdate(update.updateId)
+
+            if (assets.isEmpty()) {
+                // No assets to verify, just find the bundle
+                update.bundleHash?.let { hash ->
+                    launchAssetFile = bundleStorePath(hash)
+                }
+                callback(launchAssetFile?.exists() == true, if (launchAssetFile?.exists() != true) LauncherException("Bundle not found") else null)
+                return
+            }
+
+            // Initialize asset map with embedded assets (fallback)
+            val mutableAssetFilesMap = buildEmbeddedAssetsMap().toMutableMap()
+
+            val totalAssets = assets.size
+            val completedAssets = java.util.concurrent.atomic.AtomicInteger(0)
+            val launchError = AtomicReference<Exception?>(null)
+            val launchAssetFound = AtomicBoolean(false)
+            val latch = CountDownLatch(totalAssets)
+
+            for (asset in assets) {
+                val localFile = assetStorePath(asset.hash)
+
+                Thread {
+                    try {
+                        val exists = ensureAssetExists(asset, localFile)
+
+                        if (exists) {
+                            if (asset.isLaunchAsset) {
+                                launchAssetFile = localFile
+                                launchAssetFound.set(true)
+                            } else {
+                                val localUri = localFile.toURI().toString()
+                                synchronized(mutableAssetFilesMap) {
+                                    // Store by SHA256 hash
+                                    mutableAssetFilesMap[asset.hash] = localUri
+                                    // Also store by path-based key for Metro compatibility
+                                    asset.key?.let { key ->
+                                        mutableAssetFilesMap[key] = localUri
+                                    }
+                                }
+                            }
+                        }
+                    } catch (e: Exception) {
+                        if (asset.isLaunchAsset) {
+                            launchError.set(e)
+                        }
+                    } finally {
+                        completedAssets.incrementAndGet()
+                        latch.countDown()
+                    }
+                }.start()
+            }
+
+            // Wait for all assets to be processed
+            Thread {
+                latch.await()
+                assetFilesMap = mutableAssetFilesMap
+                val success = launchAssetFound.get()
+                callback(success, if (!success) (launchError.get() ?: LauncherException("Launch asset missing")) else null)
+            }.start()
+
+        } catch (e: Exception) {
+            callback(false, e)
+        }
+    }
+
+    /**
+     * 3-step asset fallback:
+     * 1. Check if asset exists at expected location
+     * 2. Try to copy from APK assets
+     * 3. Try to download from remote
+     */
+    private fun ensureAssetExists(asset: PulseAsset, localFile: File): Boolean {
+        // Step 1: Check if asset exists at expected location
+        if (localFile.exists()) {
+            return true
+        }
+
+        // Step 2: Try to copy from APK assets
+        if (maybeCopyAssetFromBundle(asset, localFile)) {
+            return true
+        }
+
+        // Step 3: Try to download the asset
+        return downloadAsset(asset, localFile)
+    }
+
+    private fun maybeCopyAssetFromBundle(asset: PulseAsset, toFile: File): Boolean {
+        // Load embedded manifest if not cached
+        if (embeddedManifest == null) {
+            embeddedManifest = loadEmbeddedManifest()
+        }
+
+        val embedded = embeddedManifest ?: return false
+
+        // Find matching embedded asset by key or hash
+        val matchingAsset = embedded.assets.find { embeddedAsset ->
+            (asset.key != null && embeddedAsset.key == asset.key) ||
+                    embeddedAsset.hash.equals(asset.hash, ignoreCase = true)
+        } ?: return false
+
+        val bundleFilename = matchingAsset.mainBundleFilename ?: return false
+
+        try {
+            // Get asset path in APK
+            val assetPath = if (matchingAsset.mainBundleDir?.isNotEmpty() == true) {
+                "${matchingAsset.mainBundleDir}/$bundleFilename"
+            } else {
+                bundleFilename
+            }
+
+            // Copy from APK assets
+            context.assets.open(assetPath).use { input ->
+                toFile.parentFile?.mkdirs()
+                FileOutputStream(toFile).use { output ->
+                    input.copyTo(output)
+                }
+            }
+
+            return true
+        } catch (e: Exception) {
+            pulseLogWarn(TAG, "Failed to copy asset from bundle: ${e.message}")
+            return false
+        }
+    }
+
+    private fun downloadAsset(asset: PulseAsset, toFile: File): Boolean {
+        val remoteUrl = asset.url ?: return false
+
+        try {
+            toFile.parentFile?.mkdirs()
+
+            URL(remoteUrl).openStream().use { input ->
+                FileOutputStream(toFile).use { output ->
+                    input.copyTo(output)
+                }
+            }
+
+            // Verify hash if expected
+            asset.expectedHash?.let { expectedHash ->
+                val actualHash = sha256Hex(toFile)
+                if (actualHash != expectedHash) {
+                    toFile.delete()
+                    pulseLogError(TAG, "Asset hash mismatch: expected $expectedHash, got $actualHash")
+                    return false
+                }
+            }
+
+            return true
+        } catch (e: Exception) {
+            pulseLogError(TAG, "Failed to download asset: ${e.message}")
+            toFile.delete()
+            return false
+        }
+    }
+
+    // MARK: - Asset Path Helpers
+
+    private fun assetStorePath(hash: String): File {
+        return File(directory, "assets/sha256/${hash.lowercase()}")
+    }
+
+    private fun bundleStorePath(hash: String): File {
+        // Bundle is stored in assets directory (same location as other assets)
+        return File(directory, "assets/sha256/${hash.lowercase()}")
+    }
+
+    // MARK: - Embedded Assets Map
+
+    private fun buildEmbeddedAssetsMap(): Map<String, String> {
+        val embedded = embeddedManifest ?: loadEmbeddedManifest() ?: return emptyMap()
+        val result = mutableMapOf<String, String>()
+
+        for (asset in embedded.assets) {
+            if (asset.isLaunchAsset) continue
+
+            val filename = asset.mainBundleFilename ?: continue
+            val assetPath = if (asset.mainBundleDir?.isNotEmpty() == true) {
+                "${asset.mainBundleDir}/$filename"
+            } else {
+                filename
+            }
+
+            // Verify asset exists in APK
+            try {
+                context.assets.open(assetPath).close()
+                val localUri = "asset://$assetPath"
+
+                // Store by SHA256 hash
+                result[asset.hash] = localUri
+
+                // Also store by path-based key for Metro compatibility
+                asset.key?.let { key ->
+                    result[key] = localUri
+                }
+            } catch (e: Exception) {
+                // Asset doesn't exist in bundle
+            }
+        }
+
+        return result
+    }
+
+    private fun buildEmbeddedAssetFilesMap(): Map<String, String> {
+        return buildEmbeddedAssetsMap()
+    }
+
+    // MARK: - Embedded Manifest
+
+    private fun loadEmbeddedManifest(): EmbeddedManifest? {
+        return try {
+            val json = context.assets.open("embedded-manifest.json").bufferedReader().use { it.readText() }
+            EmbeddedManifest.fromJson(json)
+        } catch (e: Exception) {
+            pulseLogWarn(TAG, "No embedded manifest found: ${e.message}")
+            null
+        }
+    }
+
+    // MARK: - Crypto
+
+    private fun sha256Hex(file: File): String {
+        val digest = MessageDigest.getInstance("SHA-256")
+        file.inputStream().use { fis ->
+            val buffer = ByteArray(8192)
+            var bytesRead: Int
+            while (fis.read(buffer).also { bytesRead = it } != -1) {
+                digest.update(buffer, 0, bytesRead)
+            }
+        }
+        return digest.digest().joinToString("") { "%02x".format(it) }
+    }
+}
+
+// MARK: - Launcher Exception
+
+class LauncherException(message: String) : Exception(message)
+
+// MARK: - Embedded Manifest Model
+
+data class EmbeddedManifest(
+    val updateId: String,
+    val runtimeVersion: String,
+    val commitTime: Long,
+    val assets: List<EmbeddedAsset>
+) {
+    companion object {
+        fun fromJson(json: String): EmbeddedManifest? {
+            return try {
+                val root = org.json.JSONObject(json)
+                val manifest = root.optJSONObject("manifest") ?: return null
+
+                val updateId = manifest.getString("updateId")
+                val runtimeVersion = manifest.getString("runtimeVersion")
+                val commitTime = manifest.optLong("commitTime", System.currentTimeMillis())
+
+                val assets = mutableListOf<EmbeddedAsset>()
+
+                // Parse assets array
+                manifest.optJSONArray("assets")?.let { assetsJson ->
+                    for (i in 0 until assetsJson.length()) {
+                        EmbeddedAsset.fromJson(assetsJson.getJSONObject(i))?.let { assets.add(it) }
+                    }
+                }
+
+                // Parse launch asset
+                manifest.optJSONObject("launchAsset")?.let { launchAssetJson ->
+                    EmbeddedAsset.fromJson(launchAssetJson, isLaunchAsset = true)?.let { assets.add(it) }
+                }
+
+                EmbeddedManifest(updateId, runtimeVersion, commitTime, assets)
+            } catch (e: Exception) {
+                pulseLogError("EmbeddedManifest", "Failed to parse: ${e.message}")
+                null
+            }
+        }
+    }
+}
+
+data class EmbeddedAsset(
+    val key: String?,
+    val hash: String,
+    val type: String?,
+    val mainBundleDir: String?,
+    val mainBundleFilename: String?,
+    val isLaunchAsset: Boolean = false
+) {
+    companion object {
+        fun fromJson(json: org.json.JSONObject, isLaunchAsset: Boolean = false): EmbeddedAsset? {
+            val hash = json.optString("hash") ?: return null
+            return EmbeddedAsset(
+                key = json.optString("key", null),
+                hash = hash,
+                type = json.optString("type", null) ?: json.optString("contentType", null),
+                mainBundleDir = json.optString("mainBundleDir", null),
+                mainBundleFilename = json.optString("mainBundleFilename", null),
+                isLaunchAsset = isLaunchAsset
+            )
+        }
+    }
+}
+
+// MARK: - Selection Policy
+
+interface PulseSelectionPolicy {
+    fun selectUpdateToLaunch(updates: List<PulseUpdate>): PulseUpdate?
+    fun selectUpdatesToDelete(launchedUpdate: PulseUpdateInfo, allUpdates: List<PulseUpdateInfo>): List<PulseUpdateInfo>
+}
+
+data class PulseUpdateInfo(
+    val updateId: String,
+    val runtimeVersion: String,
+    val commitTime: Long,
+    val status: PulseUpdateStatus,
+    val successfulLaunchCount: Int = 0,
+    val failedLaunchCount: Int = 0,
+    val isEmbedded: Boolean = false,
+    val bundleHash: String? = null,
+    val scopeKey: String? = null
+)
+
+class PulseDefaultSelectionPolicy : PulseSelectionPolicy {
+    override fun selectUpdateToLaunch(updates: List<PulseUpdate>): PulseUpdate? {
+        return updates
+            .filter { it.status == PulseUpdateStatus.READY || it.status == PulseUpdateStatus.EMBEDDED }
+            .maxByOrNull { it.commitTime.time }
+    }
+
+    override fun selectUpdatesToDelete(launchedUpdate: PulseUpdateInfo, allUpdates: List<PulseUpdateInfo>): List<PulseUpdateInfo> {
+        val toDelete = mutableListOf<PulseUpdateInfo>()
+        var newestBackup: PulseUpdateInfo? = null
+
+        for (update in allUpdates) {
+            // Never delete the currently launched update
+            if (update.updateId == launchedUpdate.updateId) continue
+
+            // Never delete embedded updates (handled by integrity check)
+            if (update.isEmbedded) continue
+
+            // Mark older updates for deletion, but track the newest as potential backup
+            if (update.commitTime < launchedUpdate.commitTime) {
+                toDelete.add(update)
+
+                if (newestBackup == null || update.commitTime > newestBackup.commitTime) {
+                    newestBackup = update
+                }
+            }
+        }
+
+        // Keep one backup (the newest older update) for rollback capability
+        newestBackup?.let { backup ->
+            toDelete.removeAll { it.updateId == backup.updateId }
+        }
+
+        return toDelete
+    }
+}