Remember the last mobile sign-in method

Author: ComputelessComputer

apps/mobile/src/app/_layout.tsx

@@ -141,6 +141,7 @@ function Gate() {
     return (
       <SignInScreen
         busy={signingIn}
+        lastSignInMethod={auth.lastSignInMethod}
         onSignIn={(method) => void handleSignIn(method)}
       />
     );

apps/mobile/src/auth/context.tsx

@@ -25,7 +25,12 @@ import {
 } from "@/auth/billing";
 import { refreshBillingEntitlement as retryBillingEntitlement } from "@/auth/billing-handoff";
 import { authStorageKey, supabase } from "@/auth/client";
-import { buildSignInUrl, type SignInMethod } from "@/auth/sign-in";
+import {
+  buildSignInUrl,
+  lastSignInMethodStorageKey,
+  parseLastSignInMethod,
+  type SignInMethod,
+} from "@/auth/sign-in";
 import {
   captureAnalytics,
   identifyAnalytics,
@@ -37,6 +42,7 @@ import {
   captureOperationalError,
   setErrorReportingUser,
 } from "@/lib/error-reporting";
+import { useMountEffect } from "@/lib/use-mount-effect";
 import { suspendMobileSync } from "@/sync/mobile-sync";
 import { updateWatchAccount } from "@/watch-connectivity";
 
@@ -46,6 +52,7 @@ export type AuthState = {
   session: Session | null;
   billing: BillingInfo;
   billingReady: boolean;
+  lastSignInMethod: SignInMethod | null;
   signIn: (method: SignInMethod) => Promise<void>;
   refreshBilling: () => Promise<boolean>;
   signOut: () => Promise<void>;
@@ -102,13 +109,16 @@ function parseAuthCallbackUrl(
 // Deep links can be delivered twice (auth-session result + Linking event);
 // mirror desktop's 5s dedupe window (apps/desktop/src/auth/deeplink.ts).
 const RECENT_CALLBACK_WINDOW_MS = 5_000;
-const inFlightTokens = new Set<string>();
+const inFlightTokens = new Map<string, Promise<boolean>>();
 const recentTokens = new Map<string, number>();
 
-function acceptAuthTokens(accessToken: string, refreshToken: string): void {
+function acceptAuthTokens(
+  accessToken: string,
+  refreshToken: string,
+): Promise<boolean> {
   const client = supabase;
   if (!client) {
-    return;
+    return Promise.resolve(false);
   }
 
   const now = Date.now();
@@ -119,16 +129,18 @@ function acceptAuthTokens(accessToken: string, refreshToken: string): void {
   }
 
   const key = `${accessToken}\n${refreshToken}`;
-  if (inFlightTokens.has(key) || recentTokens.has(key)) {
-    return;
+  if (recentTokens.has(key)) {
+    return Promise.resolve(true);
+  }
+  const inFlight = inFlightTokens.get(key);
+  if (inFlight) {
+    return inFlight;
   }
 
-  inFlightTokens.add(key);
-  void client.auth
+  const request = client.auth
     .setSession({ access_token: accessToken, refresh_token: refreshToken })
     .then(
       ({ error }) => {
-        inFlightTokens.delete(key);
         if (error) {
           captureOperationalError(error, {
             operation: "auth_session_set",
@@ -138,12 +150,12 @@ function acceptAuthTokens(accessToken: string, refreshToken: string): void {
             method: "browser_handoff",
             failure_stage: "set_session",
           });
-        } else {
-          recentTokens.set(key, Date.now());
+          return false;
         }
+        recentTokens.set(key, Date.now());
+        return true;
       },
       (error) => {
-        inFlightTokens.delete(key);
         captureOperationalError(error, {
           operation: "auth_session_set",
           tags: { method: "browser_handoff" },
@@ -152,15 +164,20 @@ function acceptAuthTokens(accessToken: string, refreshToken: string): void {
           method: "browser_handoff",
           failure_stage: "set_session",
         });
+        return false;
       },
-    );
+    )
+    .finally(() => inFlightTokens.delete(key));
+  inFlightTokens.set(key, request);
+  return request;
 }
 
-function handleAuthCallbackUrl(url: string): void {
+function handleAuthCallbackUrl(url: string): Promise<boolean> {
   const tokens = parseAuthCallbackUrl(url);
-  if (tokens) {
-    acceptAuthTokens(tokens.accessToken, tokens.refreshToken);
+  if (!tokens) {
+    return Promise.resolve(false);
   }
+  return acceptAuthTokens(tokens.accessToken, tokens.refreshToken);
 }
 
 // Offline fallback: a retryable getSession error must not lock a Pro user out
@@ -201,6 +218,9 @@ export function AuthProvider({ children }: { children: ReactNode }) {
   const [session, setSessionState] = useState<Session | null | undefined>(
     bypass ? null : undefined,
   );
+  const [lastSignInMethod, setLastSignInMethod] = useState<SignInMethod | null>(
+    null,
+  );
   const sessionRef = useRef<Session | null | undefined>(session);
   const identifiedUserIdRef = useRef<string | null>(null);
   const reportedUndecodableUserIdRef = useRef<string | null>(null);
@@ -242,6 +262,26 @@ export function AuthProvider({ children }: { children: ReactNode }) {
     }
   }, []);
 
+  useMountEffect(() => {
+    let active = true;
+    void AsyncStorage.getItem(lastSignInMethodStorageKey).then(
+      (value) => {
+        if (active) {
+          setLastSignInMethod(parseLastSignInMethod(value));
+        }
+      },
+      (error) => {
+        captureOperationalError(error, {
+          operation: "auth_last_sign_in_method_read",
+          level: "warning",
+        });
+      },
+    );
+    return () => {
+      active = false;
+    };
+  });
+
   useEffect(() => {
     const client = supabase;
     if (!client) {
@@ -311,12 +351,12 @@ export function AuthProvider({ children }: { children: ReactNode }) {
     }
 
     const subscription = Linking.addEventListener("url", (event) => {
-      handleAuthCallbackUrl(event.url);
+      void handleAuthCallbackUrl(event.url);
     });
     void Linking.getInitialURL().then(
       (url) => {
         if (url) {
-          handleAuthCallbackUrl(url);
+          void handleAuthCallbackUrl(url);
         }
       },
       (error) => {
@@ -348,7 +388,19 @@ export function AuthProvider({ children }: { children: ReactNode }) {
         "anarlog://auth/callback",
       );
       if (result.type === "success") {
-        handleAuthCallbackUrl(result.url);
+        const signedIn = await handleAuthCallbackUrl(result.url);
+        if (signedIn) {
+          setLastSignInMethod(signInMethod);
+          await AsyncStorage.setItem(
+            lastSignInMethodStorageKey,
+            signInMethod,
+          ).catch((error) => {
+            captureOperationalError(error, {
+              operation: "auth_last_sign_in_method_write",
+              level: "warning",
+            });
+          });
+        }
       } else {
         captureAnalytics("auth_failed", {
           method: "browser_handoff",
@@ -464,6 +516,7 @@ export function AuthProvider({ children }: { children: ReactNode }) {
       session: session ?? null,
       billing,
       billingReady,
+      lastSignInMethod,
       signIn,
       refreshBilling,
       signOut,
@@ -474,6 +527,7 @@ export function AuthProvider({ children }: { children: ReactNode }) {
       session,
       billing,
       billingReady,
+      lastSignInMethod,
       signIn,
       refreshBilling,
       signOut,