@swiftpatch/react-native 2.0.0

package/ios/SwiftPatch/SlotManager.swift

@@ -0,0 +1,360 @@
+import Foundation
+
+/// Represents the three slots for bundle management
+enum SlotState: String {
+    case defaultSlot = "DEFAULT_SLOT"
+    case stableSlot = "STABLE_SLOT"
+    case newSlot = "NEW_SLOT"
+}
+
+/// Represents the environment mode
+enum EnvironmentMode: String {
+    case production = "PROD"
+    case staging = "STAGE"
+}
+
+/// Manages the dual-slot architecture for safe OTA deployments.
+/// Supports: DEFAULT_SLOT (app store), STABLE_SLOT (promoted), NEW_SLOT (latest OTA)
+class SlotManager {
+
+    private let userDefaults: UserDefaults
+    private let prefsKey: String
+    private let fileManager = FileManager.default
+
+    private var baseDir: URL {
+        let documentsDir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+        return documentsDir.appendingPathComponent("swiftpatch")
+    }
+
+    private var prodDir: URL { baseDir.appendingPathComponent("prod") }
+    private var prodNewDir: URL { prodDir.appendingPathComponent("new") }
+    private var prodStableDir: URL { prodDir.appendingPathComponent("stable") }
+    private var stageDir: URL { baseDir.appendingPathComponent("stage") }
+    private var stageNewDir: URL { stageDir.appendingPathComponent("new") }
+
+    init(userDefaults: UserDefaults, prefsKey: String) {
+        self.userDefaults = userDefaults
+        self.prefsKey = prefsKey
+        ensureSlotDirectories()
+    }
+
+    // MARK: - Directory Management
+
+    func ensureSlotDirectories() {
+        try? fileManager.createDirectory(at: prodNewDir, withIntermediateDirectories: true)
+        try? fileManager.createDirectory(at: prodStableDir, withIntermediateDirectories: true)
+        try? fileManager.createDirectory(at: stageNewDir, withIntermediateDirectories: true)
+    }
+
+    // MARK: - Current State
+
+    /// Get the current environment mode
+    var currentEnvironment: EnvironmentMode {
+        get {
+            let raw = userDefaults.string(forKey: "\(prefsKey)_environment") ?? "PROD"
+            return EnvironmentMode(rawValue: raw) ?? .production
+        }
+        set {
+            userDefaults.set(newValue.rawValue, forKey: "\(prefsKey)_environment")
+        }
+    }
+
+    /// Get the current production slot
+    var currentProdSlot: SlotState {
+        get {
+            let raw = userDefaults.string(forKey: "\(prefsKey)_prod_current_slot") ?? "DEFAULT_SLOT"
+            return SlotState(rawValue: raw) ?? .defaultSlot
+        }
+        set {
+            userDefaults.set(newValue.rawValue, forKey: "\(prefsKey)_prod_current_slot")
+        }
+    }
+
+    /// Get/set production slot hashes
+    var prodNewHash: String? {
+        get { userDefaults.string(forKey: "\(prefsKey)_prod_new_hash") }
+        set { userDefaults.set(newValue, forKey: "\(prefsKey)_prod_new_hash") }
+    }
+
+    var prodStableHash: String? {
+        get { userDefaults.string(forKey: "\(prefsKey)_prod_stable_hash") }
+        set { userDefaults.set(newValue, forKey: "\(prefsKey)_prod_stable_hash") }
+    }
+
+    var prodTempHash: String? {
+        get { userDefaults.string(forKey: "\(prefsKey)_prod_temp_hash") }
+        set { userDefaults.set(newValue, forKey: "\(prefsKey)_prod_temp_hash") }
+    }
+
+    /// Stage slot hash
+    var stageNewHash: String? {
+        get { userDefaults.string(forKey: "\(prefsKey)_stage_new_hash") }
+        set { userDefaults.set(newValue, forKey: "\(prefsKey)_stage_new_hash") }
+    }
+
+    // MARK: - Bundle Path Resolution
+
+    /// Get the correct JS bundle URL based on current slot state
+    func getBundleURL() -> URL? {
+        let env = currentEnvironment
+
+        if env == .staging {
+            // In staging, use stage new slot if available
+            if let hash = stageNewHash {
+                let path = stageNewDir.appendingPathComponent("\(hash).bundle")
+                if fileManager.fileExists(atPath: path.path) {
+                    return path
+                }
+            }
+            return nil // Fall back to default
+        }
+
+        // Production mode
+        switch currentProdSlot {
+        case .newSlot:
+            if let hash = prodNewHash {
+                let path = prodNewDir.appendingPathComponent("\(hash).bundle")
+                if fileManager.fileExists(atPath: path.path) {
+                    return path
+                }
+            }
+            // Fallthrough to stable
+            if let hash = prodStableHash {
+                let path = prodStableDir.appendingPathComponent("\(hash).bundle")
+                if fileManager.fileExists(atPath: path.path) {
+                    currentProdSlot = .stableSlot
+                    return path
+                }
+            }
+            currentProdSlot = .defaultSlot
+            return nil
+
+        case .stableSlot:
+            if let hash = prodStableHash {
+                let path = prodStableDir.appendingPathComponent("\(hash).bundle")
+                if fileManager.fileExists(atPath: path.path) {
+                    return path
+                }
+            }
+            currentProdSlot = .defaultSlot
+            return nil
+
+        case .defaultSlot:
+            return nil // Use app store bundle
+        }
+    }
+
+    // MARK: - Temp Hash (Deferred Apply)
+
+    /// Apply temp hash on restart. Called during app launch.
+    /// Moves tempHash → newHash and updates slot.
+    func applyTempHashOnLaunch() {
+        guard let tempHash = prodTempHash else { return }
+
+        // Move bundle from bundles dir to prod/new dir
+        let bundlesDir = baseDir.appendingPathComponent("bundles")
+        let sourcePath = bundlesDir.appendingPathComponent("\(tempHash).bundle")
+        let destPath = prodNewDir.appendingPathComponent("\(tempHash).bundle")
+
+        if fileManager.fileExists(atPath: sourcePath.path) {
+            try? fileManager.removeItem(at: destPath)
+            try? fileManager.moveItem(at: sourcePath, to: destPath)
+        }
+
+        prodNewHash = tempHash
+        prodTempHash = nil
+        currentProdSlot = .newSlot
+
+        userDefaults.set(
+            ISO8601DateFormatter().string(from: Date()),
+            forKey: "\(prefsKey)_current_bundle_installed_at"
+        )
+    }
+
+    // MARK: - Stabilization (NEW → STABLE)
+
+    /// Promote the current NEW slot bundle to STABLE slot.
+    /// This creates a known-good fallback point.
+    func stabilize() -> Bool {
+        guard let newHash = prodNewHash else { return false }
+
+        let sourcePath = prodNewDir.appendingPathComponent("\(newHash).bundle")
+        let destPath = prodStableDir.appendingPathComponent("\(newHash).bundle")
+
+        guard fileManager.fileExists(atPath: sourcePath.path) else { return false }
+
+        // Remove old stable bundle
+        if let oldStableHash = prodStableHash {
+            let oldPath = prodStableDir.appendingPathComponent("\(oldStableHash).bundle")
+            try? fileManager.removeItem(at: oldPath)
+        }
+
+        // Copy new bundle to stable slot
+        try? fileManager.removeItem(at: destPath)
+        do {
+            try fileManager.copyItem(at: sourcePath, to: destPath)
+        } catch {
+            return false
+        }
+
+        prodStableHash = newHash
+        prodNewHash = nil
+        currentProdSlot = .stableSlot
+
+        return true
+    }
+
+    // MARK: - Rollback
+
+    /// Rollback production: NEW → STABLE → DEFAULT
+    func rollbackProd(isAutoRollback: Bool) -> String {
+        let currentSlot = currentProdSlot
+
+        switch currentSlot {
+        case .newSlot:
+            // Clear new slot
+            if let hash = prodNewHash {
+                let path = prodNewDir.appendingPathComponent("\(hash).bundle")
+                try? fileManager.removeItem(at: path)
+            }
+            prodNewHash = nil
+            prodTempHash = nil
+
+            // Fall to stable if available
+            if prodStableHash != nil {
+                currentProdSlot = .stableSlot
+                return "ROLLED_BACK_TO_STABLE"
+            } else {
+                currentProdSlot = .defaultSlot
+                return "ROLLED_BACK_TO_DEFAULT"
+            }
+
+        case .stableSlot:
+            // Clear stable slot
+            if let hash = prodStableHash {
+                let path = prodStableDir.appendingPathComponent("\(hash).bundle")
+                try? fileManager.removeItem(at: path)
+            }
+            prodStableHash = nil
+            currentProdSlot = .defaultSlot
+            return "ROLLED_BACK_TO_DEFAULT"
+
+        case .defaultSlot:
+            return "ALREADY_AT_DEFAULT"
+        }
+    }
+
+    /// Rollback staging: NEW → DEFAULT
+    func rollbackStage() {
+        if let hash = stageNewHash {
+            let path = stageNewDir.appendingPathComponent("\(hash).bundle")
+            try? fileManager.removeItem(at: path)
+        }
+        stageNewHash = nil
+    }
+
+    // MARK: - Version Change Detection
+
+    /// Check if app binary version changed (app store update).
+    /// If so, wipe all OTA bundles and reset to default.
+    func checkVersionChange() -> Bool {
+        let currentAppVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "0.0.0"
+        let lastKnownVersion = userDefaults.string(forKey: "\(prefsKey)_last_known_app_version")
+
+        if let lastVersion = lastKnownVersion, lastVersion != currentAppVersion {
+            // App binary was updated via App Store - wipe all OTA bundles
+            fallbackToDefault()
+            userDefaults.set(currentAppVersion, forKey: "\(prefsKey)_last_known_app_version")
+            return true
+        }
+
+        if lastKnownVersion == nil {
+            // First launch, just store the version
+            userDefaults.set(currentAppVersion, forKey: "\(prefsKey)_last_known_app_version")
+        }
+
+        return false
+    }
+
+    /// Wipe all OTA bundles and reset to default slot
+    func fallbackToDefault() {
+        // Clear all hashes
+        prodNewHash = nil
+        prodStableHash = nil
+        prodTempHash = nil
+        stageNewHash = nil
+        currentProdSlot = .defaultSlot
+
+        // Clear legacy keys
+        userDefaults.removeObject(forKey: "\(prefsKey)_current_bundle_hash")
+        userDefaults.removeObject(forKey: "\(prefsKey)_current_bundle_path")
+        userDefaults.removeObject(forKey: "\(prefsKey)_previous_bundle_hash")
+        userDefaults.removeObject(forKey: "\(prefsKey)_previous_bundle_path")
+        userDefaults.removeObject(forKey: "\(prefsKey)_pending_bundle_hash")
+        userDefaults.removeObject(forKey: "\(prefsKey)_pending_bundle_path")
+        userDefaults.removeObject(forKey: "\(prefsKey)_pending_install_confirmation")
+        userDefaults.set(0, forKey: "\(prefsKey)_crash_count")
+
+        // Delete all bundle directories
+        try? fileManager.removeItem(at: prodNewDir)
+        try? fileManager.removeItem(at: prodStableDir)
+        try? fileManager.removeItem(at: stageNewDir)
+
+        // Recreate
+        ensureSlotDirectories()
+    }
+
+    // MARK: - Metadata
+
+    /// Get full slot metadata as dictionary (for JS bridge)
+    func getMetadata() -> [String: Any] {
+        return [
+            "environment": currentEnvironment.rawValue,
+            "prod": [
+                "currentSlot": currentProdSlot.rawValue,
+                "newHash": prodNewHash as Any,
+                "stableHash": prodStableHash as Any,
+                "tempHash": prodTempHash as Any,
+            ],
+            "stage": [
+                "newHash": stageNewHash as Any,
+            ]
+        ]
+    }
+
+    // MARK: - Cleanup
+
+    /// Clean up unused bundles from all slots
+    func cleanup() {
+        let keepHashes = Set([prodNewHash, prodStableHash, stageNewHash].compactMap { $0 })
+
+        // Clean prod/new
+        cleanDirectory(prodNewDir, keeping: keepHashes)
+        // Clean prod/stable
+        cleanDirectory(prodStableDir, keeping: keepHashes)
+        // Clean stage/new
+        cleanDirectory(stageNewDir, keeping: keepHashes)
+
+        // Clean legacy bundles dir
+        let bundlesDir = baseDir.appendingPathComponent("bundles")
+        cleanDirectory(bundlesDir, keeping: keepHashes)
+
+        // Clean temp
+        let tempDir = baseDir.appendingPathComponent("temp")
+        if let files = try? fileManager.contentsOfDirectory(at: tempDir, includingPropertiesForKeys: nil) {
+            for file in files {
+                try? fileManager.removeItem(at: file)
+            }
+        }
+    }
+
+    private func cleanDirectory(_ dir: URL, keeping keepHashes: Set<String>) {
+        guard let files = try? fileManager.contentsOfDirectory(at: dir, includingPropertiesForKeys: nil) else { return }
+        for file in files {
+            let fileHash = file.deletingPathExtension().lastPathComponent
+            if !keepHashes.contains(fileHash) {
+                try? fileManager.removeItem(at: file)
+            }
+        }
+    }
+}

package/ios/SwiftPatch/SwiftPatchModule.m

@@ -0,0 +1,56 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(SwiftPatch, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(initialize:(NSDictionary *)config
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setDebugMode:(BOOL)enabled)
+
+RCT_EXTERN_METHOD(getCurrentBundle:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getDeviceId:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getAppVersion:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(downloadUpdate:(NSString *)url
+                  expectedHash:(NSString *)expectedHash
+                  isPatch:(BOOL)isPatch
+                  signature:(NSString *)signature
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(installUpdate:(NSString *)bundleHash
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(hasPendingInstall:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(confirmInstall:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(restart)
+
+RCT_EXTERN_METHOD(rollback:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(clearPendingUpdate:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reportStatus:(NSString *)releaseId
+                  status:(NSString *)status
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+    return YES;
+}
+
+@end