@swiftpatch/react-native 2.0.0

package/android/src/main/jni/bspatch.c

@@ -0,0 +1,188 @@
+/*-
+ * Copyright 2003-2005 Colin Percival
+ * Copyright 2012 Matthew Endsley
+ * All rights reserved
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted providing that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "bspatch.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+static int64_t offtin(uint8_t *buf)
+{
+    int64_t y;
+
+    y = buf[7] & 0x7F;
+    y = y * 256; y += buf[6];
+    y = y * 256; y += buf[5];
+    y = y * 256; y += buf[4];
+    y = y * 256; y += buf[3];
+    y = y * 256; y += buf[2];
+    y = y * 256; y += buf[1];
+    y = y * 256; y += buf[0];
+
+    if (buf[7] & 0x80) y = -y;
+
+    return y;
+}
+
+int bspatch(const uint8_t* old_data, int64_t old_size,
+            uint8_t** new_data, int64_t* new_size,
+            const uint8_t* patch_data, int64_t patch_size)
+{
+    int64_t newsize;
+    int64_t bzctrllen, bzdatalen;
+    uint8_t header[32];
+    uint8_t buf[8];
+    int64_t oldpos, newpos;
+    int64_t ctrl[3];
+    int64_t i;
+    const uint8_t *ctrl_block, *diff_block, *extra_block;
+    uint8_t *new_buf;
+
+    if (patch_size < 32) return -1;
+
+    /* Read header */
+    memcpy(header, patch_data, 32);
+
+    /* Check for appropriate magic */
+    if (memcmp(header, "BSDIFF40", 8) != 0) return -1;
+
+    /* Read lengths from header */
+    bzctrllen = offtin(header + 8);
+    bzdatalen = offtin(header + 16);
+    newsize = offtin(header + 24);
+
+    if (bzctrllen < 0 || bzdatalen < 0 || newsize < 0) return -1;
+
+    /* Set up pointers into patch data */
+    ctrl_block = patch_data + 32;
+    diff_block = ctrl_block + bzctrllen;
+    extra_block = diff_block + bzdatalen;
+
+    /* Allocate new buffer */
+    new_buf = (uint8_t*)malloc(newsize + 1);
+    if (new_buf == NULL) return -1;
+
+    oldpos = 0;
+    newpos = 0;
+
+    while (newpos < newsize) {
+        /* Read control data */
+        for (i = 0; i < 3; i++) {
+            memcpy(buf, ctrl_block, 8);
+            ctrl_block += 8;
+            ctrl[i] = offtin(buf);
+        }
+
+        /* Sanity check */
+        if (newpos + ctrl[0] > newsize) {
+            free(new_buf);
+            return -1;
+        }
+
+        /* Read diff string */
+        memcpy(new_buf + newpos, diff_block, ctrl[0]);
+        diff_block += ctrl[0];
+
+        /* Add old data to diff string */
+        for (i = 0; i < ctrl[0]; i++) {
+            if ((oldpos + i >= 0) && (oldpos + i < old_size)) {
+                new_buf[newpos + i] += old_data[oldpos + i];
+            }
+        }
+
+        /* Adjust pointers */
+        newpos += ctrl[0];
+        oldpos += ctrl[0];
+
+        /* Sanity check */
+        if (newpos + ctrl[1] > newsize) {
+            free(new_buf);
+            return -1;
+        }
+
+        /* Read extra string */
+        memcpy(new_buf + newpos, extra_block, ctrl[1]);
+        extra_block += ctrl[1];
+
+        newpos += ctrl[1];
+        oldpos += ctrl[2];
+    }
+
+    *new_data = new_buf;
+    *new_size = newsize;
+
+    return 0;
+}
+
+int bspatch_files(const char* old_path, const char* patch_path, const char* new_path)
+{
+    FILE *f;
+    uint8_t *old_data = NULL, *patch_data = NULL, *new_data = NULL;
+    int64_t old_size, patch_size, new_size;
+    int result = -1;
+
+    /* Read old file */
+    f = fopen(old_path, "rb");
+    if (f == NULL) goto cleanup;
+    fseek(f, 0, SEEK_END);
+    old_size = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    old_data = (uint8_t*)malloc(old_size);
+    if (old_data == NULL) { fclose(f); goto cleanup; }
+    if (fread(old_data, 1, old_size, f) != (size_t)old_size) { fclose(f); goto cleanup; }
+    fclose(f);
+
+    /* Read patch file */
+    f = fopen(patch_path, "rb");
+    if (f == NULL) goto cleanup;
+    fseek(f, 0, SEEK_END);
+    patch_size = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    patch_data = (uint8_t*)malloc(patch_size);
+    if (patch_data == NULL) { fclose(f); goto cleanup; }
+    if (fread(patch_data, 1, patch_size, f) != (size_t)patch_size) { fclose(f); goto cleanup; }
+    fclose(f);
+
+    /* Apply patch */
+    if (bspatch(old_data, old_size, &new_data, &new_size, patch_data, patch_size) != 0)
+        goto cleanup;
+
+    /* Write new file */
+    f = fopen(new_path, "wb");
+    if (f == NULL) goto cleanup;
+    if (fwrite(new_data, 1, new_size, f) != (size_t)new_size) { fclose(f); goto cleanup; }
+    fclose(f);
+
+    result = 0;
+
+cleanup:
+    free(old_data);
+    free(patch_data);
+    free(new_data);
+    return result;
+}

package/android/src/main/jni/bspatch.h

@@ -0,0 +1,57 @@
+/*-
+ * Copyright 2003-2005 Colin Percival
+ * All rights reserved
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted providing that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef BSPATCH_H
+#define BSPATCH_H
+
+#include <stdint.h>
+
+/**
+ * Apply a bsdiff patch.
+ *
+ * @param old_data Pointer to the old file data
+ * @param old_size Size of the old file
+ * @param new_data Output pointer that will be allocated with the new file data
+ * @param new_size Output size of the new file
+ * @param patch_data Pointer to the patch file data
+ * @param patch_size Size of the patch file
+ * @return 0 on success, -1 on failure
+ */
+int bspatch(const uint8_t* old_data, int64_t old_size,
+            uint8_t** new_data, int64_t* new_size,
+            const uint8_t* patch_data, int64_t patch_size);
+
+/**
+ * Apply a bsdiff patch using file paths.
+ *
+ * @param old_path Path to the old file
+ * @param patch_path Path to the patch file
+ * @param new_path Path to write the new file
+ * @return 0 on success, non-zero on failure
+ */
+int bspatch_files(const char* old_path, const char* patch_path, const char* new_path);
+
+#endif /* BSPATCH_H */

package/android/src/main/jni/bspatch_jni.c

@@ -0,0 +1,28 @@
+/*
+ * JNI wrapper for bspatch
+ */
+
+#include <jni.h>
+#include <string.h>
+#include "bspatch.h"
+
+JNIEXPORT jint JNICALL
+Java_com_swiftpatch_PatchApplier_nativeApplyPatch(
+    JNIEnv *env,
+    jobject thiz,
+    jstring old_path,
+    jstring patch_path,
+    jstring new_path)
+{
+    const char *old_path_str = (*env)->GetStringUTFChars(env, old_path, NULL);
+    const char *patch_path_str = (*env)->GetStringUTFChars(env, patch_path, NULL);
+    const char *new_path_str = (*env)->GetStringUTFChars(env, new_path, NULL);
+
+    int result = bspatch_files(old_path_str, patch_path_str, new_path_str);
+
+    (*env)->ReleaseStringUTFChars(env, old_path, old_path_str);
+    (*env)->ReleaseStringUTFChars(env, patch_path, patch_path_str);
+    (*env)->ReleaseStringUTFChars(env, new_path, new_path_str);
+
+    return result;
+}

package/ios/Libraries/bspatch/bspatch.c

@@ -0,0 +1,188 @@
+/*-
+ * Copyright 2003-2005 Colin Percival
+ * Copyright 2012 Matthew Endsley
+ * All rights reserved
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted providing that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "bspatch.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+static int64_t offtin(uint8_t *buf)
+{
+    int64_t y;
+
+    y = buf[7] & 0x7F;
+    y = y * 256; y += buf[6];
+    y = y * 256; y += buf[5];
+    y = y * 256; y += buf[4];
+    y = y * 256; y += buf[3];
+    y = y * 256; y += buf[2];
+    y = y * 256; y += buf[1];
+    y = y * 256; y += buf[0];
+
+    if (buf[7] & 0x80) y = -y;
+
+    return y;
+}
+
+static int bspatch_internal(const uint8_t* old_data, int64_t old_size,
+                            uint8_t** new_data, int64_t* new_size,
+                            const uint8_t* patch_data, int64_t patch_size)
+{
+    int64_t newsize;
+    int64_t bzctrllen, bzdatalen;
+    uint8_t header[32];
+    uint8_t buf[8];
+    int64_t oldpos, newpos;
+    int64_t ctrl[3];
+    int64_t i;
+    const uint8_t *ctrl_block, *diff_block, *extra_block;
+    uint8_t *new_buf;
+
+    if (patch_size < 32) return -1;
+
+    /* Read header */
+    memcpy(header, patch_data, 32);
+
+    /* Check for appropriate magic */
+    if (memcmp(header, "BSDIFF40", 8) != 0) return -1;
+
+    /* Read lengths from header */
+    bzctrllen = offtin(header + 8);
+    bzdatalen = offtin(header + 16);
+    newsize = offtin(header + 24);
+
+    if (bzctrllen < 0 || bzdatalen < 0 || newsize < 0) return -1;
+
+    /* Set up pointers into patch data */
+    ctrl_block = patch_data + 32;
+    diff_block = ctrl_block + bzctrllen;
+    extra_block = diff_block + bzdatalen;
+
+    /* Allocate new buffer */
+    new_buf = (uint8_t*)malloc((size_t)(newsize + 1));
+    if (new_buf == NULL) return -1;
+
+    oldpos = 0;
+    newpos = 0;
+
+    while (newpos < newsize) {
+        /* Read control data */
+        for (i = 0; i < 3; i++) {
+            memcpy(buf, ctrl_block, 8);
+            ctrl_block += 8;
+            ctrl[i] = offtin(buf);
+        }
+
+        /* Sanity check */
+        if (newpos + ctrl[0] > newsize) {
+            free(new_buf);
+            return -1;
+        }
+
+        /* Read diff string */
+        memcpy(new_buf + newpos, diff_block, (size_t)ctrl[0]);
+        diff_block += ctrl[0];
+
+        /* Add old data to diff string */
+        for (i = 0; i < ctrl[0]; i++) {
+            if ((oldpos + i >= 0) && (oldpos + i < old_size)) {
+                new_buf[newpos + i] += old_data[oldpos + i];
+            }
+        }
+
+        /* Adjust pointers */
+        newpos += ctrl[0];
+        oldpos += ctrl[0];
+
+        /* Sanity check */
+        if (newpos + ctrl[1] > newsize) {
+            free(new_buf);
+            return -1;
+        }
+
+        /* Read extra string */
+        memcpy(new_buf + newpos, extra_block, (size_t)ctrl[1]);
+        extra_block += ctrl[1];
+
+        newpos += ctrl[1];
+        oldpos += ctrl[2];
+    }
+
+    *new_data = new_buf;
+    *new_size = newsize;
+
+    return 0;
+}
+
+int bspatch_files(const char* old_path, const char* patch_path, const char* new_path)
+{
+    FILE *f;
+    uint8_t *old_data = NULL, *patch_data = NULL, *new_data = NULL;
+    int64_t old_size, patch_size, new_size;
+    int result = -1;
+
+    /* Read old file */
+    f = fopen(old_path, "rb");
+    if (f == NULL) goto cleanup;
+    fseek(f, 0, SEEK_END);
+    old_size = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    old_data = (uint8_t*)malloc((size_t)old_size);
+    if (old_data == NULL) { fclose(f); goto cleanup; }
+    if (fread(old_data, 1, (size_t)old_size, f) != (size_t)old_size) { fclose(f); goto cleanup; }
+    fclose(f);
+
+    /* Read patch file */
+    f = fopen(patch_path, "rb");
+    if (f == NULL) goto cleanup;
+    fseek(f, 0, SEEK_END);
+    patch_size = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    patch_data = (uint8_t*)malloc((size_t)patch_size);
+    if (patch_data == NULL) { fclose(f); goto cleanup; }
+    if (fread(patch_data, 1, (size_t)patch_size, f) != (size_t)patch_size) { fclose(f); goto cleanup; }
+    fclose(f);
+
+    /* Apply patch */
+    if (bspatch_internal(old_data, old_size, &new_data, &new_size, patch_data, patch_size) != 0)
+        goto cleanup;
+
+    /* Write new file */
+    f = fopen(new_path, "wb");
+    if (f == NULL) goto cleanup;
+    if (fwrite(new_data, 1, (size_t)new_size, f) != (size_t)new_size) { fclose(f); goto cleanup; }
+    fclose(f);
+
+    result = 0;
+
+cleanup:
+    free(old_data);
+    free(patch_data);
+    free(new_data);
+    return result;
+}

package/ios/Libraries/bspatch/bspatch.h

@@ -0,0 +1,50 @@
+/*-
+ * Copyright 2003-2005 Colin Percival
+ * All rights reserved
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted providing that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef BSPATCH_H
+#define BSPATCH_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Apply a bsdiff patch using file paths.
+ *
+ * @param old_path Path to the old file
+ * @param patch_path Path to the patch file
+ * @param new_path Path to write the new file
+ * @return 0 on success, non-zero on failure
+ */
+int bspatch_files(const char* old_path, const char* patch_path, const char* new_path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BSPATCH_H */

package/ios/Libraries/bspatch/module.modulemap

@@ -0,0 +1,4 @@
+module BSpatch {
+    header "bspatch.h"
+    export *
+}

package/ios/SwiftPatch/BundleManager.swift

@@ -0,0 +1,113 @@
+import Foundation
+
+class BundleManager {
+
+    var baseDir: URL {
+        let documentsDir = FileManager.default.urls(
+            for: .documentDirectory,
+            in: .userDomainMask
+        ).first!
+        return documentsDir.appendingPathComponent("swiftpatch")
+    }
+
+    private var bundlesDir: URL {
+        baseDir.appendingPathComponent("bundles")
+    }
+
+    private var patchesDir: URL {
+        baseDir.appendingPathComponent("patches")
+    }
+
+    private var tempDir: URL {
+        baseDir.appendingPathComponent("temp")
+    }
+
+    /// Ensure all required directories exist
+    func ensureDirectoriesExist() {
+        let fm = FileManager.default
+        try? fm.createDirectory(at: bundlesDir, withIntermediateDirectories: true)
+        try? fm.createDirectory(at: patchesDir, withIntermediateDirectories: true)
+        try? fm.createDirectory(at: tempDir, withIntermediateDirectories: true)
+    }
+
+    /// Get the file URL for a downloaded update (before processing)
+    func getDownloadFile(hash: String) -> URL {
+        tempDir.appendingPathComponent("\(hash).download")
+    }
+
+    /// Get the file URL for a decompressed file
+    func getDecompressedFile(hash: String) -> URL {
+        tempDir.appendingPathComponent("\(hash).decompressed")
+    }
+
+    /// Get the file URL for a bundle by its hash
+    func getBundleFile(hash: String) -> URL {
+        bundlesDir.appendingPathComponent("\(hash).bundle")
+    }
+
+    /// Extract the original bundled JS bundle from the app bundle
+    func extractOriginalBundle() throws -> URL {
+        let originalFile = tempDir.appendingPathComponent("original.bundle")
+
+        if FileManager.default.fileExists(atPath: originalFile.path) {
+            return originalFile
+        }
+
+        // Try main.jsbundle first
+        if let bundledURL = Bundle.main.url(forResource: "main", withExtension: "jsbundle") {
+            try FileManager.default.copyItem(at: bundledURL, to: originalFile)
+            return originalFile
+        }
+
+        // Try index.ios.bundle
+        if let bundledURL = Bundle.main.url(forResource: "index.ios", withExtension: "bundle") {
+            try FileManager.default.copyItem(at: bundledURL, to: originalFile)
+            return originalFile
+        }
+
+        throw SwiftPatchError.patchFailed
+    }
+
+    /// Clean up old bundles that are no longer needed
+    func cleanupOldBundles(userDefaults: UserDefaults, prefsKey: String) {
+        let currentHash = userDefaults.string(forKey: "\(prefsKey)_current_bundle_hash")
+        let previousHash = userDefaults.string(forKey: "\(prefsKey)_previous_bundle_hash")
+
+        let keepHashes = Set([currentHash, previousHash].compactMap { $0 })
+
+        let fm = FileManager.default
+
+        // Clean up bundles
+        if let files = try? fm.contentsOfDirectory(
+            at: bundlesDir,
+            includingPropertiesForKeys: nil
+        ) {
+            for file in files {
+                let fileHash = file.deletingPathExtension().lastPathComponent
+                if !keepHashes.contains(fileHash) {
+                    try? fm.removeItem(at: file)
+                }
+            }
+        }
+
+        // Clean up temp directory
+        if let files = try? fm.contentsOfDirectory(
+            at: tempDir,
+            includingPropertiesForKeys: nil
+        ) {
+            for file in files {
+                try? fm.removeItem(at: file)
+            }
+        }
+
+        // Clean up patches
+        if let files = try? fm.contentsOfDirectory(
+            at: patchesDir,
+            includingPropertiesForKeys: nil
+        ) {
+            for file in files {
+                try? fm.removeItem(at: file)
+            }
+        }
+    }
+}

package/ios/SwiftPatch/CrashDetector.swift

@@ -0,0 +1,71 @@
+import Foundation
+
+class CrashDetector {
+
+    private static let crashDetectionWindowSeconds: TimeInterval = 10.0
+    private static let maxCrashesBeforeRollback = 2
+
+    private let userDefaults: UserDefaults
+    private let prefsKey: String
+
+    init(userDefaults: UserDefaults, prefsKey: String) {
+        self.userDefaults = userDefaults
+        self.prefsKey = prefsKey
+    }
+
+    /// Check if we need to rollback due to a crash after install.
+    /// Called during native module initialization.
+    func checkForPendingRollback(onRollback: @escaping (String) -> Void) {
+        let pendingConfirmation = userDefaults.bool(
+            forKey: "\(prefsKey)_pending_install_confirmation"
+        )
+        guard pendingConfirmation else { return }
+
+        let installTimestamp = userDefaults.double(
+            forKey: "\(prefsKey)_install_timestamp"
+        )
+        let currentTime = Date().timeIntervalSince1970
+
+        if currentTime - installTimestamp < Self.crashDetectionWindowSeconds {
+            // Within crash detection window - this might be a crash-restart cycle
+            let crashCount = userDefaults.integer(forKey: "\(prefsKey)_crash_count") + 1
+
+            if crashCount >= Self.maxCrashesBeforeRollback {
+                let reason = "Automatic rollback after \(crashCount) crashes"
+                performRollback(reason: reason)
+                onRollback("Crashed \(crashCount) times within detection window")
+            } else {
+                userDefaults.set(crashCount, forKey: "\(prefsKey)_crash_count")
+            }
+        } else {
+            // We survived the crash detection window, mark as stable
+            confirmStable()
+        }
+    }
+
+    /// Mark the current installation as stable
+    func confirmStable() {
+        userDefaults.set(false, forKey: "\(prefsKey)_pending_install_confirmation")
+        userDefaults.set(0, forKey: "\(prefsKey)_crash_count")
+    }
+
+    private func performRollback(reason: String) {
+        let previousHash = userDefaults.string(forKey: "\(prefsKey)_previous_bundle_hash")
+        let previousPath = userDefaults.string(forKey: "\(prefsKey)_previous_bundle_path")
+
+        if let hash = previousHash, let path = previousPath {
+            userDefaults.set(hash, forKey: "\(prefsKey)_current_bundle_hash")
+            userDefaults.set(path, forKey: "\(prefsKey)_current_bundle_path")
+            userDefaults.removeObject(forKey: "\(prefsKey)_previous_bundle_hash")
+            userDefaults.removeObject(forKey: "\(prefsKey)_previous_bundle_path")
+        } else {
+            // Rollback to original bundled version
+            userDefaults.removeObject(forKey: "\(prefsKey)_current_bundle_hash")
+            userDefaults.removeObject(forKey: "\(prefsKey)_current_bundle_path")
+        }
+
+        userDefaults.set(false, forKey: "\(prefsKey)_pending_install_confirmation")
+        userDefaults.set(0, forKey: "\(prefsKey)_crash_count")
+        userDefaults.set(reason, forKey: "\(prefsKey)_last_rollback_reason")
+    }
+}