fix(messenger): never unfurl an invite URL on the website host

An apex /chat/invite link without a fragment became a web card. Also moves initWrongKey so each KDoc sits above its own function, and covers the wrong-key reducer and chat switch.

Author: bmc08gt

apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/ChatViewModel.kt

@@ -2717,18 +2717,19 @@ internal class ChatViewModel @AssistedInject constructor(
             .launchIn(viewModelScope)
     }
 
-    /**
-     * The group events that are not an RPC's answer: the gate appearing, and the taps on the
-     * invite sheet, an invite card, the gate's funding button and the group profile. The screens report the taps
-     * as events so the member count and the gate mint come from the state this holds.
-     */
+    /** Whether the key this account holds for the open chat is the wrong one (an invite join gone bad). */
     private fun initWrongKey() {
         stateFlow.map { it.chatId }.filterNotNull().distinctUntilChanged()
             .flatMapLatest { wrongKeyChats.observe(it) }
             .onEach { dispatchEvent(Event.OnWrongKey(it)) }
             .launchIn(viewModelScope)
     }
 
+    /**
+     * The group events that are not an RPC's answer: the gate appearing, and the taps on the
+     * invite sheet, an invite card, the gate's funding button and the group profile. The screens report the taps
+     * as events so the member count and the gate mint come from the state this holds.
+     */
     private fun initGroupAnalytics() {
         // Once per view model, which is once per visit: the chat flow scopes it to the Chat route.
         // Keyed on the gate being drawn — outside the group with the access decided — and not on

apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/link/LinkCardClassifier.kt

@@ -77,7 +77,14 @@ internal class LinkCardClassifier @Inject constructor(
     private fun HttpUrl.isWebsitePage(): Boolean =
         host in WEBSITE_HOSTS &&
             fragment == null &&
-            pathSegments.first().lowercase() !in SECRET_SEGMENTS
+            pathSegments.first().lowercase() !in SECRET_SEGMENTS &&
+            !isInvitePath()
+
+    /** `/chat/invite` in any case: an invite URL is never unfurled, with its fragment or without. */
+    private fun HttpUrl.isInvitePath(): Boolean =
+        pathSegments.size >= 2 &&
+            pathSegments[0].equals("chat", ignoreCase = true) &&
+            pathSegments[1].equals("invite", ignoreCase = true)
 
     /**
      * The message a tapped link points at, when it is a message link on our hosts (wrapped in a

apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatTypingGateTest.kt

@@ -31,6 +31,7 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.flowOf
+import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 import kotlinx.coroutines.test.UnconfinedTestDispatcher
@@ -195,4 +196,57 @@ class ChatTypingGateTest {
         advanceUntilIdle()
         assertFalse(viewModel.stateFlow.value.wrongKey)
     }
+
+    @Test
+    fun `the wrong-key event sets the flag and nothing else`() = runTest {
+        val viewModel = createViewModel()
+        val before = viewModel.stateFlow.value
+        viewModel.dispatchEvent(ChatViewModel.Event.OnWrongKey(true))
+        advanceUntilIdle()
+        assertEquals(before.copy(wrongKey = true), viewModel.stateFlow.value)
+
+        viewModel.dispatchEvent(ChatViewModel.Event.OnWrongKey(false))
+        advanceUntilIdle()
+        assertEquals(before, viewModel.stateFlow.value)
+    }
+
+    @Test
+    fun `the wrong-key mark follows the chat the screen switches to`() = runTest {
+        val other = ChatId(UUID.randomUUID().bytes)
+        every { contactCoordinator.lookupContact(any()) } returns Result.failure(NoSuchElementException())
+        coEvery { contactCoordinator.lookupContactByDmChatId(any()) } returns null
+        for (id in listOf(chatId, other)) {
+            every { chatCoordinator.observeMetadata(id) } returns flowOf(
+                ChatMembership(
+                    metadata = mockk<ChatMetadata>(relaxed = true) { every { this@mockk.type } returns ChatType.TIP_DM },
+                    isMember = true,
+                ),
+            )
+        }
+        val first = MutableStateFlow(true)
+        val second = MutableStateFlow(false)
+        every { wrongKeyChats.observe(chatId) } returns first
+        every { wrongKeyChats.observe(other) } returns second
+        coEvery { chatCoordinator.hydrateChat(other) } returns ChatHydration.Stored
+        every { chatCoordinator.observeMessages(other) } returns flowOf(emptyList())
+
+        val viewModel = createViewModel()
+        viewModel.dispatchEvent(ChatViewModel.Event.OnChatOpened(ChatIdentifier.ByChatId(chatId)))
+        advanceUntilIdle()
+        assertTrue(viewModel.stateFlow.value.wrongKey)
+
+        viewModel.dispatchEvent(ChatViewModel.Event.OnChatOpened(ChatIdentifier.ByChatId(other)))
+        advanceUntilIdle()
+        assertFalse(viewModel.stateFlow.value.wrongKey)
+
+        // The old chat's mark changing is no longer this screen's business.
+        first.value = false
+        first.value = true
+        advanceUntilIdle()
+        assertFalse(viewModel.stateFlow.value.wrongKey)
+
+        second.value = true
+        advanceUntilIdle()
+        assertTrue(viewModel.stateFlow.value.wrongKey)
+    }
 }

apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/link/LinkCardClassifierTest.kt

@@ -318,6 +318,29 @@ class LinkCardClassifierTest {
         assertEquals(outside, (card as? LinkCard.Web)?.url)
     }
 
+    /**
+     * The fake router above stands in for the parser. These run the real `AppRouter` (through the
+     * module that builds it), so a route the fake mis-states cannot hide an invite card.
+     */
+    @Test
+    fun `the real router gives an invite link no card on any host or wrapper`() {
+        val classifier = LinkCardClassifier(
+            com.flipcash.app.router.inject.RouterModule.providesRouter(io.mockk.mockk(relaxed = true)),
+        )
+        val secret = "A".repeat(43)
+        val invite = "/chat/invite#s=$secret"
+        for (url in listOf(
+            "https://app.flipcash.com$invite",
+            "https://flipcash.com$invite",
+            "https://jump.flipcash.com/#source=" +
+                java.net.URLEncoder.encode("https://app.flipcash.com$invite", "UTF-8"),
+            "https://app.flipcash.com/chat/invite",
+            "https://flipcash.com/chat/invite",
+        )) {
+            assertNull(classifier.firstCard(listOf(DetectedUrl(0, url.length, url))), url)
+        }
+    }
+
     /** The send-cash path under a chat opens a payment, not the group, so it stays a plain link. */
     @Test
     fun `a chat send cash link stays a link`() {