@goliapkg/sentori-react-native 6.2.0 → 6.2.1

package/ios/core/SentoriPush.swift

@@ -0,0 +1,340 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriPush.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
+import Foundation
+
+/// Push, as an app writes it.
+///
+///     let r = await Sentori.push.register()
+///     if case .failure(let reason) = r { … }
+///
+/// The pieces underneath already existed — permission, the
+/// `AppDelegate` swizzle, the token buffer, the tap and foreground
+/// callbacks — and were reachable only through the React Native
+/// bridge. What was missing everywhere but JavaScript is the part
+/// that puts a token on the server, which is the only reason a
+/// registered device is reachable at all.
+///
+/// Asked for by insight (2026-08-11): two apps with no React Native,
+/// blocked, and unwilling to reimplement the HTTP contract because a
+/// second implementation drifts silently on the one path where nobody
+/// is watching.
+@objc(SentoriPush)
+public final class SentoriPush: NSObject {
+
+    /// Why a registration did not produce a device handle. Each value
+    /// asks the host for something different, which is the only
+    /// reason to distinguish them — matching `PushRegisterFailure` in
+    /// the React Native SDK exactly, so the same integration notes
+    /// apply on both.
+    @objc public enum Failure: Int {
+        /// `Sentori.start` has not run. A wiring bug.
+        case notInitialised
+        /// The user said no. Not an error: do not retry on a timer,
+        /// and offer it again from a settings screen.
+        case permissionDenied
+        /// No push entitlement in this build, or a simulator without
+        /// one. Nothing to do at runtime.
+        case noTransport
+        /// The OS never handed back a token inside the window.
+        /// Usually provisioning; retrying later is reasonable.
+        case tokenTimeout
+        /// Sentori answered non-2xx. Settings ▸ Push is where to look.
+        case serverRejected
+
+        public var name: String {
+            switch self {
+            case .notInitialised: return "not-initialised"
+            case .permissionDenied: return "permission-denied"
+            case .noTransport: return "no-transport"
+            case .tokenTimeout: return "token-timeout"
+            case .serverRejected: return "server-rejected"
+            }
+        }
+    }
+
+    /// Registration never throws. A denied permission is an ordinary
+    /// answer, and an opt-in that throws inside someone's view model
+    /// is the failure this SDK's contract with its host is written
+    /// against.
+    public enum Result {
+        /// The `device_tokens` row id. Revoking takes it, and so does
+        /// a targeted send.
+        case success(handle: String)
+        case failure(reason: Failure, message: String)
+
+        public var handle: String? {
+            if case .success(let h) = self { return h }
+            return nil
+        }
+    }
+
+    @objc public static let shared = SentoriPush()
+
+    private let lock = NSLock()
+    private var cachedHandle: String?
+    private var onMessage: (([String: Any]) -> Void)?
+    private var onTap: (([String: Any]) -> Void)?
+    private var drainTimer: DispatchSourceTimer?
+
+    private static let handleKey = "com.sentori.push.handle"
+
+    /// Ask for permission, get a token, register it.
+    ///
+    /// Safe to call on every launch: the OS returns its cached
+    /// decision without re-prompting, and the server upserts on
+    /// `(project, provider, token)`.
+    ///
+    /// Call `Sentori.user` first if the device should be reachable
+    /// from an issue. Without it the registration carries no user key
+    /// and the device receives broadcasts only — the dashboard shows
+    /// that as "N devices, 0 addressable", which is the one symptom
+    /// with no other explanation.
+    @discardableResult
+    public func register(
+        timeout: TimeInterval = 8,
+        onMessage: (([String: Any]) -> Void)? = nil,
+        onTap: (([String: Any]) -> Void)? = nil
+    ) async -> Result {
+        guard let config = SentoriConfig.current else {
+            return .failure(reason: .notInitialised, message: "Sentori.start has not run")
+        }
+
+        // Bind before asking for anything: iOS replays a tap that
+        // happened while the app was not running as soon as the
+        // delegate attaches, and a callback set afterwards misses it.
+        lock.lock()
+        self.onMessage = onMessage
+        self.onTap = onTap
+        lock.unlock()
+
+        let status = await currentOrRequestPermission()
+        // "unavailable" is the native layer saying there is no app
+        // bundle to ask on behalf of — a test host, a CLI, some
+        // extensions. Not a decision the user made.
+        guard let status, status != "unavailable" else {
+            return .failure(reason: .noTransport, message: "no push support in this build")
+        }
+        guard ["granted", "provisional", "ephemeral"].contains(status) else {
+            return .failure(reason: .permissionDenied, message: "push permission '\(status)'")
+        }
+
+        SentoriPushNotifications.shared.registerForRemoteNotifications()
+        guard let token = await waitForToken(timeout: timeout) else {
+            return .failure(
+                reason: .tokenTimeout,
+                message: "no device token within \(Int(timeout))s"
+            )
+        }
+
+        switch await registerWithServer(token: token, config: config) {
+        case .success(let handle):
+            lock.lock()
+            cachedHandle = handle
+            lock.unlock()
+            UserDefaults.standard.set(handle, forKey: Self.handleKey)
+            startDrain()
+            return .success(handle: handle)
+        case .failure(let reason, let message):
+            return .failure(reason: reason, message: message)
+        }
+    }
+
+    /// The handle from an earlier `register`, without a round trip.
+    @objc public func cachedDeviceHandle() -> String? {
+        lock.lock()
+        let h = cachedHandle
+        lock.unlock()
+        return h ?? UserDefaults.standard.string(forKey: Self.handleKey)
+    }
+
+    /// Current permission without prompting. `nil` when there is no
+    /// push support in this build.
+    public func permissionStatus() async -> String? {
+        await withCheckedContinuation { cont in
+            SentoriPushNotifications.shared.currentPermission { cont.resume(returning: $0) }
+        }
+    }
+
+    /// Revoke the handle server-side and stop local delivery.
+    /// Idempotent — repeat calls do nothing.
+    @discardableResult
+    public func unregister() async -> Bool {
+        let handle = cachedDeviceHandle()
+        lock.lock()
+        cachedHandle = nil
+        onMessage = nil
+        onTap = nil
+        drainTimer?.cancel()
+        drainTimer = nil
+        lock.unlock()
+        UserDefaults.standard.removeObject(forKey: Self.handleKey)
+        SentoriPushNotifications.shared.unregisterForRemoteNotifications()
+
+        guard let handle, let config = SentoriConfig.current,
+            let url = URL(string: "\(config.ingestUrl)/v1/push/tokens/\(handle)")
+        else { return false }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "DELETE"
+        request.setValue("Bearer \(config.token)", forHTTPHeaderField: "Authorization")
+        request.timeoutInterval = 15
+        let ok = await withCheckedContinuation { (cont: CheckedContinuation<Bool, Never>) in
+            URLSession.shared.dataTask(with: request) { _, response, _ in
+                let code = (response as? HTTPURLResponse)?.statusCode ?? 0
+                cont.resume(returning: (200..<300).contains(code))
+            }.resume()
+        }
+        return ok
+    }
+
+    // ── internals ─────────────────────────────────────────────────
+
+    private func currentOrRequestPermission() async -> String? {
+        let current = await permissionStatus()
+        // `nil` means no native push at all; asking would not change
+        // that. Anything already decided is returned as decided,
+        // because a second prompt is not something iOS shows anyway.
+        guard let current else { return nil }
+        if current == "undetermined" || current == "notDetermined" {
+            return await withCheckedContinuation { cont in
+                SentoriPushNotifications.shared.requestPermission { cont.resume(returning: $0) }
+            }
+        }
+        return current
+    }
+
+    /// The token arrives asynchronously through the AppDelegate
+    /// swizzle and lands in the native buffer, so this polls it. Any
+    /// notifications or taps that arrive alongside are delivered
+    /// rather than dropped on the floor.
+    private func waitForToken(timeout: TimeInterval) async -> String? {
+        let deadline = Date().addingTimeInterval(timeout)
+        while Date() < deadline {
+            let state = SentoriPushNotifications.shared.drainState()
+            flush(state)
+            if let token = state["token"] as? String { return token }
+            if state["error"] != nil { return nil }
+            try? await Task.sleep(nanoseconds: 200_000_000)
+        }
+        return nil
+    }
+
+    private func registerWithServer(token: String, config: SentoriConfig) async -> Result {
+        guard let url = URL(string: "\(config.ingestUrl)/v1/push/tokens") else {
+            return .failure(reason: .serverRejected, message: "bad ingest url")
+        }
+        var body: [String: Any] = [
+            // `kind`, not `provider`. The React Native SDK sent
+            // `provider` for a year and earned a 422 for every
+            // registration it ever attempted.
+            "kind": "apns",
+            "nativeToken": token,
+            // Sandbox and production APNs are different hosts, and a
+            // token minted against one is rejected by the other.
+            "env": isDebugBuild ? "sandbox" : "production",
+        ]
+        // The same salted-nothing hash every event carries, so the
+        // dashboard can address this device by the person who hit an
+        // issue. Absent until the host calls `Sentori.user`.
+        if let userKey = SentoriScope.userKey { body["userKey"] = userKey }
+
+        guard let payload = try? JSONSerialization.data(withJSONObject: body) else {
+            return .failure(reason: .serverRejected, message: "could not encode registration")
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("Bearer \(config.token)", forHTTPHeaderField: "Authorization")
+        request.setValue("swift/\(SentoriVersion.current)", forHTTPHeaderField: "Sentori-Sdk")
+        request.httpBody = payload
+        request.timeoutInterval = 15
+
+        return await withCheckedContinuation { (cont: CheckedContinuation<Result, Never>) in
+            URLSession.shared.dataTask(with: request) { data, response, error in
+                let code = (response as? HTTPURLResponse)?.statusCode ?? 0
+                guard (200..<300).contains(code) else {
+                    let why = error?.localizedDescription ?? "HTTP \(code)"
+                    cont.resume(
+                        returning: .failure(reason: .serverRejected, message: why))
+                    return
+                }
+                // The handle is the `device_tokens` row id, a bare
+                // uuid. The RN SDK parsed it as an `ipt_*` string no
+                // server has ever returned.
+                guard let data,
+                    let j = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+                    let handle = j["token_id"] as? String, !handle.isEmpty
+                else {
+                    cont.resume(
+                        returning: .failure(
+                            reason: .serverRejected,
+                            message: "server returned no device token id"))
+                    return
+                }
+                cont.resume(returning: .success(handle: handle))
+            }.resume()
+        }
+    }
+
+    /// 1 Hz while registered. The native side buffers arrivals and
+    /// taps; this hands them to the host.
+    private func startDrain() {
+        lock.lock()
+        defer { lock.unlock() }
+        guard drainTimer == nil else { return }
+        let t = DispatchSource.makeTimerSource(queue: .global(qos: .utility))
+        t.schedule(deadline: .now() + 1, repeating: 1)
+        t.setEventHandler { [weak self] in
+            guard let self else { return }
+            self.flush(SentoriPushNotifications.shared.drainState())
+        }
+        drainTimer = t
+        t.resume()
+    }
+
+    private func flush(_ state: [String: Any]) {
+        lock.lock()
+        let message = onMessage
+        let tap = onTap
+        lock.unlock()
+        guard message != nil || tap != nil else { return }
+
+        let notifications = state["notifications"] as? [[String: Any]] ?? []
+        let taps = state["taps"] as? [[String: Any]] ?? []
+        guard !notifications.isEmpty || !taps.isEmpty else { return }
+
+        // The host's UI lives on the main thread and a notification
+        // callback almost always touches it.
+        DispatchQueue.main.async {
+            notifications.forEach { message?($0) }
+            taps.forEach { tap?($0) }
+        }
+    }
+
+    private var isDebugBuild: Bool {
+        #if DEBUG
+            return true
+        #else
+            return false
+        #endif
+    }
+
+    func __resetForTests() {
+        lock.lock()
+        cachedHandle = nil
+        onMessage = nil
+        onTap = nil
+        drainTimer?.cancel()
+        drainTimer = nil
+        lock.unlock()
+        UserDefaults.standard.removeObject(forKey: Self.handleKey)
+    }
+}
+
+extension Sentori {
+    /// `Sentori.push.register()`, matching `sentori.push.register()`
+    /// in the React Native SDK.
+    public static var push: SentoriPush { SentoriPush.shared }
+}

package/ios/{SentoriPushNotifications.swift → core/SentoriPushNotifications.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriPushNotifications.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 // v2.9 — iOS push notification bridge.
 //
 // Owns:
@@ -40,9 +43,40 @@ import ObjectiveC.runtime
 
     // MARK: Permission
 
+    /// `UNUserNotificationCenter.current()` raises
+    /// `NSInternalInconsistencyException` — "bundleProxyForCurrentProcess
+    /// is nil" — in any process without an app bundle: a unit-test
+    /// target that links this SDK, a command-line tool, some extension
+    /// hosts. An Objective-C exception cannot be caught in Swift, so
+    /// it terminates the host outright.
+    ///
+    /// That is the failure-isolation rule broken in the loudest
+    /// possible way, and it is the SDK crashing the app rather than
+    /// the app crashing. Found when this package's own test target
+    /// called it and the runner died mid-suite.
+    ///
+    /// The precondition is whether this process *is* an app bundle,
+    /// not whether it has an identifier. `bundleIdentifier` is
+    /// non-nil in an xctest host and the call raised anyway: the
+    /// message names the real cause — `mainBundle.bundleURL` pointing
+    /// at Xcode's `Agents/` directory, which LaunchServices has no
+    /// bundle proxy for.
+    ///
+    /// An app is `…/Foo.app`; a notification service extension is
+    /// `…/Bar.appex` and legitimately uses this API. Anything else —
+    /// a test runner, a command-line tool — gets "unavailable" and a
+    /// `no-transport` result rather than a terminated process.
+    private var notificationCentreIsUsable: Bool {
+        ["app", "appex"].contains(Bundle.main.bundleURL.pathExtension)
+    }
+
     /// Returns the current permission status as a JS-friendly string.
     /// Does NOT prompt.
     @objc public func currentPermission(completion: @escaping (String) -> Void) {
+        guard notificationCentreIsUsable else {
+            completion("unavailable")
+            return
+        }
         UNUserNotificationCenter.current().getNotificationSettings { settings in
             completion(authString(settings.authorizationStatus))
         }
@@ -51,6 +85,10 @@ import ObjectiveC.runtime
     /// Requests authorization. Triggers the OS prompt the first time;
     /// subsequent calls return the cached decision.
     @objc public func requestPermission(completion: @escaping (String) -> Void) {
+        guard notificationCentreIsUsable else {
+            completion("unavailable")
+            return
+        }
         let center = UNUserNotificationCenter.current()
         center.requestAuthorization(options: [.alert, .badge, .sound]) { granted, error in
             if let error = error {
@@ -71,6 +109,10 @@ import ObjectiveC.runtime
     /// method, which routes the token into our buffer.
     @objc public func registerForRemoteNotifications() {
         ensureSwizzleInstalled()
+        // Same guard as the permission calls: installing the
+        // delegate touches the notification centre, which raises in a
+        // process that is not an app bundle.
+        guard notificationCentreIsUsable else { return }
         UNUserNotificationCenter.current().delegate = self
         DispatchQueue.main.async {
             UIApplication.shared.registerForRemoteNotifications()

package/ios/{SentoriReplayCapture.swift → core/SentoriReplayCapture.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriReplayCapture.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 import UIKit
 

package/ios/{SentoriScreenshotCapture.swift → core/SentoriScreenshotCapture.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriScreenshotCapture.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 import UIKit
 
@@ -309,6 +312,17 @@ import UIKit
         return found
     }
 
+    /// Test-only seam onto the tree walk. The test that covers the
+    /// depth cap reached for it through
+    /// `value(forKey: "viewTreeForTesting")` — a name nothing defines,
+    /// and KVC cannot reach a Swift static method under any name. It
+    /// compiled because KVC is resolved at runtime, and it never ran
+    /// because the sources were loose files in an Expo module with no
+    /// test target to build.
+    internal static func viewTreeForTesting(root: UIView) -> [String: Any] {
+        return walkTree(root: root)
+    }
+
     private static func walkTree(root: UIView) -> [String: Any] {
         var nodes: [String: Any] = [:]
         var counter = 0

package/ios/{SentoriThreadSampler.swift → core/SentoriThreadSampler.swift}

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/ios/Sources/Sentori/SentoriThreadSampler.swift
+// Run `node scripts/sync-native-core.mjs` after editing it.
 import Foundation
 
 /// Captures the main thread's program-counter chain for hang reporting.

package/lib/transport.js

@@ -15,7 +15,7 @@ const MAX_RETRY = 3;
 const STORAGE_KEY = '@sentori/pending';
 const MAX_PERSISTED = 1000;
 // Pinned to package.json by a test — bump both together.
-const SDK_VERSION = '6.2.0';
+const SDK_VERSION = '6.2.1';
 let _queue = [];
 let _assertStats = new Map();
 let _flushTimer = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goliapkg/sentori-react-native",
-  "version": "6.2.0",
+  "version": "6.2.1",
   "description": "Sentori SDK for React Native — JS-layer error capture, native crash handlers (iOS / Android), batched transport, fetch + react-navigation tracing.",
   "license": "Apache-2.0 OR MIT",
   "author": "GOLIA K.K. <takagi@golia.jp> (https://golia.jp)",

package/src/transport.ts

@@ -20,7 +20,7 @@ const STORAGE_KEY = '@sentori/pending';
 const MAX_PERSISTED = 1000;
 
 // Pinned to package.json by a test — bump both together.
-const SDK_VERSION = '6.2.0';
+const SDK_VERSION = '6.2.1';
 
 let _queue: WireEvent[] = [];
 let _assertStats = new Map<string, AssertStat>();

package/ios/Tests/SentoriCrashHandlerTests.swift

@@ -1,59 +0,0 @@
-// Phase 16 sub-E: XCTest coverage for SentoriCrashHandler (回填 Phase 7).
-//
-// Run via Xcode (target → SentoriTests, ⌘U) or via xcodebuild from the
-// iOS host:
-//   xcodebuild test \
-//     -scheme SentoriTests \
-//     -destination 'platform=iOS Simulator,name=iPhone 15'
-//
-// The handler writes one JSON file per crash to
-//   <Documents>/sentori/pending/<uuid>.json
-// We can't easily re-raise NSException (it tears down the test
-// process), so we exercise the persistence helper directly instead.
-
-import XCTest
-@testable import SentoriCrashHandler
-
-final class SentoriCrashHandlerTests: XCTestCase {
-    private var pendingDir: URL!
-
-    override func setUpWithError() throws {
-        let docs = try FileManager.default.url(
-            for: .documentDirectory,
-            in: .userDomainMask,
-            appropriateFor: nil,
-            create: true
-        )
-        pendingDir = docs.appendingPathComponent("sentori/pending", isDirectory: true)
-        try? FileManager.default.removeItem(at: pendingDir)
-        try FileManager.default.createDirectory(at: pendingDir, withIntermediateDirectories: true)
-    }
-
-    func testWritePendingProducesValidEventJson() throws {
-        // Synthesize a payload like the @convention(c) handler would.
-        let exception = NSException(
-            name: NSExceptionName("XCTestSyntheticException"),
-            reason: "boom",
-            userInfo: nil
-        )
-        SentoriCrashHandler.persistForTesting(exception: exception)
-
-        let files = try FileManager.default.contentsOfDirectory(atPath: pendingDir.path)
-            .filter { $0.hasSuffix(".json") }
-        XCTAssertEqual(files.count, 1, "expected exactly one pending file, got \(files.count)")
-
-        let url = pendingDir.appendingPathComponent(files[0])
-        let data = try Data(contentsOf: url)
-        let payload = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
-        XCTAssertNotNil(payload, "pending file is not valid JSON")
-
-        // Spot-check the protocol shape (Phase 1 schema).
-        XCTAssertEqual(payload?["kind"] as? String, "error")
-        XCTAssertEqual(payload?["platform"] as? String, "ios")
-        XCTAssertNotNil(payload?["id"] as? String)
-        XCTAssertNotNil(payload?["timestamp"] as? String)
-        let error = payload?["error"] as? [String: Any]
-        XCTAssertEqual(error?["type"] as? String, "XCTestSyntheticException")
-        XCTAssertEqual(error?["message"] as? String, "boom")
-    }
-}

package/ios/Tests/SentoriScreenshotCaptureTests.swift

@@ -1,59 +0,0 @@
-// Phase 42 sub-E.10 — XCTest coverage for SentoriScreenshotCapture.
-//
-// Run via Xcode (target → SentoriTests, ⌘U) or via xcodebuild from
-// the iOS host:
-//   xcodebuild test \
-//     -scheme SentoriTests \
-//     -destination 'platform=iOS Simulator,name=iPhone 15'
-//
-// We can't drive a real key window in a unit-test target (UIScene
-// isn't connected), so each assertion below targets the helpers
-// against a synthesized UIView hierarchy. The full crash-time flow
-// (window→JPEG→base64→event JSON) is covered by the manual smoke
-// step (E.11): trigger a real NSException in the example app and
-// confirm the dashboard's "Captured at error" gallery fills in.
-
-import XCTest
-import UIKit
-@testable import SentoriScreenshotCapture
-
-final class SentoriScreenshotCaptureTests: XCTestCase {
-
-    /// `captureKeyWindow` returns nil when the app has no attached
-    /// scene — the typical test-host situation. This guards against
-    /// regressions where the helper would crash instead of failing
-    /// gracefully (e.g. force-unwrapping `UIApplication.shared.windows.first`).
-    func testCaptureKeyWindowReturnsNilWithoutWindow() {
-        // No UIScene is connected in a vanilla XCTest host — the
-        // helper must short-circuit, not crash.
-        let result = SentoriScreenshotCapture.captureKeyWindow()
-        // We don't assert nil vs non-nil rigidly because test hosts
-        // can attach a UIWindow as a side effect; the contract is
-        // simply "must not throw / crash".
-        _ = result
-    }
-
-    /// Performance gate: capture-on-a-known-size-view-hierarchy
-    /// must complete in <30 ms on a synthesized tree, matching the
-    /// budget in `ROADMAP.md` (sub-E.10 perf bench).
-    ///
-    /// The hierarchy under test is 50 nested UIView levels — much
-    /// deeper than any real app. The depth cap inside the helper
-    /// (`maxTreeDepth=10`) keeps the walk bounded so we shouldn't
-    /// blow past the budget even at extreme depth.
-    func testTreeWalkRespectsDepthCap() {
-        let root = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
-        var cursor = root
-        for _ in 0..<50 {
-            let child = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
-            cursor.addSubview(child)
-            cursor = child
-        }
-        measure {
-            // private method — guarded by `@testable` access.
-            // We're not asserting the output, just the timing budget.
-            _ = SentoriScreenshotCapture.value(forKey: "viewTreeForTesting")
-                .map { _ in 0 } ?? 0
-        }
-    }
-}