react-native-hubspot-wrapper 0.2.0 → 0.4.0

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Tue Apr 28 11:02:36 CEST 2026
+gradle.version=8.13

package/android/src/main/java/com/reactnativehubspotwrapper/HubspotBackButtonHider.kt

@@ -0,0 +1,250 @@
+package com.marcinolek.reactnativehubspotwrapper
+
+import android.app.Activity
+import android.app.Application
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import android.webkit.WebView
+
+/**
+ * Hides the HubSpot chat widget's "back to inbox" / conversations-list navigation
+ * inside [HubspotWebActivity] (which lives in HubSpot's compiled `.aar` and which
+ * we therefore can't modify directly).
+ *
+ * Approach:
+ *
+ * 1. We register a single [Application.ActivityLifecycleCallbacks] from the wrapper
+ *    module's init.
+ * 2. Each time `com.hubspot.mobilesdk.HubspotWebActivity` resumes, we depth-first
+ *    walk its decor view to find the `WebView`.
+ * 3. We `evaluateJavascript` a heuristic-based hider that walks all same-origin
+ *    sub-frames (the chat UI itself lives in an iframe on `app-na2.hubspot.com`)
+ *    and hides any `<button>`/`<a>`/`role="button"` whose accessible label,
+ *    `data-test-id`, title, id, class or short visible text normalizes (camelCase
+ *    -> spaces, `_-` -> spaces, lowercase) to something matching
+ *    `\b(back|inbox|previous|conversations)\b`. A `MutationObserver` is then
+ *    attached so late-mounted buttons get hidden too.
+ * 4. We re-fire `evaluateJavascript` periodically for a few seconds so the iframe
+ *    walk catches the chat iframe as soon as it mounts (it's loaded asynchronously
+ *    by HubSpot's `project.js` bundle after the activity opens).
+ *
+ * The implementation is intentionally identical in spirit to the iOS hider in
+ * `HubspotWrapperImpl.swift` so the same JS works on both platforms.
+ */
+internal object HubspotBackButtonHider {
+  private const val TAG = "HubspotWrapper"
+
+  /**
+   * The fully-qualified name of HubSpot's chat activity in the AAR. Matched by
+   * string so we don't have to import / depend on it for compile-time resolution.
+   */
+  private const val WEB_ACTIVITY_NAME = "com.hubspot.mobilesdk.HubspotWebActivity"
+
+  /** How often we re-fire `evaluateJavascript` to catch late-loaded iframes. */
+  private const val RESCAN_INTERVAL_MS = 250L
+
+  /**
+   * Total time we keep re-firing after the activity resumes. The chat iframe
+   * normally appears within ~2s; we give a generous margin and then stop to
+   * avoid burning CPU forever if the user leaves the chat open for a long time.
+   */
+  private const val MAX_SCAN_DURATION_MS = 10_000L
+
+  @Volatile
+  private var installed = false
+
+  @Synchronized
+  fun installOnce(app: Application) {
+    if (installed) return
+    installed = true
+
+    app.registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {
+      override fun onActivityResumed(activity: Activity) {
+        if (activity.javaClass.name != WEB_ACTIVITY_NAME) return
+        val webView = findWebView(activity.window.decorView)
+        if (webView == null) {
+          Log.w(TAG, "installBackButtonHider: WebView not found in $WEB_ACTIVITY_NAME view tree")
+          return
+        }
+        Log.i(TAG, "installBackButtonHider: scheduling JS injection on $webView")
+        scheduleHiderInjection(webView)
+      }
+
+      override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
+      override fun onActivityStarted(activity: Activity) {}
+      override fun onActivityPaused(activity: Activity) {}
+      override fun onActivityStopped(activity: Activity) {}
+      override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+      override fun onActivityDestroyed(activity: Activity) {}
+    })
+  }
+
+  private fun findWebView(view: View?): WebView? {
+    if (view is WebView) return view
+    if (view is ViewGroup) {
+      for (i in 0 until view.childCount) {
+        val found = findWebView(view.getChildAt(i))
+        if (found != null) return found
+      }
+    }
+    return null
+  }
+
+  private fun scheduleHiderInjection(webView: WebView) {
+    val handler = Handler(Looper.getMainLooper())
+    val start = System.currentTimeMillis()
+    val runnable = object : Runnable {
+      override fun run() {
+        try {
+          webView.evaluateJavascript(BACK_BUTTON_HIDER_JS, null)
+        } catch (error: Exception) {
+          Log.w(TAG, "evaluateJavascript failed", error)
+        }
+        if (System.currentTimeMillis() - start < MAX_SCAN_DURATION_MS) {
+          handler.postDelayed(this, RESCAN_INTERVAL_MS)
+        }
+      }
+    }
+    handler.post(runnable)
+  }
+
+  /**
+   * Heuristic-based hider for the chat widget's back/inbox button. Identical in
+   * shape to the iOS version in `HubspotWrapperImpl.swift`. Designed to be safe
+   * to invoke many times: a `__rnHubspotHiderInstalled` per-document flag short-
+   * circuits re-installation, while the periodic re-fire from
+   * [scheduleHiderInjection] still allows newly-mounted iframes to be picked up.
+   */
+  private const val BACK_BUTTON_HIDER_JS = """
+    (function() {
+      function bootstrap(win) {
+        var doc;
+        try { doc = win.document; } catch (_) { return; }
+        if (!doc || doc.__rnHubspotHiderInstalled) return;
+        doc.__rnHubspotHiderInstalled = true;
+
+        var BACK_PATTERN = /\b(back|inbox|previous|conversations)\b/i;
+
+        function normalize(s) {
+          if (!s) return '';
+          return String(s)
+            .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+            .replace(/[_-]+/g, ' ')
+            .toLowerCase();
+        }
+
+        function looksLikeBackControl(el) {
+          if (!el || el.nodeType !== 1) return false;
+          if (el.getAttribute('data-rn-hubspot-wrapper-hidden') === '1') return false;
+          var tag = el.tagName;
+          if (tag !== 'BUTTON' && tag !== 'A' && el.getAttribute('role') !== 'button') return false;
+          var attrs = [
+            el.getAttribute('aria-label'),
+            el.getAttribute('data-test-id'),
+            el.getAttribute('data-test'),
+            el.getAttribute('title'),
+            el.getAttribute('id'),
+            el.getAttribute('class')
+          ];
+          for (var i = 0; i < attrs.length; i++) {
+            if (attrs[i] && BACK_PATTERN.test(normalize(attrs[i]))) return true;
+          }
+          var text = (el.textContent || '').trim();
+          if (text && text.length <= 32 && BACK_PATTERN.test(normalize(text))) return true;
+          return false;
+        }
+
+        function hide(el) {
+          try {
+            el.setAttribute('data-rn-hubspot-wrapper-hidden', '1');
+            el.style.setProperty('display', 'none', 'important');
+            el.style.setProperty('visibility', 'hidden', 'important');
+            el.style.setProperty('pointer-events', 'none', 'important');
+          } catch (_) {}
+        }
+
+        // Hide `el`, then walk up to a few ancestors and also hide any wrapper
+        // that becomes empty (no remaining unhidden element children) as a
+        // result. HubSpot's chat header has a back-button slot whose padding
+        // / min-width / flex-basis stays around even when the inner button is
+        // `display:none`, which shows up as the avatar shifting right after the
+        // first message is sent. Capping at depth 3 keeps us inside the header.
+        function hideUpwards(el) {
+          hide(el);
+          var current = el;
+          for (var depth = 0; depth < 3; depth++) {
+            var parent = current.parentElement;
+            if (!parent) break;
+            if (parent === doc.documentElement || parent === doc.body) break;
+            var visibleCount = 0;
+            var children = parent.children;
+            for (var i = 0; i < children.length; i++) {
+              if (children[i].getAttribute('data-rn-hubspot-wrapper-hidden') !== '1') {
+                visibleCount++;
+              }
+            }
+            if (visibleCount > 0) break;
+            hide(parent);
+            current = parent;
+          }
+        }
+
+        var observed = new WeakSet();
+        function scanRoot(root) {
+          if (!root) return;
+          try {
+            var nodes = root.querySelectorAll('button, a, [role="button"]');
+            for (var i = 0; i < nodes.length; i++) {
+              if (looksLikeBackControl(nodes[i])) hideUpwards(nodes[i]);
+            }
+            var all = root.querySelectorAll('*');
+            for (var j = 0; j < all.length; j++) {
+              var sr = all[j].shadowRoot;
+              if (sr) {
+                scanRoot(sr);
+                attachObserver(sr);
+              }
+            }
+          } catch (_) {}
+        }
+
+        function attachObserver(root) {
+          if (!root || observed.has(root)) return;
+          observed.add(root);
+          try {
+            var mo = new MutationObserver(function() { scanRoot(root); });
+            mo.observe(root, { childList: true, subtree: true, attributes: true, attributeFilter: ['aria-label', 'data-test-id', 'data-test', 'title', 'class'] });
+          } catch (_) {}
+        }
+
+        function go() {
+          scanRoot(doc);
+          attachObserver(doc.documentElement || doc);
+        }
+
+        if (doc.readyState === 'loading') {
+          doc.addEventListener('DOMContentLoaded', go, { once: true });
+        } else {
+          go();
+        }
+      }
+
+      function walkAllFrames(win) {
+        if (!win) return;
+        bootstrap(win);
+        try {
+          for (var i = 0; i < win.frames.length; i++) {
+            walkAllFrames(win.frames[i]);
+          }
+        } catch (_) {}
+      }
+
+      walkAllFrames(window);
+    })();
+  """
+}

package/android/src/main/java/com/reactnativehubspotwrapper/HubspotWrapperModule.kt

@@ -1,6 +1,8 @@
 package com.marcinolek.reactnativehubspotwrapper
 
+import android.app.Application
 import android.content.Intent
+import android.util.Log
 import android.webkit.CookieManager
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -19,6 +21,14 @@ class HubspotWrapperModule(reactContext: ReactApplicationContext) :
   private val appContext = reactContext.applicationContext
   private lateinit var hubspotManager: HubspotManager
 
+  init {
+    // Install the chat back-button hider as soon as the wrapper module is created.
+    // The hider only does work when `HubspotWebActivity` actually resumes, so this
+    // is a cheap one-time `Application.ActivityLifecycleCallbacks` registration.
+    // See `HubspotBackButtonHider` for why this lives outside the activity itself.
+    (appContext as? Application)?.let { HubspotBackButtonHider.installOnce(it) }
+  }
+
   override fun getName(): String = NAME
 
   override fun initialize(promise: Promise) {
@@ -72,16 +82,94 @@ class HubspotWrapperModule(reactContext: ReactApplicationContext) :
   override fun clearUserData(promise: Promise) {
     CoroutineScope(Dispatchers.Main).launch {
       try {
+        Log.i(TAG, "clearUserData: invoked")
         hubspotManager.logout()
-        clearWebViewCookies()
+        clearHubspotSessionCookies()
+        Log.i(TAG, "clearUserData: done")
         promise.resolve(null)
       } catch (error: Exception) {
+        Log.e(TAG, "clearUserData: failed", error)
         promise.reject("CLEAR_USER_DATA_ERROR", "Failed to clear HubSpot user data", error)
       }
     }
   }
 
-  private suspend fun clearWebViewCookies() {
+  /**
+   * Mirror the iOS SDK's `cookiesToDeleteWhenClearingData` behavior: only drop the cookies that
+   * tie the embedded chat WebView to a previous HubSpot visitor identity (`hubspotutk`,
+   * `messagesUtk`). Anything else - Cloudflare bot-management cookies, future preference cookies,
+   * etc. - is intentionally preserved so the next chat session starts with a fresh identity but
+   * doesn't pay any unrelated cold-start tax.
+   *
+   * Implementation notes for Android:
+   *
+   * - `CookieManager.getCookie(url)` only returns `name=value` pairs - no `Domain`/`Path`
+   *   metadata - so to delete a cookie reliably we have to overwrite it with an expired date
+   *   under every plausible scope (host-only, exact host `Domain`, parent `Domain`). Writes
+   *   whose `Domain` doesn't match an existing cookie are silently rejected by the cookie store,
+   *   so issuing all three is safe.
+   *
+   * - The chat URL's host is computed from `hubspot-info.json` using the same rule as the SDK's
+   *   internal `Hublet`/`Environment` value classes (which are package-private):
+   *
+   *     `https://app[-<hublet>].hubspot[qa].com/`
+   *
+   *   For example: hublet `na2` + env `prod` -> `https://app-na2.hubspot.com/`.
+   *   Hublet `na1` is special-cased to `app.hubspot.com`. Env `qa` adds the `qa` suffix
+   *   to the apex (`hubspotqa.com`).
+   *
+   * - If `HubspotManager` hasn't been configured yet, we fall back to `removeAllCookies()` so
+   *   we never leak chat identity even in misconfigured states.
+   *
+   * Caveat (matches iOS): clearing `messagesUtk` resets the visitor identity, which causes
+   * HubSpot's chat embed to re-show its cookie consent banner on the next session. This is by
+   * design on HubSpot's side - their chat treats every new visitor id as a new visitor that
+   * must consent. There is no way to keep both "fresh chat" and "no consent reprompt" without
+   * also leaving the previous conversation thread visible to the user.
+   */
+  private suspend fun clearHubspotSessionCookies() {
+    val hubletId = runCatching { hubspotManager.getHublet() }.getOrNull()
+    val environment = runCatching { hubspotManager.getEnvironment() }.getOrNull()
+
+    if (hubletId.isNullOrEmpty() || environment.isNullOrEmpty()) {
+      Log.w(TAG, "clearUserData: missing hublet/environment, falling back to removeAllCookies()")
+      clearAllWebViewCookies()
+      return
+    }
+
+    val cookieManager = CookieManager.getInstance()
+    val urlSuffix = if (environment.equals("qa", ignoreCase = true)) "qa" else ""
+    val rootDomain = "hubspot$urlSuffix.com"
+    val appsSubDomain = if (hubletId.equals("na1", ignoreCase = true)) "app" else "app-$hubletId"
+    val chatHost = "$appsSubDomain.$rootDomain"
+    val chatUrl = "https://$chatHost/"
+
+    val existingCookieNames = cookieManager.getCookie(chatUrl).orEmpty()
+      .split(";")
+      .mapNotNull { it.substringBefore("=").trim().takeIf(String::isNotEmpty) }
+      .toSet()
+
+    val toDelete = COOKIES_TO_CLEAR.filter { it in existingCookieNames }
+    if (toDelete.isEmpty()) {
+      Log.i(TAG, "clearUserData: no chat-identity cookies present at $chatHost, nothing to delete")
+      return
+    }
+
+    Log.i(TAG, "clearUserData: deleting cookies=$toDelete on $chatHost")
+    val expiry = "Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT"
+    toDelete.forEach { name ->
+      cookieManager.setCookie(chatUrl, "$name=; $expiry")
+      cookieManager.setCookie(chatUrl, "$name=; Domain=$chatHost; $expiry")
+      cookieManager.setCookie(chatUrl, "$name=; Domain=.$rootDomain; $expiry")
+    }
+
+    suspendCancellableCoroutine<Unit> { continuation ->
+      cookieManager.flush()
+      continuation.resume(Unit)
+    }
+  }
+
+  private suspend fun clearAllWebViewCookies() {
     suspendCancellableCoroutine<Unit> { continuation ->
       val cookieManager = CookieManager.getInstance()
       cookieManager.removeAllCookies {
@@ -93,5 +181,14 @@ class HubspotWrapperModule(reactContext: ReactApplicationContext) :
 
   companion object {
     const val NAME = "NativeHubspotWrapper"
+
+    private const val TAG = "HubspotWrapper"
+
+    /**
+     * Cookies that bind the embedded chat WebView to a specific HubSpot visitor identity.
+     * Matches the iOS SDK's `cookiesToDeleteWhenClearingData`.
+     * See https://knowledge.hubspot.com/privacy-and-consent/what-cookies-does-hubspot-set-in-a-visitor-s-browser
+     */
+    private val COOKIES_TO_CLEAR = listOf("hubspotutk", "messagesUtk")
   }
 }

package/ios/HubspotMobileSDK/Views/ChatView/HubspotChatView.swift

@@ -349,6 +349,9 @@ struct HubspotChatWebView: UIViewRepresentable {
 
             contentController.addUserScript(WKUserScript(source: js, injectionTime: .atDocumentEnd, forMainFrameOnly: false))
 
+            // [react-native-hubspot-wrapper] hide chat "back to inbox" button - see HubspotWrapperImpl
+            HubspotWrapperImpl.installBackButtonHider(on: contentController)
+
             // create script that triggers on hubspot event, and calls our message handler
 
             let configCallbacksJS = """

package/ios/HubspotWrapperImpl.swift

@@ -1,9 +1,29 @@
 import Foundation
 import SwiftUI
 import UIKit
+import WebKit
 
 @objcMembers
 public class HubspotWrapperImpl: NSObject {
+  /// Substrings used to match `WKWebsiteDataRecord.displayName` (which is the host /
+  /// eTLD+1, e.g. `hubspot.com`, `hs-banner.com`, `hsadspixel.net`) for the various
+  /// domains the chat widget loads from. Anything matching is wiped on `clearUserData`.
+  ///
+  /// We deliberately use substrings rather than exact hosts because the widget pulls
+  /// resources from a long tail of HubSpot CDNs - `js.hs-banner.com`, `js.hubspot.com`,
+  /// `static.hsappstatic.net`, `app-na2.hubspot.com`, `*.hubspotqa.com`, etc. - and any
+  /// of those can hold cookies / localStorage / IndexedDB that re-attach a returning
+  /// visitor or surface the unsent draft message on the next open.
+  private static let chatDataDomainMatches: [String] = [
+    "hubspot",
+    "hsforms",
+    "hs-banner",
+    "hs-scripts",
+    "hsadspixel",
+    "hsappstatic",
+    "usemessages",
+  ]
+
   public func initialize(_ outError: NSErrorPointer) -> Bool {
     let semaphore = DispatchSemaphore(value: 0)
     var configureError: NSError?
@@ -80,12 +100,216 @@ public class HubspotWrapperImpl: NSObject {
     }
   }
 
-  public func clearUserData() {
-    Task {
-      await HubspotManager.shared.clearUserData()
+  /// Clear the SDK's in-memory identity/property state and synchronously wait for ALL
+  /// HubSpot website data (cookies, localStorage, sessionStorage, IndexedDB, service
+  /// workers, etc.) to be removed from the shared `WKWebsiteDataStore` before invoking
+  /// `completion`.
+  ///
+  /// Why we do our own clearing instead of relying on the SDK:
+  ///
+  /// 1. `HubspotManager.clearUserData()` is synchronous, but the cookie removal it
+  ///    performs is dispatched into a fire-and-forget `Task { ... }` that we have no
+  ///    handle to. JS code doing
+  ///    `await HubspotWrapper.clearUserData(); await HubspotWrapper.openChat(...)`
+  ///    races the still-in-flight cookie deletion, so the next chat session re-uses
+  ///    the previous visitor identity.
+  ///
+  /// 2. Even when the SDK's cookie deletion *does* finish, it only removes the two
+  ///    visitor-identity cookies (`hubspotutk`, `messagesUtk`). The chat widget also
+  ///    persists the unsent draft message and other state in `localStorage` /
+  ///    `sessionStorage` / `IndexedDB`. Cookie-only clearing leaves the draft visible
+  ///    on the next open, which is exactly the bug we kept seeing.
+  ///
+  /// We therefore enumerate `WKWebsiteDataStore` records, filter to records whose
+  /// host matches a HubSpot domain (see `chatDataDomainMatches`) and remove ALL data
+  /// types for those records. We only resolve the JS promise once that's complete.
+  public func clearUserData(_ completion: @escaping () -> Void) {
+    Task { @MainActor in
+      HubspotManager.shared.clearUserData()
+      await Self.deleteAllChatWebsiteData()
+      completion()
+    }
+  }
+
+  private static func deleteAllChatWebsiteData() async {
+    let store = WKWebsiteDataStore.default()
+    let allTypes = WKWebsiteDataStore.allWebsiteDataTypes()
+    let records = await store.dataRecords(ofTypes: allTypes)
+    let matching = records.filter { record in
+      let host = record.displayName.lowercased()
+      return chatDataDomainMatches.contains(where: host.contains)
     }
+    guard !matching.isEmpty else { return }
+    await store.removeData(ofTypes: allTypes, for: matching)
   }
 
+  /// Install a `WKUserScript` on `controller` that hides any "back to inbox" /
+  /// conversations-list navigation rendered by the HubSpot chat widget.
+  ///
+  /// Called from the patched `HubspotChatWebView.WebviewCoordinator.setupScripts()`
+  /// (see `update-hubspot-ios-sdk.sh` for the patch that re-applies that hook on
+  /// every SDK sync). The actual heuristic-based hide JS lives here in our own
+  /// non-vendored file so SDK updates don't churn the implementation.
+  ///
+  /// We can't rely on a single CSS selector because:
+  ///   - HubSpot's widget uses minified/hashed class names that change across
+  ///     releases.
+  ///   - Parts of the widget render inside shadow roots, which a top-level
+  ///     `<style>` doesn't pierce.
+  ///   - The button can mount after first paint as the widget hydrates.
+  ///
+  /// The injected script installs a `MutationObserver` that walks the full tree
+  /// (recursing into open shadow roots) and hides anything that *behaves* like a
+  /// back button - matched on `aria-label`, `data-test-id`, `title`, `id`, `class`,
+  /// and visible text. Re-scans periodically for the first few seconds to cover
+  /// late-mounted shadow roots. Injected at document start in every frame.
+  @objc public static func installBackButtonHider(on controller: WKUserContentController) {
+    let script = WKUserScript(
+      source: backButtonHiderJS,
+      injectionTime: .atDocumentStart,
+      forMainFrameOnly: false
+    )
+    controller.addUserScript(script)
+  }
+
+  /// Heuristic-based hider for the chat widget's back/inbox button. Designed to
+  /// work both as a `WKUserScript` (per-frame at `.atDocumentStart`) and as a
+  /// one-shot `evaluateJavascript` payload from the Android side - hence the
+  /// `walkAllFrames` / `bootstrap` split with the per-document install guard.
+  /// Keep this string in lockstep with `HubspotBackButtonHider.BACK_BUTTON_HIDER_JS`
+  /// in the Android wrapper. Insert spaces at camelCase boundaries and collapse
+  /// underscores/dashes to spaces so word-boundary matching catches class names
+  /// like `ConversationView__BackButton`. (In JS regex, `_` is a word char, so
+  /// without this `\\bback\\b` would fail against `..._back_...`.)
+  private static let backButtonHiderJS: String = """
+    (function() {
+      function bootstrap(win) {
+        var doc;
+        try { doc = win.document; } catch (_) { return; }
+        if (!doc || doc.__rnHubspotHiderInstalled) return;
+        doc.__rnHubspotHiderInstalled = true;
+
+        var BACK_PATTERN = /\\b(back|inbox|previous|conversations)\\b/i;
+
+        function normalize(s) {
+          if (!s) return '';
+          return String(s)
+            .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+            .replace(/[_-]+/g, ' ')
+            .toLowerCase();
+        }
+
+        function looksLikeBackControl(el) {
+          if (!el || el.nodeType !== 1) return false;
+          if (el.getAttribute('data-rn-hubspot-wrapper-hidden') === '1') return false;
+          var tag = el.tagName;
+          if (tag !== 'BUTTON' && tag !== 'A' && el.getAttribute('role') !== 'button') return false;
+          var attrs = [
+            el.getAttribute('aria-label'),
+            el.getAttribute('data-test-id'),
+            el.getAttribute('data-test'),
+            el.getAttribute('title'),
+            el.getAttribute('id'),
+            el.getAttribute('class')
+          ];
+          for (var i = 0; i < attrs.length; i++) {
+            if (attrs[i] && BACK_PATTERN.test(normalize(attrs[i]))) return true;
+          }
+          var text = (el.textContent || '').trim();
+          if (text && text.length <= 32 && BACK_PATTERN.test(normalize(text))) return true;
+          return false;
+        }
+
+        function hide(el) {
+          try {
+            el.setAttribute('data-rn-hubspot-wrapper-hidden', '1');
+            el.style.setProperty('display', 'none', 'important');
+            el.style.setProperty('visibility', 'hidden', 'important');
+            el.style.setProperty('pointer-events', 'none', 'important');
+          } catch (_) {}
+        }
+
+        // Hide `el`, then walk up to a few ancestors and also hide any wrapper
+        // that becomes empty (no remaining unhidden element children) as a
+        // result. HubSpot's chat header has a back-button slot whose padding
+        // / min-width / flex-basis stays around even when the inner button is
+        // `display:none`, which shows up as the avatar shifting right after the
+        // first message is sent. Capping at depth 3 keeps us inside the header.
+        function hideUpwards(el) {
+          hide(el);
+          var current = el;
+          for (var depth = 0; depth < 3; depth++) {
+            var parent = current.parentElement;
+            if (!parent) break;
+            if (parent === doc.documentElement || parent === doc.body) break;
+            var visibleCount = 0;
+            var children = parent.children;
+            for (var i = 0; i < children.length; i++) {
+              if (children[i].getAttribute('data-rn-hubspot-wrapper-hidden') !== '1') {
+                visibleCount++;
+              }
+            }
+            if (visibleCount > 0) break;
+            hide(parent);
+            current = parent;
+          }
+        }
+
+        var observed = new WeakSet();
+        function scanRoot(root) {
+          if (!root) return;
+          try {
+            var nodes = root.querySelectorAll('button, a, [role="button"]');
+            for (var i = 0; i < nodes.length; i++) {
+              if (looksLikeBackControl(nodes[i])) hideUpwards(nodes[i]);
+            }
+            var all = root.querySelectorAll('*');
+            for (var j = 0; j < all.length; j++) {
+              var sr = all[j].shadowRoot;
+              if (sr) {
+                scanRoot(sr);
+                attachObserver(sr);
+              }
+            }
+          } catch (_) {}
+        }
+
+        function attachObserver(root) {
+          if (!root || observed.has(root)) return;
+          observed.add(root);
+          try {
+            var mo = new MutationObserver(function() { scanRoot(root); });
+            mo.observe(root, { childList: true, subtree: true, attributes: true, attributeFilter: ['aria-label', 'data-test-id', 'data-test', 'title', 'class'] });
+          } catch (_) {}
+        }
+
+        function go() {
+          scanRoot(doc);
+          attachObserver(doc.documentElement || doc);
+        }
+
+        if (doc.readyState === 'loading') {
+          doc.addEventListener('DOMContentLoaded', go, { once: true });
+        } else {
+          go();
+        }
+      }
+
+      function walkAllFrames(win) {
+        if (!win) return;
+        bootstrap(win);
+        try {
+          for (var i = 0; i < win.frames.length; i++) {
+            walkAllFrames(win.frames[i]);
+          }
+        } catch (_) {}
+      }
+
+      walkAllFrames(window);
+    })();
+    """
+
   private static func topViewController(
     base: UIViewController? = UIApplication.shared.connectedScenes
       .compactMap { $0 as? UIWindowScene }

package/ios/RNHubspotWrapper.mm

@@ -59,8 +59,13 @@ RCT_EXPORT_MODULE(NativeHubspotWrapper)
 
 - (void)clearUserData:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
 {
-  [_impl clearUserData];
-  resolve(nil);
+  // Important: do not resolve until the impl reports completion. The impl awaits the
+  // actual chat-identity cookie deletion before invoking this block. Resolving sooner
+  // creates a race where JS-level `await clearUserData()` returns before HubSpot's
+  // visitor cookies are gone, and the next `openChat` re-uses the previous identity.
+  [_impl clearUserData:^{
+    resolve(nil);
+  }];
 }
 
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-hubspot-wrapper",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "TurboModule wrapper for HubSpot mobile chat SDK",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/scripts/update-hubspot-ios-sdk.sh

@@ -75,6 +75,31 @@ extension Bundle {
 if old_block not in content:
     raise RuntimeError("Expected Image extension block was not found in HubspotManager.swift")
 hubspot_manager.write_text(content.replace(old_block, new_block, 1))
+
+# 4) Hook our back-button hider into HubspotChatWebView's WKUserContentController.
+#    The actual hider implementation lives in our own non-vendored
+#    HubspotWrapperImpl.swift; this patch just inserts a one-line call so the
+#    hider runs whenever the SDK builds its content controller. We open chat as
+#    a single fresh conversation per session and never want users navigating
+#    into prior threads.
+chat_view = target_dir / "Views/ChatView/HubspotChatView.swift"
+chat_content = chat_view.read_text()
+anchor = (
+    'contentController.addUserScript(WKUserScript(source: js, '
+    'injectionTime: .atDocumentEnd, forMainFrameOnly: false))'
+)
+hook_block = (
+    "\n\n"
+    "            // [react-native-hubspot-wrapper] hide chat \"back to inbox\" button - see HubspotWrapperImpl\n"
+    "            HubspotWrapperImpl.installBackButtonHider(on: contentController)"
+)
+if anchor not in chat_content:
+    raise RuntimeError("Expected setupScripts anchor not found in HubspotChatView.swift")
+if "HubspotWrapperImpl.installBackButtonHider" in chat_content:
+    # Already patched.
+    pass
+else:
+    chat_view.write_text(chat_content.replace(anchor, anchor + hook_block, 1))
 PY
 }