@hot-updater/react-native 0.27.1 → 0.29.0

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

@@ -0,0 +1,533 @@
+package com.hotupdater
+
+import android.app.AlarmManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Handler
+import android.os.Looper
+import android.os.Process
+import android.os.SystemClock
+import android.util.Log
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSExceptionHandler
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReactMarker
+import com.facebook.react.bridge.ReactMarkerConstants
+import org.json.JSONObject
+import java.io.File
+import java.lang.reflect.Field
+import kotlin.system.exitProcess
+
+internal class HotUpdaterRecoveryManager(
+    context: Context,
+) {
+    private val appContext = context.applicationContext
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val bundleStoreDir = getBundleStoreDir(appContext)
+    private val crashMarkerFile = File(bundleStoreDir, CRASH_MARKER_FILENAME)
+    private val watchdogStateFile = File(bundleStoreDir, WATCHDOG_STATE_FILENAME)
+
+    private var currentBundleId: String? = null
+    private var shouldRollbackOnCrash = false
+    private var isMonitoring = false
+    private var recoveryRequested = false
+    private var contentAppearedCallback: ((String?) -> Unit)? = null
+    private var recoveryRestartCallback: (() -> Boolean)? = null
+
+    private val stopMonitoringRunnable =
+        Runnable {
+            cancelRecoveryWatchdog()
+            Log.d(TAG, "Stopping crash monitoring for current launch")
+            isMonitoring = false
+            recoveryRequested = false
+            shouldRollbackOnCrash = false
+            currentBundleId = null
+            contentAppearedCallback = null
+            recoveryRestartCallback = null
+            activeManager = null
+            updateNativeLaunchState(null, false)
+        }
+
+    private val installJsExceptionHooksRunnable =
+        object : Runnable {
+            override fun run() {
+                if (!isMonitoring) {
+                    return
+                }
+
+                installJavaScriptExceptionHooks()
+                mainHandler.postDelayed(this, JS_EXCEPTION_HOOK_RETRY_DELAY_MS)
+            }
+        }
+
+    private val contentAppearedListener =
+        ReactMarker.MarkerListener { name, _, _ ->
+            if (name == ReactMarkerConstants.CONTENT_APPEARED) {
+                handleContentAppeared()
+            }
+        }
+
+    fun consumePendingCrashRecovery(): PendingCrashRecovery? {
+        if (!crashMarkerFile.exists()) {
+            return null
+        }
+
+        return try {
+            val recovery = PendingCrashRecovery.fromJson(JSONObject(crashMarkerFile.readText()))
+            Log.d(
+                TAG,
+                "Consumed pending crash marker bundleId=${recovery.launchedBundleId} shouldRollback=${recovery.shouldRollback}",
+            )
+            recovery
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to read crash marker", e)
+            null
+        } finally {
+            crashMarkerFile.delete()
+        }
+    }
+
+    fun startMonitoring(
+        bundleId: String?,
+        shouldRollback: Boolean,
+        onContentAppeared: (String?) -> Unit,
+        onRecoveryRestartRequested: () -> Boolean,
+    ) {
+        crashMarkerFile.parentFile?.mkdirs()
+        contentAppearedCallback = onContentAppeared
+        currentBundleId = bundleId
+        shouldRollbackOnCrash = shouldRollback
+        isMonitoring = true
+        recoveryRequested = false
+        recoveryRestartCallback = onRecoveryRestartRequested
+        activeManager = this
+
+        ensureExceptionHandlerInstalled()
+        ensureNativeSignalHandlerInstalled()
+
+        mainHandler.removeCallbacks(installJsExceptionHooksRunnable)
+        mainHandler.removeCallbacks(stopMonitoringRunnable)
+        ReactMarker.removeListener(contentAppearedListener)
+        ReactMarker.addListener(contentAppearedListener)
+        updateNativeLaunchState(bundleId, shouldRollback)
+        if (shouldRollback) {
+            startRecoveryWatchdog()
+        } else {
+            cancelRecoveryWatchdog()
+        }
+        mainHandler.post(installJsExceptionHooksRunnable)
+
+        Log.d(TAG, "Started crash monitoring bundleId=$bundleId shouldRollback=$shouldRollback")
+    }
+
+    private fun handleContentAppeared() {
+        if (!isMonitoring) {
+            return
+        }
+
+        Log.d(TAG, "First content appeared for bundleId=$currentBundleId")
+        ReactMarker.removeListener(contentAppearedListener)
+        mainHandler.removeCallbacks(installJsExceptionHooksRunnable)
+        mainHandler.removeCallbacks(stopMonitoringRunnable)
+        contentAppearedCallback?.invoke(currentBundleId)
+        shouldRollbackOnCrash = false
+        updateNativeLaunchState(currentBundleId, false)
+        cancelRecoveryWatchdog()
+        mainHandler.postDelayed(stopMonitoringRunnable, MONITORING_GRACE_PERIOD_MS)
+    }
+
+    private fun ensureExceptionHandlerInstalled() {
+        if (exceptionHandlerInstalled) {
+            return
+        }
+
+        previousExceptionHandler = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            val manager = activeManager
+            manager?.writeCrashMarker()
+
+            if (manager?.requestAutomaticRecovery() == true) {
+                Process.killProcess(Process.myPid())
+                exitProcess(10)
+            }
+
+            previousExceptionHandler?.uncaughtException(thread, throwable)
+                ?: run {
+                    Process.killProcess(Process.myPid())
+                    exitProcess(10)
+                }
+        }
+        exceptionHandlerInstalled = true
+    }
+
+    private fun writeCrashMarker() {
+        if (!isMonitoring) {
+            return
+        }
+
+        try {
+            val payload =
+                JSONObject().apply {
+                    put("bundleId", currentBundleId ?: JSONObject.NULL)
+                    put("shouldRollback", shouldRollbackOnCrash)
+                }
+            crashMarkerFile.parentFile?.mkdirs()
+            crashMarkerFile.writeText(payload.toString())
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to write crash marker", e)
+        }
+    }
+
+    private fun startRecoveryWatchdog() {
+        try {
+            watchdogStateFile.parentFile?.mkdirs()
+            watchdogStateFile.writeText((System.currentTimeMillis() + MONITORING_GRACE_PERIOD_MS).toString())
+            scheduleRecoveryWatchdogTick(appContext, WATCHDOG_TICK_INTERVAL_MS)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to schedule recovery watchdog", e)
+        }
+    }
+
+    private fun cancelRecoveryWatchdog() {
+        watchdogStateFile.delete()
+        cancelRecoveryWatchdogAlarm(appContext)
+    }
+
+    private fun requestAutomaticRecovery(): Boolean {
+        if (!isMonitoring || !shouldRollbackOnCrash) {
+            return false
+        }
+
+        synchronized(this) {
+            if (recoveryRequested) {
+                return true
+            }
+            recoveryRequested = true
+        }
+
+        val started = recoveryRestartCallback?.invoke() == true
+        if (!started) {
+            synchronized(this) {
+                recoveryRequested = false
+            }
+            Log.w(TAG, "Failed to schedule automatic recovery restart")
+        } else {
+            Log.i(TAG, "Scheduled automatic recovery restart for bundleId=$currentBundleId")
+        }
+        return started
+    }
+
+    private fun handleJavaScriptException(exception: Exception): Boolean {
+        Log.e(TAG, "Caught React startup exception for bundleId=$currentBundleId", exception)
+        writeCrashMarker()
+        return requestAutomaticRecovery()
+    }
+
+    private fun ensureNativeSignalHandlerInstalled() {
+        if (signalHandlerInstalled || !loadNativeLibrary()) {
+            return
+        }
+
+        try {
+            nativeInstallSignalHandler(crashMarkerFile.absolutePath)
+            signalHandlerInstalled = true
+        } catch (e: UnsatisfiedLinkError) {
+            Log.w(TAG, "Signal handler not available", e)
+        }
+    }
+
+    private fun updateNativeLaunchState(
+        bundleId: String?,
+        shouldRollback: Boolean,
+    ) {
+        if (!signalHandlerInstalled || !nativeLibraryLoaded) {
+            return
+        }
+
+        try {
+            nativeUpdateLaunchState(bundleId, shouldRollback)
+        } catch (e: UnsatisfiedLinkError) {
+            Log.w(TAG, "Failed to update native launch state", e)
+        }
+    }
+
+    private fun installJavaScriptExceptionHooks() {
+        val application = appContext as? ReactApplication ?: return
+
+        if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+            installReactHostExceptionHook(application)
+        } else {
+            installLegacyExceptionHook(application)
+        }
+    }
+
+    private fun installReactHostExceptionHook(application: ReactApplication) {
+        val reactHost = getReactHost(application) ?: return
+        val reactHostDelegate =
+            findField(reactHost.javaClass, "mReactHostDelegate")?.let { field ->
+                field.isAccessible = true
+                field.get(reactHost)
+            }
+                ?: findField(reactHost.javaClass, "reactHostDelegate")?.let { field ->
+                    field.isAccessible = true
+                    field.get(reactHost)
+                }
+                ?: return
+
+        val delegateIdentity = System.identityHashCode(reactHostDelegate)
+        if (patchedReactHostDelegateIds.add(delegateIdentity)) {
+            val exceptionHandlerField = findField(reactHostDelegate.javaClass, "exceptionHandler")
+            if (exceptionHandlerField == null) {
+                patchedReactHostDelegateIds.remove(delegateIdentity)
+                return
+            }
+
+            exceptionHandlerField.isAccessible = true
+            @Suppress("UNCHECKED_CAST")
+            val previousHandler =
+                exceptionHandlerField.get(reactHostDelegate) as? (Exception) -> Unit
+
+            exceptionHandlerField.set(reactHostDelegate) { exception: Exception ->
+                if (activeManager?.handleJavaScriptException(exception) != true) {
+                    previousHandler?.invoke(exception) ?: throw exception
+                }
+            }
+        }
+
+        val reactContext =
+            findMethod(reactHost.javaClass, "getCurrentReactContext")?.invoke(reactHost) as? ReactContext
+        reactContext?.let { patchReactContextExceptionHandler(it) }
+    }
+
+    private fun installLegacyExceptionHook(application: ReactApplication) {
+        val instanceManager = application.reactNativeHost.reactInstanceManager
+        val managerIdentity = System.identityHashCode(instanceManager)
+        if (patchedInstanceManagerIds.add(managerIdentity)) {
+            val exceptionHandlerField = findField(instanceManager.javaClass, "mJSExceptionHandler")
+            if (exceptionHandlerField == null) {
+                patchedInstanceManagerIds.remove(managerIdentity)
+                return
+            }
+
+            exceptionHandlerField.isAccessible = true
+            val previousHandler = exceptionHandlerField.get(instanceManager) as? JSExceptionHandler
+            exceptionHandlerField.set(instanceManager, RecoveryJSExceptionHandler(previousHandler))
+        }
+
+        instanceManager.currentReactContext?.let { reactContext ->
+            patchReactContextExceptionHandler(reactContext)
+            patchCatalystInstanceExceptionHandler(reactContext)
+        }
+    }
+
+    private fun patchReactContextExceptionHandler(reactContext: ReactContext) {
+        val contextIdentity = System.identityHashCode(reactContext)
+        if (!patchedReactContextIds.add(contextIdentity)) {
+            return
+        }
+
+        val previousHandler = reactContext.jsExceptionHandler
+        if (previousHandler is RecoveryJSExceptionHandler) {
+            return
+        }
+
+        reactContext.setJSExceptionHandler(RecoveryJSExceptionHandler(previousHandler))
+    }
+
+    private fun patchCatalystInstanceExceptionHandler(reactContext: ReactContext) {
+        val catalystInstance =
+            try {
+                reactContext.catalystInstance
+            } catch (_: Exception) {
+                null
+            } ?: return
+
+        val catalystIdentity = System.identityHashCode(catalystInstance)
+        if (!patchedCatalystInstanceIds.add(catalystIdentity)) {
+            return
+        }
+
+        val exceptionHandlerField = findField(catalystInstance.javaClass, "mJSExceptionHandler")
+        if (exceptionHandlerField == null) {
+            patchedCatalystInstanceIds.remove(catalystIdentity)
+            return
+        }
+
+        exceptionHandlerField.isAccessible = true
+        val previousHandler = exceptionHandlerField.get(catalystInstance) as? JSExceptionHandler
+        if (previousHandler is RecoveryJSExceptionHandler) {
+            return
+        }
+        exceptionHandlerField.set(catalystInstance, RecoveryJSExceptionHandler(previousHandler))
+    }
+
+    private fun getReactHost(application: ReactApplication): Any? =
+        try {
+            findMethod(application.javaClass, "getReactHost")?.invoke(application)
+        } catch (_: Exception) {
+            null
+        }
+
+    private fun findMethod(
+        clazz: Class<*>,
+        name: String,
+    ) = runCatching { clazz.getMethod(name) }.getOrNull()
+
+    private fun findField(
+        clazz: Class<*>,
+        name: String,
+    ): Field? {
+        var current: Class<*>? = clazz
+        while (true) {
+            val currentClass = current ?: break
+            runCatching { currentClass.getDeclaredField(name) }
+                .getOrNull()
+                ?.let { return it }
+            current = currentClass.superclass
+        }
+        return null
+    }
+
+    private fun loadNativeLibrary(): Boolean {
+        if (nativeLibraryLoadAttempted) {
+            return nativeLibraryLoaded
+        }
+
+        nativeLibraryLoadAttempted = true
+        nativeLibraryLoaded =
+            try {
+                System.loadLibrary("hotupdater_recovery")
+                true
+            } catch (e: UnsatisfiedLinkError) {
+                Log.w(TAG, "Failed to load recovery native library", e)
+                false
+            }
+        return nativeLibraryLoaded
+    }
+
+    private external fun nativeInstallSignalHandler(crashMarkerPath: String)
+
+    private external fun nativeUpdateLaunchState(
+        bundleId: String?,
+        shouldRollback: Boolean,
+    )
+
+    private class RecoveryJSExceptionHandler(
+        private val previousHandler: JSExceptionHandler?,
+    ) : JSExceptionHandler {
+        override fun handleException(e: Exception) {
+            if (activeManager?.handleJavaScriptException(e) != true) {
+                previousHandler?.handleException(e) ?: throw e
+            }
+        }
+    }
+
+    companion object {
+        private const val TAG = "HotUpdaterRecovery"
+        private const val CRASH_MARKER_FILENAME = "recovery-crash-marker.json"
+        private const val WATCHDOG_STATE_FILENAME = "recovery-watchdog-state.txt"
+        private const val WATCHDOG_ACTION = "com.hotupdater.RECOVERY_WATCHDOG"
+        private const val MONITORING_GRACE_PERIOD_MS = 10_000L
+        private const val WATCHDOG_TICK_INTERVAL_MS = 1_500L
+        private const val JS_EXCEPTION_HOOK_RETRY_DELAY_MS = 50L
+
+        @Volatile
+        private var nativeLibraryLoadAttempted = false
+
+        @Volatile
+        private var nativeLibraryLoaded = false
+
+        @Volatile
+        private var signalHandlerInstalled = false
+
+        @Volatile
+        private var exceptionHandlerInstalled = false
+
+        @Volatile
+        private var previousExceptionHandler: Thread.UncaughtExceptionHandler? = null
+
+        @Volatile
+        private var activeManager: HotUpdaterRecoveryManager? = null
+
+        private val patchedInstanceManagerIds = mutableSetOf<Int>()
+        private val patchedCatalystInstanceIds = mutableSetOf<Int>()
+        private val patchedReactContextIds = mutableSetOf<Int>()
+        private val patchedReactHostDelegateIds = mutableSetOf<Int>()
+
+        @JvmStatic
+        fun handleRecoveryWatchdog(context: Context) {
+            val appContext = context.applicationContext
+            val watchdogStateFile = File(getBundleStoreDir(appContext), WATCHDOG_STATE_FILENAME)
+            val deadlineAt = watchdogStateFile.takeIf(File::exists)?.readText()?.toLongOrNull()
+            if (deadlineAt == null) {
+                cancelRecoveryWatchdogAlarm(appContext)
+                watchdogStateFile.delete()
+                return
+            }
+
+            val crashMarkerFile = File(getBundleStoreDir(appContext), CRASH_MARKER_FILENAME)
+            if (crashMarkerFile.exists()) {
+                Log.i(TAG, "Recovery watchdog detected crash marker, relaunching app")
+                watchdogStateFile.delete()
+                cancelRecoveryWatchdogAlarm(appContext)
+                launchRecoveryRestart(appContext)
+                return
+            }
+
+            if (System.currentTimeMillis() >= deadlineAt) {
+                watchdogStateFile.delete()
+                cancelRecoveryWatchdogAlarm(appContext)
+                return
+            }
+
+            scheduleRecoveryWatchdogTick(appContext, WATCHDOG_TICK_INTERVAL_MS)
+        }
+
+        private fun getBundleStoreDir(context: Context): File = File(context.getExternalFilesDir(null) ?: context.filesDir, "bundle-store")
+
+        private fun getRecoveryWatchdogIntent(context: Context): Intent =
+            Intent(context, HotUpdaterRecoveryReceiver::class.java).setAction(WATCHDOG_ACTION)
+
+        private fun getRecoveryWatchdogPendingIntent(context: Context): PendingIntent =
+            PendingIntent.getBroadcast(
+                context,
+                0,
+                getRecoveryWatchdogIntent(context),
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+            )
+
+        private fun scheduleRecoveryWatchdogTick(
+            context: Context,
+            delayMs: Long,
+        ) {
+            val alarmManager = context.getSystemService(AlarmManager::class.java) ?: return
+            val triggerAt = SystemClock.elapsedRealtime() + delayMs
+            alarmManager.set(
+                AlarmManager.ELAPSED_REALTIME_WAKEUP,
+                triggerAt,
+                getRecoveryWatchdogPendingIntent(context),
+            )
+        }
+
+        private fun cancelRecoveryWatchdogAlarm(context: Context) {
+            val alarmManager = context.getSystemService(AlarmManager::class.java) ?: return
+            alarmManager.cancel(getRecoveryWatchdogPendingIntent(context))
+        }
+
+        private fun launchRecoveryRestart(context: Context) {
+            val restartIntent =
+                Intent(context, HotUpdaterRestartActivity::class.java).apply {
+                    putExtra(HotUpdaterRestartActivity.EXTRA_PACKAGE_NAME, context.packageName)
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION)
+                }
+
+            try {
+                context.startActivity(restartIntent)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to launch recovery restart", e)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+package com.hotupdater
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+class HotUpdaterRecoveryReceiver : BroadcastReceiver() {
+    override fun onReceive(
+        context: Context,
+        intent: Intent,
+    ) {
+        HotUpdaterRecoveryManager.handleRecoveryWatchdog(context)
+    }
+}

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

@@ -0,0 +1,55 @@
+package com.hotupdater
+
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+
+internal fun Map<String, Any?>.toWritableNativeMap(): WritableNativeMap {
+    val result = WritableNativeMap()
+    forEach { (key, value) ->
+        result.putReactValue(key, value)
+    }
+    return result
+}
+
+internal fun List<*>.toWritableNativeArray(): WritableNativeArray {
+    val result = WritableNativeArray()
+    forEach { value ->
+        result.pushReactValue(value)
+    }
+    return result
+}
+
+private fun WritableMap.putReactValue(
+    key: String,
+    value: Any?,
+) {
+    when (value) {
+        null -> putNull(key)
+        is Boolean -> putBoolean(key, value)
+        is Number -> putDouble(key, value.toDouble())
+        is String -> putString(key, value)
+        is Map<*, *> -> {
+            @Suppress("UNCHECKED_CAST")
+            putMap(key, (value as Map<String, Any?>).toWritableNativeMap())
+        }
+        is List<*> -> putArray(key, value.toWritableNativeArray())
+        else -> putString(key, value.toString())
+    }
+}
+
+private fun WritableArray.pushReactValue(value: Any?) {
+    when (value) {
+        null -> pushNull()
+        is Boolean -> pushBoolean(value)
+        is Number -> pushDouble(value.toDouble())
+        is String -> pushString(value)
+        is Map<*, *> -> {
+            @Suppress("UNCHECKED_CAST")
+            pushMap((value as Map<String, Any?>).toWritableNativeMap())
+        }
+        is List<*> -> pushArray(value.toWritableNativeArray())
+        else -> pushString(value.toString())
+    }
+}

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

@@ -25,15 +25,27 @@ class TarBrDecompressionStrategy : DecompressionStrategy {
             return false
         }
 
-        // Brotli has no standard magic bytes, check file extension
-        val lowercasedPath = filePath.lowercase()
-        val isBrotli = lowercasedPath.endsWith(".tar.br") || lowercasedPath.endsWith(".br")
+        return try {
+            FileInputStream(file).use { fileInputStream ->
+                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
+                    BrotliInputStream(bufferedInputStream).use { brotliInputStream ->
+                        TarArchiveInputStream(brotliInputStream).use { tarInputStream ->
+                            val firstEntry = tarInputStream.getNextEntry()
+                            val isValid = firstEntry != null
 
-        if (!isBrotli) {
-            Log.d(TAG, "Invalid file: not a .tar.br or .br file")
-        }
+                            if (!isValid) {
+                                Log.d(TAG, "Invalid file: tar archive has no entries")
+                            }
 
-        return isBrotli
+                            isValid
+                        }
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.d(TAG, "Invalid file: Brotli/TAR validation failed - ${e.message}")
+            false
+        }
     }
 
     override fun decompress(

package/android/src/newarch/HotUpdaterModule.kt

@@ -19,6 +19,7 @@ class HotUpdaterModule internal constructor(
     reactContext: ReactApplicationContext,
 ) : HotUpdaterSpec(reactContext) {
     private val mReactApplicationContext: ReactApplicationContext = reactContext
+    private val cohortService = CohortService(reactContext)
 
     // Managed coroutine scope for the module lifecycle
     private val moduleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
@@ -145,32 +146,9 @@ class HotUpdaterModule internal constructor(
         // No-op
     }
 
-    override fun notifyAppReady(params: ReadableMap): WritableNativeMap {
-        val result = WritableNativeMap()
-        val bundleId = params.getString("bundleId")
-        if (bundleId == null) {
-            result.putString("status", "STABLE")
-            return result
-        }
-
-        val impl = getInstance()
-        val statusMap = impl.notifyAppReady(bundleId)
-
-        result.putString("status", statusMap["status"] as? String ?: "STABLE")
-        statusMap["crashedBundleId"]?.let {
-            result.putString("crashedBundleId", it as String)
-        }
-
-        return result
-    }
+    override fun notifyAppReady(): WritableNativeMap = getInstance().notifyAppReady().toWritableNativeMap()
 
-    override fun getCrashHistory(): WritableNativeArray {
-        val impl = getInstance()
-        val crashHistory = impl.getCrashHistory()
-        val result = WritableNativeArray()
-        crashHistory.forEach { result.pushString(it) }
-        return result
-    }
+    override fun getCrashHistory(): WritableNativeArray = getInstance().getCrashHistory().toWritableNativeArray()
 
     override fun clearCrashHistory(): Boolean {
         val impl = getInstance()
@@ -182,6 +160,19 @@ class HotUpdaterModule internal constructor(
         return impl.getBaseURL()
     }
 
+    override fun setCohort(cohort: String) {
+        cohortService.setCohort(cohort)
+    }
+
+    override fun getCohort(): String = cohortService.getCohort()
+
+    override fun getBundleId(): String? {
+        val impl = getInstance()
+        return impl.getBundleId()
+    }
+
+    override fun getManifest(): WritableNativeMap = getInstance().getManifest().toWritableNativeMap()
+
     override fun resetChannel(promise: Promise) {
         moduleScope.launch {
             try {