@scalebun-release/react-native 2.5.0

package/ios/Crash/ScaleBunCrashSignalStress.c

@@ -0,0 +1,137 @@
+/**
+ * Stress test for the session-id publication primitive.
+ *
+ *   clang -o /tmp/sbstress ScaleBunCrashSignalStress.c ScaleBunCrashSignalBridge.c && /tmp/sbstress
+ *
+ * (ScaleBunCrashSignalBridge.m compiles as C — it contains no Objective-C. Copy or symlink it to a
+ *  .c name, or build with `clang -x c`.)
+ *
+ * WHAT THIS DOES AND DOES NOT PROVE.
+ *
+ * It does NOT replace the safety argument. Async-signal-safety is a property of which operations are
+ * permitted in a handler, and no amount of passing runs establishes it — the previous design passed
+ * every casual test and was still wrong.
+ *
+ * What it DOES catch is implementation error: an off-by-one, a missing terminator, a truncation bug,
+ * or a publication that is not in fact atomic on this filesystem. It runs a publisher thread
+ * alternating two known ids as fast as it can, while a reader thread performs exactly the read the
+ * signal handler performs. The only acceptable observations are complete known ids.
+ *
+ * A single torn or truncated observation fails the run.
+ */
+
+#include <pthread.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include "ScaleBunCrashSignalBridge.h"
+
+#define ITERATIONS 200000
+#define SESSION_MAX 128
+
+static const char *MARKER = "/tmp/scalebun_stress_session";
+static const char *TMPP   = "/tmp/scalebun_stress_session.tmp";
+
+static const char *ID_A = "sess-AAAAAAAAAAAAAAAA";
+static const char *ID_B = "sess-BBBBBBBBBBBBBBBB";
+
+static volatile int running = 1;
+static volatile long torn = 0;
+static volatile long reads = 0;
+
+/* Byte-for-byte what scalebun_write_signal_crash does to read the id. */
+static int read_marker(char *out, size_t cap) {
+    int fd = open(MARKER, O_RDONLY);
+    if (fd < 0) return 0;
+    ssize_t n = read(fd, out, cap);
+    close(fd);
+    return n > 0 ? (int)n : 0;
+}
+
+static void *publisher(void *arg) {
+    (void)arg;
+    for (long i = 0; i < ITERATIONS && running; i++) {
+        ScaleBunCrashSignalBridgeSetSessionId((i & 1) ? ID_A : ID_B);
+    }
+    running = 0;
+    return NULL;
+}
+
+static void *reader(void *arg) {
+    (void)arg;
+    char buf[SESSION_MAX];
+    while (running) {
+        int n = read_marker(buf, sizeof(buf));
+        if (n == 0) continue;              /* marker briefly absent is fine — never a torn value */
+        reads++;
+        int okA = (n == (int)strlen(ID_A)) && memcmp(buf, ID_A, (size_t)n) == 0;
+        int okB = (n == (int)strlen(ID_B)) && memcmp(buf, ID_B, (size_t)n) == 0;
+        if (!okA && !okB) {
+            torn++;
+            if (torn <= 5) {
+                buf[n < SESSION_MAX ? n : SESSION_MAX - 1] = '\0';
+                fprintf(stderr, "TORN OBSERVATION: \"%s\" (%d bytes)\n", buf, n);
+            }
+        }
+    }
+    return NULL;
+}
+
+int main(void) {
+    unlink(MARKER);
+    unlink(TMPP);
+    ScaleBunCrashSignalBridgeInstall("/tmp/scalebun_stress_crash.json", MARKER, TMPP);
+
+    /* Boundary cases first — these are deterministic and do not need the race. */
+    char buf[SESSION_MAX];
+
+    char maxId[SESSION_MAX + 40];
+    memset(maxId, 'a', sizeof(maxId) - 1);
+    maxId[sizeof(maxId) - 1] = '\0';
+    memcpy(maxId, "sess-", 5);
+    ScaleBunCrashSignalBridgeSetSessionId(maxId);
+    int n = read_marker(buf, sizeof(buf));
+    if (n != SESSION_MAX) {
+        fprintf(stderr, "FAIL: over-long id stored %d bytes, expected %d\n", n, SESSION_MAX);
+        return 1;
+    }
+
+    ScaleBunCrashSignalBridgeSetSessionId("sess-\"drop\\these/chars");
+    n = read_marker(buf, sizeof(buf));
+    for (int i = 0; i < n; i++) {
+        char c = buf[i];
+        int ok = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+                 (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == ':';
+        if (!ok) {
+            fprintf(stderr, "FAIL: unsanitised byte 0x%02x survived publication\n", (unsigned char)c);
+            return 1;
+        }
+    }
+
+    ScaleBunCrashSignalBridgeSetSessionId(NULL);
+    if (read_marker(buf, sizeof(buf)) != 0) {
+        fprintf(stderr, "FAIL: NULL did not clear the marker\n");
+        return 1;
+    }
+
+    /* Now the race. */
+    pthread_t p, r;
+    pthread_create(&p, NULL, publisher, NULL);
+    pthread_create(&r, NULL, reader, NULL);
+    pthread_join(p, NULL);
+    pthread_join(r, NULL);
+
+    printf("boundary cases: PASS\n");
+    printf("reads observed : %ld\n", reads);
+    printf("torn           : %ld\n", torn);
+    if (reads < 1000) {
+        fprintf(stderr, "FAIL: too few reads (%ld) for the result to mean anything\n", reads);
+        return 1;
+    }
+    if (torn != 0) return 1;
+    printf("RESULT: PASS — every observation was a complete known id\n");
+    return 0;
+}

package/ios/Crash/ScaleBunCrashStorage.swift

@@ -0,0 +1,121 @@
+import Foundation
+
+/**
+ * Persists a single crash record to the app's documents directory.
+ * Written before the process terminates; read and cleared on next launch.
+ *
+ * Uses a fixed filename so only the most recent crash is kept.
+ */
+@objc class ScaleBunCrashStorage: NSObject {
+
+    static let crashFileName = "scalebun_native_crash.json"
+
+    private static var crashFilePath: String = {
+        let dir = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true).first ?? ""
+        return (dir as NSString).appendingPathComponent(crashFileName)
+    }()
+
+    /// Path as a C string — pre-computed so signal handlers can use it without heap allocation.
+    static let crashFilePathCString: UnsafePointer<CChar> = {
+        let path = crashFilePath
+        let buf = UnsafeMutablePointer<CChar>.allocate(capacity: path.utf8.count + 1)
+        path.withCString { cStr in
+            _ = strcpy(buf, cStr)
+        }
+        return UnsafePointer(buf)
+    }()
+
+    /**
+     * Session marker paths, in the SAME directory as the crash file.
+     *
+     * Same directory is a correctness requirement, not tidiness: `rename(2)` is only atomic within
+     * one filesystem, and a cross-device rename fails outright — which would leave the marker
+     * holding a stale session while the app believed it had published a new one.
+     */
+    private static let sessionMarkerName = "scalebun_active_session"
+    private static let sessionTmpName = "scalebun_active_session.tmp"
+
+    private static func cString(_ path: String) -> UnsafePointer<CChar> {
+        let buf = UnsafeMutablePointer<CChar>.allocate(capacity: path.utf8.count + 1)
+        path.withCString { _ = strcpy(buf, $0) }
+        return UnsafePointer(buf)
+    }
+
+    /// Pre-computed C strings — allocated once at startup so the signal path never allocates.
+    static let sessionMarkerPathCString: UnsafePointer<CChar> = {
+        let dir = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true).first ?? ""
+        return cString((dir as NSString).appendingPathComponent(sessionMarkerName))
+    }()
+
+    static let sessionTmpPathCString: UnsafePointer<CChar> = {
+        let dir = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true).first ?? ""
+        return cString((dir as NSString).appendingPathComponent(sessionTmpName))
+    }()
+
+    @objc static func write(_ jsonString: String) {
+        try? jsonString.write(toFile: crashFilePath, atomically: true, encoding: .utf8)
+    }
+
+    /**
+     * The session that is live RIGHT NOW.
+     *
+     * WHY IT IS STORED AHEAD OF THE CRASH. A crash record outlives the process; the JS session id
+     * did not, because it only ever existed in JS memory. So the next launch had nothing to
+     * attribute a recovered crash to except whichever session had just been created — the crash
+     * from session A landed on session B.
+     *
+     * `UserDefaults`, not a file, on purpose: reads are served from an in-memory cache once the
+     * domain is loaded, so the NSException handler does no filesystem work on the crash path.
+     *
+     * ⚠️ THIS IS **NOT** ASYNC-SIGNAL-SAFE, and is deliberately not used from the signal handler.
+     * `UserDefaults` takes locks and may allocate; calling it from a signal handler risks a
+     * deadlock inside an already-dying process. The signal path keeps its existing minimal,
+     * syscall-only record and therefore stays unattributed — see the note in the handler.
+     */
+    private static let activeSessionKey = "scalebun.activeSessionId"
+
+    @objc static func setActiveSessionId(_ sessionId: String?) {
+        if let id = sessionId, !id.isEmpty {
+            UserDefaults.standard.set(id, forKey: activeSessionKey)
+        } else {
+            UserDefaults.standard.removeObject(forKey: activeSessionKey)
+        }
+
+        /*
+         * ALSO publish into the signal handler's static buffer.
+         *
+         * The NSException path can read UserDefaults; the SIGNAL path cannot — UserDefaults takes
+         * locks and may allocate, and a lock held by the thread we just interrupted would deadlock a
+         * dying process. So the id is pushed into preallocated C storage here, in normal code, and
+         * the handler only ever reads it.
+         *
+         * Both sinks are written from this one place so the two iOS crash paths can never disagree
+         * about which session is live.
+         */
+        if let id = sessionId, !id.isEmpty {
+            id.withCString { ScaleBunCrashSignalBridgeSetSessionId($0) }
+        } else {
+            ScaleBunCrashSignalBridgeSetSessionId(nil)
+        }
+    }
+
+    @objc static func activeSessionId() -> String? {
+        let id = UserDefaults.standard.string(forKey: activeSessionKey)
+        return (id?.isEmpty ?? true) ? nil : id
+    }
+
+    @objc static func read() -> [String: Any]? {
+        guard let data = try? Data(contentsOf: URL(fileURLWithPath: crashFilePath)),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else { return nil }
+        return json
+    }
+
+    @objc static func clear() {
+        try? FileManager.default.removeItem(atPath: crashFilePath)
+    }
+
+    @objc static func hasPending() -> Bool {
+        return FileManager.default.fileExists(atPath: crashFilePath)
+    }
+}

package/ios/Crash/ScaleBunExceptionChain.swift

@@ -0,0 +1,71 @@
+import Foundation
+
+/**
+ * Installs an uncaught-exception handler WITHOUT evicting the one already there.
+ *
+ * NSSetUncaughtExceptionHandler holds exactly one handler per process. Crash
+ * reporters that arrive earlier — Firebase Crashlytics is configured in
+ * `didFinishLaunching`, before React Native starts this SDK — are replaced by
+ * whoever calls it last. ScaleBunCrashHandler used to call it bare, so on every
+ * host that also runs Crashlytics (le-garage among them) ObjC/Swift exceptions
+ * stopped reaching Crashlytics the moment the SDK started. Nothing failed
+ * visibly: the other tool's crash list simply went quiet.
+ *
+ * This keeps the previous handler and calls it after recording ours. Ours runs
+ * FIRST because the next handler may terminate the process; the reverse order
+ * would lose our record whenever it does.
+ *
+ * The fatal-signal path does not need this: ScaleBunCrashSignalBridge already
+ * saves the previous sigaction at install and restores it before re-raising.
+ *
+ * Pure Foundation on purpose, so `swift test` compiles and runs it without
+ * React (see Package.swift, target ScaleBunCrashChain).
+ */
+@objc final class ScaleBunExceptionChain: NSObject {
+
+    typealias Handler = @convention(c) (NSException) -> Void
+
+    private static var previous: Handler?
+    private static var recorder: ((NSException) -> Void)?
+    private static var installed = false
+    /// Guards against a previous handler that calls back into the current one
+    /// (some reporters invoke NSGetUncaughtExceptionHandler() when they chain).
+    private static var handling = false
+
+    /**
+     * Makes `record` the process's uncaught-exception handler and remembers the
+     * handler it displaces, which is called after `record` returns. Idempotent:
+     * a second call is ignored, so the previous handler is captured exactly once
+     * and can never be our own trampoline.
+     */
+    static func install(record: @escaping (NSException) -> Void) {
+        guard !installed else { return }
+        installed = true
+        previous = NSGetUncaughtExceptionHandler()
+        recorder = record
+        NSSetUncaughtExceptionHandler { exception in
+            ScaleBunExceptionChain.handle(exception)
+        }
+    }
+
+    /** The trampoline's body. Internal so tests can drive it without crashing. */
+    static func handle(_ exception: NSException) {
+        if handling { return }
+        handling = true
+        defer { handling = false }
+        recorder?(exception)
+        previous?(exception)
+    }
+
+    static var isInstalled: Bool { installed }
+
+    /** For tests: put back the handler we displaced and forget ours. */
+    static func uninstallForTest() {
+        guard installed else { return }
+        NSSetUncaughtExceptionHandler(previous)
+        previous = nil
+        recorder = nil
+        installed = false
+        handling = false
+    }
+}

package/ios/CrashTests/ScaleBunExceptionChainTests.swift

@@ -0,0 +1,144 @@
+import Foundation
+import XCTest
+@testable import ScaleBunCrashChain
+
+/**
+ * The SDK must not evict a host's existing crash reporter.
+ *
+ * On le-garage, Crashlytics installs its uncaught-exception handler in
+ * didFinishLaunching; the SDK started later and replaced it, so Crashlytics
+ * stopped receiving ObjC/Swift exceptions. These cases pin the chain: ours
+ * records, then the displaced handler still runs.
+ *
+ * The handler is driven through NSGetUncaughtExceptionHandler() — the exact
+ * pointer the ObjC runtime would call — so the tests exercise the installed
+ * trampoline, not a private shortcut, and never actually crash the process.
+ */
+
+// A C-convention "previous reporter". Globals, because a @convention(c)
+// closure cannot capture context.
+private var previousCalls: [String] = []
+private var order: [String] = []
+private let fakeCrashlytics: @convention(c) (NSException) -> Void = { exception in
+    previousCalls.append(exception.name.rawValue)
+    order.append("previous")
+}
+// A reporter that chains by calling whatever is installed now — which is our
+// trampoline. Without the re-entrancy guard this recurses forever.
+private let reenteringReporter: @convention(c) (NSException) -> Void = { exception in
+    order.append("reentrant")
+    NSGetUncaughtExceptionHandler()?(exception)
+}
+
+final class ScaleBunExceptionChainTests: XCTestCase {
+
+    private var originalHandler: (@convention(c) (NSException) -> Void)?
+
+    override func setUp() {
+        super.setUp()
+        originalHandler = NSGetUncaughtExceptionHandler()
+        previousCalls = []
+        order = []
+    }
+
+    override func tearDown() {
+        ScaleBunExceptionChain.uninstallForTest()
+        NSSetUncaughtExceptionHandler(originalHandler)
+        super.tearDown()
+    }
+
+    private func fire(_ name: String = "TestException") -> NSException {
+        let e = NSException(name: NSExceptionName(name), reason: "boom", userInfo: nil)
+        guard let handler = NSGetUncaughtExceptionHandler() else {
+            XCTFail("no uncaught-exception handler installed")
+            return e
+        }
+        handler(e)
+        return e
+    }
+
+    func testPreviousHandlerStillReceivesTheException() {
+        NSSetUncaughtExceptionHandler(fakeCrashlytics)
+        var recorded: [String] = []
+        ScaleBunExceptionChain.install { recorded.append($0.name.rawValue) }
+
+        _ = fire("NSInvalidArgumentException")
+
+        XCTAssertEqual(recorded, ["NSInvalidArgumentException"])
+        XCTAssertEqual(previousCalls, ["NSInvalidArgumentException"],
+                       "the host's reporter (e.g. Crashlytics) was evicted")
+    }
+
+    func testOursRecordsBeforeThePreviousHandlerRuns() {
+        // The previous handler may terminate the process; recording second
+        // would lose our record whenever it does.
+        NSSetUncaughtExceptionHandler(fakeCrashlytics)
+        ScaleBunExceptionChain.install { _ in order.append("ours") }
+
+        _ = fire()
+
+        XCTAssertEqual(order, ["ours", "previous"])
+    }
+
+    func testNoPreviousHandlerIsFine() {
+        NSSetUncaughtExceptionHandler(nil)
+        var recorded = 0
+        ScaleBunExceptionChain.install { _ in recorded += 1 }
+
+        _ = fire()
+
+        XCTAssertEqual(recorded, 1)
+        XCTAssertTrue(previousCalls.isEmpty)
+    }
+
+    func testSecondInstallIsIgnoredSoNothingRunsTwice() {
+        NSSetUncaughtExceptionHandler(fakeCrashlytics)
+        var first = 0
+        var second = 0
+        ScaleBunExceptionChain.install { _ in first += 1 }
+        // A second install must not capture our own trampoline as "previous".
+        ScaleBunExceptionChain.install { _ in second += 1 }
+
+        _ = fire()
+
+        XCTAssertEqual(first, 1)
+        XCTAssertEqual(second, 0)
+        XCTAssertEqual(previousCalls.count, 1)
+    }
+
+    func testAReporterThatCallsBackIntoUsDoesNotLoop() {
+        NSSetUncaughtExceptionHandler(reenteringReporter)
+        var recorded = 0
+        ScaleBunExceptionChain.install { _ in recorded += 1 }
+
+        _ = fire()
+
+        XCTAssertEqual(recorded, 1)
+        XCTAssertEqual(order, ["reentrant"])
+    }
+
+    func testTheHandlerCanFireAgainAfterReturning() {
+        // The re-entrancy guard must reset, or a second exception in a process
+        // that survives the first (tests, or a reporter that swallows) is lost.
+        NSSetUncaughtExceptionHandler(fakeCrashlytics)
+        var recorded = 0
+        ScaleBunExceptionChain.install { _ in recorded += 1 }
+
+        _ = fire()
+        _ = fire()
+
+        XCTAssertEqual(recorded, 2)
+        XCTAssertEqual(previousCalls.count, 2)
+    }
+
+    func testUninstallRestoresTheDisplacedHandler() {
+        NSSetUncaughtExceptionHandler(fakeCrashlytics)
+        ScaleBunExceptionChain.install { _ in }
+        ScaleBunExceptionChain.uninstallForTest()
+
+        XCTAssertFalse(ScaleBunExceptionChain.isInstalled)
+        _ = fire()
+        XCTAssertEqual(previousCalls.count, 1)
+        XCTAssertEqual(order, ["previous"])
+    }
+}

package/ios/Engage/ScaleBunEngageBridge.m

@@ -0,0 +1,32 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+/**
+ * ObjC bridge exposing the ScaleBunEngage Swift module (push-token acquisition) to
+ * React Native. Subclasses RCTEventEmitter so the JS NativeEventEmitter can
+ * subscribe to ScaleBunEngageTokenRefresh.
+ */
+@interface RCT_EXTERN_MODULE(ScaleBunEngage, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(getWindowInsets:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getPushToken:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(requestPushPermission:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(consumeInitialNotification:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(requestReview:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(startShakeDetection:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(stopShakeDetection:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end