@scalebun/react-native 1.0.2 → 1.0.4

package/ios/Ota/ScaleBunOtaBridge.mm

@@ -1,68 +1,77 @@
-#import <React/RCTBridgeModule.h>
-
-/**
- * ObjC++ bridge exposing the ScaleBunOta Swift module to React Native.
- *
- * Old Architecture: RCT_EXTERN_MODULE registers the Swift class.
- *   - `getActiveBundle` is a BLOCKING SYNCHRONOUS method (returns a value).
- *   - `getSlotState` is a BLOCKING SYNCHRONOUS method.
- *   - `stageBundle` / `applyUpdate` / `revertToPrevious` are async promise methods.
- *   - `markHealthy` is a sync void method.
- *
- * New Architecture: the `#ifdef RCT_NEW_ARCH_ENABLED` block vends ScaleBunOta as a
- * real TurboModule via the codegen-generated JSI class.
- */
-@interface RCT_EXTERN_MODULE(ScaleBunOta, NSObject)
-
-RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getActiveBundle)
-RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getSlotState)
-
-RCT_EXTERN_METHOD(stageBundle:(NSString *)sourcePath
-                  sha256:(NSString *)sha256
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(stagePatch:(NSString *)patchUrl
-                  patchSha256:(NSString *)patchSha256
-                  expectedSha256:(NSString *)expectedSha256
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(applyUpdate:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(markHealthy)
-
-RCT_EXTERN_METHOD(revertToPrevious:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
-
-@end
-
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#import <ReactCommon/RCTTurboModule.h>
-// Codegen output from src/specs/NativeScaleBunOta.ts (pod: ScaleBunSpec).
-#import <ScaleBunSpec/ScaleBunSpec.h>
-#import <UserNotifications/UserNotifications.h>
-#if __has_include(<scalebun_react_native/scalebun_react_native-Swift.h>)
-#import <scalebun_react_native/scalebun_react_native-Swift.h>
-#else
-#import "scalebun_react_native-Swift.h"
-#endif
-
-// Add TurboModule conformance + the JSI factory to the Swift `ScaleBunOta` class
-// via a category. `ScaleBunOta` is the ObjC name from `@objc(ScaleBunOta)` in Swift.
-@interface ScaleBunOta (TurboModule) <RCTTurboModule>
-@end
-
-@implementation ScaleBunOta (TurboModule)
-
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
-    (const facebook::react::ObjCTurboModule::InitParams &)params
-{
-    return std::make_shared<facebook::react::NativeScaleBunOtaSpecJSI>(params);
-}
-
-@end
-
-#endif
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTReloadCommand.h>
+
+/**
+ * ObjC++ bridge exposing the ScaleBunOta Swift module to React Native.
+ *
+ * Old Architecture: RCT_EXTERN_MODULE registers the Swift class.
+ *   - `getActiveBundle` is a BLOCKING SYNCHRONOUS method (returns a value).
+ *   - `getSlotState` is a BLOCKING SYNCHRONOUS method.
+ *   - `stageBundle` / `applyUpdate` / `revertToPrevious` are async promise methods.
+ *   - `markHealthy` is a sync void method.
+ *
+ * New Architecture: the `#ifdef RCT_NEW_ARCH_ENABLED` block vends ScaleBunOta as a
+ * real TurboModule via the codegen-generated JSI class.
+ */
+@interface RCT_EXTERN_MODULE(ScaleBunOta, NSObject)
+
+RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getActiveBundle)
+RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getSlotState)
+
+RCT_EXTERN_METHOD(stageBundle:(NSString *)sourcePath
+                  sha256:(NSString *)sha256
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(stagePatch:(NSString *)patchUrl
+                  patchSha256:(NSString *)patchSha256
+                  expectedSha256:(NSString *)expectedSha256
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(applyUpdate:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(markHealthy)
+
+RCT_EXTERN_METHOD(revertToPrevious:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(restartApp)
+
+@end
+
+// Download-progress event channel. Swift subclass of RCTEventEmitter; only
+// registration lives here. Events: ScaleBunOtaProgress {bytesRead, totalBytes}.
+@interface RCT_EXTERN_MODULE(ScaleBunOtaEvents, RCTEventEmitter)
+@end
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <ReactCommon/RCTTurboModule.h>
+// Codegen output from src/specs/NativeScaleBunOta.ts (pod: ScaleBunSpec).
+#import <ScaleBunSpec/ScaleBunSpec.h>
+#import <UserNotifications/UserNotifications.h>
+#if __has_include(<scalebun_react_native/scalebun_react_native-Swift.h>)
+#import <scalebun_react_native/scalebun_react_native-Swift.h>
+#else
+#import "scalebun_react_native-Swift.h"
+#endif
+
+// Add TurboModule conformance + the JSI factory to the Swift `ScaleBunOta` class
+// via a category. `ScaleBunOta` is the ObjC name from `@objc(ScaleBunOta)` in Swift.
+@interface ScaleBunOta (TurboModule) <RCTTurboModule>
+@end
+
+@implementation ScaleBunOta (TurboModule)
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeScaleBunOtaSpecJSI>(params);
+}
+
+@end
+
+#endif

package/ios/Ota/ScaleBunOtaEventsModule.swift

@@ -0,0 +1,61 @@
+import Foundation
+import React
+
+/**
+ * Event channel for OTA download progress (`ScaleBunOtaEvents`).
+ *
+ * A separate module because `ScaleBunOtaModule` is a plain NSObject bridge
+ * module — only an `RCTEventEmitter` subclass can send events to JS, and
+ * retrofitting the main module onto RCTEventEmitter would change its
+ * initialization contract on both architectures for the sake of one event.
+ *
+ * The JS side (`OtaOrchestrator`) listens via
+ * `new NativeEventEmitter(NativeModules.ScaleBunOtaEvents)` and turns these
+ * into `DOWNLOAD_PROGRESS` events for the `useOtaUpdate` hook plus throttled
+ * POSTs to the backend's live tracker. On Android the same payload rides
+ * `RCTDeviceEventEmitter` instead.
+ */
+@objc(ScaleBunOtaEvents)
+class ScaleBunOtaEventsModule: RCTEventEmitter {
+
+    /// The bridge instantiates the module; the downloader reaches it through
+    /// this. Weak: the bridge owns the lifetime, not us.
+    private static weak var shared: ScaleBunOtaEventsModule?
+
+    private var hasActiveListeners = false
+
+    override init() {
+        super.init()
+        ScaleBunOtaEventsModule.shared = self
+    }
+
+    @objc override static func requiresMainQueueSetup() -> Bool { false }
+
+    override func supportedEvents() -> [String]! {
+        ["ScaleBunOtaProgress"]
+    }
+
+    override func startObserving() {
+        hasActiveListeners = true
+    }
+
+    override func stopObserving() {
+        hasActiveListeners = false
+    }
+
+    /**
+     * Emit a progress tick to JS. Safe to call from any thread and from code
+     * with no bridge (returns silently) — progress display must never be able
+     * to break the download it describes.
+     */
+    static func emitProgress(bytesRead: Int64, totalBytes: Int64) {
+        guard let instance = shared, instance.hasActiveListeners else { return }
+        instance.sendEvent(
+            withName: "ScaleBunOtaProgress",
+            body: [
+                "bytesRead": bytesRead,
+                "totalBytes": totalBytes,
+            ]
+        )
+    }
+}

package/ios/Ota/ScaleBunOtaModule.swift

@@ -1,123 +1,176 @@
-import Foundation
-import React
-
-/**
- * React Native bridge for OTA bundle management (`ScaleBunOta`) on iOS.
- *
- * Sprint 2: real slot management via OtaSlotManager. All filesystem operations
- * are delegated to the slot manager (pure Swift, no RN dependency).
- *
- * The static `getBundleURL()` method is called from the host app's
- * AppDelegate.bundleURL() to resolve the active OTA bundle at launch.
- *
- * Selectors are pinned with explicit `@objc(...)` so they match the React Native
- * Codegen-generated `NativeScaleBunOtaSpec` protocol on the New Architecture and
- * the `RCT_EXTERN_*` declarations in the bridge on the Old Architecture.
- */
-@objc(ScaleBunOta)
-class ScaleBunOtaModule: NSObject, RCTBridgeModule {
-
-    private static let slotManager = OtaSlotManager()
-
-    static func moduleName() -> String! { "ScaleBunOta" }
-
-    @objc static func requiresMainQueueSetup() -> Bool { false }
-
-    /**
-     * Static entry point for AppDelegate.bundleURL().
-     *
-     * Called BEFORE React Native initializes JS — this is where the boot
-     * guard runs and the active bundle URL is resolved.
-     *
-     * Returns nil in DEBUG builds (Metro always wins) or when no OTA
-     * bundle is installed.
-     *
-     * Usage in AppDelegate.mm:
-     * ```objc
-     * - (NSURL *)bundleURL {
-     *   #if DEBUG
-     *     return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index"];
-     *   #else
-     *     NSURL *otaURL = [ScaleBunOtaModule getBundleURL];
-     *     if (otaURL) return otaURL;
-     *     return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
-     *   #endif
-     * }
-     * ```
-     */
-    @objc static func getBundleURL() -> URL? {
-        #if DEBUG
-        return nil
-        #else
-        slotManager.checkBootGuard()
-        return slotManager.currentBundleURL()
-        #endif
-    }
-
-    // MARK: - Bridge Methods
-
-    @objc(getActiveBundle)
-    func getActiveBundle() -> NSString? {
-        #if DEBUG
-        return nil
-        #else
-        guard let url = ScaleBunOtaModule.slotManager.currentBundleURL() else { return nil }
-        return url.path as NSString
-        #endif
-    }
-
-    @objc(getSlotState)
-    func getSlotState() -> NSString {
-        return ScaleBunOtaModule.slotManager.slotStateJSON() as NSString
-    }
-
-    @objc(stageBundle:sha256:resolve:reject:)
-    func stageBundle(_ sourcePath: NSString,
-                     sha256: NSString,
-                     resolve: @escaping RCTPromiseResolveBlock,
-                     reject: @escaping RCTPromiseRejectBlock) {
-        let meta: [String: Any] = [
-            "sha256": sha256 as String,
-            "installedAt": Int(Date().timeIntervalSince1970 * 1000)
-        ]
-
-        let success = ScaleBunOtaModule.slotManager.stage(
-            sourcePath: sourcePath as String,
-            expectedSha256: sha256 as String,
-            meta: meta
-        )
-        resolve(success)
-    }
-
-    @objc(stagePatch:patchSha256:expectedSha256:resolve:reject:)
-    func stagePatch(_ patchUrl: NSString,
-                    patchSha256: NSString,
-                    expectedSha256: NSString,
-                    resolve: @escaping RCTPromiseResolveBlock,
-                    reject: @escaping RCTPromiseRejectBlock) {
-        // Delta/patch updates (native bspatch) are not implemented yet — resolve
-        // false so OtaOrchestrator falls back to full-bundle staging. Declared for
-        // parity with the TS spec + Android so the patch path resolves cleanly
-        // instead of hitting an unrecognized selector.
-        resolve(false)
-    }
-
-    @objc(applyUpdate:reject:)
-    func applyUpdate(_ resolve: @escaping RCTPromiseResolveBlock,
-                     reject: @escaping RCTPromiseRejectBlock) {
-        let success = ScaleBunOtaModule.slotManager.apply()
-        resolve(success)
-    }
-
-    @objc(markHealthy)
-    func markHealthy() {
-        ScaleBunOtaModule.slotManager.markHealthy()
-    }
-
-    @objc(revertToPrevious:reject:)
-    func revertToPrevious(_ resolve: @escaping RCTPromiseResolveBlock,
-                          reject: @escaping RCTPromiseRejectBlock) {
-        let success = ScaleBunOtaModule.slotManager.revert()
-        resolve(success)
-    }
-}
+import Foundation
+import React
+
+/**
+ * React Native bridge for OTA bundle management (`ScaleBunOta`) on iOS.
+ *
+ * Sprint 2: real slot management via OtaSlotManager. All filesystem operations
+ * are delegated to the slot manager (pure Swift, no RN dependency).
+ *
+ * The static `getBundleURL()` method is called from the host app's
+ * AppDelegate.bundleURL() to resolve the active OTA bundle at launch.
+ *
+ * Selectors are pinned with explicit `@objc(...)` so they match the React Native
+ * Codegen-generated `NativeScaleBunOtaSpec` protocol on the New Architecture and
+ * the `RCT_EXTERN_*` declarations in the bridge on the Old Architecture.
+ */
+@objc(ScaleBunOta)
+class ScaleBunOtaModule: NSObject, RCTBridgeModule {
+
+    private static let slotManager = OtaSlotManager()
+
+    static func moduleName() -> String! { "ScaleBunOta" }
+
+    @objc static func requiresMainQueueSetup() -> Bool { false }
+
+    /**
+     * Static entry point for AppDelegate.bundleURL().
+     *
+     * Called BEFORE React Native initializes JS — this is where the boot
+     * guard runs and the active bundle URL is resolved.
+     *
+     * Returns nil in DEBUG builds (Metro always wins) or when no OTA
+     * bundle is installed.
+     *
+     * Usage in AppDelegate.mm:
+     * ```objc
+     * - (NSURL *)bundleURL {
+     *   #if DEBUG
+     *     return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index"];
+     *   #else
+     *     NSURL *otaURL = [ScaleBunOtaModule getBundleURL];
+     *     if (otaURL) return otaURL;
+     *     return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
+     *   #endif
+     * }
+     * ```
+     */
+    @objc static func getBundleURL() -> URL? {
+        #if DEBUG
+        return nil
+        #else
+        slotManager.checkBootGuard()
+        return slotManager.currentBundleURL()
+        #endif
+    }
+
+    // MARK: - Bridge Methods
+
+    @objc(getActiveBundle)
+    func getActiveBundle() -> NSString? {
+        #if DEBUG
+        return nil
+        #else
+        guard let url = ScaleBunOtaModule.slotManager.currentBundleURL() else { return nil }
+        return url.path as NSString
+        #endif
+    }
+
+    @objc(getSlotState)
+    func getSlotState() -> NSString {
+        return ScaleBunOtaModule.slotManager.slotStateJSON() as NSString
+    }
+
+    @objc(stageBundle:sha256:resolve:reject:)
+    /// Stage a bundle into the `next` slot.
+    ///
+    /// OTA-05: `sourcePath` may be an http(s) URL or a local file path. The JS
+    /// orchestrator has always passed `bundle.url` here while this method assumed
+    /// a filesystem path, so every install failed at staging. Accepting both keeps
+    /// the documented local-path contract for existing callers and makes the
+    /// orchestrator correct without a coordinated JS+native change.
+    func stageBundle(_ sourcePath: NSString,
+                     sha256: NSString,
+                     resolve: @escaping RCTPromiseResolveBlock,
+                     reject: @escaping RCTPromiseRejectBlock) {
+        let source = sourcePath as String
+        let meta: [String: Any] = [
+            "sha256": sha256 as String,
+            "installedAt": Int(Date().timeIntervalSince1970 * 1000)
+        ]
+
+        let lowered = source.lowercased()
+        var downloadedTo: URL?
+
+        let localPath: String
+        if lowered.hasPrefix("http://") || lowered.hasPrefix("https://") {
+            let temp = FileManager.default.temporaryDirectory
+                .appendingPathComponent("scalebun_ota_dl_\(UUID().uuidString)")
+            downloadedTo = temp
+            guard BundleDownloader.download(urlString: source, destination: temp) else {
+                resolve(false)
+                return
+            }
+            localPath = temp.path
+        } else {
+            localPath = source
+        }
+
+        // The slot manager copies into its own `_tmp_` directory and verifies the
+        // SHA-256 there, so this download is never the file that gets promoted.
+        let success = ScaleBunOtaModule.slotManager.stage(
+            sourcePath: localPath,
+            expectedSha256: sha256 as String,
+            meta: meta
+        )
+
+        if let downloadedTo = downloadedTo {
+            try? FileManager.default.removeItem(at: downloadedTo)
+        }
+        resolve(success)
+    }
+
+    @objc(stagePatch:patchSha256:expectedSha256:resolve:reject:)
+    /// Sprint 7 scaffold — binary patching is NOT implemented on iOS.
+    ///
+    /// This stub exists because the codegen spec (NativeScaleBunOta.ts) declares
+    /// `stagePatch`, so on the New Architecture the generated JSI class
+    /// dispatches the call to this selector whether or not it exists — a missing
+    /// implementation surfaces as an "unrecognized selector" exception on every
+    /// patch attempt. The identical gap broke the Android build at the start of
+    /// this effort (Kotlin fails at compile; ObjC fails at runtime, which is
+    /// worse because it ships). Resolving `false` routes the orchestrator to its
+    /// full-bundle fallback, exactly like Android.
+    func stagePatch(_ patchUrl: NSString,
+                    patchSha256: NSString,
+                    expectedSha256: NSString,
+                    resolve: @escaping RCTPromiseResolveBlock,
+                    reject: @escaping RCTPromiseRejectBlock) {
+        resolve(false)
+    }
+
+    @objc(applyUpdate:reject:)
+    func applyUpdate(_ resolve: @escaping RCTPromiseResolveBlock,
+                     reject: @escaping RCTPromiseRejectBlock) {
+        let success = ScaleBunOtaModule.slotManager.apply()
+        resolve(success)
+    }
+
+    @objc(markHealthy)
+    func markHealthy() {
+        ScaleBunOtaModule.slotManager.markHealthy()
+    }
+
+    @objc(revertToPrevious:reject:)
+    func revertToPrevious(_ resolve: @escaping RCTPromiseResolveBlock,
+                          reject: @escaping RCTPromiseRejectBlock) {
+        let success = ScaleBunOtaModule.slotManager.revert()
+        resolve(success)
+    }
+
+    /**
+     * Restart the React runtime so the applied bundle loads NOW.
+     *
+     * `DevSettings.reload()` is a silent no-op in release builds (verified live
+     * on Android; the iOS DevSettings path shares the design). RCTReloadCommand
+     * is the mechanism React Native itself uses for every reload — it re-runs
+     * `AppDelegate.bundleURL()`, which is what picks up the new `current/`.
+     * Dispatched to the main thread: reload tears down UI.
+     */
+    @objc(restartApp)
+    func restartApp() {
+        DispatchQueue.main.async {
+            RCTTriggerReloadCommandListeners("ScaleBun OTA update")
+        }
+    }
+}