sitepong 0.2.7 → 0.2.9

package/ios/ScreenRecorder/ScreenRecorderModule.swift

@@ -146,6 +146,32 @@ public class SitePongScreenRecorderModule: Module {
     Function("watchtowerGetSessionId") { () -> String? in
       return Watchtower.sessionId
     }
+
+    // MARK: - Structural replay thin bridge
+    // Forwards to SitePongStructuralCapture (UIView-tree structural capture →
+    // POST /api/replay-stream/native → server-side differ). Complements the
+    // screenshot-based Watchtower engine above.
+
+    Function("structuralStart") { (config: [String: Any]) in
+      let apiKey = config["apiKey"] as? String ?? ""
+      let projectId = config["projectId"] as? String
+      let endpoint = config["endpoint"] as? String ?? ""
+      let sessionId = config["sessionId"] as? String ?? "wt-\(Int(Date().timeIntervalSince1970 * 1000))"
+      let platform = config["platform"] as? String ?? "ios"
+      guard !endpoint.isEmpty, !apiKey.isEmpty else { return }
+      SitePongStructuralCapture.shared.start(
+        endpoint: endpoint, apiKey: apiKey, projectId: projectId,
+        sessionId: sessionId, platform: platform
+      )
+    }
+
+    Function("structuralStop") {
+      SitePongStructuralCapture.shared.stop()
+    }
+
+    Function("structuralSetScreen") { (name: String) in
+      SitePongStructuralCapture.shared.setScreen(name)
+    }
   }
 
   /// Find a UIView by React tag across all key windows (mirrors

package/ios/WatchtowerCore/StructuralRecorder.swift

@@ -0,0 +1,258 @@
+// SitePong — NATIVE (UIKit/Swift) structural session-replay capture.
+//
+// The RN adapter sources its tree from the React fiber tree; this native adapter
+// sources it from the UIView hierarchy — the same traversal WatchtowerCore
+// already does for redaction (Screenshotter walks rootViewController's subviews).
+// Each UIView is serialized to a node with its REAL frame (native gives exact
+// geometry, unlike RN where the dashboard replays flexbox), its class-derived
+// tag, text, and accessibilityIdentifier (== the RN testID). Snapshots + taps
+// are POSTed to the ingest server, where the SAME @sitepong/watchtower-replay
+// core diffs them into the SAME rrweb-style message stream the RN adapter posts
+// directly (POST /api/replay-stream/native → server-side differ).
+//
+// One platform-neutral core, two capture adapters (fiber / UIView), one stored
+// stream, one dashboard Player.
+import UIKit
+
+public final class SitePongStructuralCapture {
+    public static let shared = SitePongStructuralCapture()
+
+    private var endpoint = ""
+    private var apiKey = ""
+    private var projectId: String?
+    private var platform = "ios"
+    private var sessionId = ""
+    private var startedAt = Date()
+    private var ids: [ObjectIdentifier: Int] = [:]
+    private var nextId = 1
+    private var events: [[String: Any]] = []
+    private var screen = ""
+    private var sampleTimer: Timer?
+    private var flushTimer: Timer?
+    private var running = false
+
+    // Incremental delivery: count of events CONFIRMED stored (== next seq_start).
+    // The device ships only the delta each flush and clears its buffer, so memory
+    // stays bounded and the uplink never re-sends the whole session. Node ids
+    // (`ids`/`nextId`) stay PERSISTENT across flushes — the server stitches the
+    // deltas by id, so resetting them would corrupt the tree.
+    private var flushedEventCount = 0
+    private var sending = false
+
+    private func now() -> Int { Int(Date().timeIntervalSince(startedAt) * 1000) }
+
+    /// Start capturing. `endpoint` is the ingest base URL (e.g.
+    /// https://ingest.sitepong.com); `apiKey` is the project key.
+    public func start(endpoint: String, apiKey: String, projectId: String?, sessionId: String, platform: String = "ios") {
+        guard !running else { return }
+        self.endpoint = endpoint.hasSuffix("/") ? String(endpoint.dropLast()) : endpoint
+        self.apiKey = apiKey
+        self.projectId = projectId
+        self.sessionId = sessionId
+        self.platform = platform
+        self.startedAt = Date()
+        self.running = true
+
+        // Global tap capture: a recognizer on the key window that never steals the
+        // touch (cancelsTouchesInView=false, simultaneous) — the native analogue
+        // of the RN touch wrapper.
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.4) { [weak self] in
+            guard let self = self, let w = self.keyWindow() else { return }
+            let g = UITapGestureRecognizer(target: self, action: #selector(self.onTap(_:)))
+            g.cancelsTouchesInView = false
+            g.delegate = SPStructuralTapDelegate.shared
+            w.addGestureRecognizer(g)
+        }
+        sampleTimer = Timer.scheduledTimer(withTimeInterval: 0.12, repeats: true) { [weak self] _ in self?.sample() }
+        flushTimer = Timer.scheduledTimer(withTimeInterval: 4.0, repeats: true) { [weak self] _ in self?.flush() }
+
+        // Flush on background so the tail isn't stranded when timers suspend.
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(onBackground),
+            name: UIApplication.didEnterBackgroundNotification, object: nil
+        )
+    }
+
+    @objc private func onBackground() {
+        guard running else { return }
+        flush()
+    }
+
+    public func setScreen(_ name: String) {
+        guard running, name != screen else { return }
+        sample()
+        events.append(["t": now(), "type": "screen", "name": name])
+        screen = name
+    }
+
+    public func stop() {
+        guard running else { return }
+        running = false
+        sampleTimer?.invalidate(); sampleTimer = nil
+        flushTimer?.invalidate(); flushTimer = nil
+        NotificationCenter.default.removeObserver(
+            self, name: UIApplication.didEnterBackgroundNotification, object: nil
+        )
+        flush()
+    }
+
+    private func idFor(_ v: UIView) -> Int {
+        let k = ObjectIdentifier(v)
+        if let id = ids[k] { return id }
+        let id = nextId; nextId += 1; ids[k] = id
+        return id
+    }
+
+    private func keyWindow() -> UIWindow? {
+        UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }.flatMap { $0.windows }
+            .first(where: { $0.isKeyWindow }) ??
+        UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }.flatMap { $0.windows }.first
+    }
+
+    // MARK: - tree serialization
+    private func tagFor(_ v: UIView) -> String {
+        switch v {
+        case is UILabel: return "Text"
+        case is UIImageView: return "Image"
+        case is UITextField, is UITextView: return "TextInput"
+        case is UIScrollView: return "ScrollView"
+        case is UIButton, is UIControl: return "Pressable"
+        default: return "View"
+        }
+    }
+
+    private func hex(_ c: UIColor?) -> String? {
+        guard let c = c else { return nil }
+        var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
+        guard c.getRed(&r, green: &g, blue: &b, alpha: &a), a > 0.01 else { return nil }
+        return String(format: "#%02x%02x%02x", Int(r * 255), Int(g * 255), Int(b * 255))
+    }
+
+    private func textFor(_ v: UIView) -> String? {
+        if let l = v as? UILabel { return l.text }
+        if let b = v as? UIButton { return b.title(for: .normal) ?? b.titleLabel?.text }
+        if let t = v as? UITextField { return t.isSecureTextEntry ? nil : t.text }
+        return nil
+    }
+
+    private func serialize(_ v: UIView, in window: UIWindow) -> [String: Any]? {
+        if v.isHidden || v.alpha < 0.02 { return nil }
+        let f = v.convert(v.bounds, to: window)
+        var attrs: [String: String] = [:]
+        if let aid = v.accessibilityIdentifier, !aid.isEmpty { attrs["testID"] = aid }
+        if let al = v.accessibilityLabel, !al.isEmpty { attrs["accessibilityLabel"] = al }
+        if let bg = hex(v.backgroundColor) { attrs["backgroundColor"] = bg }
+        if v.layer.cornerRadius > 0 { attrs["borderRadius"] = String(Int(v.layer.cornerRadius)) }
+        if let secure = (v as? UITextField)?.isSecureTextEntry, secure { attrs["wtSensitive"] = "true" }
+        if let l = v as? UILabel {
+            attrs["color"] = hex(l.textColor) ?? "#111111"
+            attrs["fontSize"] = String(Int(l.font.pointSize))
+        }
+        attrs["frame"] = "\(Int(f.origin.x)),\(Int(f.origin.y)),\(Int(f.size.width)),\(Int(f.size.height))"
+        let tag = tagFor(v)
+        var node: [String: Any] = ["id": idFor(v), "tag": tag, "attrs": attrs]
+        if let t = textFor(v), !t.isEmpty { node["text"] = t }
+        // Don't descend into text/controls' internal subviews (keeps the tree clean).
+        if !(v is UILabel) && !(v is UIButton) {
+            var kids: [[String: Any]] = []
+            for sub in v.subviews { if let s = serialize(sub, in: window) { kids.append(s) } }
+            node["children"] = kids
+        } else {
+            node["children"] = []
+        }
+        return node
+    }
+
+    private func sample() {
+        guard running, let w = keyWindow(), let root = serialize(w, in: w) else { return }
+        events.append(["t": now(), "type": "snapshot", "tree": root])
+    }
+
+    @objc private func onTap(_ g: UITapGestureRecognizer) {
+        guard running, let w = keyWindow() else { return }
+        let p = g.location(in: w)
+        let hit = w.hitTest(p, with: nil)
+        sample()
+        var nodeId = 0
+        if let hit = hit { nodeId = idFor(deepestInteresting(hit)) }
+        let bounds = w.bounds
+        events.append([
+            "t": now(), "type": "tap", "nodeId": nodeId,
+            "x": Double(p.x / max(bounds.width, 1)), "y": Double(p.y / max(bounds.height, 1)),
+        ])
+    }
+
+    private func deepestInteresting(_ v: UIView) -> UIView {
+        var cur: UIView? = v
+        while let c = cur {
+            if c.accessibilityIdentifier?.isEmpty == false { return c }
+            if c is UIControl { return c }
+            cur = c.superview
+        }
+        return v
+    }
+
+    /// Ship the pending event delta (only what's accumulated since the last
+    /// confirmed flush), then clear the device buffer. The batch carries its
+    /// `seq_start` so the server dedups retries; a failed batch is re-queued so
+    /// nothing is lost offline. All buffer mutation stays on the main thread.
+    private func flush() {
+        guard !endpoint.isEmpty, !sending, !events.isEmpty, let w = keyWindow() else { return }
+        let batch = events
+        let seqStart = flushedEventCount
+        events.removeAll(keepingCapacity: true) // drain the device buffer
+        sending = true
+        post(batch: batch, seqStart: seqStart,
+             viewport: (Int(w.bounds.width), Int(w.bounds.height)), attempt: 0)
+    }
+
+    private func post(batch: [[String: Any]], seqStart: Int, viewport: (Int, Int), attempt: Int) {
+        let payload: [String: Any] = [
+            "session_id": sessionId,
+            "platform": platform,
+            "viewport": ["w": viewport.0, "h": viewport.1],
+            "seq_start": seqStart,
+            "events": batch,
+        ]
+        guard let body = try? JSONSerialization.data(withJSONObject: payload),
+              let url = URL(string: "\(endpoint)/api/replay-stream/native") else {
+            DispatchQueue.main.async { self.sending = false }
+            return
+        }
+        var req = URLRequest(url: url)
+        req.httpMethod = "POST"
+        req.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        req.setValue(apiKey, forHTTPHeaderField: "X-API-Key")
+        if let pid = projectId { req.setValue(pid, forHTTPHeaderField: "X-Project-ID") }
+        req.httpBody = body
+
+        URLSession.shared.dataTask(with: req) { [weak self] _, resp, err in
+            guard let self = self else { return }
+            let ok = (resp as? HTTPURLResponse).map { (200..<300).contains($0.statusCode) } ?? false
+            DispatchQueue.main.async {
+                if ok && err == nil {
+                    self.flushedEventCount = seqStart + batch.count
+                    self.sending = false
+                } else if attempt < 3 {
+                    let delay = pow(2.0, Double(attempt)) // 1,2,4s
+                    DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
+                        self.post(batch: batch, seqStart: seqStart, viewport: viewport, attempt: attempt + 1)
+                    }
+                } else {
+                    // Give up on this attempt: re-queue at the front so the seq
+                    // stays contiguous and the delta re-sends on the next flush.
+                    self.events.insert(contentsOf: batch, at: 0)
+                    self.sending = false
+                }
+            }
+        }.resume()
+    }
+}
+
+/// Allow the capture recognizer to run alongside buttons/scroll gestures.
+final class SPStructuralTapDelegate: NSObject, UIGestureRecognizerDelegate {
+    static let shared = SPStructuralTapDelegate()
+    func gestureRecognizer(_ g: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith other: UIGestureRecognizer) -> Bool { true }
+    func gestureRecognizer(_ g: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool { true }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sitepong",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Official SitePong SDK for error tracking and monitoring",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -157,22 +157,23 @@
     "web-vitals": "^4.2.4"
   },
   "devDependencies": {
+    "@react-native-async-storage/async-storage": "^2.2.0",
+    "@sitepong/capture-core": "*",
+    "@sitepong/watchtower-recorder": "*",
     "@types/express": "^5.0.6",
     "@types/node": "^20.10.0",
     "@types/react": "^19.2.9",
     "@typescript-eslint/eslint-plugin": "^6.13.0",
     "@typescript-eslint/parser": "^6.13.0",
     "eslint": "^8.55.0",
+    "expo-modules-core": "~3.0.0",
+    "expo-sqlite": "~16.0.4",
     "next": "^16.1.4",
     "react": "^19.2.3",
+    "react-native": "0.83.2",
     "tsup": "^8.0.1",
     "typescript": "^5.3.0",
-    "vitest": "^1.0.0",
-    "react-native": "0.83.2",
-    "@react-native-async-storage/async-storage": "^2.2.0",
-    "expo-sqlite": "~16.0.4",
-    "expo-modules-core": "~3.0.0",
-    "@sitepong/capture-core": "*"
+    "vitest": "^1.0.0"
   },
   "engines": {
     "node": ">=16.0.0"