From 9372081b99d0e03f113b615559307a3e263dfd1e Mon Sep 17 00:00:00 2001
From: Connor Lindsey <cblindsey3@gmail.com>
Date: Wed, 21 Jan 2026 09:30:49 -0800
Subject: [PATCH 1/3] fix: add broadcast channel listener for Slack OAuth flow

---
 .../src/modules/slack/hooks/useSlackAuth.ts   |  5 ++-
 .../SlackAuthButton/SlackAuthButton.tsx       | 43 +++++++++++++------
 2 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/packages/react-core/src/modules/slack/hooks/useSlackAuth.ts b/packages/react-core/src/modules/slack/hooks/useSlackAuth.ts
index 91f5c9eb1..321c862b8 100644
--- a/packages/react-core/src/modules/slack/hooks/useSlackAuth.ts
+++ b/packages/react-core/src/modules/slack/hooks/useSlackAuth.ts
@@ -13,7 +13,7 @@ const DEFAULT_SLACK_SCOPES = [
 ];
 
 type UseSlackAuthOutput = {
-  buildSlackAuthUrl: () => string;
+  buildSlackAuthUrl: (requestId: string) => string;
   disconnectFromSlack: () => void;
 };
 
@@ -82,10 +82,11 @@ function useSlackAuth(
     setActionLabel,
   ]);
 
-  const buildSlackAuthUrl = useCallback(() => {
+  const buildSlackAuthUrl = useCallback((requestId: string) => {
     const rawParams = {
       state: JSON.stringify({
         redirect_url: redirectUrl,
+        request_id: requestId,
         access_token_object: {
           object_id: tenantId,
           collection: TENANT_OBJECT_COLLECTION,
diff --git a/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx b/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx
index 589a3f3a7..883c5b200 100644
--- a/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx
+++ b/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx
@@ -4,7 +4,7 @@ import {
   useSlackAuth,
   useTranslations,
 } from "@knocklabs/react-core";
-import { FunctionComponent, useMemo } from "react";
+import { FunctionComponent, useId, useMemo } from "react";
 import { useEffect } from "react";
 
 import { openPopupWindow } from "../../../core/utils";
@@ -33,6 +33,8 @@ export const SlackAuthButton: FunctionComponent<SlackAuthButtonProps> = ({
   const { t } = useTranslations();
   const knock = useKnockClient();
 
+  const requestId = useId();
+
   const {
     setConnectionStatus,
     connectionStatus,
@@ -56,35 +58,50 @@ export const SlackAuthButton: FunctionComponent<SlackAuthButtonProps> = ({
   );
 
   useEffect(() => {
-    const receiveMessage = (event: MessageEvent) => {
-      if (event.origin !== knock.host) {
-        return;
-      }
-
+    const handleAuthMessage = (data: string) => {
       try {
-        if (event.data === "authComplete") {
+        if (data === "authComplete") {
           setConnectionStatus("connected");
         }
 
-        if (event.data === "authFailed") {
+        if (data === "authFailed") {
           setConnectionStatus("error");
         }
 
         if (onAuthenticationComplete) {
-          onAuthenticationComplete(event.data);
+          onAuthenticationComplete(data);
         }
       } catch (_error) {
         setConnectionStatus("error");
       }
     };
 
+    // Listen for both window.postMessage and BroadcastChannel
+    const receiveMessage = (event: MessageEvent) => {
+      if (event.origin !== knock.host) {
+        return;
+      }
+      handleAuthMessage(event.data);
+    };
+
     window.addEventListener("message", receiveMessage, false);
 
-    // Cleanup the event listener when the component unmounts
+    let broadcastChannel: BroadcastChannel | null = null;
+    if (typeof BroadcastChannel !== "undefined") {
+      broadcastChannel = new BroadcastChannel(`knock:oauth:${requestId}`);
+      broadcastChannel.onmessage = (event) => {
+        if (event.data.origin === knock.host) {
+          handleAuthMessage(event.data.type || event.data);
+        }
+      };
+    }
+
+    // Cleanup listeners when component unmounts
     return () => {
       window.removeEventListener("message", receiveMessage);
+      broadcastChannel?.close();
     };
-  }, [knock.host, onAuthenticationComplete, setConnectionStatus]);
+  }, [knock.host, requestId, onAuthenticationComplete, setConnectionStatus]);
 
   const disconnectLabel = t("slackDisconnect") || null;
   const reconnectLabel = t("slackReconnect") || null;
@@ -110,7 +127,7 @@ export const SlackAuthButton: FunctionComponent<SlackAuthButtonProps> = ({
   if (connectionStatus === "error") {
     return (
       <button
-        onClick={() => openPopupWindow(buildSlackAuthUrl())}
+        onClick={() => openPopupWindow(buildSlackAuthUrl(requestId))}
         className="rsk-connect__button rsk-connect__button--error"
         onMouseEnter={() => setActionLabel(reconnectLabel)}
         onMouseLeave={() => setActionLabel(null)}
@@ -127,7 +144,7 @@ export const SlackAuthButton: FunctionComponent<SlackAuthButtonProps> = ({
   if (connectionStatus === "disconnected") {
     return (
       <button
-        onClick={() => openPopupWindow(buildSlackAuthUrl())}
+        onClick={() => openPopupWindow(buildSlackAuthUrl(requestId))}
         className="rsk-connect__button rsk-connect__button--disconnected"
       >
         <SlackIcon height="16px" width="16px" />

From b7508c2ee299bef45f4b3072d9416b54a2fc0d68 Mon Sep 17 00:00:00 2001
From: Connor Lindsey <cblindsey3@gmail.com>
Date: Wed, 21 Jan 2026 13:49:20 -0800
Subject: [PATCH 2/3] use polling instead of broadcast channel

---
 .changeset/tiny-donuts-travel.md              |   6 +
 .../ms-teams/context/KnockMsTeamsProvider.tsx |   5 +-
 .../slack/context/KnockSlackProvider.tsx      |   5 +-
 .../src/modules/slack/hooks/useSlackAuth.ts   |   5 +-
 packages/react/src/modules/core/utils.ts      |   2 +-
 .../MsTeamsAuthButton/MsTeamsAuthButton.tsx   | 120 ++++++++++++---
 .../SlackAuthButton/SlackAuthButton.tsx       | 144 +++++++++++++-----
 7 files changed, 226 insertions(+), 61 deletions(-)
 create mode 100644 .changeset/tiny-donuts-travel.md

diff --git a/.changeset/tiny-donuts-travel.md b/.changeset/tiny-donuts-travel.md
new file mode 100644
index 000000000..b9c7c804f
--- /dev/null
+++ b/.changeset/tiny-donuts-travel.md
@@ -0,0 +1,6 @@
+---
+"@knocklabs/react-core": patch
+"@knocklabs/react": patch
+---
+
+fix: poll to check if OAuth connection succeeded in case popup communication fails
diff --git a/packages/react-core/src/modules/ms-teams/context/KnockMsTeamsProvider.tsx b/packages/react-core/src/modules/ms-teams/context/KnockMsTeamsProvider.tsx
index bce03b7ff..4d18853f7 100644
--- a/packages/react-core/src/modules/ms-teams/context/KnockMsTeamsProvider.tsx
+++ b/packages/react-core/src/modules/ms-teams/context/KnockMsTeamsProvider.tsx
@@ -1,5 +1,5 @@
 import * as React from "react";
-import { PropsWithChildren } from "react";
+import { PropsWithChildren, useRef } from "react";
 
 import { useKnockClient } from "../../core";
 import { msTeamsProviderKey } from "../../core/utils";
@@ -15,6 +15,7 @@ export interface KnockMsTeamsProviderState {
   setErrorLabel: (label: string) => void;
   actionLabel: string | null;
   setActionLabel: (label: string | null) => void;
+  popupWindowRef: React.MutableRefObject<Window | null>;
 }
 
 const MsTeamsProviderStateContext =
@@ -29,6 +30,7 @@ export const KnockMsTeamsProvider: React.FC<
   PropsWithChildren<KnockMsTeamsProviderProps>
 > = ({ knockMsTeamsChannelId, tenantId, children }) => {
   const knock = useKnockClient();
+  const popupWindowRef = useRef<Window | null>(null);
 
   const {
     connectionStatus,
@@ -56,6 +58,7 @@ export const KnockMsTeamsProvider: React.FC<
         setActionLabel,
         knockMsTeamsChannelId,
         tenantId,
+        popupWindowRef,
       }}
     >
       {children}
diff --git a/packages/react-core/src/modules/slack/context/KnockSlackProvider.tsx b/packages/react-core/src/modules/slack/context/KnockSlackProvider.tsx
index 0b44b95cc..3cf4c80b2 100644
--- a/packages/react-core/src/modules/slack/context/KnockSlackProvider.tsx
+++ b/packages/react-core/src/modules/slack/context/KnockSlackProvider.tsx
@@ -1,6 +1,6 @@
 import { useSlackConnectionStatus } from "..";
 import * as React from "react";
-import { PropsWithChildren } from "react";
+import { PropsWithChildren, useRef } from "react";
 
 import { slackProviderKey } from "../../core";
 import { useKnockClient } from "../../core";
@@ -19,6 +19,7 @@ export interface KnockSlackProviderState {
   setErrorLabel: (label: string) => void;
   actionLabel: string | null;
   setActionLabel: (label: string | null) => void;
+  popupWindowRef: React.MutableRefObject<Window | null>;
 }
 
 const SlackProviderStateContext =
@@ -44,6 +45,7 @@ export const KnockSlackProvider: React.FC<
   const tenantId = "tenantId" in props ? props.tenantId : props.tenant;
 
   const knock = useKnockClient();
+  const popupWindowRef = useRef<Window | null>(null);
 
   const {
     connectionStatus,
@@ -73,6 +75,7 @@ export const KnockSlackProvider: React.FC<
         // Assign the same value to both tenant and tenantId for backwards compatibility
         tenant: tenantId,
         tenantId,
+        popupWindowRef,
       }}
     >
       {children}
diff --git a/packages/react-core/src/modules/slack/hooks/useSlackAuth.ts b/packages/react-core/src/modules/slack/hooks/useSlackAuth.ts
index 321c862b8..91f5c9eb1 100644
--- a/packages/react-core/src/modules/slack/hooks/useSlackAuth.ts
+++ b/packages/react-core/src/modules/slack/hooks/useSlackAuth.ts
@@ -13,7 +13,7 @@ const DEFAULT_SLACK_SCOPES = [
 ];
 
 type UseSlackAuthOutput = {
-  buildSlackAuthUrl: (requestId: string) => string;
+  buildSlackAuthUrl: () => string;
   disconnectFromSlack: () => void;
 };
 
@@ -82,11 +82,10 @@ function useSlackAuth(
     setActionLabel,
   ]);
 
-  const buildSlackAuthUrl = useCallback((requestId: string) => {
+  const buildSlackAuthUrl = useCallback(() => {
     const rawParams = {
       state: JSON.stringify({
         redirect_url: redirectUrl,
-        request_id: requestId,
         access_token_object: {
           object_id: tenantId,
           collection: TENANT_OBJECT_COLLECTION,
diff --git a/packages/react/src/modules/core/utils.ts b/packages/react/src/modules/core/utils.ts
index e6fa0b0c3..274afb5ae 100644
--- a/packages/react/src/modules/core/utils.ts
+++ b/packages/react/src/modules/core/utils.ts
@@ -18,7 +18,7 @@ export const openPopupWindow = (url: string) => {
   // Window features
   const features = `width=${width},height=${height},top=${top},left=${left}`;
 
-  window.open(url, "_blank", features);
+  return window.open(url, "_blank", features);
 };
 
 export const checkForWindow = () => {
diff --git a/packages/react/src/modules/ms-teams/components/MsTeamsAuthButton/MsTeamsAuthButton.tsx b/packages/react/src/modules/ms-teams/components/MsTeamsAuthButton/MsTeamsAuthButton.tsx
index 656f0e7b6..d513049d7 100644
--- a/packages/react/src/modules/ms-teams/components/MsTeamsAuthButton/MsTeamsAuthButton.tsx
+++ b/packages/react/src/modules/ms-teams/components/MsTeamsAuthButton/MsTeamsAuthButton.tsx
@@ -48,6 +48,9 @@ export const MsTeamsAuthButton: FunctionComponent<MsTeamsAuthButtonProps> = ({
     setActionLabel,
     actionLabel,
     errorLabel,
+    tenantId,
+    knockMsTeamsChannelId,
+    popupWindowRef,
   } = useKnockMsTeamsClient();
 
   const { buildMsTeamsAuthUrl, disconnectFromMsTeams } = useMsTeamsAuth(
@@ -61,28 +64,103 @@ export const MsTeamsAuthButton: FunctionComponent<MsTeamsAuthButtonProps> = ({
         return;
       }
 
-      try {
-        if (event.data === "authComplete") {
-          setConnectionStatus("connected");
-        }
-
-        if (event.data === "authFailed") {
-          setConnectionStatus("error");
-        }
-
+      if (event.data === "authComplete") {
+        setConnectionStatus("connected");
         onAuthenticationComplete?.(event.data);
-      } catch (_error) {
+        // Clear popup ref so polling stops and doesn't trigger callback again
+        if (popupWindowRef.current && !popupWindowRef.current.closed) {
+          popupWindowRef.current.close();
+        }
+        popupWindowRef.current = null;
+      } else if (event.data === "authFailed") {
         setConnectionStatus("error");
+        popupWindowRef.current = null;
       }
     };
 
     window.addEventListener("message", receiveMessage, false);
+    return () => window.removeEventListener("message", receiveMessage);
+  }, [
+    knock.host,
+    onAuthenticationComplete,
+    setConnectionStatus,
+    popupWindowRef,
+  ]);
+
+  useEffect(
+    () => {
+      let pollCount = 0;
+      const maxPolls = 90;
+      let popupClosedAt: number | null = null;
+      let isActive = true;
+
+      const pollInterval = setInterval(async () => {
+        if (!isActive) {
+          clearInterval(pollInterval);
+          return;
+        }
 
-    // Cleanup the event listener when the component unmounts
-    return () => {
-      window.removeEventListener("message", receiveMessage);
-    };
-  }, [knock.host, onAuthenticationComplete, setConnectionStatus]);
+        const popupWindow = popupWindowRef.current;
+        if (!popupWindow) {
+          return;
+        }
+
+        pollCount++;
+
+        // Check if popup is closed
+        const isPopupClosed = popupWindow.closed;
+        if (isPopupClosed && !popupClosedAt) {
+          popupClosedAt = Date.now();
+        }
+
+        // Stop condition 1: Max timeout reached
+        if (pollCount >= maxPolls) {
+          clearInterval(pollInterval);
+          setConnectionStatus("error");
+          return;
+        }
+
+        // Stop condition 2: Popup closed + grace period expired
+        if (popupClosedAt && Date.now() - popupClosedAt > 10000) {
+          clearInterval(pollInterval);
+          popupWindowRef.current = null;
+          return;
+        }
+
+        try {
+          const authRes = await knock.msTeams.authCheck({
+            tenant: tenantId,
+            knockChannelId: knockMsTeamsChannelId,
+          });
+
+          // Stop condition 3: Success detected
+          if (authRes.connection?.ok) {
+            clearInterval(pollInterval);
+            setConnectionStatus("connected");
+            if (onAuthenticationComplete) {
+              onAuthenticationComplete("authComplete");
+            }
+            if (popupWindow && !popupWindow.closed) {
+              popupWindow.close();
+            }
+            popupWindowRef.current = null;
+          }
+        } catch (_error) {
+          // Continue polling on error
+        }
+      }, 2000);
+
+      return () => {
+        isActive = false;
+        clearInterval(pollInterval);
+      };
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      // Empty deps - run once on mount and keep polling
+      // This is intentionally simple/brute force
+    ],
+  );
 
   const disconnectLabel = t("msTeamsDisconnect") || null;
   const reconnectLabel = t("msTeamsReconnect") || null;
@@ -108,7 +186,11 @@ export const MsTeamsAuthButton: FunctionComponent<MsTeamsAuthButtonProps> = ({
   if (connectionStatus === "error") {
     return (
       <button
-        onClick={() => openPopupWindow(buildMsTeamsAuthUrl())}
+        onClick={() => {
+          const popup = openPopupWindow(buildMsTeamsAuthUrl());
+          popupWindowRef.current = popup;
+          setConnectionStatus("connecting");
+        }}
         className="rtk-connect__button rtk-connect__button--error"
         onMouseEnter={() => setActionLabel(reconnectLabel)}
         onMouseLeave={() => setActionLabel(null)}
@@ -125,7 +207,11 @@ export const MsTeamsAuthButton: FunctionComponent<MsTeamsAuthButtonProps> = ({
   if (connectionStatus === "disconnected") {
     return (
       <button
-        onClick={() => openPopupWindow(buildMsTeamsAuthUrl())}
+        onClick={() => {
+          const popup = openPopupWindow(buildMsTeamsAuthUrl());
+          popupWindowRef.current = popup;
+          setConnectionStatus("connecting");
+        }}
         className="rtk-connect__button rtk-connect__button--disconnected"
       >
         <MsTeamsIcon height="16px" width="16px" />
diff --git a/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx b/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx
index 883c5b200..2fbaefa60 100644
--- a/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx
+++ b/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx
@@ -4,7 +4,7 @@ import {
   useSlackAuth,
   useTranslations,
 } from "@knocklabs/react-core";
-import { FunctionComponent, useId, useMemo } from "react";
+import { FunctionComponent, useMemo } from "react";
 import { useEffect } from "react";
 
 import { openPopupWindow } from "../../../core/utils";
@@ -33,14 +33,15 @@ export const SlackAuthButton: FunctionComponent<SlackAuthButtonProps> = ({
   const { t } = useTranslations();
   const knock = useKnockClient();
 
-  const requestId = useId();
-
   const {
     setConnectionStatus,
     connectionStatus,
     setActionLabel,
     actionLabel,
     errorLabel,
+    tenantId,
+    knockSlackChannelId,
+    popupWindowRef,
   } = useKnockSlackClient();
 
   const useSlackAuthOptions = useMemo(
@@ -58,50 +59,109 @@ export const SlackAuthButton: FunctionComponent<SlackAuthButtonProps> = ({
   );
 
   useEffect(() => {
-    const handleAuthMessage = (data: string) => {
-      try {
-        if (data === "authComplete") {
-          setConnectionStatus("connected");
-        }
-
-        if (data === "authFailed") {
-          setConnectionStatus("error");
-        }
+    const receiveMessage = (event: MessageEvent) => {
+      if (event.origin !== knock.host) {
+        return;
+      }
 
+      if (event.data === "authComplete") {
+        setConnectionStatus("connected");
         if (onAuthenticationComplete) {
-          onAuthenticationComplete(data);
+          onAuthenticationComplete(event.data);
+        }
+        // Clear popup ref so polling stops and doesn't trigger callback again
+        if (popupWindowRef.current && !popupWindowRef.current.closed) {
+          popupWindowRef.current.close();
         }
-      } catch (_error) {
+        popupWindowRef.current = null;
+      } else if (event.data === "authFailed") {
         setConnectionStatus("error");
+        popupWindowRef.current = null;
       }
     };
 
-    // Listen for both window.postMessage and BroadcastChannel
-    const receiveMessage = (event: MessageEvent) => {
-      if (event.origin !== knock.host) {
-        return;
-      }
-      handleAuthMessage(event.data);
-    };
-
     window.addEventListener("message", receiveMessage, false);
+    return () => window.removeEventListener("message", receiveMessage);
+  }, [
+    knock.host,
+    onAuthenticationComplete,
+    setConnectionStatus,
+    popupWindowRef,
+  ]);
+
+  useEffect(
+    () => {
+      let pollCount = 0;
+      const maxPolls = 90;
+      let popupClosedAt: number | null = null;
+      let isActive = true;
+
+      const pollInterval = setInterval(async () => {
+        if (!isActive) {
+          clearInterval(pollInterval);
+          return;
+        }
 
-    let broadcastChannel: BroadcastChannel | null = null;
-    if (typeof BroadcastChannel !== "undefined") {
-      broadcastChannel = new BroadcastChannel(`knock:oauth:${requestId}`);
-      broadcastChannel.onmessage = (event) => {
-        if (event.data.origin === knock.host) {
-          handleAuthMessage(event.data.type || event.data);
+        const popupWindow = popupWindowRef.current;
+        if (!popupWindow) {
+          return;
         }
-      };
-    }
 
-    // Cleanup listeners when component unmounts
-    return () => {
-      window.removeEventListener("message", receiveMessage);
-      broadcastChannel?.close();
-    };
-  }, [knock.host, requestId, onAuthenticationComplete, setConnectionStatus]);
+        pollCount++;
+
+        const isPopupClosed = popupWindow.closed;
+        if (isPopupClosed && !popupClosedAt) {
+          popupClosedAt = Date.now();
+        }
+
+        // Stop condition 1: Max timeout reached
+        if (pollCount >= maxPolls) {
+          clearInterval(pollInterval);
+          setConnectionStatus("error");
+          return;
+        }
+
+        // Stop condition 2: Popup closed + grace period expired
+        if (popupClosedAt && Date.now() - popupClosedAt > 10000) {
+          clearInterval(pollInterval);
+          popupWindowRef.current = null;
+          return;
+        }
+
+        try {
+          const authRes = await knock.slack.authCheck({
+            tenant: tenantId,
+            knockChannelId: knockSlackChannelId,
+          });
+
+          // Stop condition 3: Success detected
+          if (authRes.connection?.ok) {
+            clearInterval(pollInterval);
+            setConnectionStatus("connected");
+            if (onAuthenticationComplete) {
+              onAuthenticationComplete("authComplete");
+            }
+            if (popupWindow && !popupWindow.closed) {
+              popupWindow.close();
+            }
+            popupWindowRef.current = null;
+          }
+        } catch (_error) {
+          // Continue polling on error
+        }
+      }, 2000);
+
+      return () => {
+        isActive = false;
+        clearInterval(pollInterval);
+      };
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      // Empty deps - run once on mount and keep polling
+      // This is intentionally simple/brute force
+    ],
+  );
 
   const disconnectLabel = t("slackDisconnect") || null;
   const reconnectLabel = t("slackReconnect") || null;
@@ -127,7 +187,11 @@ export const SlackAuthButton: FunctionComponent<SlackAuthButtonProps> = ({
   if (connectionStatus === "error") {
     return (
       <button
-        onClick={() => openPopupWindow(buildSlackAuthUrl(requestId))}
+        onClick={() => {
+          const popup = openPopupWindow(buildSlackAuthUrl());
+          popupWindowRef.current = popup;
+          setConnectionStatus("connecting");
+        }}
         className="rsk-connect__button rsk-connect__button--error"
         onMouseEnter={() => setActionLabel(reconnectLabel)}
         onMouseLeave={() => setActionLabel(null)}
@@ -144,7 +208,11 @@ export const SlackAuthButton: FunctionComponent<SlackAuthButtonProps> = ({
   if (connectionStatus === "disconnected") {
     return (
       <button
-        onClick={() => openPopupWindow(buildSlackAuthUrl(requestId))}
+        onClick={() => {
+          const popup = openPopupWindow(buildSlackAuthUrl());
+          popupWindowRef.current = popup;
+          setConnectionStatus("connecting");
+        }}
         className="rsk-connect__button rsk-connect__button--disconnected"
       >
         <SlackIcon height="16px" width="16px" />

From 6dce5000176b1f5d8c2681876931962bc720bc2f Mon Sep 17 00:00:00 2001
From: Connor Lindsey <cblindsey3@gmail.com>
Date: Thu, 22 Jan 2026 09:28:08 -0800
Subject: [PATCH 3/3] refactor shared oauth hooks

---
 .changeset/tiny-donuts-travel.md              |   2 +-
 packages/react-core/src/index.ts              |   4 +
 .../src/modules/core/hooks/index.ts           |   2 +
 .../src/modules/core/hooks/useAuthPolling.ts  | 115 ++++++++++
 .../core/hooks/useAuthPostMessageListener.ts  |  70 ++++++
 packages/react-core/src/modules/core/index.ts |   8 +-
 packages/react-core/src/modules/core/types.ts |  25 ++
 .../ms-teams/context/KnockMsTeamsProvider.tsx |   3 +-
 .../hooks/useMsTeamsConnectionStatus.ts       |   8 +-
 .../slack/context/KnockSlackProvider.tsx      |   3 +-
 .../slack/hooks/useSlackConnectionStatus.ts   |   8 +-
 .../test/core/hooks/useAuthPolling.test.ts    | 216 ++++++++++++++++++
 .../hooks/useAuthPostMessageListener.test.ts  | 114 +++++++++
 .../MsTeamsAuthButton/MsTeamsAuthButton.tsx   | 121 ++--------
 .../SlackAuthButton/SlackAuthButton.tsx       | 123 ++--------
 .../test/ms-teams/MsTeamsAuthButton.test.tsx  |   6 +
 .../react/test/slack/SlackAuthButton.test.tsx |   6 +
 17 files changed, 608 insertions(+), 226 deletions(-)
 create mode 100644 packages/react-core/src/modules/core/hooks/useAuthPolling.ts
 create mode 100644 packages/react-core/src/modules/core/hooks/useAuthPostMessageListener.ts
 create mode 100644 packages/react-core/src/modules/core/types.ts
 create mode 100644 packages/react-core/test/core/hooks/useAuthPolling.test.ts
 create mode 100644 packages/react-core/test/core/hooks/useAuthPostMessageListener.test.ts

diff --git a/.changeset/tiny-donuts-travel.md b/.changeset/tiny-donuts-travel.md
index b9c7c804f..c1685a04c 100644
--- a/.changeset/tiny-donuts-travel.md
+++ b/.changeset/tiny-donuts-travel.md
@@ -3,4 +3,4 @@
 "@knocklabs/react": patch
 ---
 
-fix: poll to check if OAuth connection succeeded in case popup communication fails
+fix: poll to check if OAuth connection succeeded in case popup communication fails during Slack and Microsoft Teams auth flows
diff --git a/packages/react-core/src/index.ts b/packages/react-core/src/index.ts
index 134994ac8..722918029 100644
--- a/packages/react-core/src/index.ts
+++ b/packages/react-core/src/index.ts
@@ -8,10 +8,14 @@ export {
   renderNodeOrFallback,
   slackProviderKey,
   toSentenceCase,
+  type AuthCheckResult,
   type ColorMode,
+  type ConnectionStatus,
   type KnockProviderProps,
   type KnockProviderState,
   useAuthenticatedKnockClient,
+  useAuthPolling,
+  useAuthPostMessageListener,
   useKnockClient,
   useStableOptions,
 } from "./modules/core";
diff --git a/packages/react-core/src/modules/core/hooks/index.ts b/packages/react-core/src/modules/core/hooks/index.ts
index 5e5803537..4c2ce7d9b 100644
--- a/packages/react-core/src/modules/core/hooks/index.ts
+++ b/packages/react-core/src/modules/core/hooks/index.ts
@@ -1,2 +1,4 @@
 export { default as useAuthenticatedKnockClient } from "./useAuthenticatedKnockClient";
 export { default as useStableOptions } from "./useStableOptions";
+export { useAuthPostMessageListener } from "./useAuthPostMessageListener";
+export { useAuthPolling } from "./useAuthPolling";
diff --git a/packages/react-core/src/modules/core/hooks/useAuthPolling.ts b/packages/react-core/src/modules/core/hooks/useAuthPolling.ts
new file mode 100644
index 000000000..c4862e623
--- /dev/null
+++ b/packages/react-core/src/modules/core/hooks/useAuthPolling.ts
@@ -0,0 +1,115 @@
+import { useEffect } from "react";
+
+import { AuthCheckResult, ConnectionStatus } from "../types";
+
+export interface UseAuthPollingOptions {
+  popupWindowRef: React.MutableRefObject<Window | null>;
+  setConnectionStatus: (status: ConnectionStatus) => void;
+  authCheckFn: () => Promise<AuthCheckResult>;
+  onAuthenticationComplete?: (authenticationResp: string) => void;
+}
+
+/**
+ * Hook that polls an authentication check endpoint until success or timeout.
+ *
+ * Polls every 2 seconds for up to 3 minutes (90 iterations). Has three stop conditions:
+ * 1. Max timeout reached → sets error status
+ * 2. Popup closed + 10s grace period → stops silently
+ * 3. Success detected via authCheckFn → updates status and closes popup
+ *
+ * @param options - Configuration options for the polling mechanism
+ *
+ * @example
+ * ```tsx
+ * useAuthPolling({
+ *   popupWindowRef,
+ *   setConnectionStatus,
+ *   onAuthenticationComplete,
+ *   authCheckFn: useCallback(async () => {
+ *     return knock.slack.authCheck({
+ *       tenant: tenantId,
+ *       knockChannelId: knockSlackChannelId,
+ *     });
+ *   }, [knock.slack, tenantId, knockSlackChannelId]),
+ * });
+ * ```
+ */
+export function useAuthPolling(options: UseAuthPollingOptions): void {
+  const {
+    popupWindowRef,
+    setConnectionStatus,
+    onAuthenticationComplete,
+    authCheckFn,
+  } = options;
+
+  useEffect(
+    () => {
+      let pollCount = 0;
+      const maxPolls = 90;
+      let popupClosedAt: number | null = null;
+      let isActive = true;
+
+      const pollInterval = setInterval(async () => {
+        if (!isActive) {
+          clearInterval(pollInterval);
+          return;
+        }
+
+        const popupWindow = popupWindowRef.current;
+        if (!popupWindow) {
+          return;
+        }
+
+        pollCount++;
+
+        const isPopupClosed = popupWindow.closed;
+        if (isPopupClosed && !popupClosedAt) {
+          popupClosedAt = Date.now();
+        }
+
+        // Stop condition 1: Max timeout reached
+        if (pollCount >= maxPolls) {
+          clearInterval(pollInterval);
+          setConnectionStatus("error");
+          return;
+        }
+
+        // Stop condition 2: Popup closed + grace period expired
+        if (popupClosedAt && Date.now() - popupClosedAt > 10000) {
+          clearInterval(pollInterval);
+          popupWindowRef.current = null;
+          return;
+        }
+
+        try {
+          const authRes = await authCheckFn();
+
+          // Stop condition 3: Success detected
+          if (authRes.connection?.ok) {
+            clearInterval(pollInterval);
+            setConnectionStatus("connected");
+            if (onAuthenticationComplete) {
+              onAuthenticationComplete("authComplete");
+            }
+            if (popupWindow && !popupWindow.closed) {
+              popupWindow.close();
+            }
+            popupWindowRef.current = null;
+          }
+        } catch (_error) {
+          // Continue polling on error
+        }
+      }, 2000);
+
+      return () => {
+        isActive = false;
+        clearInterval(pollInterval);
+      };
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      // Empty deps - run once on mount and keep polling
+      // This is intentionally simple/brute force
+    ],
+  );
+}
diff --git a/packages/react-core/src/modules/core/hooks/useAuthPostMessageListener.ts b/packages/react-core/src/modules/core/hooks/useAuthPostMessageListener.ts
new file mode 100644
index 000000000..40451af5d
--- /dev/null
+++ b/packages/react-core/src/modules/core/hooks/useAuthPostMessageListener.ts
@@ -0,0 +1,70 @@
+import { useEffect } from "react";
+
+import { ConnectionStatus } from "../types";
+
+export interface UseAuthPostMessageListenerOptions {
+  knockHost: string;
+  popupWindowRef: React.MutableRefObject<Window | null>;
+  setConnectionStatus: (status: ConnectionStatus) => void;
+  onAuthenticationComplete?: (authenticationResp: string) => void;
+}
+
+/**
+ * Hook that listens for postMessage events from OAuth popup windows.
+ *
+ * Handles "authComplete" and "authFailed" messages sent from the OAuth flow popup,
+ * validates the message origin, updates connection status, and closes the popup.
+ *
+ * @param options - Configuration options for the postMessage listener
+ *
+ * @example
+ * ```tsx
+ * useAuthPostMessageListener({
+ *   knockHost: knock.host,
+ *   popupWindowRef,
+ *   setConnectionStatus,
+ *   onAuthenticationComplete,
+ * });
+ * ```
+ */
+export function useAuthPostMessageListener(
+  options: UseAuthPostMessageListenerOptions,
+): void {
+  const {
+    knockHost,
+    popupWindowRef,
+    setConnectionStatus,
+    onAuthenticationComplete,
+  } = options;
+
+  useEffect(() => {
+    const receiveMessage = (event: MessageEvent) => {
+      // Validate message origin for security
+      if (event.origin !== knockHost) {
+        return;
+      }
+
+      if (event.data === "authComplete") {
+        setConnectionStatus("connected");
+        onAuthenticationComplete?.(event.data);
+        // Clear popup ref so polling stops and doesn't trigger callback again
+        if (popupWindowRef.current && !popupWindowRef.current.closed) {
+          popupWindowRef.current.close();
+        }
+        popupWindowRef.current = null;
+      } else if (event.data === "authFailed") {
+        setConnectionStatus("error");
+        onAuthenticationComplete?.(event.data);
+        popupWindowRef.current = null;
+      }
+    };
+
+    window.addEventListener("message", receiveMessage, false);
+    return () => window.removeEventListener("message", receiveMessage);
+  }, [
+    knockHost,
+    onAuthenticationComplete,
+    setConnectionStatus,
+    popupWindowRef,
+  ]);
+}
diff --git a/packages/react-core/src/modules/core/index.ts b/packages/react-core/src/modules/core/index.ts
index 13fae233c..bc6d02d81 100644
--- a/packages/react-core/src/modules/core/index.ts
+++ b/packages/react-core/src/modules/core/index.ts
@@ -4,7 +4,12 @@ export {
   type KnockProviderProps,
   type KnockProviderState,
 } from "./context";
-export { useAuthenticatedKnockClient, useStableOptions } from "./hooks";
+export {
+  useAuthenticatedKnockClient,
+  useStableOptions,
+  useAuthPostMessageListener,
+  useAuthPolling,
+} from "./hooks";
 export { FilterStatus, type ColorMode } from "./constants";
 export {
   formatBadgeCount,
@@ -15,3 +20,4 @@ export {
   slackProviderKey,
   msTeamsProviderKey,
 } from "./utils";
+export { type ConnectionStatus, type AuthCheckResult } from "./types";
diff --git a/packages/react-core/src/modules/core/types.ts b/packages/react-core/src/modules/core/types.ts
new file mode 100644
index 000000000..fd0e3b8d5
--- /dev/null
+++ b/packages/react-core/src/modules/core/types.ts
@@ -0,0 +1,25 @@
+/**
+ * Represents the connection status for OAuth-based integrations (Slack, MS Teams, etc.)
+ */
+export type ConnectionStatus =
+  | "connecting"
+  | "connected"
+  | "disconnected"
+  | "error"
+  | "disconnecting";
+
+/**
+ * Result returned by authentication check API calls
+ */
+export interface AuthCheckResult {
+  connection?: {
+    ok?: boolean;
+    error?: string;
+  };
+  code?: string;
+  response?: {
+    data?: {
+      message?: string;
+    };
+  };
+}
diff --git a/packages/react-core/src/modules/ms-teams/context/KnockMsTeamsProvider.tsx b/packages/react-core/src/modules/ms-teams/context/KnockMsTeamsProvider.tsx
index 4d18853f7..3c9e6e573 100644
--- a/packages/react-core/src/modules/ms-teams/context/KnockMsTeamsProvider.tsx
+++ b/packages/react-core/src/modules/ms-teams/context/KnockMsTeamsProvider.tsx
@@ -1,10 +1,9 @@
 import * as React from "react";
 import { PropsWithChildren, useRef } from "react";
 
-import { useKnockClient } from "../../core";
+import { type ConnectionStatus, useKnockClient } from "../../core";
 import { msTeamsProviderKey } from "../../core/utils";
 import { useMsTeamsConnectionStatus } from "../hooks";
-import { ConnectionStatus } from "../hooks/useMsTeamsConnectionStatus";
 
 export interface KnockMsTeamsProviderState {
   knockMsTeamsChannelId: string;
diff --git a/packages/react-core/src/modules/ms-teams/hooks/useMsTeamsConnectionStatus.ts b/packages/react-core/src/modules/ms-teams/hooks/useMsTeamsConnectionStatus.ts
index 644d96ad2..9c51295bc 100644
--- a/packages/react-core/src/modules/ms-teams/hooks/useMsTeamsConnectionStatus.ts
+++ b/packages/react-core/src/modules/ms-teams/hooks/useMsTeamsConnectionStatus.ts
@@ -1,15 +1,9 @@
 import Knock from "@knocklabs/client";
 import { useEffect, useState } from "react";
 
+import { type ConnectionStatus } from "../../core/types";
 import { useTranslations } from "../../i18n";
 
-export type ConnectionStatus =
-  | "connecting"
-  | "connected"
-  | "disconnected"
-  | "error"
-  | "disconnecting";
-
 type UseMsTeamsConnectionStatusOutput = {
   connectionStatus: ConnectionStatus;
   setConnectionStatus: (status: ConnectionStatus) => void;
diff --git a/packages/react-core/src/modules/slack/context/KnockSlackProvider.tsx b/packages/react-core/src/modules/slack/context/KnockSlackProvider.tsx
index 3cf4c80b2..1d3152f98 100644
--- a/packages/react-core/src/modules/slack/context/KnockSlackProvider.tsx
+++ b/packages/react-core/src/modules/slack/context/KnockSlackProvider.tsx
@@ -2,9 +2,8 @@ import { useSlackConnectionStatus } from "..";
 import * as React from "react";
 import { PropsWithChildren, useRef } from "react";
 
-import { slackProviderKey } from "../../core";
+import { type ConnectionStatus, slackProviderKey } from "../../core";
 import { useKnockClient } from "../../core";
-import { ConnectionStatus } from "../hooks/useSlackConnectionStatus";
 
 export interface KnockSlackProviderState {
   knockSlackChannelId: string;
diff --git a/packages/react-core/src/modules/slack/hooks/useSlackConnectionStatus.ts b/packages/react-core/src/modules/slack/hooks/useSlackConnectionStatus.ts
index 6b7050a42..b374fdf23 100644
--- a/packages/react-core/src/modules/slack/hooks/useSlackConnectionStatus.ts
+++ b/packages/react-core/src/modules/slack/hooks/useSlackConnectionStatus.ts
@@ -1,15 +1,9 @@
 import Knock from "@knocklabs/client";
 import { useEffect, useState } from "react";
 
+import { type ConnectionStatus } from "../../core/types";
 import { useTranslations } from "../../i18n";
 
-export type ConnectionStatus =
-  | "connecting"
-  | "connected"
-  | "disconnected"
-  | "error"
-  | "disconnecting";
-
 type UseSlackConnectionStatusOutput = {
   connectionStatus: ConnectionStatus;
   setConnectionStatus: (status: ConnectionStatus) => void;
diff --git a/packages/react-core/test/core/hooks/useAuthPolling.test.ts b/packages/react-core/test/core/hooks/useAuthPolling.test.ts
new file mode 100644
index 000000000..e4ee03609
--- /dev/null
+++ b/packages/react-core/test/core/hooks/useAuthPolling.test.ts
@@ -0,0 +1,216 @@
+import { renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { useAuthPolling } from "../../../src/modules/core/hooks/useAuthPolling";
+import type {
+  AuthCheckResult,
+  ConnectionStatus,
+} from "../../../src/modules/core/types";
+
+describe("useAuthPolling", () => {
+  let popupWindowRef: { current: Window | null };
+  let setConnectionStatus: ReturnType<typeof vi.fn<[ConnectionStatus], void>>;
+  let onAuthenticationComplete:
+    | ReturnType<typeof vi.fn<[string], void>>
+    | undefined;
+  let authCheckFn: ReturnType<typeof vi.fn<[], Promise<AuthCheckResult>>>;
+  let mockPopup: Window;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+
+    // Create a mock popup window
+    mockPopup = {
+      close: vi.fn(),
+      closed: false,
+    } as unknown as Window;
+
+    popupWindowRef = { current: mockPopup };
+    setConnectionStatus = vi.fn();
+    onAuthenticationComplete = vi.fn();
+    authCheckFn = vi.fn(() => Promise.resolve({ connection: { ok: false } }));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("should poll authCheckFn every 2 seconds", async () => {
+    renderHook(() =>
+      useAuthPolling({
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+        authCheckFn,
+      }),
+    );
+
+    // Fast-forward 2 seconds
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(authCheckFn).toHaveBeenCalledTimes(1);
+
+    // Fast-forward another 2 seconds
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(authCheckFn).toHaveBeenCalledTimes(2);
+
+    // Fast-forward another 2 seconds
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(authCheckFn).toHaveBeenCalledTimes(3);
+  });
+
+  it("should stop polling and set connected status on success", async () => {
+    authCheckFn = vi.fn(() => Promise.resolve({ connection: { ok: true } }));
+
+    renderHook(() =>
+      useAuthPolling({
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+        authCheckFn,
+      }),
+    );
+
+    await vi.advanceTimersByTimeAsync(2000);
+
+    expect(setConnectionStatus).toHaveBeenCalledWith("connected");
+    expect(onAuthenticationComplete).toHaveBeenCalledWith("authComplete");
+    expect(mockPopup.close).toHaveBeenCalled();
+    expect(popupWindowRef.current).toBeNull();
+
+    // Should not poll again after success
+    const callCount = authCheckFn.mock.calls.length;
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(authCheckFn).toHaveBeenCalledTimes(callCount);
+  });
+
+  it("should set error status after max polls (90 iterations)", async () => {
+    renderHook(() =>
+      useAuthPolling({
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+        authCheckFn,
+      }),
+    );
+
+    // Fast-forward 90 iterations (180 seconds)
+    await vi.advanceTimersByTimeAsync(90 * 2000);
+
+    expect(setConnectionStatus).toHaveBeenCalledWith("error");
+  });
+
+  it("should stop polling after popup closed + 10s grace period", async () => {
+    renderHook(() =>
+      useAuthPolling({
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+        authCheckFn,
+      }),
+    );
+
+    // Poll once
+    await vi.advanceTimersByTimeAsync(2000);
+    const initialCallCount = authCheckFn.mock.calls.length;
+
+    // Close the popup (starts grace period timer)
+    mockPopup.closed = true;
+
+    // Advance past the grace period (10+ seconds)
+    await vi.advanceTimersByTimeAsync(12000);
+
+    // Should not call setConnectionStatus with error (stops silently)
+    expect(setConnectionStatus).not.toHaveBeenCalledWith("error");
+    expect(setConnectionStatus).not.toHaveBeenCalledWith("connected");
+
+    // Should still have polled during grace period
+    expect(authCheckFn.mock.calls.length).toBeGreaterThan(initialCallCount);
+
+    // Should not poll again after grace period + some buffer
+    const callCountAfterGracePeriod = authCheckFn.mock.calls.length;
+    await vi.advanceTimersByTimeAsync(4000);
+    expect(authCheckFn).toHaveBeenCalledTimes(callCountAfterGracePeriod);
+  });
+
+  it("should not poll if popupWindowRef is null", async () => {
+    popupWindowRef.current = null;
+
+    renderHook(() =>
+      useAuthPolling({
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+        authCheckFn,
+      }),
+    );
+
+    await vi.advanceTimersByTimeAsync(10000);
+
+    expect(authCheckFn).not.toHaveBeenCalled();
+  });
+
+  it("should continue polling on authCheckFn error", async () => {
+    authCheckFn = vi.fn(() => Promise.reject(new Error("Network error")));
+
+    renderHook(() =>
+      useAuthPolling({
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+        authCheckFn,
+      }),
+    );
+
+    // First poll (will error)
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(authCheckFn).toHaveBeenCalledTimes(1);
+
+    // Should continue polling despite error
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(authCheckFn).toHaveBeenCalledTimes(2);
+
+    // Should not set error status on individual poll errors
+    expect(setConnectionStatus).not.toHaveBeenCalledWith("error");
+  });
+
+  it("should not close popup if already closed on success", async () => {
+    authCheckFn = vi.fn(() => Promise.resolve({ connection: { ok: true } }));
+    mockPopup.closed = true;
+
+    renderHook(() =>
+      useAuthPolling({
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+        authCheckFn,
+      }),
+    );
+
+    await vi.advanceTimersByTimeAsync(2000);
+
+    expect(setConnectionStatus).toHaveBeenCalledWith("connected");
+    expect(mockPopup.close).not.toHaveBeenCalled();
+    expect(popupWindowRef.current).toBeNull();
+  });
+
+  it("should clean up interval on unmount", async () => {
+    const { unmount } = renderHook(() =>
+      useAuthPolling({
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+        authCheckFn,
+      }),
+    );
+
+    await vi.advanceTimersByTimeAsync(2000);
+    const callCountBeforeUnmount = authCheckFn.mock.calls.length;
+
+    unmount();
+
+    // Should not poll after unmount
+    await vi.advanceTimersByTimeAsync(4000);
+    expect(authCheckFn).toHaveBeenCalledTimes(callCountBeforeUnmount);
+  });
+});
diff --git a/packages/react-core/test/core/hooks/useAuthPostMessageListener.test.ts b/packages/react-core/test/core/hooks/useAuthPostMessageListener.test.ts
new file mode 100644
index 000000000..c84e24b70
--- /dev/null
+++ b/packages/react-core/test/core/hooks/useAuthPostMessageListener.test.ts
@@ -0,0 +1,114 @@
+import { renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { useAuthPostMessageListener } from "../../../src/modules/core/hooks/useAuthPostMessageListener";
+
+describe("useAuthPostMessageListener", () => {
+  const knockHost = "https://api.knock.app";
+  let popupWindowRef: { current: Window | null };
+  let setConnectionStatus: ReturnType<typeof vi.fn>;
+  let onAuthenticationComplete: ReturnType<typeof vi.fn> | undefined;
+  let mockPopup: { close: ReturnType<typeof vi.fn>; closed: boolean };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Create a mock popup window
+    mockPopup = {
+      close: vi.fn(),
+      closed: false,
+    };
+
+    popupWindowRef = { current: mockPopup };
+    setConnectionStatus = vi.fn();
+    onAuthenticationComplete = vi.fn();
+  });
+
+  it("should handle authComplete message and update status", () => {
+    renderHook(() =>
+      useAuthPostMessageListener({
+        knockHost,
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+      }),
+    );
+
+    // Simulate postMessage event with authComplete
+    const event = new MessageEvent("message", {
+      data: "authComplete",
+      origin: knockHost,
+    });
+    window.dispatchEvent(event);
+
+    expect(setConnectionStatus).toHaveBeenCalledWith("connected");
+    expect(onAuthenticationComplete).toHaveBeenCalledWith("authComplete");
+    expect(mockPopup.close).toHaveBeenCalled();
+    expect(popupWindowRef.current).toBeNull();
+  });
+
+  it("should handle authFailed message and update status", () => {
+    renderHook(() =>
+      useAuthPostMessageListener({
+        knockHost,
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+      }),
+    );
+
+    // Simulate postMessage event with authFailed
+    const event = new MessageEvent("message", {
+      data: "authFailed",
+      origin: knockHost,
+    });
+    window.dispatchEvent(event);
+
+    expect(setConnectionStatus).toHaveBeenCalledWith("error");
+    expect(popupWindowRef.current).toBeNull();
+  });
+
+  it("should ignore messages from different origins", () => {
+    renderHook(() =>
+      useAuthPostMessageListener({
+        knockHost,
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+      }),
+    );
+
+    // Simulate postMessage event from different origin
+    const event = new MessageEvent("message", {
+      data: "authComplete",
+      origin: "https://evil.com",
+    });
+    window.dispatchEvent(event);
+
+    expect(setConnectionStatus).not.toHaveBeenCalled();
+    expect(onAuthenticationComplete).not.toHaveBeenCalled();
+    expect(mockPopup.close).not.toHaveBeenCalled();
+  });
+
+  it("should clean up event listener on unmount", () => {
+    const removeEventListenerSpy = vi.spyOn(window, "removeEventListener");
+
+    const { unmount } = renderHook(() =>
+      useAuthPostMessageListener({
+        knockHost,
+        popupWindowRef,
+        setConnectionStatus,
+        onAuthenticationComplete,
+      }),
+    );
+
+    unmount();
+
+    expect(removeEventListenerSpy).toHaveBeenCalledWith(
+      "message",
+      expect.any(Function),
+    );
+
+    removeEventListenerSpy.mockRestore();
+  });
+});
diff --git a/packages/react/src/modules/ms-teams/components/MsTeamsAuthButton/MsTeamsAuthButton.tsx b/packages/react/src/modules/ms-teams/components/MsTeamsAuthButton/MsTeamsAuthButton.tsx
index d513049d7..98e20c1fe 100644
--- a/packages/react/src/modules/ms-teams/components/MsTeamsAuthButton/MsTeamsAuthButton.tsx
+++ b/packages/react/src/modules/ms-teams/components/MsTeamsAuthButton/MsTeamsAuthButton.tsx
@@ -1,10 +1,12 @@
 import {
+  useAuthPolling,
+  useAuthPostMessageListener,
   useKnockClient,
   useKnockMsTeamsClient,
   useMsTeamsAuth,
   useTranslations,
 } from "@knocklabs/react-core";
-import { FunctionComponent, useEffect } from "react";
+import { FunctionComponent, useCallback } from "react";
 
 import { openPopupWindow } from "../../../core/utils";
 import "../../theme.css";
@@ -58,109 +60,24 @@ export const MsTeamsAuthButton: FunctionComponent<MsTeamsAuthButtonProps> = ({
     redirectUrl,
   );
 
-  useEffect(() => {
-    const receiveMessage = (event: MessageEvent) => {
-      if (event.origin !== knock.host) {
-        return;
-      }
-
-      if (event.data === "authComplete") {
-        setConnectionStatus("connected");
-        onAuthenticationComplete?.(event.data);
-        // Clear popup ref so polling stops and doesn't trigger callback again
-        if (popupWindowRef.current && !popupWindowRef.current.closed) {
-          popupWindowRef.current.close();
-        }
-        popupWindowRef.current = null;
-      } else if (event.data === "authFailed") {
-        setConnectionStatus("error");
-        popupWindowRef.current = null;
-      }
-    };
-
-    window.addEventListener("message", receiveMessage, false);
-    return () => window.removeEventListener("message", receiveMessage);
-  }, [
-    knock.host,
-    onAuthenticationComplete,
-    setConnectionStatus,
+  useAuthPostMessageListener({
+    knockHost: knock.host,
     popupWindowRef,
-  ]);
-
-  useEffect(
-    () => {
-      let pollCount = 0;
-      const maxPolls = 90;
-      let popupClosedAt: number | null = null;
-      let isActive = true;
-
-      const pollInterval = setInterval(async () => {
-        if (!isActive) {
-          clearInterval(pollInterval);
-          return;
-        }
-
-        const popupWindow = popupWindowRef.current;
-        if (!popupWindow) {
-          return;
-        }
-
-        pollCount++;
-
-        // Check if popup is closed
-        const isPopupClosed = popupWindow.closed;
-        if (isPopupClosed && !popupClosedAt) {
-          popupClosedAt = Date.now();
-        }
-
-        // Stop condition 1: Max timeout reached
-        if (pollCount >= maxPolls) {
-          clearInterval(pollInterval);
-          setConnectionStatus("error");
-          return;
-        }
-
-        // Stop condition 2: Popup closed + grace period expired
-        if (popupClosedAt && Date.now() - popupClosedAt > 10000) {
-          clearInterval(pollInterval);
-          popupWindowRef.current = null;
-          return;
-        }
-
-        try {
-          const authRes = await knock.msTeams.authCheck({
-            tenant: tenantId,
-            knockChannelId: knockMsTeamsChannelId,
-          });
-
-          // Stop condition 3: Success detected
-          if (authRes.connection?.ok) {
-            clearInterval(pollInterval);
-            setConnectionStatus("connected");
-            if (onAuthenticationComplete) {
-              onAuthenticationComplete("authComplete");
-            }
-            if (popupWindow && !popupWindow.closed) {
-              popupWindow.close();
-            }
-            popupWindowRef.current = null;
-          }
-        } catch (_error) {
-          // Continue polling on error
-        }
-      }, 2000);
+    setConnectionStatus,
+    onAuthenticationComplete,
+  });
 
-      return () => {
-        isActive = false;
-        clearInterval(pollInterval);
-      };
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [
-      // Empty deps - run once on mount and keep polling
-      // This is intentionally simple/brute force
-    ],
-  );
+  useAuthPolling({
+    popupWindowRef,
+    setConnectionStatus,
+    onAuthenticationComplete,
+    authCheckFn: useCallback(async () => {
+      return knock.msTeams.authCheck({
+        tenant: tenantId,
+        knockChannelId: knockMsTeamsChannelId,
+      });
+    }, [knock.msTeams, tenantId, knockMsTeamsChannelId]),
+  });
 
   const disconnectLabel = t("msTeamsDisconnect") || null;
   const reconnectLabel = t("msTeamsReconnect") || null;
diff --git a/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx b/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx
index 2fbaefa60..0da638b33 100644
--- a/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx
+++ b/packages/react/src/modules/slack/components/SlackAuthButton/SlackAuthButton.tsx
@@ -1,11 +1,12 @@
 import {
+  useAuthPolling,
+  useAuthPostMessageListener,
   useKnockClient,
   useKnockSlackClient,
   useSlackAuth,
   useTranslations,
 } from "@knocklabs/react-core";
-import { FunctionComponent, useMemo } from "react";
-import { useEffect } from "react";
+import { FunctionComponent, useCallback, useMemo } from "react";
 
 import { openPopupWindow } from "../../../core/utils";
 import "../../theme.css";
@@ -58,110 +59,24 @@ export const SlackAuthButton: FunctionComponent<SlackAuthButtonProps> = ({
     useSlackAuthOptions,
   );
 
-  useEffect(() => {
-    const receiveMessage = (event: MessageEvent) => {
-      if (event.origin !== knock.host) {
-        return;
-      }
-
-      if (event.data === "authComplete") {
-        setConnectionStatus("connected");
-        if (onAuthenticationComplete) {
-          onAuthenticationComplete(event.data);
-        }
-        // Clear popup ref so polling stops and doesn't trigger callback again
-        if (popupWindowRef.current && !popupWindowRef.current.closed) {
-          popupWindowRef.current.close();
-        }
-        popupWindowRef.current = null;
-      } else if (event.data === "authFailed") {
-        setConnectionStatus("error");
-        popupWindowRef.current = null;
-      }
-    };
-
-    window.addEventListener("message", receiveMessage, false);
-    return () => window.removeEventListener("message", receiveMessage);
-  }, [
-    knock.host,
-    onAuthenticationComplete,
-    setConnectionStatus,
+  useAuthPostMessageListener({
+    knockHost: knock.host,
     popupWindowRef,
-  ]);
-
-  useEffect(
-    () => {
-      let pollCount = 0;
-      const maxPolls = 90;
-      let popupClosedAt: number | null = null;
-      let isActive = true;
-
-      const pollInterval = setInterval(async () => {
-        if (!isActive) {
-          clearInterval(pollInterval);
-          return;
-        }
-
-        const popupWindow = popupWindowRef.current;
-        if (!popupWindow) {
-          return;
-        }
-
-        pollCount++;
-
-        const isPopupClosed = popupWindow.closed;
-        if (isPopupClosed && !popupClosedAt) {
-          popupClosedAt = Date.now();
-        }
-
-        // Stop condition 1: Max timeout reached
-        if (pollCount >= maxPolls) {
-          clearInterval(pollInterval);
-          setConnectionStatus("error");
-          return;
-        }
-
-        // Stop condition 2: Popup closed + grace period expired
-        if (popupClosedAt && Date.now() - popupClosedAt > 10000) {
-          clearInterval(pollInterval);
-          popupWindowRef.current = null;
-          return;
-        }
-
-        try {
-          const authRes = await knock.slack.authCheck({
-            tenant: tenantId,
-            knockChannelId: knockSlackChannelId,
-          });
-
-          // Stop condition 3: Success detected
-          if (authRes.connection?.ok) {
-            clearInterval(pollInterval);
-            setConnectionStatus("connected");
-            if (onAuthenticationComplete) {
-              onAuthenticationComplete("authComplete");
-            }
-            if (popupWindow && !popupWindow.closed) {
-              popupWindow.close();
-            }
-            popupWindowRef.current = null;
-          }
-        } catch (_error) {
-          // Continue polling on error
-        }
-      }, 2000);
+    setConnectionStatus,
+    onAuthenticationComplete,
+  });
 
-      return () => {
-        isActive = false;
-        clearInterval(pollInterval);
-      };
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [
-      // Empty deps - run once on mount and keep polling
-      // This is intentionally simple/brute force
-    ],
-  );
+  useAuthPolling({
+    popupWindowRef,
+    setConnectionStatus,
+    onAuthenticationComplete,
+    authCheckFn: useCallback(async () => {
+      return knock.slack.authCheck({
+        tenant: tenantId,
+        knockChannelId: knockSlackChannelId,
+      });
+    }, [knock.slack, tenantId, knockSlackChannelId]),
+  });
 
   const disconnectLabel = t("slackDisconnect") || null;
   const reconnectLabel = t("slackReconnect") || null;
diff --git a/packages/react/test/ms-teams/MsTeamsAuthButton.test.tsx b/packages/react/test/ms-teams/MsTeamsAuthButton.test.tsx
index 8e640d806..e275936a3 100644
--- a/packages/react/test/ms-teams/MsTeamsAuthButton.test.tsx
+++ b/packages/react/test/ms-teams/MsTeamsAuthButton.test.tsx
@@ -36,6 +36,9 @@ describe("MsTeamsAuthButton", () => {
       setActionLabel: vi.fn(),
       actionLabel: null,
       errorLabel: null,
+      tenantId: "tenant_123",
+      knockMsTeamsChannelId: "channel_123",
+      popupWindowRef: { current: null },
     };
 
     const { getByText } = render(
@@ -53,6 +56,9 @@ describe("MsTeamsAuthButton", () => {
       setActionLabel: vi.fn(),
       actionLabel: null,
       errorLabel: "Error",
+      tenantId: "tenant_123",
+      knockMsTeamsChannelId: "channel_123",
+      popupWindowRef: { current: null },
     };
 
     const { getByText } = render(
diff --git a/packages/react/test/slack/SlackAuthButton.test.tsx b/packages/react/test/slack/SlackAuthButton.test.tsx
index b4cefb680..a5783f93c 100644
--- a/packages/react/test/slack/SlackAuthButton.test.tsx
+++ b/packages/react/test/slack/SlackAuthButton.test.tsx
@@ -32,6 +32,9 @@ describe("SlackAuthButton", () => {
       setActionLabel: vi.fn(),
       actionLabel: null,
       errorLabel: null,
+      tenantId: "tenant_123",
+      knockSlackChannelId: "channel_123",
+      popupWindowRef: { current: null },
     };
 
     const { getByText } = render(<SlackAuthButton slackClientId="cid" />);
@@ -47,6 +50,9 @@ describe("SlackAuthButton", () => {
       setActionLabel: vi.fn(),
       actionLabel: null,
       errorLabel: "Slack Err",
+      tenantId: "tenant_123",
+      knockSlackChannelId: "channel_123",
+      popupWindowRef: { current: null },
     };
 
     const { getByText } = render(<SlackAuthButton slackClientId="cid" />);