@swiftpatch/react-native 2.0.0

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

@@ -0,0 +1,79 @@
+package com.swiftpatch
+
+import android.content.SharedPreferences
+
+class CrashDetector(
+    private val prefs: SharedPreferences
+) {
+    companion object {
+        private const val CRASH_DETECTION_WINDOW_MS = 10_000L // 10 seconds
+        private const val MAX_CRASHES_BEFORE_ROLLBACK = 2
+    }
+
+    /**
+     * Check if we need to rollback due to a crash after install.
+     * Called during native module initialization.
+     */
+    fun checkForPendingRollback(onRollback: (String) -> Unit) {
+        val pendingConfirmation =
+            prefs.getBoolean("pending_install_confirmation", false)
+        if (!pendingConfirmation) return
+
+        val installTimestamp = prefs.getLong("install_timestamp", 0)
+        val currentTime = System.currentTimeMillis()
+
+        if (currentTime - installTimestamp < CRASH_DETECTION_WINDOW_MS) {
+            // Within crash detection window - this might be a crash-restart cycle
+            val crashCount = prefs.getInt("crash_count", 0) + 1
+
+            if (crashCount >= MAX_CRASHES_BEFORE_ROLLBACK) {
+                // Too many crashes, rollback
+                val reason = "Automatic rollback after $crashCount crashes"
+                performRollback(reason)
+                onRollback("Crashed $crashCount times within detection window")
+            } else {
+                prefs.edit().putInt("crash_count", crashCount).apply()
+            }
+        } else {
+            // We survived the crash detection window, mark as stable
+            confirmStable()
+        }
+    }
+
+    /**
+     * Mark the current installation as stable.
+     * Called from JS after the app has been running stably.
+     */
+    fun confirmStable() {
+        prefs.edit()
+            .putBoolean("pending_install_confirmation", false)
+            .putInt("crash_count", 0)
+            .apply()
+    }
+
+    private fun performRollback(reason: String) {
+        val previousHash = prefs.getString("previous_bundle_hash", null)
+        val previousPath = prefs.getString("previous_bundle_path", null)
+
+        if (previousHash != null && previousPath != null) {
+            prefs.edit()
+                .putString("current_bundle_hash", previousHash)
+                .putString("current_bundle_path", previousPath)
+                .remove("previous_bundle_hash")
+                .remove("previous_bundle_path")
+                .putBoolean("pending_install_confirmation", false)
+                .putInt("crash_count", 0)
+                .putString("last_rollback_reason", reason)
+                .apply()
+        } else {
+            // Rollback to original bundled version
+            prefs.edit()
+                .remove("current_bundle_hash")
+                .remove("current_bundle_path")
+                .putBoolean("pending_install_confirmation", false)
+                .putInt("crash_count", 0)
+                .putString("last_rollback_reason", reason)
+                .apply()
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+package com.swiftpatch
+
+import android.util.Base64
+import java.io.File
+import java.io.FileInputStream
+import java.security.KeyFactory
+import java.security.MessageDigest
+import java.security.Signature
+import java.security.spec.X509EncodedKeySpec
+
+class CryptoVerifier {
+
+    /**
+     * Calculate SHA-256 hash of a file
+     */
+    fun sha256(file: File): String {
+        val digest = MessageDigest.getInstance("SHA-256")
+
+        FileInputStream(file).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) }
+    }
+
+    /**
+     * Verify RSA signature
+     *
+     * @param data The data that was signed (usually the bundle hash)
+     * @param signatureBase64 The signature in base64 format
+     * @param publicKeyPem The public key in PEM format
+     */
+    fun verifySignature(
+        data: String,
+        signatureBase64: String,
+        publicKeyPem: String
+    ): Boolean {
+        return try {
+            // Parse public key from PEM
+            val publicKeyBytes = Base64.decode(
+                publicKeyPem
+                    .replace("-----BEGIN PUBLIC KEY-----", "")
+                    .replace("-----END PUBLIC KEY-----", "")
+                    .replace("\n", "")
+                    .replace("\r", "")
+                    .trim(),
+                Base64.DEFAULT
+            )
+
+            val keySpec = X509EncodedKeySpec(publicKeyBytes)
+            val keyFactory = KeyFactory.getInstance("RSA")
+            val publicKey = keyFactory.generatePublic(keySpec)
+
+            // Verify signature
+            val signature = Signature.getInstance("SHA256withRSA")
+            signature.initVerify(publicKey)
+            signature.update(data.toByteArray(Charsets.UTF_8))
+
+            val signatureBytes = Base64.decode(signatureBase64, Base64.DEFAULT)
+            signature.verify(signatureBytes)
+        } catch (_: Exception) {
+            false
+        }
+    }
+}

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

@@ -0,0 +1,120 @@
+package com.swiftpatch
+
+import java.io.File
+import java.io.FileOutputStream
+import java.io.RandomAccessFile
+import java.net.HttpURLConnection
+import java.net.URL
+
+data class DownloadProgress(
+    val downloadedBytes: Long,
+    val totalBytes: Long,
+    val percentage: Int
+)
+
+class DownloadManager {
+
+    private var lastProgressTime = 0L
+    private val progressThrottleMs = 300L // Throttle progress callbacks
+
+    fun download(
+        urlString: String,
+        outputFile: File,
+        onProgress: (DownloadProgress) -> Unit
+    ) {
+        val url = URL(urlString)
+        val connection = url.openConnection() as HttpURLConnection
+
+        try {
+            connection.requestMethod = "GET"
+            connection.connectTimeout = 30_000
+            connection.readTimeout = 60_000
+
+            // Resume download support
+            var downloadedBytes = 0L
+            if (outputFile.exists() && outputFile.length() > 0) {
+                downloadedBytes = outputFile.length()
+                connection.setRequestProperty("Range", "bytes=$downloadedBytes-")
+            }
+
+            connection.connect()
+
+            val responseCode = connection.responseCode
+
+            // Handle resume response
+            val isResume = responseCode == 206
+            if (responseCode !in listOf(200, 206)) {
+                throw RuntimeException("Download failed with HTTP $responseCode")
+            }
+
+            val contentLength = connection.contentLengthLong
+            val totalBytes = if (isResume) {
+                downloadedBytes + contentLength
+            } else {
+                contentLength
+            }
+
+            // Ensure parent directory exists
+            outputFile.parentFile?.mkdirs()
+
+            connection.inputStream.use { input ->
+                val outputStream = if (isResume) {
+                    // Append to existing file
+                    FileOutputStream(outputFile, true)
+                } else {
+                    downloadedBytes = 0
+                    FileOutputStream(outputFile)
+                }
+
+                outputStream.use { output ->
+                    val buffer = ByteArray(8192)
+                    var bytesRead: Int
+
+                    while (input.read(buffer).also { bytesRead = it } != -1) {
+                        output.write(buffer, 0, bytesRead)
+                        downloadedBytes += bytesRead
+
+                        // Throttle progress callbacks
+                        val now = System.currentTimeMillis()
+                        if (now - lastProgressTime >= progressThrottleMs) {
+                            lastProgressTime = now
+                            val percentage = if (totalBytes > 0) {
+                                ((downloadedBytes * 100) / totalBytes).toInt()
+                            } else {
+                                0
+                            }
+
+                            onProgress(
+                                DownloadProgress(
+                                    downloadedBytes = downloadedBytes,
+                                    totalBytes = if (totalBytes > 0) totalBytes else downloadedBytes,
+                                    percentage = percentage.coerceIn(0, 100)
+                                )
+                            )
+                        }
+                    }
+                }
+            }
+
+            // Final progress callback
+            val finalPercentage = if (totalBytes > 0) {
+                ((downloadedBytes * 100) / totalBytes).toInt()
+            } else { 100 }
+
+            onProgress(
+                DownloadProgress(
+                    downloadedBytes = downloadedBytes,
+                    totalBytes = if (totalBytes > 0) totalBytes else downloadedBytes,
+                    percentage = finalPercentage.coerceIn(0, 100)
+                )
+            )
+
+            if (!outputFile.exists() || outputFile.length() == 0L) {
+                throw RuntimeException("Downloaded file is empty")
+            }
+
+        } finally {
+            connection.disconnect()
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+package com.swiftpatch
+
+import android.content.SharedPreferences
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.UUID
+import java.util.concurrent.locks.ReentrantReadWriteLock
+import kotlin.concurrent.read
+import kotlin.concurrent.write
+
+enum class SwiftPatchEventType(val value: String) {
+    DOWNLOAD_PROD_STARTED("DOWNLOAD_PROD_STARTED"),
+    DOWNLOAD_PROD_COMPLETED("DOWNLOAD_PROD_COMPLETED"),
+    DOWNLOAD_PROD_FAILED("DOWNLOAD_PROD_FAILED"),
+    INSTALLED_PROD("INSTALLED_PROD"),
+    ROLLBACK_PROD("ROLLBACK_PROD"),
+    STABILIZE_PROD("STABILIZE_PROD"),
+    CORRUPTION_PROD("CORRUPTION_PROD"),
+    DOWNLOAD_STAGE_STARTED("DOWNLOAD_STAGE_STARTED"),
+    DOWNLOAD_STAGE_COMPLETED("DOWNLOAD_STAGE_COMPLETED"),
+    DOWNLOAD_STAGE_FAILED("DOWNLOAD_STAGE_FAILED"),
+    INSTALLED_STAGE("INSTALLED_STAGE"),
+    SYNC_ERROR("SYNC_ERROR"),
+    VERSION_CHANGED("VERSION_CHANGED"),
+    CRASH_DETECTED("CRASH_DETECTED"),
+}
+
+class EventQueue(private val prefs: SharedPreferences) {
+
+    private val lock = ReentrantReadWriteLock()
+    private val eventsKey = "event_queue"
+
+    fun pushEvent(
+        type: SwiftPatchEventType,
+        releaseHash: String? = null,
+        errorMessage: String? = null,
+        metadata: Map<String, Any>? = null
+    ) {
+        lock.write {
+            val events = loadEvents()
+            val event = JSONObject().apply {
+                put("id", UUID.randomUUID().toString())
+                put("eventType", type.value)
+                put("timestamp", System.currentTimeMillis().toDouble() / 1000.0)
+                releaseHash?.let { put("releaseHash", it) }
+                errorMessage?.let { put("errorMessage", it) }
+                metadata?.let { meta ->
+                    val metaObj = JSONObject()
+                    meta.forEach { (key, value) -> metaObj.put(key, value) }
+                    put("metadata", metaObj)
+                }
+            }
+            events.put(event)
+            saveEvents(events)
+        }
+    }
+
+    fun popEvents(): JSONArray {
+        return lock.read {
+            loadEvents()
+        }
+    }
+
+    fun acknowledgeEvents(eventIds: List<String>) {
+        lock.write {
+            val events = loadEvents()
+            val filtered = JSONArray()
+            for (i in 0 until events.length()) {
+                val event = events.getJSONObject(i)
+                if (event.optString("id") !in eventIds) {
+                    filtered.put(event)
+                }
+            }
+            saveEvents(filtered)
+        }
+    }
+
+    private fun loadEvents(): JSONArray {
+        val raw = prefs.getString(eventsKey, null) ?: return JSONArray()
+        return try { JSONArray(raw) } catch (_: Exception) { JSONArray() }
+    }
+
+    private fun saveEvents(events: JSONArray) {
+        prefs.edit().putString(eventsKey, events.toString()).apply()
+    }
+}

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

@@ -0,0 +1,60 @@
+package com.swiftpatch
+
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.util.zip.GZIPInputStream
+
+object FileUtils {
+
+    /**
+     * Decompress a brotli-compressed file.
+     *
+     * Note: For production, integrate a proper Brotli decoder (e.g., org.brotli:dec).
+     * This implementation handles gzip as a fallback.
+     */
+    fun decompressBrotli(input: File, output: File) {
+        // Attempt gzip decompression as a practical fallback.
+        // For true brotli support, add org.brotli:dec dependency.
+        try {
+            GZIPInputStream(FileInputStream(input)).use { gzis ->
+                FileOutputStream(output).use { fos ->
+                    gzis.copyTo(fos)
+                }
+            }
+        } catch (_: Exception) {
+            // If not gzip, just copy directly (assuming uncompressed or
+            // pre-decompressed by the server)
+            input.copyTo(output, overwrite = true)
+        }
+    }
+
+    /**
+     * Safely delete a file, ignoring errors
+     */
+    fun safeDelete(file: File) {
+        try {
+            if (file.exists()) {
+                file.delete()
+            }
+        } catch (_: Exception) {
+            // Ignore deletion errors
+        }
+    }
+
+    /**
+     * Get the size of a file in a human-readable format
+     */
+    fun humanReadableSize(bytes: Long): String {
+        val units = arrayOf("B", "KB", "MB", "GB")
+        var size = bytes.toDouble()
+        var unitIndex = 0
+
+        while (size >= 1024 && unitIndex < units.size - 1) {
+            size /= 1024
+            unitIndex++
+        }
+
+        return "%.1f %s".format(size, units[unitIndex])
+    }
+}

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

@@ -0,0 +1,60 @@
+package com.swiftpatch
+
+import java.io.File
+
+class PatchApplier {
+
+    companion object {
+        init {
+            System.loadLibrary("bspatch")
+        }
+    }
+
+    /**
+     * Apply a bsdiff patch to create a new file
+     *
+     * @param oldFile The original file
+     * @param patchFile The patch file
+     * @param newFile The output file (will be created)
+     */
+    fun applyPatch(oldFile: File, patchFile: File, newFile: File) {
+        if (!oldFile.exists()) {
+            throw IllegalArgumentException(
+                "Old file does not exist: ${oldFile.absolutePath}"
+            )
+        }
+        if (!patchFile.exists()) {
+            throw IllegalArgumentException(
+                "Patch file does not exist: ${patchFile.absolutePath}"
+            )
+        }
+
+        // Ensure parent directory exists
+        newFile.parentFile?.mkdirs()
+
+        // Call native bspatch
+        val result = nativeApplyPatch(
+            oldFile.absolutePath,
+            patchFile.absolutePath,
+            newFile.absolutePath
+        )
+
+        if (result != 0) {
+            newFile.delete()
+            throw RuntimeException("bspatch failed with code: $result")
+        }
+
+        if (!newFile.exists()) {
+            throw RuntimeException("bspatch did not create output file")
+        }
+    }
+
+    /**
+     * Native JNI method for applying bspatch
+     */
+    private external fun nativeApplyPatch(
+        oldPath: String,
+        patchPath: String,
+        newPath: String
+    ): Int
+}

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

@@ -0,0 +1,84 @@
+package com.swiftpatch
+
+import android.content.Context
+import org.json.JSONObject
+import java.io.File
+
+class SignalCrashHandler private constructor(private val context: Context) {
+
+    companion object {
+        @Volatile
+        private var instance: SignalCrashHandler? = null
+
+        fun init(context: Context): SignalCrashHandler {
+            return instance ?: synchronized(this) {
+                instance ?: SignalCrashHandler(context.applicationContext).also { instance = it }
+            }
+        }
+
+        fun getInstance(): SignalCrashHandler? = instance
+    }
+
+    private val crashMarkerFile: File
+        get() = File(context.filesDir, "swiftpatch/crash_marker.json")
+
+    @Volatile
+    var isMounted = false
+        private set
+
+    fun markMounted() { isMounted = true }
+    fun markUnmounted() { isMounted = false }
+
+    fun installHandler() {
+        val defaultHandler = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            writeCrashMarker(throwable)
+            defaultHandler?.uncaughtException(thread, throwable)
+        }
+    }
+
+    private fun writeCrashMarker(throwable: Throwable) {
+        try {
+            val crashInfo = JSONObject().apply {
+                put("exceptionType", throwable.javaClass.name)
+                put("message", throwable.message ?: "")
+                put("timestamp", System.currentTimeMillis().toDouble() / 1000.0)
+                put("wasMounted", isMounted)
+            }
+            crashMarkerFile.parentFile?.mkdirs()
+            crashMarkerFile.writeText(crashInfo.toString())
+        } catch (_: Exception) {
+            // Best effort
+        }
+    }
+
+    data class CrashMarkerInfo(
+        val exceptionType: String,
+        val message: String,
+        val timestamp: Double,
+        val wasMounted: Boolean
+    )
+
+    fun checkForCrashMarker(): CrashMarkerInfo? {
+        if (!crashMarkerFile.exists()) return null
+
+        return try {
+            val json = JSONObject(crashMarkerFile.readText())
+            crashMarkerFile.delete()
+
+            CrashMarkerInfo(
+                exceptionType = json.optString("exceptionType", "Unknown"),
+                message = json.optString("message", ""),
+                timestamp = json.optDouble("timestamp", 0.0),
+                wasMounted = json.optBoolean("wasMounted", false)
+            )
+        } catch (_: Exception) {
+            crashMarkerFile.delete()
+            null
+        }
+    }
+
+    fun shouldAutoRollback(crashInfo: CrashMarkerInfo): Boolean {
+        return !crashInfo.wasMounted
+    }
+}