@mcp-ts/sdk 1.6.1 → 1.6.2

package/dist/client/react.js

@@ -627,14 +627,31 @@ function useMcp(options) {
 }
 var AUTH_CODE_MESSAGE = "MCP_AUTH_CODE";
 var AUTH_RESULT_MESSAGE = "MCP_AUTH_RESULT";
+var AUTH_CHANNEL_NAME = "mcp-auth-channel";
+function createAuthBroadcastChannel() {
+  if (typeof BroadcastChannel === "undefined") {
+    return null;
+  }
+  try {
+    return new BroadcastChannel(AUTH_CHANNEL_NAME);
+  } catch {
+    return null;
+  }
+}
 function postPopupResult(popupWindow, result) {
-  popupWindow?.postMessage(
-    {
-      type: AUTH_RESULT_MESSAGE,
-      ...result
-    },
-    window.location.origin
-  );
+  const payload = {
+    type: AUTH_RESULT_MESSAGE,
+    ...result
+  };
+  try {
+    popupWindow?.postMessage(payload, window.location.origin);
+  } catch {
+  }
+  const channel = createAuthBroadcastChannel();
+  if (channel) {
+    channel.postMessage(payload);
+    channel.close();
+  }
 }
 function openCenteredPopup(url, options = {}) {
   const {
@@ -675,60 +692,87 @@ function createOAuthPopupRedirectHandler(options = {}) {
 }
 function useMcpOAuthPopup(connections, finishAuth) {
   const pendingPopupsRef = react.useRef(/* @__PURE__ */ new Map());
+  const processingCodesRef = react.useRef(/* @__PURE__ */ new Set());
   react.useEffect(() => {
     const handleMessage = async (event) => {
-      if (event.origin !== window.location.origin) {
+      if (event.origin && event.origin !== window.location.origin) {
         return;
       }
-      if (event.data?.type !== AUTH_CODE_MESSAGE || !event.data.code) {
+      const code = typeof event.data?.code === "string" ? event.data.code : "";
+      if (event.data?.type !== AUTH_CODE_MESSAGE || !code) {
         return;
       }
       const popupWindow = event.source && "postMessage" in event.source ? event.source : null;
       const targetSessionId = typeof event.data.sessionId === "string" ? event.data.sessionId : "";
+      if (popupWindow && targetSessionId) {
+        pendingPopupsRef.current.set(targetSessionId, popupWindow);
+      }
       if (!targetSessionId) {
-        postPopupResult(popupWindow, {
-          success: false,
-          error: "Missing OAuth session identifier"
-        });
+        if (popupWindow) {
+          postPopupResult(popupWindow, {
+            success: false,
+            error: "Missing OAuth session identifier"
+          });
+        }
         return;
       }
       const targetSession = connections.find((connection) => connection.sessionId === targetSessionId);
       if (!targetSession) {
-        postPopupResult(popupWindow, {
-          sessionId: targetSessionId,
-          success: false,
-          error: "OAuth session not found in the current client state"
-        });
+        if (popupWindow) {
+          postPopupResult(popupWindow, {
+            sessionId: targetSessionId,
+            success: false,
+            error: "OAuth session not found in the current client state"
+          });
+        }
         return;
       }
-      if (popupWindow) {
-        pendingPopupsRef.current.set(targetSession.sessionId, popupWindow);
+      const codeKey = `${targetSession.sessionId}:${code}`;
+      if (processingCodesRef.current.has(codeKey)) {
+        return;
       }
+      processingCodesRef.current.add(codeKey);
       try {
-        await finishAuth(targetSession.sessionId, event.data.code);
+        await finishAuth(targetSession.sessionId, code);
       } catch (error) {
+        processingCodesRef.current.delete(codeKey);
         pendingPopupsRef.current.delete(targetSession.sessionId);
-        postPopupResult(popupWindow, {
-          sessionId: targetSession.sessionId,
-          success: false,
-          error: error instanceof Error ? error.message : "Failed to finish auth"
-        });
+        if (popupWindow) {
+          postPopupResult(popupWindow, {
+            sessionId: targetSession.sessionId,
+            success: false,
+            error: error instanceof Error ? error.message : "Failed to finish auth"
+          });
+        }
+      }
+    };
+    const channel = createAuthBroadcastChannel();
+    const handleChannelMessage = (event) => {
+      if (event.data?.type === AUTH_CODE_MESSAGE) {
+        void handleMessage(event);
       }
     };
     window.addEventListener("message", handleMessage);
-    return () => window.removeEventListener("message", handleMessage);
+    channel?.addEventListener("message", handleChannelMessage);
+    return () => {
+      window.removeEventListener("message", handleMessage);
+      channel?.removeEventListener("message", handleChannelMessage);
+      channel?.close();
+    };
   }, [connections, finishAuth]);
   react.useEffect(() => {
     for (const connection of connections) {
-      const popupWindow = pendingPopupsRef.current.get(connection.sessionId);
-      if (!popupWindow) {
-        continue;
-      }
-      if (connection.state === "AUTHENTICATED") {
+      const popupWindow = pendingPopupsRef.current.get(connection.sessionId) || null;
+      if (connection.state === "AUTHENTICATED" || connection.state === "READY" || connection.state === "CONNECTED") {
         postPopupResult(popupWindow, {
           sessionId: connection.sessionId,
           success: true
         });
+        for (const codeKey of processingCodesRef.current) {
+          if (codeKey.startsWith(`${connection.sessionId}:`)) {
+            processingCodesRef.current.delete(codeKey);
+          }
+        }
         pendingPopupsRef.current.delete(connection.sessionId);
         continue;
       }
@@ -738,6 +782,11 @@ function useMcpOAuthPopup(connections, finishAuth) {
           success: false,
           error: connection.error || "Failed to complete authorization"
         });
+        for (const codeKey of processingCodesRef.current) {
+          if (codeKey.startsWith(`${connection.sessionId}:`)) {
+            processingCodesRef.current.delete(codeKey);
+          }
+        }
         pendingPopupsRef.current.delete(connection.sessionId);
       }
     }
@@ -758,10 +807,9 @@ function McpOAuthCallbackContent({
 }) {
   const [phase, setPhase] = react.useState(debugPhase || "loading");
   const [errorMessage, setErrorMessage] = react.useState("");
-  const openerMissing = typeof window !== "undefined" ? !window.opener : false;
   const missingCode = !code;
   const missingSessionId = !sessionId;
-  const blockingError = openerMissing ? "Error: No opener window found. This window should be opened from the app." : missingCode ? "Error: No authorization code received." : missingSessionId ? "Error: No OAuth state received." : null;
+  const blockingError = missingCode ? "Error: No authorization code received." : missingSessionId ? "Error: No OAuth state received." : null;
   react.useEffect(() => {
     if (debugPhase) {
       setPhase(debugPhase);
@@ -774,8 +822,9 @@ function McpOAuthCallbackContent({
       return;
     }
     let closed = false;
+    const channel = createAuthBroadcastChannel();
     const handleResult = (event) => {
-      if (event.origin !== window.location.origin) {
+      if (event.origin && event.origin !== window.location.origin) {
         return;
       }
       if (event.data?.type !== AUTH_RESULT_MESSAGE) {
@@ -787,6 +836,7 @@ function McpOAuthCallbackContent({
       if (event.data.success) {
         setPhase("success");
         window.removeEventListener("message", handleResult);
+        channel?.close();
         closed = true;
         window.setTimeout(() => window.close(), 1200);
         return;
@@ -796,21 +846,23 @@ function McpOAuthCallbackContent({
       setErrorMessage(message);
     };
     window.addEventListener("message", handleResult);
-    try {
-      window.opener.postMessage(
-        { type: AUTH_CODE_MESSAGE, code, sessionId },
-        window.location.origin
-      );
-    } catch (error) {
-      console.error("Failed to communicate with opener:", error);
-      window.setTimeout(() => {
+    channel?.addEventListener("message", handleResult);
+    const payload = { type: AUTH_CODE_MESSAGE, code, sessionId };
+    if (window.opener) {
+      try {
+        window.opener.postMessage(payload, window.location.origin);
+      } catch {
         setPhase("error");
         setErrorMessage("Error: Could not communicate with main window.");
-      }, 0);
+      }
+    }
+    if (channel) {
+      channel.postMessage(payload);
     }
     return () => {
       if (!closed) {
         window.removeEventListener("message", handleResult);
+        channel?.close();
       }
     };
   }, [blockingError, code, sessionId, debugPhase]);