@swiftpatch/react-native 2.0.0

package/android/src/main/java/com/swiftpatch/SwiftPatchModule.kt

@@ -0,0 +1,630 @@
+package com.swiftpatch
+
+import android.content.Context
+import android.content.SharedPreferences
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import kotlinx.coroutines.*
+import org.json.JSONArray
+import java.io.File
+import java.util.*
+
+class SwiftPatchModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        private const val TAG = "SwiftPatch"
+        private const val PREFS_NAME = "swiftpatch_prefs"
+
+        @JvmStatic
+        fun getJSBundleFile(context: Context): String? {
+            val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            val slotManager = SlotManager(context, prefs)
+
+            // Check for version change
+            if (slotManager.checkVersionChange()) {
+                return null
+            }
+
+            // Apply temp hash on launch
+            slotManager.applyTempHashOnLaunch()
+
+            // Get bundle from slot manager
+            return slotManager.getBundleFile()
+        }
+    }
+
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private val prefs: SharedPreferences =
+        reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+    private val bundleManager = BundleManager(reactContext)
+    private val downloadManager = DownloadManager()
+    private val patchApplier = PatchApplier()
+    private val cryptoVerifier = CryptoVerifier()
+    private val slotManager = SlotManager(reactContext, prefs)
+    private val eventQueue = EventQueue(prefs)
+    private val crashDetector = CrashDetector(prefs)
+
+    private var config: SwiftPatchConfig? = null
+    private var isDebugMode = false
+
+    override fun getName(): String = "SwiftPatch"
+
+    override fun initialize() {
+        super.initialize()
+
+        // Install crash handler
+        val signalHandler = SignalCrashHandler.init(reactApplicationContext)
+        signalHandler.installHandler()
+
+        // Check for crash marker from previous run
+        signalHandler.checkForCrashMarker()?.let { crashInfo ->
+            if (signalHandler.shouldAutoRollback(crashInfo)) {
+                val result = slotManager.rollbackProd(isAutoRollback = true)
+                eventQueue.pushEvent(
+                    type = SwiftPatchEventType.CRASH_DETECTED,
+                    metadata = mapOf(
+                        "exceptionType" to crashInfo.exceptionType,
+                        "autoRollback" to true,
+                        "rollbackResult" to result,
+                    )
+                )
+                sendEvent("SwiftPatch:rollbackOccurred", Arguments.createMap().apply {
+                    putString("reason", "Crash detected: ${crashInfo.exceptionType}, auto-rollback to $result")
+                })
+            } else {
+                eventQueue.pushEvent(
+                    type = SwiftPatchEventType.CRASH_DETECTED,
+                    metadata = mapOf(
+                        "exceptionType" to crashInfo.exceptionType,
+                        "autoRollback" to false,
+                    )
+                )
+            }
+        }
+
+        // Also check timer-based crash detection (legacy/fallback)
+        crashDetector.checkForPendingRollback { reason ->
+            sendEvent("SwiftPatch:rollbackOccurred", Arguments.createMap().apply {
+                putString("reason", reason)
+            })
+        }
+
+        // Check for version change
+        if (slotManager.checkVersionChange()) {
+            eventQueue.pushEvent(type = SwiftPatchEventType.VERSION_CHANGED)
+            sendEvent("SwiftPatch:versionChanged", Arguments.createMap().apply {
+                putString("reason", "App binary version changed, reset to default bundle")
+            })
+        }
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        scope.cancel()
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // INITIALIZATION
+    // ═══════════════════════════════════════════════════════════════
+
+    @ReactMethod
+    fun initialize(configMap: ReadableMap, promise: Promise) {
+        try {
+            config = SwiftPatchConfig(
+                deploymentKey = configMap.getString("deploymentKey")
+                    ?: throw IllegalArgumentException("deploymentKey required"),
+                serverUrl = configMap.getString("serverUrl")
+                    ?: "https://swiftpatch.hyperbrainlabs.com/api/v1",
+                publicKey = if (configMap.hasKey("publicKey") && !configMap.isNull("publicKey"))
+                    configMap.getString("publicKey") else null
+            )
+
+            bundleManager.ensureDirectoriesExist()
+            slotManager.ensureSlotDirectories()
+
+            log("Initialized with deployment key: ${config?.deploymentKey?.take(8)}...")
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("INIT_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun setDebugMode(enabled: Boolean) {
+        isDebugMode = enabled
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // MOUNT STATE
+    // ═══════════════════════════════════════════════════════════════
+
+    @ReactMethod
+    fun markMounted(promise: Promise) {
+        SignalCrashHandler.getInstance()?.markMounted()
+        promise.resolve(null)
+    }
+
+    @ReactMethod
+    fun markUnmounted(promise: Promise) {
+        SignalCrashHandler.getInstance()?.markUnmounted()
+        promise.resolve(null)
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // BUNDLE INFORMATION
+    // ═══════════════════════════════════════════════════════════════
+
+    @ReactMethod
+    fun getCurrentBundle(promise: Promise) {
+        try {
+            val env = slotManager.currentEnvironment
+
+            if (env == EnvironmentMode.STAGING) {
+                val hash = slotManager.stageNewHash
+                if (hash != null) {
+                    promise.resolve(Arguments.createMap().apply {
+                        putString("hash", hash)
+                        putString("version", "staging")
+                        putString("installedAt", "")
+                        putBoolean("isOriginal", false)
+                        putString("slot", "NEW_SLOT")
+                        putString("environment", "STAGE")
+                    })
+                } else {
+                    promise.resolve(Arguments.createMap().apply {
+                        putString("hash", "original")
+                        putString("version", "0.0.0")
+                        putString("installedAt", "")
+                        putBoolean("isOriginal", true)
+                        putString("slot", "DEFAULT_SLOT")
+                        putString("environment", "STAGE")
+                    })
+                }
+                return
+            }
+
+            val slot = slotManager.currentProdSlot
+            val hash = when (slot) {
+                SlotState.NEW_SLOT -> slotManager.prodNewHash
+                SlotState.STABLE_SLOT -> slotManager.prodStableHash
+                SlotState.DEFAULT_SLOT -> null
+            }
+
+            if (hash != null) {
+                promise.resolve(Arguments.createMap().apply {
+                    putString("hash", hash)
+                    putString("version", prefs.getString("current_bundle_version", "unknown"))
+                    putString("installedAt", prefs.getString("current_bundle_installed_at", ""))
+                    putBoolean("isOriginal", false)
+                    putString("slot", slot.value)
+                    putString("environment", "PROD")
+                })
+            } else {
+                promise.resolve(Arguments.createMap().apply {
+                    putString("hash", "original")
+                    putString("version", "0.0.0")
+                    putString("installedAt", "")
+                    putBoolean("isOriginal", true)
+                    putString("slot", "DEFAULT_SLOT")
+                    putString("environment", "PROD")
+                })
+            }
+        } catch (e: Exception) {
+            promise.reject("GET_BUNDLE_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun getSlotMetadata(promise: Promise) {
+        try {
+            val metadata = slotManager.getMetadata()
+            promise.resolve(Arguments.makeNativeMap(metadata as Map<String, Any?>))
+        } catch (e: Exception) {
+            promise.reject("META_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun getDeviceId(promise: Promise) {
+        try {
+            var deviceId = prefs.getString("device_id", null)
+            if (deviceId == null) {
+                deviceId = UUID.randomUUID().toString()
+                prefs.edit().putString("device_id", deviceId).apply()
+            }
+            promise.resolve(deviceId)
+        } catch (e: Exception) {
+            promise.reject("DEVICE_ID_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun getAppVersion(promise: Promise) {
+        try {
+            val packageInfo = reactApplicationContext.packageManager
+                .getPackageInfo(reactApplicationContext.packageName, 0)
+            promise.resolve(packageInfo.versionName ?: "0.0.0")
+        } catch (e: Exception) {
+            promise.reject("APP_VERSION_ERROR", e.message, e)
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // ENVIRONMENT SWITCHING
+    // ═══════════════════════════════════════════════════════════════
+
+    @ReactMethod
+    fun switchEnvironment(environment: String, promise: Promise) {
+        try {
+            val env = EnvironmentMode.from(environment)
+            slotManager.currentEnvironment = env
+            log("Switched environment to: $environment")
+            promise.resolve(Arguments.makeNativeMap(slotManager.getMetadata() as Map<String, Any?>))
+        } catch (e: Exception) {
+            promise.reject("ENV_ERROR", e.message, e)
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // DOWNLOAD & INSTALL
+    // ═══════════════════════════════════════════════════════════════
+
+    @ReactMethod
+    fun downloadUpdate(
+        url: String,
+        expectedHash: String,
+        isPatch: Boolean,
+        signature: String?,
+        promise: Promise
+    ) {
+        scope.launch {
+            try {
+                log("Downloading update from: $url (isPatch: $isPatch)")
+                eventQueue.pushEvent(SwiftPatchEventType.DOWNLOAD_PROD_STARTED, expectedHash)
+
+                val downloadFile = bundleManager.getDownloadFile(expectedHash)
+
+                // Download with progress (supports resume via Range header)
+                downloadManager.download(url, downloadFile) { progress ->
+                    sendEvent("SwiftPatch:downloadProgress", Arguments.createMap().apply {
+                        putDouble("downloadedBytes", progress.downloadedBytes.toDouble())
+                        putDouble("totalBytes", progress.totalBytes.toDouble())
+                        putInt("percentage", progress.percentage)
+                    })
+                }
+
+                log("Download complete, processing...")
+
+                // Decompress if needed
+                val decompressedFile = if (url.endsWith(".br")) {
+                    val decompressed = bundleManager.getDecompressedFile(expectedHash)
+                    FileUtils.decompressBrotli(downloadFile, decompressed)
+                    downloadFile.delete()
+                    decompressed
+                } else {
+                    downloadFile
+                }
+
+                // Apply patch or use as full bundle
+                val finalBundle = if (isPatch) {
+                    log("Applying patch...")
+                    val currentHash = when (slotManager.currentProdSlot) {
+                        SlotState.NEW_SLOT -> slotManager.prodNewHash
+                        SlotState.STABLE_SLOT -> slotManager.prodStableHash
+                        SlotState.DEFAULT_SLOT -> null
+                    }
+                    val currentBundleFile = if (currentHash != null) {
+                        bundleManager.getBundleFile(currentHash)
+                    } else {
+                        bundleManager.extractOriginalBundle(reactApplicationContext)
+                    }
+
+                    val patchedFile = bundleManager.getBundleFile(expectedHash)
+                    patchApplier.applyPatch(currentBundleFile, decompressedFile, patchedFile)
+                    decompressedFile.delete()
+                    patchedFile
+                } else {
+                    val bundleFile = bundleManager.getBundleFile(expectedHash)
+                    if (decompressedFile.absolutePath != bundleFile.absolutePath) {
+                        decompressedFile.renameTo(bundleFile)
+                    }
+                    bundleFile
+                }
+
+                // Verify hash
+                log("Verifying hash...")
+                val actualHash = cryptoVerifier.sha256(finalBundle)
+                if (actualHash != expectedHash) {
+                    finalBundle.delete()
+                    eventQueue.pushEvent(SwiftPatchEventType.DOWNLOAD_PROD_FAILED, expectedHash, "Hash mismatch")
+                    throw SecurityException("Hash mismatch: expected $expectedHash, got $actualHash")
+                }
+
+                // Verify signature
+                if (signature != null && config?.publicKey != null) {
+                    log("Verifying signature...")
+                    if (!cryptoVerifier.verifySignature(actualHash, signature, config!!.publicKey!!)) {
+                        finalBundle.delete()
+                        eventQueue.pushEvent(SwiftPatchEventType.DOWNLOAD_PROD_FAILED, expectedHash, "Signature invalid")
+                        throw SecurityException("Signature verification failed")
+                    }
+                }
+
+                // Set as temp hash (deferred apply)
+                slotManager.prodTempHash = expectedHash
+
+                eventQueue.pushEvent(SwiftPatchEventType.DOWNLOAD_PROD_COMPLETED, expectedHash)
+                log("Download and verification complete, tempHash set: $expectedHash")
+                withContext(Dispatchers.Main) { promise.resolve(null) }
+
+            } catch (e: Exception) {
+                log("Download failed: ${e.message}")
+                eventQueue.pushEvent(SwiftPatchEventType.DOWNLOAD_PROD_FAILED, expectedHash, e.message)
+                withContext(Dispatchers.Main) { promise.reject("DOWNLOAD_ERROR", e.message, e) }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun downloadStageBundle(url: String, expectedHash: String, promise: Promise) {
+        scope.launch {
+            try {
+                eventQueue.pushEvent(SwiftPatchEventType.DOWNLOAD_STAGE_STARTED, expectedHash)
+
+                val downloadFile = bundleManager.getDownloadFile("stage_$expectedHash")
+
+                downloadManager.download(url, downloadFile) { progress ->
+                    sendEvent("SwiftPatch:downloadProgress", Arguments.createMap().apply {
+                        putDouble("downloadedBytes", progress.downloadedBytes.toDouble())
+                        putDouble("totalBytes", progress.totalBytes.toDouble())
+                        putInt("percentage", progress.percentage)
+                    })
+                }
+
+                val stageDir = File(File(reactApplicationContext.filesDir, "swiftpatch/stage"), "new")
+                stageDir.mkdirs()
+                val destFile = File(stageDir, "$expectedHash.bundle")
+                destFile.delete()
+                downloadFile.renameTo(destFile)
+
+                slotManager.stageNewHash = expectedHash
+                eventQueue.pushEvent(SwiftPatchEventType.DOWNLOAD_STAGE_COMPLETED, expectedHash)
+                withContext(Dispatchers.Main) { promise.resolve(null) }
+
+            } catch (e: Exception) {
+                eventQueue.pushEvent(SwiftPatchEventType.DOWNLOAD_STAGE_FAILED, expectedHash, e.message)
+                withContext(Dispatchers.Main) { promise.reject("DOWNLOAD_ERROR", e.message, e) }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun installUpdate(bundleHash: String, promise: Promise) {
+        try {
+            if (slotManager.prodTempHash == null) {
+                val pendingHash = prefs.getString("pending_bundle_hash", null)
+                if (pendingHash != bundleHash) {
+                    throw IllegalStateException("No pending bundle found")
+                }
+            }
+
+            prefs.edit()
+                .putBoolean("pending_install_confirmation", true)
+                .putLong("install_timestamp", System.currentTimeMillis())
+                .apply()
+
+            log("Update marked for install: $bundleHash")
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("INSTALL_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun hasPendingInstall(promise: Promise) {
+        try {
+            val hasPending = slotManager.prodTempHash != null ||
+                prefs.getString("pending_bundle_hash", null) != null
+            promise.resolve(hasPending)
+        } catch (e: Exception) {
+            promise.reject("ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun confirmInstall(promise: Promise) {
+        try {
+            prefs.edit()
+                .putBoolean("pending_install_confirmation", false)
+                .putInt("crash_count", 0)
+                .apply()
+
+            slotManager.cleanup()
+            log("Install confirmed, cleaned up old bundles")
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("ERROR", e.message, e)
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // STABILIZATION
+    // ═══════════════════════════════════════════════════════════════
+
+    @ReactMethod
+    fun stabilize(promise: Promise) {
+        try {
+            val success = slotManager.stabilize()
+            if (success) {
+                eventQueue.pushEvent(SwiftPatchEventType.STABILIZE_PROD, slotManager.prodStableHash)
+                log("Bundle stabilized (promoted NEW → STABLE)")
+                promise.resolve(Arguments.makeNativeMap(slotManager.getMetadata() as Map<String, Any?>))
+            } else {
+                promise.reject("STABILIZE_ERROR", "No bundle in NEW slot to stabilize", null)
+            }
+        } catch (e: Exception) {
+            promise.reject("STABILIZE_ERROR", e.message, e)
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // RESTART & ROLLBACK
+    // ═══════════════════════════════════════════════════════════════
+
+    @ReactMethod
+    fun restart() {
+        log("Restarting app...")
+        val intent = reactApplicationContext.packageManager
+            .getLaunchIntentForPackage(reactApplicationContext.packageName)
+        intent?.addFlags(
+            android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP or
+                    android.content.Intent.FLAG_ACTIVITY_NEW_TASK or
+                    android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK
+        )
+        reactApplicationContext.startActivity(intent)
+        android.os.Process.killProcess(android.os.Process.myPid())
+    }
+
+    @ReactMethod
+    fun rollback(promise: Promise) {
+        try {
+            val result = slotManager.rollbackProd(isAutoRollback = false)
+            prefs.edit()
+                .putBoolean("pending_install_confirmation", false)
+                .putInt("crash_count", 0)
+                .apply()
+            eventQueue.pushEvent(SwiftPatchEventType.ROLLBACK_PROD, metadata = mapOf("result" to result, "manual" to true))
+            log("Rollback complete: $result")
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.reject("ROLLBACK_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun clearPendingUpdate(promise: Promise) {
+        try {
+            slotManager.prodTempHash = null
+
+            val pendingPath = prefs.getString("pending_bundle_path", null)
+            if (pendingPath != null) File(pendingPath).delete()
+
+            prefs.edit()
+                .remove("pending_bundle_hash")
+                .remove("pending_bundle_path")
+                .apply()
+
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("ERROR", e.message, e)
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // EVENT QUEUE
+    // ═══════════════════════════════════════════════════════════════
+
+    @ReactMethod
+    fun popEvents(promise: Promise) {
+        try {
+            val events = eventQueue.popEvents()
+            val result = Arguments.createArray()
+            for (i in 0 until events.length()) {
+                result.pushMap(Arguments.makeNativeMap(jsonObjectToMap(events.getJSONObject(i))))
+            }
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.reject("EVENT_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun acknowledgeEvents(eventIdsJson: String, promise: Promise) {
+        try {
+            val ids = JSONArray(eventIdsJson)
+            val idList = mutableListOf<String>()
+            for (i in 0 until ids.length()) {
+                idList.add(ids.getString(i))
+            }
+            eventQueue.acknowledgeEvents(idList)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("EVENT_ERROR", e.message, e)
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // LAUNCH TRACKING
+    // ═══════════════════════════════════════════════════════════════
+
+    @ReactMethod
+    fun recordSuccessfulLaunch(bundleHash: String, promise: Promise) {
+        try {
+            val key = "launch_count_$bundleHash"
+            val count = prefs.getInt(key, 0) + 1
+            prefs.edit().putInt(key, count).apply()
+
+            if (count == 1) {
+                eventQueue.pushEvent(SwiftPatchEventType.INSTALLED_PROD, bundleHash)
+            }
+
+            promise.resolve(count)
+        } catch (e: Exception) {
+            promise.reject("LAUNCH_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun getLaunchCount(bundleHash: String, promise: Promise) {
+        try {
+            promise.resolve(prefs.getInt("launch_count_$bundleHash", 0))
+        } catch (e: Exception) {
+            promise.reject("LAUNCH_ERROR", e.message, e)
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // STATUS REPORTING
+    // ═══════════════════════════════════════════════════════════════
+
+    @ReactMethod
+    fun reportStatus(releaseId: String, status: String, promise: Promise) {
+        promise.resolve(null)
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // HELPERS
+    // ═══════════════════════════════════════════════════════════════
+
+    private fun sendEvent(eventName: String, params: WritableMap) {
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+
+    private fun log(message: String) {
+        if (isDebugMode) {
+            android.util.Log.d(TAG, message)
+        }
+    }
+
+    private fun jsonObjectToMap(json: org.json.JSONObject): Map<String, Any?> {
+        val map = mutableMapOf<String, Any?>()
+        json.keys().forEach { key ->
+            val value = json.opt(key)
+            map[key] = when (value) {
+                is org.json.JSONObject -> jsonObjectToMap(value)
+                org.json.JSONObject.NULL -> null
+                else -> value
+            }
+        }
+        return map
+    }
+}
+
+data class SwiftPatchConfig(
+    val deploymentKey: String,
+    val serverUrl: String,
+    val publicKey: String?
+)

package/android/src/main/java/com/swiftpatch/SwiftPatchPackage.kt

@@ -0,0 +1,21 @@
+package com.swiftpatch
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class SwiftPatchPackage : ReactPackage {
+
+    override fun createNativeModules(
+        reactContext: ReactApplicationContext
+    ): List<NativeModule> {
+        return listOf(SwiftPatchModule(reactContext))
+    }
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/android/src/main/jni/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.22)
+project(bspatch)
+
+add_library(bspatch SHARED
+    bspatch_jni.c
+    bspatch.c
+)
+
+target_include_directories(bspatch PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+
+find_library(log-lib log)
+target_link_libraries(bspatch ${log-lib})