appview: migrate handlers to GetMultiAccountUser

appview/issues/issues.go

···
 
 func (rp *Issues) RepoSingleIssue(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "RepoSingleIssue")
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)
···
 
 	userReactions := map[models.ReactionKind]bool{}
 	if user != nil {
-		userReactions = db.GetReactionStatusMap(rp.db, user.Did, issue.AtUri())
+		userReactions = db.GetReactionStatusMap(rp.db, user.Active.Did, issue.AtUri())
 	}
 
 	backlinks, err := db.GetBacklinks(rp.db, issue.AtUri())
···
 
 func (rp *Issues) EditIssue(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "EditIssue")
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 			return
 		}
 
-		ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueNSID, user.Did, newIssue.Rkey)
+		ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueNSID, user.Active.Did, newIssue.Rkey)
 		if err != nil {
 			l.Error("failed to get record", "err", err)
 			rp.pages.Notice(w, noticeId, "Failed to edit issue, no record found on PDS.")
···
 
 		_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoIssueNSID,
-			Repo:       user.Did,
+			Repo:       user.Active.Did,
 			Rkey:       newIssue.Rkey,
 			SwapRecord: ex.Cid,
 			Record: &lexutil.LexiconTypeDecoder{
···
 
 func (rp *Issues) CloseIssue(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "CloseIssue")
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)
···
 		return
 	}
 
-	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
+	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
 	isRepoOwner := roles.IsOwner()
 	isCollaborator := roles.IsCollaborator()
-	isIssueOwner := user.Did == issue.Did
+	isIssueOwner := user.Active.Did == issue.Did
 
 	// TODO: make this more granular
 	if isIssueOwner || isRepoOwner || isCollaborator {
···
 		issue.Open = false
 
 		// notify about the issue closure
-		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)
+		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Active.Did), issue)
 
 		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
···
 
 func (rp *Issues) ReopenIssue(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "ReopenIssue")
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)
···
 		return
 	}
 
-	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
+	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
 	isRepoOwner := roles.IsOwner()
 	isCollaborator := roles.IsCollaborator()
-	isIssueOwner := user.Did == issue.Did
+	isIssueOwner := user.Active.Did == issue.Did
 
 	if isCollaborator || isRepoOwner || isIssueOwner {
 		err := db.ReopenIssues(
···
 		issue.Open = true
 
 		// notify about the issue reopen
-		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)
+		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Active.Did), issue)
 
 		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
···
 
 func (rp *Issues) NewIssueComment(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "NewIssueComment")
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)
···
 	mentions, references := rp.mentionsResolver.Resolve(r.Context(), body)
 
 	comment := models.IssueComment{
-		Did:        user.Did,
+		Did:        user.Active.Did,
 		Rkey:       tid.TID(),
 		IssueAt:    issue.AtUri().String(),
 		ReplyTo:    replyTo,
···
 
 func (rp *Issues) IssueComment(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "IssueComment")
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 
 func (rp *Issues) EditIssueComment(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "EditIssueComment")
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 	}
 	comment := comments[0]
 
-	if comment.Did != user.Did {
-		l.Error("unauthorized comment edit", "expectedDid", comment.Did, "gotDid", user.Did)
+	if comment.Did != user.Active.Did {
+		l.Error("unauthorized comment edit", "expectedDid", comment.Did, "gotDid", user.Active.Did)
 		http.Error(w, "you are not the author of this comment", http.StatusUnauthorized)
 		return
 	}
···
 		// rkey is optional, it was introduced later
 		if newComment.Rkey != "" {
 			// update the record on pds
-			ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueCommentNSID, user.Did, comment.Rkey)
+			ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueCommentNSID, user.Active.Did, comment.Rkey)
 			if err != nil {
 				l.Error("failed to get record", "err", err, "did", newComment.Did, "rkey", newComment.Rkey)
 				rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "Failed to update description, no record found on PDS.")
···
 
 			_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 				Collection: tangled.RepoIssueCommentNSID,
-				Repo:       user.Did,
+				Repo:       user.Active.Did,
 				Rkey:       newComment.Rkey,
 				SwapRecord: ex.Cid,
 				Record: &lexutil.LexiconTypeDecoder{
···
 
 func (rp *Issues) ReplyIssueCommentPlaceholder(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "ReplyIssueCommentPlaceholder")
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 
 func (rp *Issues) ReplyIssueComment(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "ReplyIssueComment")
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 
 func (rp *Issues) DeleteIssueComment(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "DeleteIssueComment")
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 	}
 	comment := comments[0]
 
-	if comment.Did != user.Did {
-		l.Error("unauthorized action", "expectedDid", comment.Did, "gotDid", user.Did)
+	if comment.Did != user.Active.Did {
+		l.Error("unauthorized action", "expectedDid", comment.Did, "gotDid", user.Active.Did)
 		http.Error(w, "you are not the author of this comment", http.StatusUnauthorized)
 		return
 	}
···
 		}
 		_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 			Collection: tangled.RepoIssueCommentNSID,
-			Repo:       user.Did,
+			Repo:       user.Active.Did,
 			Rkey:       comment.Rkey,
 		})
 		if err != nil {
···
 
 	page := pagination.FromContext(r.Context())
 
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)
···
 	}
 
 	rp.pages.RepoIssues(w, pages.RepoIssuesParams{
-		LoggedInUser:    rp.oauth.GetUser(r),
+		LoggedInUser:    rp.oauth.GetMultiAccountUser(r),
 		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),
 		Issues:          issues,
 		IssueCount:      totalIssues,
···
 
 func (rp *Issues) NewIssue(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "NewIssue")
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 			Title:      r.FormValue("title"),
 			Body:       body,
 			Open:       true,
-			Did:        user.Did,
+			Did:        user.Active.Did,
 			Created:    time.Now(),
 			Mentions:   mentions,
 			References: references,
···
 		}
 		resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoIssueNSID,
-			Repo:       user.Did,
+			Repo:       user.Active.Did,
 			Rkey:       issue.Rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &record,

appview/knots/knots.go

···
 }
 
 func (k *Knots) knots(w http.ResponseWriter, r *http.Request) {
-	user := k.OAuth.GetUser(r)
+	user := k.OAuth.GetMultiAccountUser(r)
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 	)
 	if err != nil {
 		k.Logger.Error("failed to fetch knot registrations", "err", err)
···
 func (k *Knots) dashboard(w http.ResponseWriter, r *http.Request) {
 	l := k.Logger.With("handler", "dashboard")
 
-	user := k.OAuth.GetUser(r)
-	l = l.With("user", user.Did)
+	user := k.OAuth.GetMultiAccountUser(r)
+	l = l.With("user", user.Active.Did)
 
 	domain := chi.URLParam(r, "domain")
 	if domain == "" {
···
 
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("domain", domain),
 	)
 	if err != nil {
···
 }
 
 func (k *Knots) register(w http.ResponseWriter, r *http.Request) {
-	user := k.OAuth.GetUser(r)
+	user := k.OAuth.GetMultiAccountUser(r)
 	l := k.Logger.With("handler", "register")
 
 	noticeId := "register-error"
···
 		return
 	}
 	l = l.With("domain", domain)
-	l = l.With("user", user.Did)
+	l = l.With("user", user.Active.Did)
 
 	tx, err := k.Db.Begin()
 	if err != nil {
···
 		k.Enforcer.E.LoadPolicy()
 	}()
 
-	err = db.AddKnot(tx, domain, user.Did)
+	err = db.AddKnot(tx, domain, user.Active.Did)
 	if err != nil {
 		l.Error("failed to insert", "err", err)
 		fail()
···
 		return
 	}
 
-	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.KnotNSID, user.Did, domain)
+	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.KnotNSID, user.Active.Did, domain)
 	var exCid *string
 	if ex != nil {
 		exCid = ex.Cid
···
 	// re-announce by registering under same rkey
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.KnotNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       domain,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.Knot{
···
 	}
 
 	// begin verification
-	err = serververify.RunVerification(r.Context(), domain, user.Did, k.Config.Core.Dev)
+	err = serververify.RunVerification(r.Context(), domain, user.Active.Did, k.Config.Core.Dev)
 	if err != nil {
 		l.Error("verification failed", "err", err)
 		k.Pages.HxRefresh(w)
 		return
 	}
 
-	err = serververify.MarkKnotVerified(k.Db, k.Enforcer, domain, user.Did)
+	err = serververify.MarkKnotVerified(k.Db, k.Enforcer, domain, user.Active.Did)
 	if err != nil {
 		l.Error("failed to mark verified", "err", err)
 		k.Pages.HxRefresh(w)
···
 }
 
 func (k *Knots) delete(w http.ResponseWriter, r *http.Request) {
-	user := k.OAuth.GetUser(r)
+	user := k.OAuth.GetMultiAccountUser(r)
 	l := k.Logger.With("handler", "delete")
 
 	noticeId := "operation-error"
···
 	// get record from db first
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("domain", domain),
 	)
 	if err != nil {
···
 
 	err = db.DeleteKnot(
 		tx,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("domain", domain),
 	)
 	if err != nil {
···
 
 	_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 		Collection: tangled.KnotNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       domain,
 	})
 	if err != nil {
···
 }
 
 func (k *Knots) retry(w http.ResponseWriter, r *http.Request) {
-	user := k.OAuth.GetUser(r)
+	user := k.OAuth.GetMultiAccountUser(r)
 	l := k.Logger.With("handler", "retry")
 
 	noticeId := "operation-error"
···
 		return
 	}
 	l = l.With("domain", domain)
-	l = l.With("user", user.Did)
+	l = l.With("user", user.Active.Did)
 
 	// get record from db first
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("domain", domain),
 	)
 	if err != nil {
···
 	registration := registrations[0]
 
 	// begin verification
-	err = serververify.RunVerification(r.Context(), domain, user.Did, k.Config.Core.Dev)
+	err = serververify.RunVerification(r.Context(), domain, user.Active.Did, k.Config.Core.Dev)
 	if err != nil {
 		l.Error("verification failed", "err", err)
 
···
 		return
 	}
 
-	err = serververify.MarkKnotVerified(k.Db, k.Enforcer, domain, user.Did)
+	err = serververify.MarkKnotVerified(k.Db, k.Enforcer, domain, user.Active.Did)
 	if err != nil {
 		l.Error("failed to mark verified", "err", err)
 		k.Pages.Notice(w, noticeId, err.Error())
···
 			return
 		}
 
-		ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.KnotNSID, user.Did, domain)
+		ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.KnotNSID, user.Active.Did, domain)
 		var exCid *string
 		if ex != nil {
 			exCid = ex.Cid
···
 		// ignore the error here
 		_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.KnotNSID,
-			Repo:       user.Did,
+			Repo:       user.Active.Did,
 			Rkey:       domain,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &tangled.Knot{
···
 	// Get updated registration to show
 	registrations, err = db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("domain", domain),
 	)
 	if err != nil {
···
 }
 
 func (k *Knots) addMember(w http.ResponseWriter, r *http.Request) {
-	user := k.OAuth.GetUser(r)
+	user := k.OAuth.GetMultiAccountUser(r)
 	l := k.Logger.With("handler", "addMember")
 
 	domain := chi.URLParam(r, "domain")
···
 		return
 	}
 	l = l.With("domain", domain)
-	l = l.With("user", user.Did)
+	l = l.With("user", user.Active.Did)
 
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("domain", domain),
 		orm.FilterIsNot("registered", "null"),
 	)
···
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.KnotMemberNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       rkey,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.KnotMember{
···
 }
 
 func (k *Knots) removeMember(w http.ResponseWriter, r *http.Request) {
-	user := k.OAuth.GetUser(r)
+	user := k.OAuth.GetMultiAccountUser(r)
 	l := k.Logger.With("handler", "removeMember")
 
 	noticeId := "operation-error"
···
 		return
 	}
 	l = l.With("domain", domain)
-	l = l.With("user", user.Did)
+	l = l.With("user", user.Active.Did)
 
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("domain", domain),
 		orm.FilterIsNot("registered", "null"),
 	)

appview/labels/labels.go

···
 // - this handler should calculate the diff in order to create the labelop record
 // - we need the diff in order to maintain a "history" of operations performed by users
 func (l *Labels) PerformLabelOp(w http.ResponseWriter, r *http.Request) {
-	user := l.oauth.GetUser(r)
+	user := l.oauth.GetMultiAccountUser(r)
 
 	noticeId := "add-label-error"
 
···
 		return
 	}
 
-	did := user.Did
+	did := user.Active.Did
 	rkey := tid.TID()
 	performedAt := time.Now()
 	indexedAt := time.Now()

appview/middleware/middleware.go

···
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			// requires auth also
-			actor := mw.oauth.GetUser(r)
+			actor := mw.oauth.GetMultiAccountUser(r)
 			if actor == nil {
 				// we need a logged in user
 				log.Printf("not logged in, redirecting")
···
 				return
 			}
 
-			ok, err := mw.enforcer.E.HasGroupingPolicy(actor.Did, group, domain)
+			ok, err := mw.enforcer.E.HasGroupingPolicy(actor.Active.Did, group, domain)
 			if err != nil || !ok {
-				// we need a logged in user
-				log.Printf("%s does not have perms of a %s in domain %s", actor.Did, group, domain)
+				log.Printf("%s does not have perms of a %s in domain %s", actor.Active.Did, group, domain)
 				http.Error(w, "Forbiden", http.StatusUnauthorized)
 				return
 			}
···
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			// requires auth also
-			actor := mw.oauth.GetUser(r)
+			actor := mw.oauth.GetMultiAccountUser(r)
 			if actor == nil {
 				// we need a logged in user
 				log.Printf("not logged in, redirecting")
···
 				return
 			}
 
-			ok, err := mw.enforcer.E.Enforce(actor.Did, f.Knot, f.DidSlashRepo(), requiredPerm)
+			ok, err := mw.enforcer.E.Enforce(actor.Active.Did, f.Knot, f.DidSlashRepo(), requiredPerm)
 			if err != nil || !ok {
-				// we need a logged in user
-				log.Printf("%s does not have perms of a %s in repo %s", actor.Did, requiredPerm, f.DidSlashRepo())
+				log.Printf("%s does not have perms of a %s in repo %s", actor.Active.Did, requiredPerm, f.DidSlashRepo())
 				http.Error(w, "Forbiden", http.StatusUnauthorized)
 				return
 			}

appview/notifications/notifications.go

···
 
 func (n *Notifications) notificationsPage(w http.ResponseWriter, r *http.Request) {
 	l := n.logger.With("handler", "notificationsPage")
-	user := n.oauth.GetUser(r)
+	user := n.oauth.GetMultiAccountUser(r)
 
 	page := pagination.FromContext(r.Context())
 
 	total, err := db.CountNotifications(
 		n.db,
-		orm.FilterEq("recipient_did", user.Did),
+		orm.FilterEq("recipient_did", user.Active.Did),
 	)
 	if err != nil {
 		l.Error("failed to get total notifications", "err", err)
···
 	notifications, err := db.GetNotificationsWithEntities(
 		n.db,
 		page,
-		orm.FilterEq("recipient_did", user.Did),
+		orm.FilterEq("recipient_did", user.Active.Did),
 	)
 	if err != nil {
 		l.Error("failed to get notifications", "err", err)
···
 		return
 	}
 
-	err = db.MarkAllNotificationsRead(n.db, user.Did)
+	err = db.MarkAllNotificationsRead(n.db, user.Active.Did)
 	if err != nil {
 		l.Error("failed to mark notifications as read", "err", err)
 	}
···
 }
 
 func (n *Notifications) getUnreadCount(w http.ResponseWriter, r *http.Request) {
-	user := n.oauth.GetUser(r)
+	user := n.oauth.GetMultiAccountUser(r)
 	if user == nil {
 		http.Error(w, "Forbidden", http.StatusUnauthorized)
 		return
···
 
 	count, err := db.CountNotifications(
 		n.db,
-		orm.FilterEq("recipient_did", user.Did),
+		orm.FilterEq("recipient_did", user.Active.Did),
 		orm.FilterEq("read", 0),
 	)
 	if err != nil {

appview/pipelines/pipelines.go

···
 }
 
 func (p *Pipelines) Index(w http.ResponseWriter, r *http.Request) {
-	user := p.oauth.GetUser(r)
+	user := p.oauth.GetMultiAccountUser(r)
 	l := p.logger.With("handler", "Index")
 
 	f, err := p.repoResolver.Resolve(r)
···
 }
 
 func (p *Pipelines) Workflow(w http.ResponseWriter, r *http.Request) {
-	user := p.oauth.GetUser(r)
+	user := p.oauth.GetMultiAccountUser(r)
 	l := p.logger.With("handler", "Workflow")
 
 	f, err := p.repoResolver.Resolve(r)

appview/pulls/pulls.go

···
 func (s *Pulls) PullActions(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
-		user := s.oauth.GetUser(r)
+		user := s.oauth.GetMultiAccountUser(r)
 		f, err := s.repoResolver.Resolve(r)
 		if err != nil {
 			log.Println("failed to get repo and knot", err)
···
 		mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
 		branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
 		resubmitResult := pages.Unknown
-		if user.Did == pull.OwnerDid {
+		if user.Active.Did == pull.OwnerDid {
 			resubmitResult = s.resubmitCheck(r, f, pull, stack)
 		}
 
···
 }
 
 func (s *Pulls) RepoSinglePull(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
 		log.Println("failed to get repo and knot", err)
···
 	mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
 	branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
 	resubmitResult := pages.Unknown
-	if user != nil && user.Did == pull.OwnerDid {
+	if user != nil && user.Active != nil && user.Active.Did == pull.OwnerDid {
 		resubmitResult = s.resubmitCheck(r, f, pull, stack)
 	}
 
···
 
 	userReactions := map[models.ReactionKind]bool{}
 	if user != nil {
-		userReactions = db.GetReactionStatusMap(s.db, user.Did, pull.AtUri())
+		userReactions = db.GetReactionStatusMap(s.db, user.Active.Did, pull.AtUri())
 	}
 
 	labelDefs, err := db.GetLabelDefinitions(
···
 		return nil
 	}
 
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	if user == nil {
 		return nil
 	}
···
 	}
 
 	// user can only delete branch if they are a collaborator in the repo that the branch belongs to
-	perms := s.enforcer.GetPermissionsInRepo(user.Did, repo.Knot, repo.DidSlashRepo())
+	perms := s.enforcer.GetPermissionsInRepo(user.Active.Did, repo.Knot, repo.DidSlashRepo())
 	if !slices.Contains(perms, "repo:push") {
 		return nil
 	}
···
 }
 
 func (s *Pulls) RepoPullPatch(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	var diffOpts types.DiffOpts
 	if d := r.URL.Query().Get("diff"); d == "split" {
···
 }
 
 func (s *Pulls) RepoPullInterdiff(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	var diffOpts types.DiffOpts
 	if d := r.URL.Query().Get("diff"); d == "split" {
···
 	interdiff := patchutil.Interdiff(previousPatch, currentPatch)
 
 	s.pages.RepoPullInterdiffPage(w, pages.RepoPullInterdiffParams{
-		LoggedInUser: s.oauth.GetUser(r),
+		LoggedInUser: s.oauth.GetMultiAccountUser(r),
 		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),
 		Pull:         pull,
 		Round:        roundIdInt,
···
 func (s *Pulls) RepoPulls(w http.ResponseWriter, r *http.Request) {
 	l := s.logger.With("handler", "RepoPulls")
 
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	params := r.URL.Query()
 
 	state := models.PullOpen
···
 	}
 
 	s.pages.RepoPulls(w, pages.RepoPullsParams{
-		LoggedInUser: s.oauth.GetUser(r),
+		LoggedInUser: s.oauth.GetMultiAccountUser(r),
 		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),
 		Pulls:        pulls,
 		LabelDefs:    defs,
···
 }
 
 func (s *Pulls) PullComment(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
 		log.Println("failed to get repo and knot", err)
···
 		}
 		atResp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoPullCommentNSID,
-			Repo:       user.Did,
+			Repo:       user.Active.Did,
 			Rkey:       tid.TID(),
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &tangled.RepoPullComment{
···
 		}
 
 		comment := &models.PullComment{
-			OwnerDid:     user.Did,
+			OwnerDid:     user.Active.Did,
 			RepoAt:       f.RepoAt().String(),
 			PullId:       pull.PullId,
 			Body:         body,
···
 }
 
 func (s *Pulls) NewPull(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
 		log.Println("failed to get repo and knot", err)
···
 		}
 
 		// Determine PR type based on input parameters
-		roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
+		roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
 		isPushAllowed := roles.IsPushAllowed()
 		isBranchBased := isPushAllowed && sourceBranch != "" && fromFork == ""
 		isForkBased := fromFork != "" && sourceBranch != ""
···
 	w http.ResponseWriter,
 	r *http.Request,
 	repo *models.Repo,
-	user *oauth.User,
+	user *oauth.MultiAccountUser,
 	title,
 	body,
 	targetBranch,
···
 	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)
 }
 
-func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) {
+func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.MultiAccountUser, title, body, targetBranch, patch string, isStacked bool) {
 	if err := s.validator.ValidatePatch(&patch); err != nil {
 		s.logger.Error("patch validation failed", "err", err)
 		s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")
···
 	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked)
 }
 
-func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {
+func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.MultiAccountUser, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {
 	repoString := strings.SplitN(forkRepo, "/", 2)
 	forkOwnerDid := repoString[0]
 	repoName := repoString[1]
···
 	w http.ResponseWriter,
 	r *http.Request,
 	repo *models.Repo,
-	user *oauth.User,
+	user *oauth.MultiAccountUser,
 	title, body, targetBranch string,
 	patch string,
 	combined string,
···
 		Title:        title,
 		Body:         body,
 		TargetBranch: targetBranch,
-		OwnerDid:     user.Did,
+		OwnerDid:     user.Active.Did,
 		RepoAt:       repo.RepoAt(),
 		Rkey:         rkey,
 		Mentions:     mentions,
···
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.RepoPullNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       rkey,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.RepoPull{
···
 	w http.ResponseWriter,
 	r *http.Request,
 	repo *models.Repo,
-	user *oauth.User,
+	user *oauth.MultiAccountUser,
 	targetBranch string,
 	patch string,
 	sourceRev string,
···
 		})
 	}
 	_, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{
-		Repo:   user.Did,
+		Repo:   user.Active.Did,
 		Writes: writes,
 	})
 	if err != nil {
···
 }
 
 func (s *Pulls) PatchUploadFragment(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	s.pages.PullPatchUploadFragment(w, pages.PullPatchUploadParams{
 		RepoInfo: s.repoResolver.GetRepoInfo(r, user),
···
 }
 
 func (s *Pulls) CompareBranchesFragment(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
 		log.Println("failed to get repo and knot", err)
···
 }
 
 func (s *Pulls) CompareForksFragment(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
-	forks, err := db.GetForksByDid(s.db, user.Did)
+	forks, err := db.GetForksByDid(s.db, user.Active.Did)
 	if err != nil {
 		log.Println("failed to get forks", err)
 		return
···
 }
 
 func (s *Pulls) CompareForksBranchesFragment(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
···
 }
 
 func (s *Pulls) ResubmitPull(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
···
 }
 
 func (s *Pulls) resubmitPatch(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
···
 		return
 	}
 
-	if user.Did != pull.OwnerDid {
+	if user.Active.Did != pull.OwnerDid {
 		log.Println("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
 		return
···
 }
 
 func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
···
 		return
 	}
 
-	if user.Did != pull.OwnerDid {
+	if user.Active.Did != pull.OwnerDid {
 		log.Println("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
 		return
 	}
 
-	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
+	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
 	if !roles.IsPushAllowed() {
 		log.Println("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
···
 }
 
 func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
···
 		return
 	}
 
-	if user.Did != pull.OwnerDid {
+	if user.Active.Did != pull.OwnerDid {
 		log.Println("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
 		return
···
 	w http.ResponseWriter,
 	r *http.Request,
 	repo *models.Repo,
-	user *oauth.User,
+	user *oauth.MultiAccountUser,
 	pull *models.Pull,
 	patch string,
 	combined string,
···
 		return
 	}
 
-	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, user.Did, pull.Rkey)
+	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, user.Active.Did, pull.Rkey)
 	if err != nil {
 		// failed to get record
 		s.pages.Notice(w, "resubmit-error", "Failed to update pull, no record found on PDS.")
···
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.RepoPullNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       pull.Rkey,
 		SwapRecord: ex.Cid,
 		Record: &lexutil.LexiconTypeDecoder{
···
 	w http.ResponseWriter,
 	r *http.Request,
 	repo *models.Repo,
-	user *oauth.User,
+	user *oauth.MultiAccountUser,
 	pull *models.Pull,
 	patch string,
 	stackId string,
···
 	}
 
 	_, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{
-		Repo:   user.Did,
+		Repo:   user.Active.Did,
 		Writes: writes,
 	})
 	if err != nil {
···
 }
 
 func (s *Pulls) MergePull(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
 		log.Println("failed to resolve repo:", err)
···
 
 	// notify about the pull merge
 	for _, p := range pullsToMerge {
-		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
+		s.notifier.NewPullState(r.Context(), syntax.DID(user.Active.Did), p)
 	}
 
 	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
···
 }
 
 func (s *Pulls) ClosePull(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
···
 	}
 
 	// auth filter: only owner or collaborators can close
-	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
+	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
 	isOwner := roles.IsOwner()
 	isCollaborator := roles.IsCollaborator()
-	isPullAuthor := user.Did == pull.OwnerDid
+	isPullAuthor := user.Active.Did == pull.OwnerDid
 	isCloseAllowed := isOwner || isCollaborator || isPullAuthor
 	if !isCloseAllowed {
 		log.Println("failed to close pull")
···
 	}
 
 	for _, p := range pullsToClose {
-		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
+		s.notifier.NewPullState(r.Context(), syntax.DID(user.Active.Did), p)
 	}
 
 	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
···
 }
 
 func (s *Pulls) ReopenPull(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
···
 	}
 
 	// auth filter: only owner or collaborators can close
-	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
+	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
 	isOwner := roles.IsOwner()
 	isCollaborator := roles.IsCollaborator()
-	isPullAuthor := user.Did == pull.OwnerDid
+	isPullAuthor := user.Active.Did == pull.OwnerDid
 	isCloseAllowed := isOwner || isCollaborator || isPullAuthor
 	if !isCloseAllowed {
 		log.Println("failed to close pull")
···
 	}
 
 	for _, p := range pullsToReopen {
-		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
+		s.notifier.NewPullState(r.Context(), syntax.DID(user.Active.Did), p)
 	}
 
 	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
 }
 
-func (s *Pulls) newStack(ctx context.Context, repo *models.Repo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {
+func (s *Pulls) newStack(ctx context.Context, repo *models.Repo, user *oauth.MultiAccountUser, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {
 	formatPatches, err := patchutil.ExtractPatches(patch)
 	if err != nil {
 		return nil, fmt.Errorf("Failed to extract patches: %v", err)
···
 			Title:        title,
 			Body:         body,
 			TargetBranch: targetBranch,
-			OwnerDid:     user.Did,
+			OwnerDid:     user.Active.Did,
 			RepoAt:       repo.RepoAt(),
 			Rkey:         rkey,
 			Mentions:     mentions,

appview/repo/artifact.go

···
 
 // TODO: proper statuses here on early exit
 func (rp *Repo) AttachArtifact(w http.ResponseWriter, r *http.Request) {
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	tagParam := chi.URLParam(r, "tag")
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 
 	putRecordResp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.RepoArtifactNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       rkey,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.RepoArtifact{
···
 	defer tx.Rollback()
 
 	artifact := models.Artifact{
-		Did:       user.Did,
+		Did:       user.Active.Did,
 		Rkey:      rkey,
 		RepoAt:    f.RepoAt(),
 		Tag:       tag.Tag.Hash,
···
 
 // TODO: proper statuses here on early exit
 func (rp *Repo) DeleteArtifact(w http.ResponseWriter, r *http.Request) {
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	tagParam := chi.URLParam(r, "tag")
 	filename := chi.URLParam(r, "file")
 	f, err := rp.repoResolver.Resolve(r)
···
 
 	artifact := artifacts[0]
 
-	if user.Did != artifact.Did {
+	if user.Active.Did != artifact.Did {
 		log.Println("user not authorized to delete artifact", err)
 		rp.pages.Notice(w, "remove", "Unauthorized deletion of artifact.")
 		return
···
 
 	_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 		Collection: tangled.RepoArtifactNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       artifact.Rkey,
 	})
 	if err != nil {

appview/repo/blob.go

···
 	// Create the blob view
 	blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())
 
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	rp.pages.RepoBlob(w, pages.RepoBlobParams{
 		LoggedInUser:    user,

appview/repo/branches.go

···
 		return
 	}
 	sortBranches(result.Branches)
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	rp.pages.RepoBranches(w, pages.RepoBranchesParams{
 		LoggedInUser:         user,
 		RepoInfo:             rp.repoResolver.GetRepoInfo(r, user),

appview/repo/compare.go

···
 func (rp *Repo) CompareNew(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "RepoCompareNew")
 
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)
···
 func (rp *Repo) Compare(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "RepoCompare")
 
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)

appview/repo/index.go

···
 		Host: host,
 	}
 
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	// Build index response from multiple XRPC calls
 	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)

appview/repo/log.go

···
 		}
 	}
 
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true)
 	if err != nil {
···
 		l.Error("failed to GetVerifiedCommits", "err", err)
 	}
 
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	pipelines, err := getPipelineStatuses(rp.db, f, []string{result.Diff.Commit.This})
 	if err != nil {
 		l.Error("failed to getPipelineStatuses", "err", err)

appview/repo/repo.go

···
 
 // modify the spindle configured for this repo
 func (rp *Repo) EditSpindle(w http.ResponseWriter, r *http.Request) {
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "EditSpindle")
-	l = l.With("did", user.Did)
+	l = l.With("did", user.Active.Did)
 
 	errorId := "operation-error"
 	fail := func(msg string, err error) {
···
 
 	if !removingSpindle {
 		// ensure that this is a valid spindle for this user
-		validSpindles, err := rp.enforcer.GetSpindlesForUser(user.Did)
+		validSpindles, err := rp.enforcer.GetSpindlesForUser(user.Active.Did)
 		if err != nil {
 			fail("Failed to find spindles. Try again later.", err)
 			return
···
 }
 
 func (rp *Repo) AddLabelDef(w http.ResponseWriter, r *http.Request) {
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "AddLabel")
-	l = l.With("did", user.Did)
+	l = l.With("did", user.Active.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 	}
 
 	label := models.LabelDefinition{
-		Did:       user.Did,
+		Did:       user.Active.Did,
 		Rkey:      tid.TID(),
 		Name:      name,
 		ValueType: valueType,
···
 }
 
 func (rp *Repo) DeleteLabelDef(w http.ResponseWriter, r *http.Request) {
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "DeleteLabel")
-	l = l.With("did", user.Did)
+	l = l.With("did", user.Active.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 }
 
 func (rp *Repo) SubscribeLabel(w http.ResponseWriter, r *http.Request) {
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "SubscribeLabel")
-	l = l.With("did", user.Did)
+	l = l.With("did", user.Active.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 }
 
 func (rp *Repo) UnsubscribeLabel(w http.ResponseWriter, r *http.Request) {
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "UnsubscribeLabel")
-	l = l.With("did", user.Did)
+	l = l.With("did", user.Active.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 	}
 	state := states[subject]
 
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	rp.pages.LabelPanel(w, pages.LabelPanelParams{
 		LoggedInUser: user,
 		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
···
 	}
 	state := states[subject]
 
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	rp.pages.EditLabelPanel(w, pages.EditLabelPanelParams{
 		LoggedInUser: user,
 		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
···
 }
 
 func (rp *Repo) AddCollaborator(w http.ResponseWriter, r *http.Request) {
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "AddCollaborator")
-	l = l.With("did", user.Did)
+	l = l.With("did", user.Active.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 		return
 	}
 
-	if collaboratorIdent.DID.String() == user.Did {
+	if collaboratorIdent.DID.String() == user.Active.Did {
 		fail("You seem to be adding yourself as a collaborator.", nil)
 		return
 	}
···
 	}
 
 	// emit a record
-	currentUser := rp.oauth.GetUser(r)
+	currentUser := rp.oauth.GetMultiAccountUser(r)
 	rkey := tid.TID()
 	createdAt := time.Now()
 	resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.RepoCollaboratorNSID,
-		Repo:       currentUser.Did,
+		Repo:       currentUser.Active.Did,
 		Rkey:       rkey,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.RepoCollaborator{
···
 	}
 
 	err = db.AddCollaborator(tx, models.Collaborator{
-		Did:        syntax.DID(currentUser.Did),
+		Did:        syntax.DID(currentUser.Active.Did),
 		Rkey:       rkey,
 		SubjectDid: collaboratorIdent.DID,
 		RepoAt:     f.RepoAt(),
···
 }
 
 func (rp *Repo) DeleteRepo(w http.ResponseWriter, r *http.Request) {
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "DeleteRepo")
 
 	noticeId := "operation-error"
···
 	}
 	_, err = comatproto.RepoDeleteRecord(r.Context(), atpClient, &comatproto.RepoDeleteRecord_Input{
 		Collection: tangled.RepoNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       f.Rkey,
 	})
 	if err != nil {
···
 	ref := chi.URLParam(r, "ref")
 	ref, _ = url.PathUnescape(ref)
 
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to resolve source repo", "err", err)
···
 			r.Context(),
 			client,
 			&tangled.RepoForkSync_Input{
-				Did:    user.Did,
+				Did:    user.Active.Did,
 				Name:   f.Name,
 				Source: f.Source,
 				Branch: ref,
···
 func (rp *Repo) ForkRepo(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "ForkRepo")
 
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to resolve source repo", "err", err)
···
 
 	switch r.Method {
 	case http.MethodGet:
-		user := rp.oauth.GetUser(r)
-		knots, err := rp.enforcer.GetKnotsForUser(user.Did)
+		user := rp.oauth.GetMultiAccountUser(r)
+		knots, err := rp.enforcer.GetKnotsForUser(user.Active.Did)
 		if err != nil {
 			rp.pages.Notice(w, "repo", "Invalid user account.")
 			return
···
 		}
 		l = l.With("targetKnot", targetKnot)
 
-		ok, err := rp.enforcer.E.Enforce(user.Did, targetKnot, targetKnot, "repo:create")
+		ok, err := rp.enforcer.E.Enforce(user.Active.Did, targetKnot, targetKnot, "repo:create")
 		if err != nil || !ok {
 			rp.pages.Notice(w, "repo", "You do not have permission to create a repo in this knot.")
 			return
···
 		// in the user's account.
 		existingRepo, err := db.GetRepo(
 			rp.db,
-			orm.FilterEq("did", user.Did),
+			orm.FilterEq("did", user.Active.Did),
 			orm.FilterEq("name", forkName),
 		)
 		if err != nil {
···
 		// create an atproto record for this fork
 		rkey := tid.TID()
 		repo := &models.Repo{
-			Did:         user.Did,
+			Did:         user.Active.Did,
 			Name:        forkName,
 			Knot:        targetKnot,
 			Rkey:        rkey,
···
 
 		atresp, err := comatproto.RepoPutRecord(r.Context(), atpClient, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoNSID,
-			Repo:       user.Did,
+			Repo:       user.Active.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &record,
···
 		}
 
 		// acls
-		p, _ := securejoin.SecureJoin(user.Did, forkName)
-		err = rp.enforcer.AddRepo(user.Did, targetKnot, p)
+		p, _ := securejoin.SecureJoin(user.Active.Did, forkName)
+		err = rp.enforcer.AddRepo(user.Active.Did, targetKnot, p)
 		if err != nil {
 			l.Error("failed to add ACLs", "err", err)
 			rp.pages.Notice(w, "repo", "Failed to set up repository permissions.")
···
 		aturi = ""
 
 		rp.notifier.NewRepo(r.Context(), repo)
-		rp.pages.HxLocation(w, fmt.Sprintf("/%s/%s", user.Did, forkName))
+		rp.pages.HxLocation(w, fmt.Sprintf("/%s/%s", user.Active.Did, forkName))
 	}
 }
 

appview/repo/settings.go

···
 }
 
 func (rp *Repo) Secrets(w http.ResponseWriter, r *http.Request) {
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "Secrets")
-	l = l.With("did", user.Did)
+	l = l.With("did", user.Active.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 	l := rp.logger.With("handler", "generalSettings")
 
 	f, err := rp.repoResolver.Resolve(r)
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	scheme := "http"
 	if !rp.config.Core.Dev {
···
 	l := rp.logger.With("handler", "accessSettings")
 
 	f, err := rp.repoResolver.Resolve(r)
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	collaborators, err := func(repo *models.Repo) ([]pages.Collaborator, error) {
 		repoCollaborators, err := rp.enforcer.E.GetImplicitUsersForResourceByDomain(repo.DidSlashRepo(), repo.Knot)
···
 	l := rp.logger.With("handler", "pipelineSettings")
 
 	f, err := rp.repoResolver.Resolve(r)
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 
 	// all spindles that the repo owner is a member of
 	spindles, err := rp.enforcer.GetSpindlesForUser(f.Did)

appview/repo/tags.go

···
 			danglingArtifacts = append(danglingArtifacts, a)
 		}
 	}
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	rp.pages.RepoTags(w, pages.RepoTagsParams{
 		LoggedInUser:      user,
 		RepoInfo:          rp.repoResolver.GetRepoInfo(r, user),

appview/repo/tree.go

···
 		http.Redirect(w, r, redirectTo, http.StatusFound)
 		return
 	}
-	user := rp.oauth.GetUser(r)
+	user := rp.oauth.GetMultiAccountUser(r)
 	var breadcrumbs [][]string
 	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", ownerSlashRepo, url.PathEscape(ref))})
 	if treePath != "" {

appview/reporesolver/resolver.go

···
 // 2. [x] remove `rr`, `CurrentDir`, `Ref` fields from `ResolvedRepo`
 // 3. [x] remove `ResolvedRepo`
 // 4. [ ] replace reporesolver to reposervice
-func (rr *RepoResolver) GetRepoInfo(r *http.Request, user *oauth.User) repoinfo.RepoInfo {
+func (rr *RepoResolver) GetRepoInfo(r *http.Request, user *oauth.MultiAccountUser) repoinfo.RepoInfo {
 	ownerId, ook := r.Context().Value("resolvedId").(identity.Identity)
 	repo, rok := r.Context().Value("repo").(*models.Repo)
 	if !ook || !rok {
···
 	repoAt := repo.RepoAt()
 	isStarred := false
 	roles := repoinfo.RolesInRepo{}
-	if user != nil {
-		isStarred = db.GetStarStatus(rr.execer, user.Did, repoAt)
-		roles.Roles = rr.enforcer.GetPermissionsInRepo(user.Did, repo.Knot, repo.DidSlashRepo())
+	if user != nil && user.Active != nil {
+		isStarred = db.GetStarStatus(rr.execer, user.Active.Did, repoAt)
+		roles.Roles = rr.enforcer.GetPermissionsInRepo(user.Active.Did, repo.Knot, repo.DidSlashRepo())
 	}
 
 	stats := repo.RepoStats

appview/settings/settings.go

···
 }
 
 func (s *Settings) profileSettings(w http.ResponseWriter, r *http.Request) {
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 
 	s.Pages.UserProfileSettings(w, pages.UserProfileSettingsParams{
 		LoggedInUser: user,
···
 }
 
 func (s *Settings) notificationsSettings(w http.ResponseWriter, r *http.Request) {
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 	did := s.OAuth.GetDid(r)
 
 	prefs, err := db.GetNotificationPreference(s.Db, did)
···
 }
 
 func (s *Settings) keysSettings(w http.ResponseWriter, r *http.Request) {
-	user := s.OAuth.GetUser(r)
-	pubKeys, err := db.GetPublicKeysForDid(s.Db, user.Did)
+	user := s.OAuth.GetMultiAccountUser(r)
+	pubKeys, err := db.GetPublicKeysForDid(s.Db, user.Active.Did)
 	if err != nil {
 		log.Println(err)
 	}
···
 }
 
 func (s *Settings) emailsSettings(w http.ResponseWriter, r *http.Request) {
-	user := s.OAuth.GetUser(r)
-	emails, err := db.GetAllEmails(s.Db, user.Did)
+	user := s.OAuth.GetMultiAccountUser(r)
+	emails, err := db.GetAllEmails(s.Db, user.Active.Did)
 	if err != nil {
 		log.Println(err)
 	}

appview/spindles/spindles.go

···
 }
 
 func (s *Spindles) spindles(w http.ResponseWriter, r *http.Request) {
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 	all, err := db.GetSpindles(
 		s.Db,
-		orm.FilterEq("owner", user.Did),
+		orm.FilterEq("owner", user.Active.Did),
 	)
 	if err != nil {
 		s.Logger.Error("failed to fetch spindles", "err", err)
···
 func (s *Spindles) dashboard(w http.ResponseWriter, r *http.Request) {
 	l := s.Logger.With("handler", "dashboard")
 
-	user := s.OAuth.GetUser(r)
-	l = l.With("user", user.Did)
+	user := s.OAuth.GetMultiAccountUser(r)
+	l = l.With("user", user.Active.Did)
 
 	instance := chi.URLParam(r, "instance")
 	if instance == "" {
···
 	spindles, err := db.GetSpindles(
 		s.Db,
 		orm.FilterEq("instance", instance),
-		orm.FilterEq("owner", user.Did),
+		orm.FilterEq("owner", user.Active.Did),
 		orm.FilterIsNot("verified", "null"),
 	)
 	if err != nil || len(spindles) != 1 {
···
 //
 // if the spindle is not up yet, the user is free to retry verification at a later point
 func (s *Spindles) register(w http.ResponseWriter, r *http.Request) {
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 	l := s.Logger.With("handler", "register")
 
 	noticeId := "register-error"
···
 		return
 	}
 	l = l.With("instance", instance)
-	l = l.With("user", user.Did)
+	l = l.With("user", user.Active.Did)
 
 	tx, err := s.Db.Begin()
 	if err != nil {
···
 	}()
 
 	err = db.AddSpindle(tx, models.Spindle{
-		Owner:    syntax.DID(user.Did),
+		Owner:    syntax.DID(user.Active.Did),
 		Instance: instance,
 	})
 	if err != nil {
···
 		return
 	}
 
-	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.SpindleNSID, user.Did, instance)
+	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.SpindleNSID, user.Active.Did, instance)
 	var exCid *string
 	if ex != nil {
 		exCid = ex.Cid
···
 	// re-announce by registering under same rkey
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.SpindleNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       instance,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.Spindle{
···
 	}
 
 	// begin verification
-	err = serververify.RunVerification(r.Context(), instance, user.Did, s.Config.Core.Dev)
+	err = serververify.RunVerification(r.Context(), instance, user.Active.Did, s.Config.Core.Dev)
 	if err != nil {
 		l.Error("verification failed", "err", err)
 		s.Pages.HxRefresh(w)
 		return
 	}
 
-	_, err = serververify.MarkSpindleVerified(s.Db, s.Enforcer, instance, user.Did)
+	_, err = serververify.MarkSpindleVerified(s.Db, s.Enforcer, instance, user.Active.Did)
 	if err != nil {
 		l.Error("failed to mark verified", "err", err)
 		s.Pages.HxRefresh(w)
···
 }
 
 func (s *Spindles) delete(w http.ResponseWriter, r *http.Request) {
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 	l := s.Logger.With("handler", "delete")
 
 	noticeId := "operation-error"
···
 
 	spindles, err := db.GetSpindles(
 		s.Db,
-		orm.FilterEq("owner", user.Did),
+		orm.FilterEq("owner", user.Active.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil || len(spindles) != 1 {
···
 		return
 	}
 
-	if string(spindles[0].Owner) != user.Did {
-		l.Error("unauthorized", "user", user.Did, "owner", spindles[0].Owner)
+	if string(spindles[0].Owner) != user.Active.Did {
+		l.Error("unauthorized", "user", user.Active.Did, "owner", spindles[0].Owner)
 		s.Pages.Notice(w, noticeId, "Failed to delete spindle, unauthorized deletion attempt.")
 		return
 	}
···
 	// remove spindle members first
 	err = db.RemoveSpindleMember(
 		tx,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil {
···
 
 	err = db.DeleteSpindle(
 		tx,
-		orm.FilterEq("owner", user.Did),
+		orm.FilterEq("owner", user.Active.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil {
···
 
 	_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 		Collection: tangled.SpindleNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       instance,
 	})
 	if err != nil {
···
 }
 
 func (s *Spindles) retry(w http.ResponseWriter, r *http.Request) {
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 	l := s.Logger.With("handler", "retry")
 
 	noticeId := "operation-error"
···
 		return
 	}
 	l = l.With("instance", instance)
-	l = l.With("user", user.Did)
+	l = l.With("user", user.Active.Did)
 
 	spindles, err := db.GetSpindles(
 		s.Db,
-		orm.FilterEq("owner", user.Did),
+		orm.FilterEq("owner", user.Active.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil || len(spindles) != 1 {
···
 		return
 	}
 
-	if string(spindles[0].Owner) != user.Did {
-		l.Error("unauthorized", "user", user.Did, "owner", spindles[0].Owner)
+	if string(spindles[0].Owner) != user.Active.Did {
+		l.Error("unauthorized", "user", user.Active.Did, "owner", spindles[0].Owner)
 		s.Pages.Notice(w, noticeId, "Failed to verify spindle, unauthorized verification attempt.")
 		return
 	}
 
 	// begin verification
-	err = serververify.RunVerification(r.Context(), instance, user.Did, s.Config.Core.Dev)
+	err = serververify.RunVerification(r.Context(), instance, user.Active.Did, s.Config.Core.Dev)
 	if err != nil {
 		l.Error("verification failed", "err", err)
 
···
 		return
 	}
 
-	rowId, err := serververify.MarkSpindleVerified(s.Db, s.Enforcer, instance, user.Did)
+	rowId, err := serververify.MarkSpindleVerified(s.Db, s.Enforcer, instance, user.Active.Did)
 	if err != nil {
 		l.Error("failed to mark verified", "err", err)
 		s.Pages.Notice(w, noticeId, err.Error())
···
 }
 
 func (s *Spindles) addMember(w http.ResponseWriter, r *http.Request) {
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 	l := s.Logger.With("handler", "addMember")
 
 	instance := chi.URLParam(r, "instance")
···
 		return
 	}
 	l = l.With("instance", instance)
-	l = l.With("user", user.Did)
+	l = l.With("user", user.Active.Did)
 
 	spindles, err := db.GetSpindles(
 		s.Db,
-		orm.FilterEq("owner", user.Did),
+		orm.FilterEq("owner", user.Active.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil || len(spindles) != 1 {
···
 		s.Pages.Notice(w, noticeId, defaultErr)
 	}
 
-	if string(spindles[0].Owner) != user.Did {
-		l.Error("unauthorized", "user", user.Did, "owner", spindles[0].Owner)
+	if string(spindles[0].Owner) != user.Active.Did {
+		l.Error("unauthorized", "user", user.Active.Did, "owner", spindles[0].Owner)
 		s.Pages.Notice(w, noticeId, "Failed to add member, unauthorized attempt.")
 		return
 	}
···
 
 	// add member to db
 	if err = db.AddSpindleMember(tx, models.SpindleMember{
-		Did:      syntax.DID(user.Did),
+		Did:      syntax.DID(user.Active.Did),
 		Rkey:     rkey,
 		Instance: instance,
 		Subject:  memberId.DID,
···
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.SpindleMemberNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       rkey,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.SpindleMember{
···
 }
 
 func (s *Spindles) removeMember(w http.ResponseWriter, r *http.Request) {
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 	l := s.Logger.With("handler", "removeMember")
 
 	noticeId := "operation-error"
···
 		return
 	}
 	l = l.With("instance", instance)
-	l = l.With("user", user.Did)
+	l = l.With("user", user.Active.Did)
 
 	spindles, err := db.GetSpindles(
 		s.Db,
-		orm.FilterEq("owner", user.Did),
+		orm.FilterEq("owner", user.Active.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil || len(spindles) != 1 {
···
 		return
 	}
 
-	if string(spindles[0].Owner) != user.Did {
-		l.Error("unauthorized", "user", user.Did, "owner", spindles[0].Owner)
+	if string(spindles[0].Owner) != user.Active.Did {
+		l.Error("unauthorized", "user", user.Active.Did, "owner", spindles[0].Owner)
 		s.Pages.Notice(w, noticeId, "Failed to remove member, unauthorized attempt.")
 		return
 	}
···
 	// get the record from the DB first:
 	members, err := db.GetSpindleMembers(
 		s.Db,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("instance", instance),
 		orm.FilterEq("subject", memberId.DID),
 	)
···
 	// remove from db
 	if err = db.RemoveSpindleMember(
 		tx,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("instance", instance),
 		orm.FilterEq("subject", memberId.DID),
 	); err != nil {
···
 	// remove from pds
 	_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 		Collection: tangled.SpindleMemberNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       members[0].Rkey,
 	})
 	if err != nil {

appview/state/follow.go

···
 )
 
 func (s *State) Follow(w http.ResponseWriter, r *http.Request) {
-	currentUser := s.oauth.GetUser(r)
+	currentUser := s.oauth.GetMultiAccountUser(r)
 
 	subject := r.URL.Query().Get("subject")
 	if subject == "" {
···
 		return
 	}
 
-	if currentUser.Did == subjectIdent.DID.String() {
+	if currentUser.Active.Did == subjectIdent.DID.String() {
 		log.Println("cant follow or unfollow yourself")
 		return
 	}
···
 		rkey := tid.TID()
 		resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.GraphFollowNSID,
-			Repo:       currentUser.Did,
+			Repo:       currentUser.Active.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &tangled.GraphFollow{
···
 		log.Println("created atproto record: ", resp.Uri)
 
 		follow := &models.Follow{
-			UserDid:    currentUser.Did,
+			UserDid:    currentUser.Active.Did,
 			SubjectDid: subjectIdent.DID.String(),
 			Rkey:       rkey,
 		}
···
 		return
 	case http.MethodDelete:
 		// find the record in the db
-		follow, err := db.GetFollow(s.db, currentUser.Did, subjectIdent.DID.String())
+		follow, err := db.GetFollow(s.db, currentUser.Active.Did, subjectIdent.DID.String())
 		if err != nil {
 			log.Println("failed to get follow relationship")
 			return
···
 
 		_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 			Collection: tangled.GraphFollowNSID,
-			Repo:       currentUser.Did,
+			Repo:       currentUser.Active.Did,
 			Rkey:       follow.Rkey,
 		})
 
···
 			return
 		}
 
-		err = db.DeleteFollowByRkey(s.db, currentUser.Did, follow.Rkey)
+		err = db.DeleteFollowByRkey(s.db, currentUser.Active.Did, follow.Rkey)
 		if err != nil {
 			log.Println("failed to delete follow from DB")
 			// this is not an issue, the firehose event might have already done this

appview/state/gfi.go

···
 )
 
 func (s *State) GoodFirstIssues(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	page := pagination.FromContext(r.Context())
 

appview/state/profile.go

···
 		return nil, fmt.Errorf("failed to get follower stats: %w", err)
 	}
 
-	loggedInUser := s.oauth.GetUser(r)
+	loggedInUser := s.oauth.GetMultiAccountUser(r)
 	followStatus := models.IsNotFollowing
 	if loggedInUser != nil {
-		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)
+		followStatus = db.GetFollowStatus(s.db, loggedInUser.Active.Did, did)
 	}
 
 	now := time.Now()
···
 	}
 
 	s.pages.ProfileOverview(w, pages.ProfileOverviewParams{
-		LoggedInUser:       s.oauth.GetUser(r),
+		LoggedInUser:       s.oauth.GetMultiAccountUser(r),
 		Card:               profile,
 		Repos:              pinnedRepos,
 		CollaboratingRepos: pinnedCollaboratingRepos,
···
 	}
 
 	err = s.pages.ProfileRepos(w, pages.ProfileReposParams{
-		LoggedInUser: s.oauth.GetUser(r),
+		LoggedInUser: s.oauth.GetMultiAccountUser(r),
 		Repos:        repos,
 		Card:         profile,
 	})
···
 	}
 
 	err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{
-		LoggedInUser: s.oauth.GetUser(r),
+		LoggedInUser: s.oauth.GetMultiAccountUser(r),
 		Repos:        repos,
 		Card:         profile,
 	})
···
 	}
 
 	err = s.pages.ProfileStrings(w, pages.ProfileStringsParams{
-		LoggedInUser: s.oauth.GetUser(r),
+		LoggedInUser: s.oauth.GetMultiAccountUser(r),
 		Strings:      strings,
 		Card:         profile,
 	})
···
 	}
 	l = l.With("profileDid", profile.UserDid)
 
-	loggedInUser := s.oauth.GetUser(r)
+	loggedInUser := s.oauth.GetMultiAccountUser(r)
 	params := FollowsPageParams{
 		Card: profile,
 	}
···
 
 	loggedInUserFollowing := make(map[string]struct{})
 	if loggedInUser != nil {
-		following, err := db.GetFollowing(s.db, loggedInUser.Did)
+		following, err := db.GetFollowing(s.db, loggedInUser.Active.Did)
 		if err != nil {
-			l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.Did)
+			l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.Active.Did)
 			return &params, err
 		}
 		loggedInUserFollowing = make(map[string]struct{}, len(following))
···
 		followStatus := models.IsNotFollowing
 		if _, exists := loggedInUserFollowing[did]; exists {
 			followStatus = models.IsFollowing
-		} else if loggedInUser != nil && loggedInUser.Did == did {
+		} else if loggedInUser != nil && loggedInUser.Active.Did == did {
 			followStatus = models.IsSelf
 		}
 
···
 	}
 
 	s.pages.ProfileFollowers(w, pages.ProfileFollowersParams{
-		LoggedInUser: s.oauth.GetUser(r),
+		LoggedInUser: s.oauth.GetMultiAccountUser(r),
 		Followers:    followPage.Follows,
 		Card:         followPage.Card,
 	})
···
 	}
 
 	s.pages.ProfileFollowing(w, pages.ProfileFollowingParams{
-		LoggedInUser: s.oauth.GetUser(r),
+		LoggedInUser: s.oauth.GetMultiAccountUser(r),
 		Following:    followPage.Follows,
 		Card:         followPage.Card,
 	})
···
 }
 
 func (s *State) UpdateProfileBio(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	err := r.ParseForm()
 	if err != nil {
···
 		return
 	}
 
-	profile, err := db.GetProfile(s.db, user.Did)
+	profile, err := db.GetProfile(s.db, user.Active.Did)
 	if err != nil {
-		log.Printf("getting profile data for %s: %s", user.Did, err)
+		log.Printf("getting profile data for %s: %s", user.Active.Did, err)
 	}
 
 	profile.Description = r.FormValue("description")
···
 }
 
 func (s *State) UpdateProfilePins(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	err := r.ParseForm()
 	if err != nil {
···
 		return
 	}
 
-	profile, err := db.GetProfile(s.db, user.Did)
+	profile, err := db.GetProfile(s.db, user.Active.Did)
 	if err != nil {
-		log.Printf("getting profile data for %s: %s", user.Did, err)
+		log.Printf("getting profile data for %s: %s", user.Active.Did, err)
 	}
 
 	i := 0
···
 }
 
 func (s *State) updateProfile(profile *models.Profile, w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	tx, err := s.db.BeginTx(r.Context(), nil)
 	if err != nil {
 		log.Println("failed to start transaction", err)
···
 		vanityStats = append(vanityStats, string(v.Kind))
 	}
 
-	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
+	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Active.Did, "self")
 	var cid *string
 	if ex != nil {
 		cid = ex.Cid
···
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.ActorProfileNSID,
-		Repo:       user.Did,
+		Repo:       user.Active.Did,
 		Rkey:       "self",
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.ActorProfile{
···
 
 	s.notifier.UpdateProfile(r.Context(), profile)
 
-	s.pages.HxRedirect(w, "/"+user.Did)
+	s.pages.HxRedirect(w, "/"+user.Active.Did)
 }
 
 func (s *State) EditBioFragment(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
-	profile, err := db.GetProfile(s.db, user.Did)
+	profile, err := db.GetProfile(s.db, user.Active.Did)
 	if err != nil {
-		log.Printf("getting profile data for %s: %s", user.Did, err)
+		log.Printf("getting profile data for %s: %s", user.Active.Did, err)
 	}
 
 	s.pages.EditBioFragment(w, pages.EditBioParams{
···
 }
 
 func (s *State) EditPinsFragment(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
-	profile, err := db.GetProfile(s.db, user.Did)
+	profile, err := db.GetProfile(s.db, user.Active.Did)
 	if err != nil {
-		log.Printf("getting profile data for %s: %s", user.Did, err)
+		log.Printf("getting profile data for %s: %s", user.Active.Did, err)
 	}
 
-	repos, err := db.GetRepos(s.db, 0, orm.FilterEq("did", user.Did))
+	repos, err := db.GetRepos(s.db, 0, orm.FilterEq("did", user.Active.Did))
 	if err != nil {
-		log.Printf("getting repos for %s: %s", user.Did, err)
+		log.Printf("getting repos for %s: %s", user.Active.Did, err)
 	}
 
-	collaboratingRepos, err := db.CollaboratingIn(s.db, user.Did)
+	collaboratingRepos, err := db.CollaboratingIn(s.db, user.Active.Did)
 	if err != nil {
-		log.Printf("getting collaborating repos for %s: %s", user.Did, err)
+		log.Printf("getting collaborating repos for %s: %s", user.Active.Did, err)
 	}
 
 	allRepos := []pages.PinnedRepo{}

appview/state/reaction.go

···
 )
 
 func (s *State) React(w http.ResponseWriter, r *http.Request) {
-	currentUser := s.oauth.GetUser(r)
+	currentUser := s.oauth.GetMultiAccountUser(r)
 
 	subject := r.URL.Query().Get("subject")
 	if subject == "" {
···
 		rkey := tid.TID()
 		resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.FeedReactionNSID,
-			Repo:       currentUser.Did,
+			Repo:       currentUser.Active.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &tangled.FeedReaction{
···
 			return
 		}
 
-		err = db.AddReaction(s.db, currentUser.Did, subjectUri, reactionKind, rkey)
+		err = db.AddReaction(s.db, currentUser.Active.Did, subjectUri, reactionKind, rkey)
 		if err != nil {
 			log.Println("failed to react", err)
 			return
···
 
 		return
 	case http.MethodDelete:
-		reaction, err := db.GetReaction(s.db, currentUser.Did, subjectUri, reactionKind)
+		reaction, err := db.GetReaction(s.db, currentUser.Active.Did, subjectUri, reactionKind)
 		if err != nil {
-			log.Println("failed to get reaction relationship for", currentUser.Did, subjectUri)
+			log.Println("failed to get reaction relationship for", currentUser.Active.Did, subjectUri)
 			return
 		}
 
 		_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 			Collection: tangled.FeedReactionNSID,
-			Repo:       currentUser.Did,
+			Repo:       currentUser.Active.Did,
 			Rkey:       reaction.Rkey,
 		})
 
···
 			return
 		}
 
-		err = db.DeleteReactionByRkey(s.db, currentUser.Did, reaction.Rkey)
+		err = db.DeleteReactionByRkey(s.db, currentUser.Active.Did, reaction.Rkey)
 		if err != nil {
 			log.Println("failed to delete reaction from DB")
 			// this is not an issue, the firehose event might have already done this

appview/state/star.go

···
 )
 
 func (s *State) Star(w http.ResponseWriter, r *http.Request) {
-	currentUser := s.oauth.GetUser(r)
+	currentUser := s.oauth.GetMultiAccountUser(r)
 
 	subject := r.URL.Query().Get("subject")
 	if subject == "" {
···
 		rkey := tid.TID()
 		resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.FeedStarNSID,
-			Repo:       currentUser.Did,
+			Repo:       currentUser.Active.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &tangled.FeedStar{
···
 		log.Println("created atproto record: ", resp.Uri)
 
 		star := &models.Star{
-			Did:    currentUser.Did,
+			Did:    currentUser.Active.Did,
 			RepoAt: subjectUri,
 			Rkey:   rkey,
 		}
···
 		return
 	case http.MethodDelete:
 		// find the record in the db
-		star, err := db.GetStar(s.db, currentUser.Did, subjectUri)
+		star, err := db.GetStar(s.db, currentUser.Active.Did, subjectUri)
 		if err != nil {
 			log.Println("failed to get star relationship")
 			return
···
 
 		_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 			Collection: tangled.FeedStarNSID,
-			Repo:       currentUser.Did,
+			Repo:       currentUser.Active.Did,
 			Rkey:       star.Rkey,
 		})
 
···
 			return
 		}
 
-		err = db.DeleteStarByRkey(s.db, currentUser.Did, star.Rkey)
+		err = db.DeleteStarByRkey(s.db, currentUser.Active.Did, star.Rkey)
 		if err != nil {
 			log.Println("failed to delete star from DB")
 			// this is not an issue, the firehose event might have already done this

appview/state/state.go

···
 }
 
 func (s *State) TermsOfService(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	s.pages.TermsOfService(w, pages.TermsOfServiceParams{
 		LoggedInUser: user,
 	})
 }
 
 func (s *State) PrivacyPolicy(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	s.pages.PrivacyPolicy(w, pages.PrivacyPolicyParams{
 		LoggedInUser: user,
 	})
 }
 
 func (s *State) Brand(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	s.pages.Brand(w, pages.BrandParams{
 		LoggedInUser: user,
 	})
 }
 
 func (s *State) HomeOrTimeline(w http.ResponseWriter, r *http.Request) {
-	if s.oauth.GetUser(r) != nil {
+	if s.oauth.GetMultiAccountUser(r) != nil {
 		s.Timeline(w, r)
 		return
 	}
···
 }
 
 func (s *State) Timeline(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 
 	// TODO: set this flag based on the UI
 	filtered := false
 
 	var userDid string
-	if user != nil {
-		userDid = user.Did
+	if user != nil && user.Active != nil {
+		userDid = user.Active.Did
 	}
 	timeline, err := db.MakeTimeline(s.db, 50, userDid, filtered)
 	if err != nil {
···
 }
 
 func (s *State) UpgradeBanner(w http.ResponseWriter, r *http.Request) {
-	user := s.oauth.GetUser(r)
+	user := s.oauth.GetMultiAccountUser(r)
 	if user == nil {
 		return
 	}
 
 	l := s.logger.With("handler", "UpgradeBanner")
-	l = l.With("did", user.Did)
+	l = l.With("did", user.Active.Did)
 
 	regs, err := db.GetRegistrations(
 		s.db,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("needs_upgrade", 1),
 	)
 	if err != nil {
···
 
 	spindles, err := db.GetSpindles(
 		s.db,
-		orm.FilterEq("owner", user.Did),
+		orm.FilterEq("owner", user.Active.Did),
 		orm.FilterEq("needs_upgrade", 1),
 	)
 	if err != nil {
···
 func (s *State) NewRepo(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
-		user := s.oauth.GetUser(r)
-		knots, err := s.enforcer.GetKnotsForUser(user.Did)
+		user := s.oauth.GetMultiAccountUser(r)
+		knots, err := s.enforcer.GetKnotsForUser(user.Active.Did)
 		if err != nil {
 			s.pages.Notice(w, "repo", "Invalid user account.")
 			return
···
 	case http.MethodPost:
 		l := s.logger.With("handler", "NewRepo")
 
-		user := s.oauth.GetUser(r)
-		l = l.With("did", user.Did)
+		user := s.oauth.GetMultiAccountUser(r)
+		l = l.With("did", user.Active.Did)
 
 		// form validation
 		domain := r.FormValue("domain")
···
 		description := r.FormValue("description")
 
 		// ACL validation
-		ok, err := s.enforcer.E.Enforce(user.Did, domain, domain, "repo:create")
+		ok, err := s.enforcer.E.Enforce(user.Active.Did, domain, domain, "repo:create")
 		if err != nil || !ok {
 			l.Info("unauthorized")
 			s.pages.Notice(w, "repo", "You do not have permission to create a repo in this knot.")
···
 		// Check for existing repos
 		existingRepo, err := db.GetRepo(
 			s.db,
-			orm.FilterEq("did", user.Did),
+			orm.FilterEq("did", user.Active.Did),
 			orm.FilterEq("name", repoName),
 		)
 		if err == nil && existingRepo != nil {
···
 		// create atproto record for this repo
 		rkey := tid.TID()
 		repo := &models.Repo{
-			Did:         user.Did,
+			Did:         user.Active.Did,
 			Name:        repoName,
 			Knot:        domain,
 			Rkey:        rkey,
···
 
 		atresp, err := comatproto.RepoPutRecord(r.Context(), atpClient, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoNSID,
-			Repo:       user.Did,
+			Repo:       user.Active.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &record,
···
 		}
 
 		// acls
-		p, _ := securejoin.SecureJoin(user.Did, repoName)
-		err = s.enforcer.AddRepo(user.Did, domain, p)
+		p, _ := securejoin.SecureJoin(user.Active.Did, repoName)
+		err = s.enforcer.AddRepo(user.Active.Did, domain, p)
 		if err != nil {
 			l.Error("acl setup failed", "err", err)
 			s.pages.Notice(w, "repo", "Failed to set up repository permissions.")
···
 		aturi = ""
 
 		s.notifier.NewRepo(r.Context(), repo)
-		s.pages.HxLocation(w, fmt.Sprintf("/%s/%s", user.Did, repoName))
+		s.pages.HxLocation(w, fmt.Sprintf("/%s/%s", user.Active.Did, repoName))
 	}
 }
 

appview/strings/strings.go

···
 	}
 
 	s.Pages.StringsTimeline(w, pages.StringTimelineParams{
-		LoggedInUser: s.OAuth.GetUser(r),
+		LoggedInUser: s.OAuth.GetMultiAccountUser(r),
 		Strings:      strings,
 	})
 }
···
 	if err != nil {
 		l.Error("failed to get star count", "err", err)
 	}
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 	isStarred := false
 	if user != nil {
-		isStarred = db.GetStarStatus(s.Db, user.Did, string.AtUri())
+		isStarred = db.GetStarStatus(s.Db, user.Active.Did, string.AtUri())
 	}
 
 	s.Pages.SingleString(w, pages.SingleStringParams{
···
 func (s *Strings) edit(w http.ResponseWriter, r *http.Request) {
 	l := s.Logger.With("handler", "edit")
 
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 
 	id, ok := r.Context().Value("resolvedId").(identity.Identity)
 	if !ok {
···
 	first := all[0]
 
 	// verify that the logged in user owns this string
-	if user.Did != id.DID.String() {
-		l.Error("unauthorized request", "expected", id.DID, "got", user.Did)
+	if user.Active.Did != id.DID.String() {
+		l.Error("unauthorized request", "expected", id.DID, "got", user.Active.Did)
 		w.WriteHeader(http.StatusUnauthorized)
 		return
 	}
···
 	case http.MethodGet:
 		// return the form with prefilled fields
 		s.Pages.PutString(w, pages.PutStringParams{
-			LoggedInUser: s.OAuth.GetUser(r),
+			LoggedInUser: s.OAuth.GetMultiAccountUser(r),
 			Action:       "edit",
 			String:       first,
 		})
···
 		s.Notifier.EditString(r.Context(), &entry)
 
 		// if that went okay, redir to the string
-		s.Pages.HxRedirect(w, "/strings/"+user.Did+"/"+entry.Rkey)
+		s.Pages.HxRedirect(w, "/strings/"+user.Active.Did+"/"+entry.Rkey)
 	}
 
 }
 
 func (s *Strings) create(w http.ResponseWriter, r *http.Request) {
 	l := s.Logger.With("handler", "create")
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 
 	switch r.Method {
 	case http.MethodGet:
 		s.Pages.PutString(w, pages.PutStringParams{
-			LoggedInUser: s.OAuth.GetUser(r),
+			LoggedInUser: s.OAuth.GetMultiAccountUser(r),
 			Action:       "new",
 		})
 	case http.MethodPost:
···
 		description := r.FormValue("description")
 
 		string := models.String{
-			Did:         syntax.DID(user.Did),
+			Did:         syntax.DID(user.Active.Did),
 			Rkey:        tid.TID(),
 			Filename:    filename,
 			Description: description,
···
 
 		resp, err := comatproto.RepoPutRecord(r.Context(), client, &atproto.RepoPutRecord_Input{
 			Collection: tangled.StringNSID,
-			Repo:       user.Did,
+			Repo:       user.Active.Did,
 			Rkey:       string.Rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &record,
···
 		s.Notifier.NewString(r.Context(), &string)
 
 		// successful
-		s.Pages.HxRedirect(w, "/strings/"+user.Did+"/"+string.Rkey)
+		s.Pages.HxRedirect(w, "/strings/"+user.Active.Did+"/"+string.Rkey)
 	}
 }
 
 func (s *Strings) delete(w http.ResponseWriter, r *http.Request) {
 	l := s.Logger.With("handler", "create")
-	user := s.OAuth.GetUser(r)
+	user := s.OAuth.GetMultiAccountUser(r)
 	fail := func(msg string, err error) {
 		l.Error(msg, "err", err)
 		s.Pages.Notice(w, "error", msg)
···
 		return
 	}
 
-	if user.Did != id.DID.String() {
-		fail("You cannot delete this string", fmt.Errorf("unauthorized deletion, %s != %s", user.Did, id.DID.String()))
+	if user.Active.Did != id.DID.String() {
+		fail("You cannot delete this string", fmt.Errorf("unauthorized deletion, %s != %s", user.Active.Did, id.DID.String()))
 		return
 	}
 
 	if err := db.DeleteString(
 		s.Db,
-		orm.FilterEq("did", user.Did),
+		orm.FilterEq("did", user.Active.Did),
 		orm.FilterEq("rkey", rkey),
 	); err != nil {
 		fail("Failed to delete string.", err)
 		return
 	}
 
-	s.Notifier.DeleteString(r.Context(), user.Did, rkey)
+	s.Notifier.DeleteString(r.Context(), user.Active.Did, rkey)
 
-	s.Pages.HxRedirect(w, "/strings/"+user.Did)
+	s.Pages.HxRedirect(w, "/strings/"+user.Active.Did)
 }
 
 func (s *Strings) comment(w http.ResponseWriter, r *http.Request) {