sitepong 0.2.6 → 0.2.8

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,199 @@
+// 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
+
+    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() }
+    }
+
+    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
+        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
+    }
+
+    private func flush() {
+        guard !endpoint.isEmpty, !events.isEmpty, let w = keyWindow() else { return }
+        let payload: [String: Any] = [
+            "session_id": sessionId,
+            "platform": platform,
+            "viewport": ["w": Int(w.bounds.width), "h": Int(w.bounds.height)],
+            "events": events,
+        ]
+        guard let body = try? JSONSerialization.data(withJSONObject: payload),
+              let url = URL(string: "\(endpoint)/api/replay-stream/native") else { 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).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/ios/WatchtowerCore/TapEvent.swift

@@ -15,6 +15,11 @@ public struct CaptureEvent: Codable {
     public var device_model: String?
     public var os_version: String?
 
+    // identity traits — only populated on an "identify" event (Watchtower.setUser
+    // with email/name), so PII is sent once per identify, not on every tap.
+    public var email: String?
+    public var name: String?
+
     // screen_view
     public var screen_name: String?
     public var prev_screen_name: String?

package/ios/WatchtowerCore/Watchtower.swift

@@ -58,12 +58,18 @@ public enum Watchtower {
     /// Identity (§1.1 distinct_id): stamped on every subsequent event. Pass nil
     /// to return to anonymous. The RN layer feeds the SDK's identify() through
     /// this; native hosts call it directly.
-    public static func setUser(_ distinctId: String?) {
+    ///
+    /// Optionally pass `email` / `name` traits: they are sent once as an
+    /// `identify` event (not stamped on every tap) so the dashboard can label
+    /// the user by name/email instead of a raw id.
+    public static func setUser(_ distinctId: String?, email: String? = nil, name: String? = nil) {
         #if canImport(UIKit)
         if Thread.isMainThread {
-            WatchtowerEngine.shared.setUser(distinctId)
+            WatchtowerEngine.shared.setUser(distinctId, email: email, name: name)
         } else {
-            DispatchQueue.main.async { WatchtowerEngine.shared.setUser(distinctId) }
+            DispatchQueue.main.async {
+                WatchtowerEngine.shared.setUser(distinctId, email: email, name: name)
+            }
         }
         #endif
     }

package/ios/WatchtowerCore/WatchtowerEngine.swift

@@ -15,6 +15,9 @@ final class WatchtowerEngine {
     private var appVersion: String?
     /// Identity from Watchtower.setUser (§1.1 distinct_id). nil = anonymous.
     private var distinctId: String?
+    /// Optional identity traits, sent once via an "identify" event.
+    private var userEmail: String?
+    private var userName: String?
     /// Hardware identifier (utsname.machine, e.g. "iPhone17,1") + OS version,
     /// stamped on every event (§1.1).
     private var deviceModel: String?
@@ -103,8 +106,17 @@ final class WatchtowerEngine {
         transport = nil
     }
 
-    func setUser(_ id: String?) {
+    func setUser(_ id: String?, email: String? = nil, name: String? = nil) {
         distinctId = id
+        userEmail = email
+        userName = name
+        // Emit a one-shot identify so downstream can attach name/email to this
+        // distinct_id without stamping PII on every tap. No-op until running.
+        guard isRunning, id != nil || email != nil || name != nil else { return }
+        var ev = baseEvent(type: "identify")
+        ev.email = email
+        ev.name = name
+        emit(ev)
     }
 
     var currentSessionId: String? { isRunning ? sessionId : nil }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sitepong",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "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"