feat: handle auth flow natively

src/extension/background-script/connectors/alby.ts

@@ -237,7 +237,9 @@ export default class Alby implements Connector {
         throw new Error("OAuth client credentials missing");
       }
 
-      const redirectURL = browser.identity.getRedirectURL();
+      const redirectURL =
+        "https://9dfeeffab3456fdb4be6e2296ca1a4c6b124ee94.extensions.allizom.org/";
+
       const authClient = new auth.OAuth2User({
         request_options: this._getRequestOptions(),
         client_id: clientId,
@@ -259,9 +261,7 @@ export default class Alby implements Connector {
       authClient.on("tokenRefreshed", (token: Token) => {
         this._updateOAuthToken(token);
       });
-      // Currently the JS SDK guarantees request of a new refresh token is done synchronously.
-      // The only way a refresh should fail is if the refresh token has expired, which is handled when the connector is initialized.
-      // If a token refresh fails after init then the connector will be unusable, but we will still log errors here so that this can be debugged if it does ever happen.
+
       authClient.on("tokenRefreshFailed", (error: Error) => {
         console.error("Failed to Refresh token", error);
       });
@@ -273,8 +273,6 @@ export default class Alby implements Connector {
           }
           return authClient;
         } catch (error) {
-          // if auth token refresh fails, the refresh token has probably expired or is invalid
-          // the user will be asked to re-login
           console.error("Failed to request new auth token", error);
         }
       }
@@ -285,28 +283,60 @@ export default class Alby implements Connector {
       });
 
       authUrl += "&webln=false"; // stop getalby.com login modal launching lnurl auth
-      const authResult = await this.launchWebAuthFlow(authUrl);
-      const code = new URL(authResult).searchParams.get("code");
-      if (!code) {
-        throw new Error("Authentication failed: missing authResult");
-      }
 
-      const token = await authClient.requestAccessToken(code);
-      await this._updateOAuthToken(token.token);
-      return authClient;
+      const oAuthTab = await browser.tabs.create({ url: authUrl });
+
+      return new Promise<auth.OAuth2User>((resolve, reject) => {
+        const handleUpdated = (
+          tabId: number,
+          changeInfo: browser.Tabs.OnUpdatedChangeInfoType,
+          tab: browser.Tabs.Tab
+        ) => {
+          if (changeInfo.status === "complete" && tabId === oAuthTab.id) {
+            const authorizationCode = this.extractCodeFromTabUrl(tab.url);
+
+            if (authorizationCode) {
+              authClient
+                .requestAccessToken(authorizationCode)
+                .then((token) => {
+                  this._updateOAuthToken(token.token);
+                  resolve(authClient);
+                })
+                .catch((error) => {
+                  console.error("Failed to request new auth token", error);
+                  reject(error);
+                })
+                .finally(() => {
+                  browser.tabs.remove(tabId);
+                  browser.tabs.onUpdated.removeListener(handleUpdated);
+                });
+            }
+          }
+        };
+        const handleRemoved = (tabId: number) => {
+          if (tabId === oAuthTab.id) {
+            // The user closed the authentication tab without completing the flow
+            const error = new Error("OAuth authentication canceled by user");
+            reject(error);
+            browser.tabs.onRemoved.removeListener(handleRemoved);
+          }
+        };
+
+        browser.tabs.onUpdated.addListener(handleUpdated);
+        browser.tabs.onRemoved.addListener(handleRemoved);
+      });
     } catch (error) {
       console.error(error);
       throw error;
     }
   }
 
-  async launchWebAuthFlow(authUrl: string) {
-    const authResult = await browser.identity.launchWebAuthFlow({
-      interactive: true,
-      url: authUrl,
-    });
-
-    return authResult;
+  private extractCodeFromTabUrl(url: string | undefined): string | null {
+    if (!url) {
+      return null;
+    }
+    const urlSearchParams = new URLSearchParams(url.split("?")[1]);
+    return urlSearchParams.get("code") || null;
   }
 
   private async _request<T>(func: (client: Client) => T) {