tweaks

src/state/session/agent.ts

@@ -33,7 +33,18 @@ export async function createAgentAndResume(
     event: AtpSessionEvent,
   ) => void,
 ) {
-  const agent = new BskyAgent({service: storedAccount.service})
+  const agent = new BskyAgent({
+    service: storedAccount.service,
+    persistSession: event => {
+      const {session} = agent
+      if (!session?.did) return // @TODO SESSION - ?
+
+      onSessionChange(agent, session.did, event)
+      if (event !== 'create' && event !== 'update') {
+        addSessionErrorLog(session.did, event)
+      }
+    },
+  })
   if (storedAccount.pdsUrl) {
     agent.sessionManager.pdsUrl = new URL(storedAccount.pdsUrl)
   }
@@ -43,10 +54,9 @@ export async function createAgentAndResume(
   if (isSessionExpired(storedAccount)) {
     await networkRetry(1, () => agent.resumeSession(prevSession))
   } else {
-    agent.session = prevSession
     if (!storedAccount.signupQueued) {
-      // Intentionally not awaited to unblock the UI:
+      // @TODO SESSION - We were not awaiting this before. Why? And why is it now broken if we do not await?
-      networkRetry(3, () => agent.resumeSession(prevSession)).catch(
+      await networkRetry(3, () => agent.resumeSession(prevSession)).catch(
         (e: any) => {
           logger.error(`networkRetry failed to resume session`, {
             status: e?.status || 'unknown',
@@ -60,7 +70,7 @@ export async function createAgentAndResume(
     }
   }
 
-  return prepareAgent(agent, gates, moderation, onSessionChange)
+  return prepareAgent(agent, gates, moderation)
 }
 
 export async function createAgentAndLogin(
@@ -81,41 +91,45 @@ export async function createAgentAndLogin(
     event: AtpSessionEvent,
   ) => void,
 ) {
-  const agent = new BskyAgent({service})
+  const agent = new BskyAgent({
+    service,
+    persistSession: event => {
+      const {session} = agent
+      if (!session?.did) return // @TODO SESSION - ?
+
+      onSessionChange(agent, session.did, event)
+      if (event !== 'create' && event !== 'update') {
+        addSessionErrorLog(session.did, event)
+      }
+    },
+  })
   await agent.login({identifier, password, authFactorToken})
 
   const account = agentToSessionAccountOrThrow(agent)
   const gates = tryFetchGates(account.did, 'prefer-fresh-gates')
   const moderation = configureModerationForAccount(agent, account)
-  return prepareAgent(agent, moderation, gates, onSessionChange)
+  return prepareAgent(agent, moderation, gates)
 }
 
-export async function createAgentAndCreateAccount(
+export async function createAgentAndCreateAccount({
-  {
+  service,
-    service,
+  email,
-    email,
+  password,
-    password,
+  handle,
-    handle,
+  birthDate,
-    birthDate,
+  inviteCode,
-    inviteCode,
+  verificationPhone,
-    verificationPhone,
+  verificationCode,
-    verificationCode,
+}: {
-  }: {
+  service: string
-    service: string
+  email: string
-    email: string
+  password: string
-    password: string
+  handle: string
-    handle: string
+  birthDate: Date
-    birthDate: Date
+  inviteCode?: string
-    inviteCode?: string
+  verificationPhone?: string
-    verificationPhone?: string
+  verificationCode?: string
-    verificationCode?: string
+}) {
-  },
-  onSessionChange: (
-    agent: BskyAgent,
-    did: string,
-    event: AtpSessionEvent,
-  ) => void,
-) {
   const agent = new BskyAgent({service})
   await agent.createAccount({
     email,
@@ -174,7 +188,7 @@ export async function createAgentAndCreateAccount(
     logger.error(e, {context: `session: failed snoozeEmailConfirmationPrompt`})
   }
 
-  return prepareAgent(agent, gates, moderation, onSessionChange)
+  return prepareAgent(agent, gates, moderation)
 }
 
 async function prepareAgent(
@@ -182,23 +196,12 @@ async function prepareAgent(
   // Not awaited in the calling code so we can delay blocking on them.
   gates: Promise<void>,
   moderation: Promise<void>,
-  onSessionChange: (
-    agent: BskyAgent,
-    did: string,
-    event: AtpSessionEvent,
-  ) => void,
 ) {
   // There's nothing else left to do, so block on them here.
   await Promise.all([gates, moderation])
 
   // Now the agent is ready.
   const account = agentToSessionAccountOrThrow(agent)
-  agent.setPersistSessionHandler(event => {
-    onSessionChange(agent, account.did, event)
-    if (event !== 'create' && event !== 'update') {
-      addSessionErrorLog(account.did, event)
-    }
-  })
   return {agent, account}
 }
 

src/state/session/index.tsx

@@ -14,7 +14,6 @@ import {
   createAgentAndCreateAccount,
   createAgentAndLogin,
   createAgentAndResume,
-  sessionAccountToSession,
 } from './agent'
 import {getInitialState, reducer} from './reducer'
 
@@ -70,10 +69,7 @@ export function Provider({children}: React.PropsWithChildren<{}>) {
       const signal = cancelPendingTask()
       track('Try Create Account')
       logEvent('account:create:begin', {})
-      const {agent, account} = await createAgentAndCreateAccount(
+      const {agent, account} = await createAgentAndCreateAccount(params)
-        params,
-        onAgentSessionChange,
-      )
 
       if (signal.aborted) {
         return
@@ -87,7 +83,7 @@ export function Provider({children}: React.PropsWithChildren<{}>) {
       logEvent('account:create:success', {})
       addSessionDebugLog({type: 'method:end', method: 'createAccount', account})
     },
-    [onAgentSessionChange, cancelPendingTask],
+    [cancelPendingTask],
   )
 
   const login = React.useCallback<SessionApiContext['login']>(
@@ -196,20 +192,12 @@ export function Provider({children}: React.PropsWithChildren<{}>) {
       const syncedAccount = synced.accounts.find(
         a => a.did === synced.currentAccount?.did,
       )
-      if (syncedAccount && syncedAccount.refreshJwt) {
+      if (
-        if (syncedAccount.did !== state.currentAgentState.did) {
+        syncedAccount &&
-          resumeSession(syncedAccount)
+        syncedAccount.refreshJwt &&
-        } else {
+        syncedAccount.did !== state.currentAgentState.did
-          const agent = state.currentAgentState.agent as BskyAgent
+      ) {
-          const prevSession = agent.session
+        resumeSession(syncedAccount)
-          agent.session = sessionAccountToSession(syncedAccount)
-          addSessionDebugLog({
-            type: 'agent:patch',
-            agent,
-            prevSession,
-            nextSession: agent.session,
-          })
-        }
       }
     })
   }, [state, resumeSession])
@@ -249,8 +237,8 @@ export function Provider({children}: React.PropsWithChildren<{}>) {
       addSessionDebugLog({type: 'agent:switch', prevAgent, nextAgent: agent})
       // We never reuse agents so let's fully neutralize the previous one.
       // This ensures it won't try to consume any refresh tokens.
-      prevAgent.session = undefined
+      // prevAgent.session = undefined
-      prevAgent.setPersistSessionHandler(undefined)
+      // prevAgent.setPersistSessionHandler(undefined)
     }
   }, [agent])