@swiftpatch/react-native 2.0.0

package/ios/SwiftPatch/SwiftPatchModule.swift

@@ -0,0 +1,621 @@
+import Foundation
+import React
+
+@objc(SwiftPatch)
+class SwiftPatchModule: RCTEventEmitter {
+
+    // MARK: - Static Properties
+
+    private static let prefsKey = "swiftpatch_prefs"
+    private static var userDefaults: UserDefaults {
+        UserDefaults.standard
+    }
+
+    /// Static SlotManager for getJSBundleFile (called before module init)
+    private static var staticSlotManager: SlotManager?
+
+    /// Get the JS bundle file path (called from AppDelegate)
+    @objc static func getJSBundleFile() -> URL? {
+        let sm = getOrCreateSlotManager()
+
+        // Check for version change first
+        let versionChanged = sm.checkVersionChange()
+        if versionChanged {
+            return nil // Fall back to default bundle
+        }
+
+        // Apply temp hash if pending
+        sm.applyTempHashOnLaunch()
+
+        // Get bundle URL from slot manager
+        return sm.getBundleURL()
+    }
+
+    private static func getOrCreateSlotManager() -> SlotManager {
+        if staticSlotManager == nil {
+            staticSlotManager = SlotManager(userDefaults: userDefaults, prefsKey: prefsKey)
+        }
+        return staticSlotManager!
+    }
+
+    // MARK: - Instance Properties
+
+    private var config: SwiftPatchConfigModel?
+    private var isDebugMode = false
+
+    private lazy var spBundleManager = BundleManager()
+    private lazy var downloadManager = SPDownloadManager()
+    private lazy var patchApplier = PatchApplier()
+    private lazy var cryptoVerifier = CryptoVerifier()
+
+    private lazy var slotManager: SlotManager = {
+        let sm = Self.getOrCreateSlotManager()
+        return sm
+    }()
+
+    private lazy var eventQueue: EventQueue = {
+        EventQueue(userDefaults: Self.userDefaults, prefsKey: Self.prefsKey)
+    }()
+
+    private lazy var crashDetector: CrashDetector = {
+        CrashDetector(userDefaults: Self.userDefaults, prefsKey: Self.prefsKey)
+    }()
+
+    // MARK: - RCTEventEmitter
+
+    override func supportedEvents() -> [String]! {
+        return [
+            "SwiftPatch:downloadProgress",
+            "SwiftPatch:installComplete",
+            "SwiftPatch:rollbackOccurred",
+            "SwiftPatch:error",
+            "SwiftPatch:event",
+            "SwiftPatch:versionChanged",
+        ]
+    }
+
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    // MARK: - Initialization
+
+    override init() {
+        super.init()
+
+        // Install signal-level crash handlers
+        SignalCrashHandler.shared.installSignalHandlers()
+
+        // Check for crash marker from previous run
+        if let crashInfo = SignalCrashHandler.shared.checkForCrashMarker() {
+            if SignalCrashHandler.shared.shouldAutoRollback(crashInfo: crashInfo) {
+                // App crashed before mounting - auto rollback
+                let result = slotManager.rollbackProd(isAutoRollback: true)
+                eventQueue.pushEvent(
+                    type: .crashDetected,
+                    metadata: [
+                        "signalName": crashInfo.signalName,
+                        "signalNumber": crashInfo.signalNumber,
+                        "autoRollback": true,
+                        "rollbackResult": result,
+                    ]
+                )
+                sendEvent(
+                    withName: "SwiftPatch:rollbackOccurred",
+                    body: ["reason": "Native crash detected: \(crashInfo.signalName), auto-rollback to \(result)"]
+                )
+            } else {
+                // App crashed after mounting - log but don't auto-rollback
+                eventQueue.pushEvent(
+                    type: .crashDetected,
+                    metadata: [
+                        "signalName": crashInfo.signalName,
+                        "signalNumber": crashInfo.signalNumber,
+                        "autoRollback": false,
+                    ]
+                )
+            }
+        }
+
+        // Also check timer-based crash detection (legacy/fallback)
+        crashDetector.checkForPendingRollback { [weak self] reason in
+            self?.sendEvent(
+                withName: "SwiftPatch:rollbackOccurred",
+                body: ["reason": reason]
+            )
+        }
+
+        // Check for version change
+        if slotManager.checkVersionChange() {
+            eventQueue.pushEvent(type: .versionChanged)
+            sendEvent(
+                withName: "SwiftPatch:versionChanged",
+                body: ["reason": "App binary version changed, reset to default bundle"]
+            )
+        }
+    }
+
+    @objc
+    func initialize(_ configDict: NSDictionary,
+                    resolver resolve: @escaping RCTPromiseResolveBlock,
+                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let deploymentKey = configDict["deploymentKey"] as? String else {
+            reject("INIT_ERROR", "deploymentKey is required", nil)
+            return
+        }
+
+        config = SwiftPatchConfigModel(
+            deploymentKey: deploymentKey,
+            serverUrl: configDict["serverUrl"] as? String ?? "https://swiftpatch.hyperbrainlabs.com/api/v1",
+            publicKey: configDict["publicKey"] as? String
+        )
+
+        spBundleManager.ensureDirectoriesExist()
+        slotManager.ensureSlotDirectories()
+
+        log("Initialized with deployment key: \(String(deploymentKey.prefix(8)))...")
+        resolve(nil)
+    }
+
+    @objc
+    func setDebugMode(_ enabled: Bool) {
+        isDebugMode = enabled
+    }
+
+    // MARK: - Mount State (for signal crash handler)
+
+    @objc
+    func markMounted(_ resolve: @escaping RCTPromiseResolveBlock,
+                     rejecter reject: @escaping RCTPromiseRejectBlock) {
+        SignalCrashHandler.shared.markMounted()
+        resolve(nil)
+    }
+
+    @objc
+    func markUnmounted(_ resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        SignalCrashHandler.shared.markUnmounted()
+        resolve(nil)
+    }
+
+    // MARK: - Bundle Information
+
+    @objc
+    func getCurrentBundle(_ resolve: @escaping RCTPromiseResolveBlock,
+                          rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let env = slotManager.currentEnvironment
+
+        if env == .staging {
+            if let hash = slotManager.stageNewHash {
+                resolve([
+                    "hash": hash,
+                    "version": "staging",
+                    "installedAt": "",
+                    "isOriginal": false,
+                    "slot": "NEW_SLOT",
+                    "environment": "STAGE",
+                ] as [String: Any])
+            } else {
+                resolve([
+                    "hash": "original",
+                    "version": "0.0.0",
+                    "installedAt": "",
+                    "isOriginal": true,
+                    "slot": "DEFAULT_SLOT",
+                    "environment": "STAGE",
+                ] as [String: Any])
+            }
+            return
+        }
+
+        // Production mode
+        let slot = slotManager.currentProdSlot
+        var hash: String?
+        switch slot {
+        case .newSlot: hash = slotManager.prodNewHash
+        case .stableSlot: hash = slotManager.prodStableHash
+        case .defaultSlot: hash = nil
+        }
+
+        if let hash = hash {
+            let installedAt = Self.userDefaults.string(forKey: "\(Self.prefsKey)_current_bundle_installed_at") ?? ""
+            resolve([
+                "hash": hash,
+                "version": Self.userDefaults.string(forKey: "\(Self.prefsKey)_current_bundle_version") ?? "unknown",
+                "installedAt": installedAt,
+                "isOriginal": false,
+                "slot": slot.rawValue,
+                "environment": "PROD",
+            ] as [String: Any])
+        } else {
+            resolve([
+                "hash": "original",
+                "version": "0.0.0",
+                "installedAt": "",
+                "isOriginal": true,
+                "slot": "DEFAULT_SLOT",
+                "environment": "PROD",
+            ] as [String: Any])
+        }
+    }
+
+    @objc
+    func getSlotMetadata(_ resolve: @escaping RCTPromiseResolveBlock,
+                         rejecter reject: @escaping RCTPromiseRejectBlock) {
+        resolve(slotManager.getMetadata())
+    }
+
+    @objc
+    func getDeviceId(_ resolve: @escaping RCTPromiseResolveBlock,
+                     rejecter reject: @escaping RCTPromiseRejectBlock) {
+        var deviceId = Self.userDefaults.string(forKey: "\(Self.prefsKey)_device_id")
+        if deviceId == nil {
+            deviceId = UUID().uuidString
+            Self.userDefaults.set(deviceId, forKey: "\(Self.prefsKey)_device_id")
+        }
+        resolve(deviceId)
+    }
+
+    @objc
+    func getAppVersion(_ resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "0.0.0"
+        resolve(version)
+    }
+
+    // MARK: - Environment Switching
+
+    @objc
+    func switchEnvironment(_ environment: String,
+                           resolver resolve: @escaping RCTPromiseResolveBlock,
+                           rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let env = EnvironmentMode(rawValue: environment) else {
+            reject("ENV_ERROR", "Invalid environment: \(environment). Use 'PROD' or 'STAGE'.", nil)
+            return
+        }
+        slotManager.currentEnvironment = env
+        log("Switched environment to: \(environment)")
+        resolve(slotManager.getMetadata())
+    }
+
+    // MARK: - Download & Install
+
+    @objc
+    func downloadUpdate(_ url: String,
+                        expectedHash: String,
+                        isPatch: Bool,
+                        signature: String?,
+                        resolver resolve: @escaping RCTPromiseResolveBlock,
+                        rejecter reject: @escaping RCTPromiseRejectBlock) {
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else { return }
+
+            do {
+                self.log("Downloading update from: \(url) (isPatch: \(isPatch))")
+                self.eventQueue.pushEvent(type: .downloadProdStarted, releaseHash: expectedHash)
+
+                let downloadFile = self.spBundleManager.getDownloadFile(hash: expectedHash)
+
+                // Download with progress
+                try self.downloadManager.download(
+                    urlString: url,
+                    to: downloadFile
+                ) { [weak self] progress in
+                    self?.sendEvent(withName: "SwiftPatch:downloadProgress", body: [
+                        "downloadedBytes": progress.downloadedBytes,
+                        "totalBytes": progress.totalBytes,
+                        "percentage": progress.percentage
+                    ])
+                }
+
+                self.log("Download complete, processing...")
+
+                // Decompress if brotli
+                let decompressedFile: URL
+                if url.hasSuffix(".br") {
+                    decompressedFile = self.spBundleManager.getDecompressedFile(hash: expectedHash)
+                    try SPFileUtils.decompressGzip(from: downloadFile, to: decompressedFile)
+                    try FileManager.default.removeItem(at: downloadFile)
+                } else {
+                    decompressedFile = downloadFile
+                }
+
+                // Apply patch or use as full bundle
+                let finalBundle: URL
+                if isPatch {
+                    self.log("Applying patch...")
+                    let currentHash: String?
+                    switch self.slotManager.currentProdSlot {
+                    case .newSlot: currentHash = self.slotManager.prodNewHash
+                    case .stableSlot: currentHash = self.slotManager.prodStableHash
+                    case .defaultSlot: currentHash = nil
+                    }
+
+                    let currentBundleFile: URL
+                    if let hash = currentHash {
+                        currentBundleFile = self.spBundleManager.getBundleFile(hash: hash)
+                    } else {
+                        currentBundleFile = try self.spBundleManager.extractOriginalBundle()
+                    }
+
+                    finalBundle = self.spBundleManager.getBundleFile(hash: expectedHash)
+                    try self.patchApplier.applyPatch(
+                        oldFile: currentBundleFile,
+                        patchFile: decompressedFile,
+                        newFile: finalBundle
+                    )
+                    try? FileManager.default.removeItem(at: decompressedFile)
+                } else {
+                    finalBundle = self.spBundleManager.getBundleFile(hash: expectedHash)
+                    if decompressedFile != finalBundle {
+                        try? FileManager.default.removeItem(at: finalBundle)
+                        try FileManager.default.moveItem(at: decompressedFile, to: finalBundle)
+                    }
+                }
+
+                // Verify hash
+                self.log("Verifying hash...")
+                let actualHash = try self.cryptoVerifier.sha256(fileURL: finalBundle)
+                guard actualHash == expectedHash else {
+                    try? FileManager.default.removeItem(at: finalBundle)
+                    self.eventQueue.pushEvent(type: .downloadProdFailed, releaseHash: expectedHash, errorMessage: "Hash mismatch")
+                    throw SwiftPatchError.hashMismatch(expected: expectedHash, actual: actualHash)
+                }
+
+                // Verify signature
+                if let signature = signature, let publicKey = self.config?.publicKey {
+                    self.log("Verifying signature...")
+                    guard self.cryptoVerifier.verifySignature(
+                        data: actualHash,
+                        signature: signature,
+                        publicKey: publicKey
+                    ) else {
+                        try? FileManager.default.removeItem(at: finalBundle)
+                        self.eventQueue.pushEvent(type: .downloadProdFailed, releaseHash: expectedHash, errorMessage: "Signature invalid")
+                        throw SwiftPatchError.signatureInvalid
+                    }
+                }
+
+                // Set as temp hash (deferred apply)
+                self.slotManager.prodTempHash = expectedHash
+
+                self.eventQueue.pushEvent(type: .downloadProdCompleted, releaseHash: expectedHash)
+                self.log("Download and verification complete, tempHash set: \(expectedHash)")
+                resolve(nil)
+
+            } catch {
+                self.log("Download failed: \(error.localizedDescription)")
+                self.eventQueue.pushEvent(type: .downloadProdFailed, releaseHash: expectedHash, errorMessage: error.localizedDescription)
+                reject("DOWNLOAD_ERROR", error.localizedDescription, error)
+            }
+        }
+    }
+
+    /// Download a stage bundle (for testing)
+    @objc
+    func downloadStageBundle(_ url: String,
+                             expectedHash: String,
+                             resolver resolve: @escaping RCTPromiseResolveBlock,
+                             rejecter reject: @escaping RCTPromiseRejectBlock) {
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else { return }
+
+            do {
+                self.eventQueue.pushEvent(type: .downloadStageStarted, releaseHash: expectedHash)
+
+                let downloadFile = self.spBundleManager.getDownloadFile(hash: "stage_\(expectedHash)")
+
+                try self.downloadManager.download(urlString: url, to: downloadFile) { [weak self] progress in
+                    self?.sendEvent(withName: "SwiftPatch:downloadProgress", body: [
+                        "downloadedBytes": progress.downloadedBytes,
+                        "totalBytes": progress.totalBytes,
+                        "percentage": progress.percentage
+                    ])
+                }
+
+                // Move to stage directory
+                let stageDir = self.spBundleManager.baseDir.appendingPathComponent("stage/new")
+                try? FileManager.default.createDirectory(at: stageDir, withIntermediateDirectories: true)
+                let destPath = stageDir.appendingPathComponent("\(expectedHash).bundle")
+                try? FileManager.default.removeItem(at: destPath)
+                try FileManager.default.moveItem(at: downloadFile, to: destPath)
+
+                self.slotManager.stageNewHash = expectedHash
+                self.eventQueue.pushEvent(type: .downloadStageCompleted, releaseHash: expectedHash)
+                resolve(nil)
+
+            } catch {
+                self.eventQueue.pushEvent(type: .downloadStageFailed, releaseHash: expectedHash, errorMessage: error.localizedDescription)
+                reject("DOWNLOAD_ERROR", error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc
+    func installUpdate(_ bundleHash: String,
+                       resolver resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        // With the new temp hash system, install just means "apply temp on next restart"
+        // The temp hash is already set during download.
+        // This method is kept for backward compatibility and explicit install trigger.
+
+        if slotManager.prodTempHash == nil {
+            // Check legacy pending system
+            guard let pendingHash = Self.userDefaults.string(
+                forKey: "\(Self.prefsKey)_pending_bundle_hash"
+            ), pendingHash == bundleHash else {
+                reject("INSTALL_ERROR", "No pending bundle found", nil)
+                return
+            }
+        }
+
+        Self.userDefaults.set(true, forKey: "\(Self.prefsKey)_pending_install_confirmation")
+        Self.userDefaults.set(Date().timeIntervalSince1970, forKey: "\(Self.prefsKey)_install_timestamp")
+
+        log("Update marked for install: \(bundleHash)")
+        resolve(nil)
+    }
+
+    @objc
+    func hasPendingInstall(_ resolve: @escaping RCTPromiseResolveBlock,
+                           rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let hasPending = slotManager.prodTempHash != nil ||
+            Self.userDefaults.string(forKey: "\(Self.prefsKey)_pending_bundle_hash") != nil
+        resolve(hasPending)
+    }
+
+    @objc
+    func confirmInstall(_ resolve: @escaping RCTPromiseResolveBlock,
+                        rejecter reject: @escaping RCTPromiseRejectBlock) {
+        Self.userDefaults.set(false, forKey: "\(Self.prefsKey)_pending_install_confirmation")
+        Self.userDefaults.set(0, forKey: "\(Self.prefsKey)_crash_count")
+        slotManager.cleanup()
+        log("Install confirmed")
+        resolve(nil)
+    }
+
+    // MARK: - Stabilization
+
+    @objc
+    func stabilize(_ resolve: @escaping RCTPromiseResolveBlock,
+                   rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let success = slotManager.stabilize()
+        if success {
+            eventQueue.pushEvent(type: .stabilizeProd, releaseHash: slotManager.prodStableHash)
+            log("Bundle stabilized (promoted NEW → STABLE)")
+            resolve(slotManager.getMetadata())
+        } else {
+            reject("STABILIZE_ERROR", "No bundle in NEW slot to stabilize", nil)
+        }
+    }
+
+    // MARK: - Restart & Rollback
+
+    @objc
+    func restart() {
+        log("Restarting app...")
+        DispatchQueue.main.async {
+            if let bridge = RCTBridge.current() {
+                bridge.reload()
+            }
+        }
+    }
+
+    @objc
+    func rollback(_ resolve: @escaping RCTPromiseResolveBlock,
+                  rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let result = slotManager.rollbackProd(isAutoRollback: false)
+        Self.userDefaults.set(false, forKey: "\(Self.prefsKey)_pending_install_confirmation")
+        Self.userDefaults.set(0, forKey: "\(Self.prefsKey)_crash_count")
+        eventQueue.pushEvent(type: .rollbackProd, metadata: ["result": result, "manual": true])
+        log("Rollback complete: \(result)")
+        resolve(result)
+    }
+
+    @objc
+    func clearPendingUpdate(_ resolve: @escaping RCTPromiseResolveBlock,
+                            rejecter reject: @escaping RCTPromiseRejectBlock) {
+        slotManager.prodTempHash = nil
+
+        if let pendingPath = Self.userDefaults.string(forKey: "\(Self.prefsKey)_pending_bundle_path") {
+            try? FileManager.default.removeItem(atPath: pendingPath)
+        }
+        Self.userDefaults.removeObject(forKey: "\(Self.prefsKey)_pending_bundle_hash")
+        Self.userDefaults.removeObject(forKey: "\(Self.prefsKey)_pending_bundle_path")
+
+        resolve(nil)
+    }
+
+    // MARK: - Event Queue (JS Bridge)
+
+    @objc
+    func popEvents(_ resolve: @escaping RCTPromiseResolveBlock,
+                   rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let events = eventQueue.popEvents()
+        resolve(events)
+    }
+
+    @objc
+    func acknowledgeEvents(_ eventIdsJson: String,
+                           resolver resolve: @escaping RCTPromiseResolveBlock,
+                           rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let data = eventIdsJson.data(using: .utf8),
+              let ids = try? JSONSerialization.jsonObject(with: data) as? [String] else {
+            reject("EVENT_ERROR", "Invalid event IDs JSON", nil)
+            return
+        }
+        eventQueue.acknowledgeEvents(eventIds: ids)
+        resolve(nil)
+    }
+
+    // MARK: - Launch Success Tracking
+
+    @objc
+    func recordSuccessfulLaunch(_ bundleHash: String,
+                                resolver resolve: @escaping RCTPromiseResolveBlock,
+                                rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let key = "\(Self.prefsKey)_launch_count_\(bundleHash)"
+        let count = Self.userDefaults.integer(forKey: key) + 1
+        Self.userDefaults.set(count, forKey: key)
+
+        if count == 1 {
+            // First successful launch of this hash
+            eventQueue.pushEvent(type: .installedProd, releaseHash: bundleHash)
+        }
+
+        resolve(count)
+    }
+
+    @objc
+    func getLaunchCount(_ bundleHash: String,
+                        resolver resolve: @escaping RCTPromiseResolveBlock,
+                        rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let key = "\(Self.prefsKey)_launch_count_\(bundleHash)"
+        resolve(Self.userDefaults.integer(forKey: key))
+    }
+
+    // MARK: - Status Reporting
+
+    @objc
+    func reportStatus(_ releaseId: String,
+                      status: String,
+                      resolver resolve: @escaping RCTPromiseResolveBlock,
+                      rejecter reject: @escaping RCTPromiseRejectBlock) {
+        resolve(nil)
+    }
+
+    // MARK: - Helpers
+
+    private func log(_ message: String) {
+        if isDebugMode {
+            print("[SwiftPatch] \(message)")
+        }
+    }
+}
+
+// MARK: - Supporting Types
+
+struct SwiftPatchConfigModel {
+    let deploymentKey: String
+    let serverUrl: String
+    let publicKey: String?
+}
+
+enum SwiftPatchError: LocalizedError {
+    case hashMismatch(expected: String, actual: String)
+    case signatureInvalid
+    case patchFailed
+
+    var errorDescription: String? {
+        switch self {
+        case .hashMismatch(let expected, let actual):
+            return "Hash mismatch: expected \(expected), got \(actual)"
+        case .signatureInvalid:
+            return "Signature verification failed"
+        case .patchFailed:
+            return "Failed to apply patch"
+        }
+    }
+}