@swiftpatch/react-native 2.0.0

package/ios/SwiftPatch/CryptoVerifier.swift

@@ -0,0 +1,70 @@
+import Foundation
+import CommonCrypto
+import Security
+
+class CryptoVerifier {
+
+    /// Calculate SHA-256 hash of a file
+    func sha256(fileURL: URL) throws -> String {
+        let data = try Data(contentsOf: fileURL)
+        var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+
+        data.withUnsafeBytes { buffer in
+            _ = CC_SHA256(buffer.baseAddress, CC_LONG(data.count), &hash)
+        }
+
+        return hash.map { String(format: "%02x", $0) }.joined()
+    }
+
+    /// Verify RSA signature
+    ///
+    /// - Parameters:
+    ///   - data: The data that was signed (usually the bundle hash)
+    ///   - signature: The signature in base64 format
+    ///   - publicKey: The public key in PEM format
+    func verifySignature(data: String, signature: String, publicKey: String) -> Bool {
+        guard let signatureData = Data(base64Encoded: signature),
+              let dataBytes = data.data(using: .utf8),
+              let secKey = parsePublicKey(pem: publicKey) else {
+            return false
+        }
+
+        var error: Unmanaged<CFError>?
+        let result = SecKeyVerifySignature(
+            secKey,
+            .rsaSignatureMessagePKCS1v15SHA256,
+            dataBytes as CFData,
+            signatureData as CFData,
+            &error
+        )
+
+        return result
+    }
+
+    // MARK: - Private
+
+    private func parsePublicKey(pem: String) -> SecKey? {
+        // Strip PEM headers
+        let stripped = pem
+            .replacingOccurrences(of: "-----BEGIN PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "-----END PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "\n", with: "")
+            .replacingOccurrences(of: "\r", with: "")
+            .trimmingCharacters(in: .whitespaces)
+
+        guard let keyData = Data(base64Encoded: stripped) else {
+            return nil
+        }
+
+        let attributes: [String: Any] = [
+            kSecAttrKeyType as String: kSecAttrKeyTypeRSA,
+            kSecAttrKeyClass as String: kSecAttrKeyClassPublic,
+            kSecAttrKeySizeInBits as String: 2048
+        ]
+
+        var error: Unmanaged<CFError>?
+        let key = SecKeyCreateWithData(keyData as CFData, attributes as CFDictionary, &error)
+
+        return key
+    }
+}

package/ios/SwiftPatch/DownloadManager.swift

@@ -0,0 +1,125 @@
+import Foundation
+
+struct SPDownloadProgress {
+    let downloadedBytes: Int64
+    let totalBytes: Int64
+    let percentage: Int
+}
+
+class SPDownloadManager {
+
+    /// Download a file from a URL with progress reporting (synchronous)
+    func download(
+        urlString: String,
+        to outputURL: URL,
+        onProgress: @escaping (SPDownloadProgress) -> Void
+    ) throws {
+        guard let url = URL(string: urlString) else {
+            throw NSError(
+                domain: "SwiftPatch",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid URL: \(urlString)"]
+            )
+        }
+
+        let semaphore = DispatchSemaphore(value: 0)
+        var downloadError: Error?
+
+        let delegate = DownloadDelegate(
+            outputURL: outputURL,
+            onProgress: onProgress,
+            completion: { error in
+                downloadError = error
+                semaphore.signal()
+            }
+        )
+
+        let session = URLSession(
+            configuration: .default,
+            delegate: delegate,
+            delegateQueue: nil
+        )
+
+        let task = session.downloadTask(with: url)
+        task.resume()
+
+        semaphore.wait()
+        session.invalidateAndCancel()
+
+        if let error = downloadError {
+            throw error
+        }
+
+        guard FileManager.default.fileExists(atPath: outputURL.path) else {
+            throw NSError(
+                domain: "SwiftPatch",
+                code: -2,
+                userInfo: [NSLocalizedDescriptionKey: "Downloaded file not found"]
+            )
+        }
+    }
+}
+
+// MARK: - Download Delegate
+
+private class DownloadDelegate: NSObject, URLSessionDownloadDelegate {
+    let outputURL: URL
+    let onProgress: (SPDownloadProgress) -> Void
+    let completion: (Error?) -> Void
+
+    init(outputURL: URL, onProgress: @escaping (SPDownloadProgress) -> Void, completion: @escaping (Error?) -> Void) {
+        self.outputURL = outputURL
+        self.onProgress = onProgress
+        self.completion = completion
+    }
+
+    func urlSession(_ session: URLSession,
+                    downloadTask: URLSessionDownloadTask,
+                    didFinishDownloadingTo location: URL) {
+        do {
+            // Remove existing file if present
+            let fm = FileManager.default
+            if fm.fileExists(atPath: outputURL.path) {
+                try fm.removeItem(at: outputURL)
+            }
+
+            // Ensure parent directory exists
+            try fm.createDirectory(
+                at: outputURL.deletingLastPathComponent(),
+                withIntermediateDirectories: true
+            )
+
+            try fm.moveItem(at: location, to: outputURL)
+            completion(nil)
+        } catch {
+            completion(error)
+        }
+    }
+
+    func urlSession(_ session: URLSession,
+                    downloadTask: URLSessionDownloadTask,
+                    didWriteData bytesWritten: Int64,
+                    totalBytesWritten: Int64,
+                    totalBytesExpectedToWrite: Int64) {
+        let total = totalBytesExpectedToWrite > 0
+            ? totalBytesExpectedToWrite
+            : totalBytesWritten
+        let percentage = total > 0
+            ? Int((totalBytesWritten * 100) / total)
+            : 0
+
+        onProgress(SPDownloadProgress(
+            downloadedBytes: totalBytesWritten,
+            totalBytes: total,
+            percentage: min(percentage, 100)
+        ))
+    }
+
+    func urlSession(_ session: URLSession,
+                    task: URLSessionTask,
+                    didCompleteWithError error: Error?) {
+        if let error = error {
+            completion(error)
+        }
+    }
+}

package/ios/SwiftPatch/EventQueue.swift

@@ -0,0 +1,116 @@
+import Foundation
+
+/// Types of SDK events that are queued and sent to the analytics backend
+enum SwiftPatchEventType: String {
+    case downloadProdStarted = "DOWNLOAD_PROD_STARTED"
+    case downloadProdCompleted = "DOWNLOAD_PROD_COMPLETED"
+    case downloadProdFailed = "DOWNLOAD_PROD_FAILED"
+    case installedProd = "INSTALLED_PROD"
+    case rollbackProd = "ROLLBACK_PROD"
+    case stabilizeProd = "STABILIZE_PROD"
+    case corruptionProd = "CORRUPTION_PROD"
+    case downloadStageStarted = "DOWNLOAD_STAGE_STARTED"
+    case downloadStageCompleted = "DOWNLOAD_STAGE_COMPLETED"
+    case downloadStageFailed = "DOWNLOAD_STAGE_FAILED"
+    case installedStage = "INSTALLED_STAGE"
+    case syncError = "SYNC_ERROR"
+    case versionChanged = "VERSION_CHANGED"
+    case crashDetected = "CRASH_DETECTED"
+}
+
+/// A single event entry
+struct SwiftPatchEvent {
+    let id: String
+    let eventType: SwiftPatchEventType
+    let timestamp: TimeInterval
+    let releaseHash: String?
+    let errorMessage: String?
+    let metadata: [String: Any]?
+
+    func toDictionary() -> [String: Any] {
+        var dict: [String: Any] = [
+            "id": id,
+            "eventType": eventType.rawValue,
+            "timestamp": timestamp,
+        ]
+        if let hash = releaseHash { dict["releaseHash"] = hash }
+        if let error = errorMessage { dict["errorMessage"] = error }
+        if let meta = metadata { dict["metadata"] = meta }
+        return dict
+    }
+}
+
+/// Thread-safe event queue that persists events to UserDefaults.
+/// Events are queued natively and polled by JS for batch sending to the analytics backend.
+class EventQueue {
+
+    private let userDefaults: UserDefaults
+    private let prefsKey: String
+    private let queue = DispatchQueue(label: "com.swiftpatch.eventqueue", attributes: .concurrent)
+
+    init(userDefaults: UserDefaults, prefsKey: String) {
+        self.userDefaults = userDefaults
+        self.prefsKey = prefsKey
+    }
+
+    // MARK: - Push Events
+
+    func pushEvent(type: SwiftPatchEventType, releaseHash: String? = nil, errorMessage: String? = nil, metadata: [String: Any]? = nil) {
+        let event = SwiftPatchEvent(
+            id: UUID().uuidString,
+            eventType: type,
+            timestamp: Date().timeIntervalSince1970,
+            releaseHash: releaseHash,
+            errorMessage: errorMessage,
+            metadata: metadata
+        )
+
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            var events = self.loadEvents()
+            events.append(event.toDictionary())
+            self.saveEvents(events)
+        }
+    }
+
+    // MARK: - Pop Events (called from JS)
+
+    /// Pop all pending events. Returns JSON-encoded array.
+    func popEvents() -> [[String: Any]] {
+        var result: [[String: Any]] = []
+        queue.sync {
+            result = loadEvents()
+        }
+        return result
+    }
+
+    // MARK: - Acknowledge Events (remove processed events)
+
+    func acknowledgeEvents(eventIds: [String]) {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self else { return }
+            var events = self.loadEvents()
+            events.removeAll { event in
+                guard let id = event["id"] as? String else { return false }
+                return eventIds.contains(id)
+            }
+            self.saveEvents(events)
+        }
+    }
+
+    // MARK: - Persistence
+
+    private func loadEvents() -> [[String: Any]] {
+        guard let data = userDefaults.data(forKey: "\(prefsKey)_event_queue"),
+              let events = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else {
+            return []
+        }
+        return events
+    }
+
+    private func saveEvents(_ events: [[String: Any]]) {
+        if let data = try? JSONSerialization.data(withJSONObject: events) {
+            userDefaults.set(data, forKey: "\(prefsKey)_event_queue")
+        }
+    }
+}

package/ios/SwiftPatch/FileUtils.swift

@@ -0,0 +1,38 @@
+import Foundation
+
+enum SPFileUtils {
+
+    /// Decompress a gzip-compressed file.
+    /// For production brotli support, integrate a proper Brotli framework.
+    static func decompressGzip(from input: URL, to output: URL) throws {
+        let inputData = try Data(contentsOf: input)
+
+        // Check for gzip magic bytes (0x1f 0x8b)
+        if inputData.count >= 2 && inputData[0] == 0x1F && inputData[1] == 0x8B {
+            // Use built-in NSData decompression
+            let decompressed = try (inputData as NSData).decompressed(using: .zlib)
+            try (decompressed as Data).write(to: output)
+        } else {
+            // Not compressed, just copy
+            try FileManager.default.copyItem(at: input, to: output)
+        }
+    }
+
+    /// Safely delete a file, ignoring errors
+    static func safeDelete(at url: URL) {
+        try? FileManager.default.removeItem(at: url)
+    }
+
+    /// Get the size of a file
+    static func fileSize(at url: URL) -> Int64 {
+        let attrs = try? FileManager.default.attributesOfItem(atPath: url.path)
+        return (attrs?[.size] as? Int64) ?? 0
+    }
+
+    /// Get a human-readable size string
+    static func humanReadableSize(bytes: Int64) -> String {
+        let formatter = ByteCountFormatter()
+        formatter.countStyle = .file
+        return formatter.string(fromByteCount: bytes)
+    }
+}

package/ios/SwiftPatch/PatchApplier.swift

@@ -0,0 +1,41 @@
+import Foundation
+import BSpatch
+
+class PatchApplier {
+
+    /// Apply a bsdiff patch to create a new file
+    ///
+    /// - Parameters:
+    ///   - oldFile: URL to the original file
+    ///   - patchFile: URL to the patch file
+    ///   - newFile: URL where the new file will be written
+    func applyPatch(oldFile: URL, patchFile: URL, newFile: URL) throws {
+        guard FileManager.default.fileExists(atPath: oldFile.path) else {
+            throw SwiftPatchError.patchFailed
+        }
+        guard FileManager.default.fileExists(atPath: patchFile.path) else {
+            throw SwiftPatchError.patchFailed
+        }
+
+        // Ensure parent directory exists
+        try FileManager.default.createDirectory(
+            at: newFile.deletingLastPathComponent(),
+            withIntermediateDirectories: true
+        )
+
+        let result = bspatch_files(
+            oldFile.path.cString(using: .utf8),
+            patchFile.path.cString(using: .utf8),
+            newFile.path.cString(using: .utf8)
+        )
+
+        guard result == 0 else {
+            try? FileManager.default.removeItem(at: newFile)
+            throw SwiftPatchError.patchFailed
+        }
+
+        guard FileManager.default.fileExists(atPath: newFile.path) else {
+            throw SwiftPatchError.patchFailed
+        }
+    }
+}

package/ios/SwiftPatch/SignalCrashHandler.swift

@@ -0,0 +1,129 @@
+import Foundation
+
+/// Native signal-level crash handler for detecting startup crashes
+/// and triggering automatic rollbacks.
+///
+/// Unlike the timer-based CrashDetector, this catches actual fatal signals
+/// (SIGABRT, SIGSEGV, etc.) and writes crash markers to disk.
+/// On next launch, if a crash marker exists and the app was not mounted
+/// (i.e., crashed during startup), auto-rollback is triggered.
+final class SignalCrashHandler {
+
+    static let shared = SignalCrashHandler()
+
+    private let crashMarkerFile: URL
+    private let prefsKey: String = "swiftpatch_prefs"
+
+    /// Whether the React Native component tree has mounted
+    private(set) var isMounted = false
+
+    private init() {
+        let documentsDir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+        crashMarkerFile = documentsDir.appendingPathComponent("swiftpatch").appendingPathComponent("crash_marker.json")
+    }
+
+    // MARK: - Signal Handlers
+
+    /// Install signal handlers for fatal signals
+    func installSignalHandlers() {
+        signal(SIGABRT, signalHandler)
+        signal(SIGILL, signalHandler)
+        signal(SIGSEGV, signalHandler)
+        signal(SIGFPE, signalHandler)
+        signal(SIGBUS, signalHandler)
+        signal(SIGTRAP, signalHandler)
+        signal(SIGPIPE, signalHandler)
+        signal(SIGSYS, signalHandler)
+    }
+
+    /// Mark the app UI as mounted (called from JS when component tree renders)
+    func markMounted() {
+        isMounted = true
+    }
+
+    /// Mark the app UI as unmounted
+    func markUnmounted() {
+        isMounted = false
+    }
+
+    // MARK: - Crash Marker
+
+    /// Check for crash marker from previous run.
+    /// Returns the crash info if a crash marker exists, nil otherwise.
+    func checkForCrashMarker() -> CrashMarkerInfo? {
+        guard FileManager.default.fileExists(atPath: crashMarkerFile.path) else {
+            return nil
+        }
+
+        guard let data = try? Data(contentsOf: crashMarkerFile),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            // Remove corrupt marker
+            try? FileManager.default.removeItem(at: crashMarkerFile)
+            return nil
+        }
+
+        // Remove marker after reading
+        try? FileManager.default.removeItem(at: crashMarkerFile)
+
+        return CrashMarkerInfo(
+            signalNumber: json["signal"] as? Int ?? 0,
+            signalName: json["signalName"] as? String ?? "UNKNOWN",
+            timestamp: json["timestamp"] as? TimeInterval ?? 0,
+            wasMounted: json["wasMounted"] as? Bool ?? false
+        )
+    }
+
+    /// Write a crash marker to disk. Called from signal handler.
+    private func writeCrashMarker(signalNumber: Int32) {
+        let signalName: String
+        switch signalNumber {
+        case SIGABRT: signalName = "SIGABRT"
+        case SIGILL: signalName = "SIGILL"
+        case SIGSEGV: signalName = "SIGSEGV"
+        case SIGFPE: signalName = "SIGFPE"
+        case SIGBUS: signalName = "SIGBUS"
+        case SIGTRAP: signalName = "SIGTRAP"
+        case SIGPIPE: signalName = "SIGPIPE"
+        case SIGSYS: signalName = "SIGSYS"
+        default: signalName = "SIGNAL_\(signalNumber)"
+        }
+
+        let crashInfo: [String: Any] = [
+            "signal": signalNumber,
+            "signalName": signalName,
+            "timestamp": Date().timeIntervalSince1970,
+            "wasMounted": isMounted,
+        ]
+
+        // Write synchronously (we're in a signal handler, limited operations)
+        if let data = try? JSONSerialization.data(withJSONObject: crashInfo) {
+            // Ensure directory exists
+            let dir = crashMarkerFile.deletingLastPathComponent()
+            try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+            try? data.write(to: crashMarkerFile, options: .atomic)
+        }
+    }
+
+    /// Check if we should auto-rollback based on crash marker
+    func shouldAutoRollback(crashInfo: CrashMarkerInfo) -> Bool {
+        // Only auto-rollback if the app crashed before mounting (startup crash)
+        return !crashInfo.wasMounted
+    }
+}
+
+/// Info about a crash from the previous app run
+struct CrashMarkerInfo {
+    let signalNumber: Int
+    let signalName: String
+    let timestamp: TimeInterval
+    let wasMounted: Bool
+}
+
+// C-level signal handler function (must be a plain C function)
+private func signalHandler(_ signal: Int32) {
+    SignalCrashHandler.shared.writeCrashMarker(signalNumber: signal)
+
+    // Re-raise the signal to get default behavior (crash report, etc.)
+    Foundation.signal(signal, SIG_DFL)
+    raise(signal)
+}