appview: remove `oauth.User` type

This is not required anymore. `MultiAccountUser` can just hold active
user DID.

Signed-off-by: Seongmin Lee <[e-mail]>

appview/issues/issues.go

···
 
 	userReactions := map[models.ReactionKind]bool{}
 	if user != nil {
-		userReactions = db.GetReactionStatusMap(rp.db, user.Active.Did, issue.AtUri())
+		userReactions = db.GetReactionStatusMap(rp.db, user.Did, issue.AtUri())
 	}
 
 	backlinks, err := db.GetBacklinks(rp.db, issue.AtUri())
···
 			return
 		}
 
-		ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueNSID, user.Active.Did, newIssue.Rkey)
+		ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueNSID, user.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.Active.Did,
+			Repo:       user.Did,
 			Rkey:       newIssue.Rkey,
 			SwapRecord: ex.Cid,
 			Record: &lexutil.LexiconTypeDecoder{
···
 		return
 	}
 
-	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
+	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
 	isRepoOwner := roles.IsOwner()
 	isCollaborator := roles.IsCollaborator()
-	isIssueOwner := user.Active.Did == issue.Did
+	isIssueOwner := user.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.Active.Did), issue)
+		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)
 
 		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
···
 		return
 	}
 
-	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
+	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
 	isRepoOwner := roles.IsOwner()
 	isCollaborator := roles.IsCollaborator()
-	isIssueOwner := user.Active.Did == issue.Did
+	isIssueOwner := user.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.Active.Did), issue)
+		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)
 
 		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
···
 	mentions, references := rp.mentionsResolver.Resolve(r.Context(), body)
 
 	comment := models.IssueComment{
-		Did:        user.Active.Did,
+		Did:        user.Did,
 		Rkey:       tid.TID(),
 		IssueAt:    issue.AtUri().String(),
 		ReplyTo:    replyTo,
···
 	}
 	comment := comments[0]
 
-	if comment.Did != user.Active.Did {
-		l.Error("unauthorized comment edit", "expectedDid", comment.Did, "gotDid", user.Active.Did)
+	if comment.Did != user.Did {
+		l.Error("unauthorized comment edit", "expectedDid", comment.Did, "gotDid", user.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.Active.Did, comment.Rkey)
+			ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueCommentNSID, user.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.Active.Did,
+				Repo:       user.Did,
 				Rkey:       newComment.Rkey,
 				SwapRecord: ex.Cid,
 				Record: &lexutil.LexiconTypeDecoder{
···
 	}
 	comment := comments[0]
 
-	if comment.Did != user.Active.Did {
-		l.Error("unauthorized action", "expectedDid", comment.Did, "gotDid", user.Active.Did)
+	if comment.Did != user.Did {
+		l.Error("unauthorized action", "expectedDid", comment.Did, "gotDid", user.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.Active.Did,
+			Repo:       user.Did,
 			Rkey:       comment.Rkey,
 		})
 		if err != nil {
···
 			Title:      r.FormValue("title"),
 			Body:       body,
 			Open:       true,
-			Did:        user.Active.Did,
+			Did:        user.Did,
 			Created:    time.Now(),
 			Mentions:   mentions,
 			References: references,
···
 		}
 		resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoIssueNSID,
-			Repo:       user.Active.Did,
+			Repo:       user.Did,
 			Rkey:       issue.Rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &record,

appview/knots/knots.go

···
 	user := k.OAuth.GetMultiAccountUser(r)
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Active.Did),
+		orm.FilterEq("did", user.Did),
 	)
 	if err != nil {
 		k.Logger.Error("failed to fetch knot registrations", "err", err)
···
 	l := k.Logger.With("handler", "dashboard")
 
 	user := k.OAuth.GetMultiAccountUser(r)
-	l = l.With("user", user.Active.Did)
+	l = l.With("user", user.Did)
 
 	domain := chi.URLParam(r, "domain")
 	if domain == "" {
···
 
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Active.Did),
+		orm.FilterEq("did", user.Did),
 		orm.FilterEq("domain", domain),
 	)
 	if err != nil {
···
 		return
 	}
 	l = l.With("domain", domain)
-	l = l.With("user", user.Active.Did)
+	l = l.With("user", user.Did)
 
 	tx, err := k.Db.Begin()
 	if err != nil {
···
 		k.Enforcer.E.LoadPolicy()
 	}()
 
-	err = db.AddKnot(tx, domain, user.Active.Did)
+	err = db.AddKnot(tx, domain, user.Did)
 	if err != nil {
 		l.Error("failed to insert", "err", err)
 		fail()
···
 		return
 	}
 
-	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.KnotNSID, user.Active.Did, domain)
+	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.KnotNSID, user.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.Active.Did,
+		Repo:       user.Did,
 		Rkey:       domain,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.Knot{
···
 	}
 
 	// begin verification
-	err = serververify.RunVerification(r.Context(), domain, user.Active.Did, k.Config.Core.Dev)
+	err = serververify.RunVerification(r.Context(), domain, user.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.Active.Did)
+	err = serververify.MarkKnotVerified(k.Db, k.Enforcer, domain, user.Did)
 	if err != nil {
 		l.Error("failed to mark verified", "err", err)
 		k.Pages.HxRefresh(w)
···
 	// get record from db first
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Active.Did),
+		orm.FilterEq("did", user.Did),
 		orm.FilterEq("domain", domain),
 	)
 	if err != nil {
···
 
 	err = db.DeleteKnot(
 		tx,
-		orm.FilterEq("did", user.Active.Did),
+		orm.FilterEq("did", user.Did),
 		orm.FilterEq("domain", domain),
 	)
 	if err != nil {
···
 
 	_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 		Collection: tangled.KnotNSID,
-		Repo:       user.Active.Did,
+		Repo:       user.Did,
 		Rkey:       domain,
 	})
 	if err != nil {
···
 		return
 	}
 	l = l.With("domain", domain)
-	l = l.With("user", user.Active.Did)
+	l = l.With("user", user.Did)
 
 	// get record from db first
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Active.Did),
+		orm.FilterEq("did", user.Did),
 		orm.FilterEq("domain", domain),
 	)
 	if err != nil {
···
 	registration := registrations[0]
 
 	// begin verification
-	err = serververify.RunVerification(r.Context(), domain, user.Active.Did, k.Config.Core.Dev)
+	err = serververify.RunVerification(r.Context(), domain, user.Did, k.Config.Core.Dev)
 	if err != nil {
 		l.Error("verification failed", "err", err)
 
···
 		return
 	}
 
-	err = serververify.MarkKnotVerified(k.Db, k.Enforcer, domain, user.Active.Did)
+	err = serververify.MarkKnotVerified(k.Db, k.Enforcer, domain, user.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.Active.Did, domain)
+		ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.KnotNSID, user.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.Active.Did,
+			Repo:       user.Did,
 			Rkey:       domain,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &tangled.Knot{
···
 	// Get updated registration to show
 	registrations, err = db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Active.Did),
+		orm.FilterEq("did", user.Did),
 		orm.FilterEq("domain", domain),
 	)
 	if err != nil {
···
 		return
 	}
 	l = l.With("domain", domain)
-	l = l.With("user", user.Active.Did)
+	l = l.With("user", user.Did)
 
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Active.Did),
+		orm.FilterEq("did", user.Did),
 		orm.FilterEq("domain", domain),
 		orm.FilterIsNot("registered", "null"),
 	)
···
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.KnotMemberNSID,
-		Repo:       user.Active.Did,
+		Repo:       user.Did,
 		Rkey:       rkey,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.KnotMember{
···
 		return
 	}
 	l = l.With("domain", domain)
-	l = l.With("user", user.Active.Did)
+	l = l.With("user", user.Did)
 
 	registrations, err := db.GetRegistrations(
 		k.Db,
-		orm.FilterEq("did", user.Active.Did),
+		orm.FilterEq("did", user.Did),
 		orm.FilterEq("domain", domain),
 		orm.FilterIsNot("registered", "null"),
 	)

appview/labels/labels.go

···
 		return
 	}
 
-	did := user.Active.Did
+	did := user.Did
 	rkey := tid.TID()
 	performedAt := time.Now()
 	indexedAt := time.Now()

appview/middleware/middleware.go

···
 				return
 			}
 
-			ok, err := mw.enforcer.E.HasGroupingPolicy(actor.Active.Did, group, domain)
+			ok, err := mw.enforcer.E.HasGroupingPolicy(actor.Did, group, domain)
 			if err != nil || !ok {
-				log.Printf("%s does not have perms of a %s in domain %s", actor.Active.Did, group, domain)
+				log.Printf("%s does not have perms of a %s in domain %s", actor.Did, group, domain)
 				http.Error(w, "Forbiden", http.StatusUnauthorized)
 				return
 			}
···
 				return
 			}
 
-			ok, err := mw.enforcer.E.Enforce(actor.Active.Did, f.Knot, f.DidSlashRepo(), requiredPerm)
+			ok, err := mw.enforcer.E.Enforce(actor.Did, f.Knot, f.DidSlashRepo(), requiredPerm)
 			if err != nil || !ok {
-				log.Printf("%s does not have perms of a %s in repo %s", actor.Active.Did, requiredPerm, f.DidSlashRepo())
+				log.Printf("%s does not have perms of a %s in repo %s", actor.Did, requiredPerm, f.DidSlashRepo())
 				http.Error(w, "Forbiden", http.StatusUnauthorized)
 				return
 			}

appview/notifications/notifications.go

···
 
 	total, err := db.CountNotifications(
 		n.db,
-		orm.FilterEq("recipient_did", user.Active.Did),
+		orm.FilterEq("recipient_did", user.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.Active.Did),
+		orm.FilterEq("recipient_did", user.Did),
 	)
 	if err != nil {
 		l.Error("failed to get notifications", "err", err)
···
 		return
 	}
 
-	err = db.MarkAllNotificationsRead(n.db, user.Active.Did)
+	err = db.MarkAllNotificationsRead(n.db, user.Did)
 	if err != nil {
 		l.Error("failed to mark notifications as read", "err", err)
 	}
···
 
 	count, err := db.CountNotifications(
 		n.db,
-		orm.FilterEq("recipient_did", user.Active.Did),
+		orm.FilterEq("recipient_did", user.Did),
 		orm.FilterEq("read", 0),
 	)
 	if err != nil {

appview/oauth/accounts.go

···
 }
 
 type MultiAccountUser struct {
-	Active   User
+	Did      string
 	Accounts []AccountInfo
-}
-
-func (m *MultiAccountUser) Did() string {
-	return m.Active.Did
 }
 
 func (o *OAuth) GetAccounts(r *http.Request) *AccountRegistry {
···
 
 	registry := o.GetAccounts(r)
 	return &MultiAccountUser{
-		Active: User{
-			Did: sess.Data.AccountDID.String(),
-		},
+		Did:      sess.Data.AccountDID.String(),
 		Accounts: registry.Accounts,
 	}
 }

appview/oauth/oauth.go

···
 	return o.saveAccounts(w, r, registry)
 }
 
-type User struct {
-	Did string
-}
-
 func (o *OAuth) GetDid(r *http.Request) string {
 	if u := o.GetMultiAccountUser(r); u != nil {
-		return u.Did()
+		return u.Did
 	}
 
 	return ""

appview/pulls/pulls.go

···
 		mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
 		branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
 		resubmitResult := pages.Unknown
-		if user.Active.Did == pull.OwnerDid {
+		if user.Did == pull.OwnerDid {
 			resubmitResult = s.resubmitCheck(r, f, pull, stack)
 		}
 
···
 	mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
 	branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
 	resubmitResult := pages.Unknown
-	if user != nil && user.Active.Did == pull.OwnerDid {
+	if user != nil && user.Did == pull.OwnerDid {
 		resubmitResult = s.resubmitCheck(r, f, pull, stack)
 	}
 
···
 
 	userReactions := map[models.ReactionKind]bool{}
 	if user != nil {
-		userReactions = db.GetReactionStatusMap(s.db, user.Active.Did, pull.AtUri())
+		userReactions = db.GetReactionStatusMap(s.db, user.Did, pull.AtUri())
 	}
 
 	labelDefs, err := db.GetLabelDefinitions(
···
 	}
 
 	// user can only delete branch if they are a collaborator in the repo that the branch belongs to
-	perms := s.enforcer.GetPermissionsInRepo(user.Active.Did, repo.Knot, repo.DidSlashRepo())
+	perms := s.enforcer.GetPermissionsInRepo(user.Did, repo.Knot, repo.DidSlashRepo())
 	if !slices.Contains(perms, "repo:push") {
 		return nil
 	}
···
 		}
 		atResp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoPullCommentNSID,
-			Repo:       user.Active.Did,
+			Repo:       user.Did,
 			Rkey:       tid.TID(),
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &tangled.RepoPullComment{
···
 		}
 
 		comment := &models.PullComment{
-			OwnerDid:     user.Active.Did,
+			OwnerDid:     user.Did,
 			RepoAt:       f.RepoAt().String(),
 			PullId:       pull.PullId,
 			Body:         body,
···
 		fromFork := r.FormValue("fork")
 		sourceBranch := r.FormValue("sourceBranch")
 		patch := r.FormValue("patch")
-		userDid := syntax.DID(user.Active.Did)
+		userDid := syntax.DID(user.Did)
 
 		if targetBranch == "" {
 			s.pages.Notice(w, "pull", "Target branch is required.")
···
 func (s *Pulls) CompareForksFragment(w http.ResponseWriter, r *http.Request) {
 	user := s.oauth.GetMultiAccountUser(r)
 
-	forks, err := db.GetForksByDid(s.db, user.Active.Did)
+	forks, err := db.GetForksByDid(s.db, user.Did)
 	if err != nil {
 		log.Println("failed to get forks", err)
 		return
···
 		return
 	}
 
-	if user == nil || user.Active.Did != pull.OwnerDid {
+	if user == nil || user.Did != pull.OwnerDid {
 		log.Println("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
 		return
···
 
 	patch := r.FormValue("patch")
 
-	s.resubmitPullHelper(w, r, f, syntax.DID(user.Active.Did), pull, patch, "", "")
+	s.resubmitPullHelper(w, r, f, syntax.DID(user.Did), pull, patch, "", "")
 }
 
 func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {
···
 		return
 	}
 
-	if user == nil || user.Active.Did != pull.OwnerDid {
+	if user == nil || user.Did != pull.OwnerDid {
 		log.Println("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
 		return
···
 		return
 	}
 
-	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
+	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
 	if !roles.IsPushAllowed() {
 		log.Println("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
···
 	patch := comparison.FormatPatchRaw
 	combined := comparison.CombinedPatchRaw
 
-	s.resubmitPullHelper(w, r, f, syntax.DID(user.Active.Did), pull, patch, combined, sourceRev)
+	s.resubmitPullHelper(w, r, f, syntax.DID(user.Did), pull, patch, combined, sourceRev)
 }
 
 func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {
···
 		return
 	}
 
-	if user == nil || user.Active.Did != pull.OwnerDid {
+	if user == nil || user.Did != pull.OwnerDid {
 		log.Println("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
 		return
···
 	patch := comparison.FormatPatchRaw
 	combined := comparison.CombinedPatchRaw
 
-	s.resubmitPullHelper(w, r, f, syntax.DID(user.Active.Did), pull, patch, combined, sourceRev)
+	s.resubmitPullHelper(w, r, f, syntax.DID(user.Did), pull, patch, combined, sourceRev)
 }
 
 func (s *Pulls) resubmitPullHelper(
···
 
 	// notify about the pull merge
 	for _, p := range pullsToMerge {
-		s.notifier.NewPullState(r.Context(), syntax.DID(user.Active.Did), p)
+		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
 	}
 
 	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
···
 	}
 
 	// auth filter: only owner or collaborators can close
-	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
+	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
 	isOwner := roles.IsOwner()
 	isCollaborator := roles.IsCollaborator()
-	isPullAuthor := user.Active.Did == pull.OwnerDid
+	isPullAuthor := user.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.Active.Did), p)
+		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
 	}
 
 	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
···
 	}
 
 	// auth filter: only owner or collaborators can close
-	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
+	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
 	isOwner := roles.IsOwner()
 	isCollaborator := roles.IsCollaborator()
-	isPullAuthor := user.Active.Did == pull.OwnerDid
+	isPullAuthor := user.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.Active.Did), p)
+		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
 	}
 
 	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

appview/repo/artifact.go

···
 
 	putRecordResp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.RepoArtifactNSID,
-		Repo:       user.Active.Did,
+		Repo:       user.Did,
 		Rkey:       rkey,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.RepoArtifact{
···
 	defer tx.Rollback()
 
 	artifact := models.Artifact{
-		Did:       user.Active.Did,
+		Did:       user.Did,
 		Rkey:      rkey,
 		RepoAt:    f.RepoAt(),
 		Tag:       tag.Tag.Hash,
···
 
 	artifact := artifacts[0]
 
-	if user.Active.Did != artifact.Did {
+	if user.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.Active.Did,
+		Repo:       user.Did,
 		Rkey:       artifact.Rkey,
 	})
 	if err != nil {

appview/repo/repo.go

···
 func (rp *Repo) EditSpindle(w http.ResponseWriter, r *http.Request) {
 	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "EditSpindle")
-	l = l.With("did", user.Active.Did)
+	l = l.With("did", user.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.Active.Did)
+		validSpindles, err := rp.enforcer.GetSpindlesForUser(user.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.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "AddLabel")
-	l = l.With("did", user.Active.Did)
+	l = l.With("did", user.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 	}
 
 	label := models.LabelDefinition{
-		Did:       user.Active.Did,
+		Did:       user.Did,
 		Rkey:      tid.TID(),
 		Name:      name,
 		ValueType: valueType,
···
 func (rp *Repo) DeleteLabelDef(w http.ResponseWriter, r *http.Request) {
 	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "DeleteLabel")
-	l = l.With("did", user.Active.Did)
+	l = l.With("did", user.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 func (rp *Repo) SubscribeLabel(w http.ResponseWriter, r *http.Request) {
 	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "SubscribeLabel")
-	l = l.With("did", user.Active.Did)
+	l = l.With("did", user.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 func (rp *Repo) UnsubscribeLabel(w http.ResponseWriter, r *http.Request) {
 	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "UnsubscribeLabel")
-	l = l.With("did", user.Active.Did)
+	l = l.With("did", user.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 func (rp *Repo) AddCollaborator(w http.ResponseWriter, r *http.Request) {
 	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "AddCollaborator")
-	l = l.With("did", user.Active.Did)
+	l = l.With("did", user.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
···
 		return
 	}
 
-	if collaboratorIdent.DID.String() == user.Active.Did {
+	if collaboratorIdent.DID.String() == user.Did {
 		fail("You seem to be adding yourself as a collaborator.", nil)
 		return
 	}
···
 	createdAt := time.Now()
 	resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.RepoCollaboratorNSID,
-		Repo:       currentUser.Active.Did,
+		Repo:       currentUser.Did,
 		Rkey:       rkey,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.RepoCollaborator{
···
 	}
 
 	err = db.AddCollaborator(tx, models.Collaborator{
-		Did:        syntax.DID(currentUser.Active.Did),
+		Did:        syntax.DID(currentUser.Did),
 		Rkey:       rkey,
 		SubjectDid: collaboratorIdent.DID,
 		RepoAt:     f.RepoAt(),
···
 	}
 	_, err = comatproto.RepoDeleteRecord(r.Context(), atpClient, &comatproto.RepoDeleteRecord_Input{
 		Collection: tangled.RepoNSID,
-		Repo:       user.Active.Did,
+		Repo:       user.Did,
 		Rkey:       f.Rkey,
 	})
 	if err != nil {
···
 			r.Context(),
 			client,
 			&tangled.RepoForkSync_Input{
-				Did:    user.Active.Did,
+				Did:    user.Did,
 				Name:   f.Name,
 				Source: f.Source,
 				Branch: ref,
···
 	switch r.Method {
 	case http.MethodGet:
 		user := rp.oauth.GetMultiAccountUser(r)
-		knots, err := rp.enforcer.GetKnotsForUser(user.Active.Did)
+		knots, err := rp.enforcer.GetKnotsForUser(user.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.Active.Did, targetKnot, targetKnot, "repo:create")
+		ok, err := rp.enforcer.E.Enforce(user.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.Active.Did),
+			orm.FilterEq("did", user.Did),
 			orm.FilterEq("name", forkName),
 		)
 		if err != nil {
···
 		// create an atproto record for this fork
 		rkey := tid.TID()
 		repo := &models.Repo{
-			Did:         user.Active.Did,
+			Did:         user.Did,
 			Name:        forkName,
 			Knot:        targetKnot,
 			Rkey:        rkey,
···
 
 		atresp, err := comatproto.RepoPutRecord(r.Context(), atpClient, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoNSID,
-			Repo:       user.Active.Did,
+			Repo:       user.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &record,
···
 		}
 
 		// acls
-		p, _ := securejoin.SecureJoin(user.Active.Did, forkName)
-		err = rp.enforcer.AddRepo(user.Active.Did, targetKnot, p)
+		p, _ := securejoin.SecureJoin(user.Did, forkName)
+		err = rp.enforcer.AddRepo(user.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.Active.Did, forkName))
+		rp.pages.HxLocation(w, fmt.Sprintf("/%s/%s", user.Did, forkName))
 	}
 }
 

appview/repo/settings.go

···
 func (rp *Repo) Secrets(w http.ResponseWriter, r *http.Request) {
 	user := rp.oauth.GetMultiAccountUser(r)
 	l := rp.logger.With("handler", "Secrets")
-	l = l.With("did", user.Active.Did)
+	l = l.With("did", user.Did)
 
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {

appview/reporesolver/resolver.go

···
 	isStarred := false
 	roles := repoinfo.RolesInRepo{}
 	if user != nil {
-		isStarred = db.GetStarStatus(rr.execer, user.Active.Did, repoAt)
-		roles.Roles = rr.enforcer.GetPermissionsInRepo(user.Active.Did, repo.Knot, repo.DidSlashRepo())
+		isStarred = db.GetStarStatus(rr.execer, user.Did, repoAt)
+		roles.Roles = rr.enforcer.GetPermissionsInRepo(user.Did, repo.Knot, repo.DidSlashRepo())
 	}
 
 	stats := repo.RepoStats

appview/settings/settings.go

···
 
 func (s *Settings) keysSettings(w http.ResponseWriter, r *http.Request) {
 	user := s.OAuth.GetMultiAccountUser(r)
-	pubKeys, err := db.GetPublicKeysForDid(s.Db, user.Active.Did)
+	pubKeys, err := db.GetPublicKeysForDid(s.Db, user.Did)
 	if err != nil {
 		log.Println(err)
 	}
···
 
 func (s *Settings) emailsSettings(w http.ResponseWriter, r *http.Request) {
 	user := s.OAuth.GetMultiAccountUser(r)
-	emails, err := db.GetAllEmails(s.Db, user.Active.Did)
+	emails, err := db.GetAllEmails(s.Db, user.Did)
 	if err != nil {
 		log.Println(err)
 	}

appview/spindles/spindles.go

···
 	user := s.OAuth.GetMultiAccountUser(r)
 	all, err := db.GetSpindles(
 		s.Db,
-		orm.FilterEq("owner", user.Active.Did),
+		orm.FilterEq("owner", user.Did),
 	)
 	if err != nil {
 		s.Logger.Error("failed to fetch spindles", "err", err)
···
 	l := s.Logger.With("handler", "dashboard")
 
 	user := s.OAuth.GetMultiAccountUser(r)
-	l = l.With("user", user.Active.Did)
+	l = l.With("user", user.Did)
 
 	instance := chi.URLParam(r, "instance")
 	if instance == "" {
···
 	spindles, err := db.GetSpindles(
 		s.Db,
 		orm.FilterEq("instance", instance),
-		orm.FilterEq("owner", user.Active.Did),
+		orm.FilterEq("owner", user.Did),
 		orm.FilterIsNot("verified", "null"),
 	)
 	if err != nil || len(spindles) != 1 {
···
 		return
 	}
 	l = l.With("instance", instance)
-	l = l.With("user", user.Active.Did)
+	l = l.With("user", user.Did)
 
 	tx, err := s.Db.Begin()
 	if err != nil {
···
 	}()
 
 	err = db.AddSpindle(tx, models.Spindle{
-		Owner:    syntax.DID(user.Active.Did),
+		Owner:    syntax.DID(user.Did),
 		Instance: instance,
 	})
 	if err != nil {
···
 		return
 	}
 
-	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.SpindleNSID, user.Active.Did, instance)
+	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.SpindleNSID, user.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.Active.Did,
+		Repo:       user.Did,
 		Rkey:       instance,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.Spindle{
···
 	}
 
 	// begin verification
-	err = serververify.RunVerification(r.Context(), instance, user.Active.Did, s.Config.Core.Dev)
+	err = serververify.RunVerification(r.Context(), instance, user.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.Active.Did)
+	_, err = serververify.MarkSpindleVerified(s.Db, s.Enforcer, instance, user.Did)
 	if err != nil {
 		l.Error("failed to mark verified", "err", err)
 		s.Pages.HxRefresh(w)
···
 
 	spindles, err := db.GetSpindles(
 		s.Db,
-		orm.FilterEq("owner", user.Active.Did),
+		orm.FilterEq("owner", user.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil || len(spindles) != 1 {
···
 		return
 	}
 
-	if string(spindles[0].Owner) != user.Active.Did {
-		l.Error("unauthorized", "user", user.Active.Did, "owner", spindles[0].Owner)
+	if string(spindles[0].Owner) != user.Did {
+		l.Error("unauthorized", "user", user.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.Active.Did),
+		orm.FilterEq("did", user.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil {
···
 
 	err = db.DeleteSpindle(
 		tx,
-		orm.FilterEq("owner", user.Active.Did),
+		orm.FilterEq("owner", user.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil {
···
 
 	_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 		Collection: tangled.SpindleNSID,
-		Repo:       user.Active.Did,
+		Repo:       user.Did,
 		Rkey:       instance,
 	})
 	if err != nil {
···
 		return
 	}
 	l = l.With("instance", instance)
-	l = l.With("user", user.Active.Did)
+	l = l.With("user", user.Did)
 
 	spindles, err := db.GetSpindles(
 		s.Db,
-		orm.FilterEq("owner", user.Active.Did),
+		orm.FilterEq("owner", user.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil || len(spindles) != 1 {
···
 		return
 	}
 
-	if string(spindles[0].Owner) != user.Active.Did {
-		l.Error("unauthorized", "user", user.Active.Did, "owner", spindles[0].Owner)
+	if string(spindles[0].Owner) != user.Did {
+		l.Error("unauthorized", "user", user.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.Active.Did, s.Config.Core.Dev)
+	err = serververify.RunVerification(r.Context(), instance, user.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.Active.Did)
+	rowId, err := serververify.MarkSpindleVerified(s.Db, s.Enforcer, instance, user.Did)
 	if err != nil {
 		l.Error("failed to mark verified", "err", err)
 		s.Pages.Notice(w, noticeId, err.Error())
···
 		return
 	}
 	l = l.With("instance", instance)
-	l = l.With("user", user.Active.Did)
+	l = l.With("user", user.Did)
 
 	spindles, err := db.GetSpindles(
 		s.Db,
-		orm.FilterEq("owner", user.Active.Did),
+		orm.FilterEq("owner", user.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil || len(spindles) != 1 {
···
 		s.Pages.Notice(w, noticeId, defaultErr)
 	}
 
-	if string(spindles[0].Owner) != user.Active.Did {
-		l.Error("unauthorized", "user", user.Active.Did, "owner", spindles[0].Owner)
+	if string(spindles[0].Owner) != user.Did {
+		l.Error("unauthorized", "user", user.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.Active.Did),
+		Did:      syntax.DID(user.Did),
 		Rkey:     rkey,
 		Instance: instance,
 		Subject:  memberId.DID,
···
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.SpindleMemberNSID,
-		Repo:       user.Active.Did,
+		Repo:       user.Did,
 		Rkey:       rkey,
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.SpindleMember{
···
 		return
 	}
 	l = l.With("instance", instance)
-	l = l.With("user", user.Active.Did)
+	l = l.With("user", user.Did)
 
 	spindles, err := db.GetSpindles(
 		s.Db,
-		orm.FilterEq("owner", user.Active.Did),
+		orm.FilterEq("owner", user.Did),
 		orm.FilterEq("instance", instance),
 	)
 	if err != nil || len(spindles) != 1 {
···
 		return
 	}
 
-	if string(spindles[0].Owner) != user.Active.Did {
-		l.Error("unauthorized", "user", user.Active.Did, "owner", spindles[0].Owner)
+	if string(spindles[0].Owner) != user.Did {
+		l.Error("unauthorized", "user", user.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.Active.Did),
+		orm.FilterEq("did", user.Did),
 		orm.FilterEq("instance", instance),
 		orm.FilterEq("subject", memberId.DID),
 	)
···
 	// remove from db
 	if err = db.RemoveSpindleMember(
 		tx,
-		orm.FilterEq("did", user.Active.Did),
+		orm.FilterEq("did", user.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.Active.Did,
+		Repo:       user.Did,
 		Rkey:       members[0].Rkey,
 	})
 	if err != nil {

appview/state/accounts.go

···
 	}
 
 	currentUser := s.oauth.GetMultiAccountUser(r)
-	isCurrentAccount := currentUser != nil && currentUser.Active.Did == did
+	isCurrentAccount := currentUser != nil && currentUser.Did == did
 
 	var remainingAccounts []string
 	if currentUser != nil {

appview/state/follow.go

···
 		return
 	}
 
-	if currentUser.Active.Did == subjectIdent.DID.String() {
+	if currentUser.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.Active.Did,
+			Repo:       currentUser.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &tangled.GraphFollow{
···
 		log.Println("created atproto record: ", resp.Uri)
 
 		follow := &models.Follow{
-			UserDid:    currentUser.Active.Did,
+			UserDid:    currentUser.Did,
 			SubjectDid: subjectIdent.DID.String(),
 			Rkey:       rkey,
 		}
···
 		return
 	case http.MethodDelete:
 		// find the record in the db
-		follow, err := db.GetFollow(s.db, currentUser.Active.Did, subjectIdent.DID.String())
+		follow, err := db.GetFollow(s.db, currentUser.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.Active.Did,
+			Repo:       currentUser.Did,
 			Rkey:       follow.Rkey,
 		})
 
···
 			return
 		}
 
-		err = db.DeleteFollowByRkey(s.db, currentUser.Active.Did, follow.Rkey)
+		err = db.DeleteFollowByRkey(s.db, currentUser.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/login.go

···
 		return
 	}
 
-	currentDid := currentUser.Active.Did
+	currentDid := currentUser.Did
 
 	var remainingAccounts []string
 	for _, acc := range currentUser.Accounts {

appview/state/profile.go

···
 	loggedInUser := s.oauth.GetMultiAccountUser(r)
 	followStatus := models.IsNotFollowing
 	if loggedInUser != nil {
-		followStatus = db.GetFollowStatus(s.db, loggedInUser.Active.Did, did)
+		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)
 	}
 
 	now := time.Now()
···
 
 	loggedInUserFollowing := make(map[string]struct{})
 	if loggedInUser != nil {
-		following, err := db.GetFollowing(s.db, loggedInUser.Active.Did)
+		following, err := db.GetFollowing(s.db, loggedInUser.Did)
 		if err != nil {
-			l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.Active.Did)
+			l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.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.Active.Did == did {
+		} else if loggedInUser != nil && loggedInUser.Did == did {
 			followStatus = models.IsSelf
 		}
 
···
 		return
 	}
 
-	profile, err := db.GetProfile(s.db, user.Active.Did)
+	profile, err := db.GetProfile(s.db, user.Did)
 	if err != nil {
-		log.Printf("getting profile data for %s: %s", user.Active.Did, err)
+		log.Printf("getting profile data for %s: %s", user.Did, err)
 	}
 
 	profile.Description = r.FormValue("description")
···
 		return
 	}
 
-	profile, err := db.GetProfile(s.db, user.Active.Did)
+	profile, err := db.GetProfile(s.db, user.Did)
 	if err != nil {
-		log.Printf("getting profile data for %s: %s", user.Active.Did, err)
+		log.Printf("getting profile data for %s: %s", user.Did, err)
 	}
 
 	i := 0
···
 		vanityStats = append(vanityStats, string(v.Kind))
 	}
 
-	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Active.Did, "self")
+	ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.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.Active.Did,
+		Repo:       user.Did,
 		Rkey:       "self",
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.ActorProfile{
···
 
 	s.notifier.UpdateProfile(r.Context(), profile)
 
-	s.pages.HxRedirect(w, "/"+user.Active.Did)
+	s.pages.HxRedirect(w, "/"+user.Did)
 }
 
 func (s *State) EditBioFragment(w http.ResponseWriter, r *http.Request) {
 	user := s.oauth.GetMultiAccountUser(r)
 
-	profile, err := db.GetProfile(s.db, user.Active.Did)
+	profile, err := db.GetProfile(s.db, user.Did)
 	if err != nil {
-		log.Printf("getting profile data for %s: %s", user.Active.Did, err)
+		log.Printf("getting profile data for %s: %s", user.Did, err)
 	}
 
 	s.pages.EditBioFragment(w, pages.EditBioParams{
···
 func (s *State) EditPinsFragment(w http.ResponseWriter, r *http.Request) {
 	user := s.oauth.GetMultiAccountUser(r)
 
-	profile, err := db.GetProfile(s.db, user.Active.Did)
+	profile, err := db.GetProfile(s.db, user.Did)
 	if err != nil {
-		log.Printf("getting profile data for %s: %s", user.Active.Did, err)
+		log.Printf("getting profile data for %s: %s", user.Did, err)
 	}
 
-	repos, err := db.GetRepos(s.db, 0, orm.FilterEq("did", user.Active.Did))
+	repos, err := db.GetRepos(s.db, 0, orm.FilterEq("did", user.Did))
 	if err != nil {
-		log.Printf("getting repos for %s: %s", user.Active.Did, err)
+		log.Printf("getting repos for %s: %s", user.Did, err)
 	}
 
-	collaboratingRepos, err := db.CollaboratingIn(s.db, user.Active.Did)
+	collaboratingRepos, err := db.CollaboratingIn(s.db, user.Did)
 	if err != nil {
-		log.Printf("getting collaborating repos for %s: %s", user.Active.Did, err)
+		log.Printf("getting collaborating repos for %s: %s", user.Did, err)
 	}
 
 	allRepos := []pages.PinnedRepo{}
···
 func (s *State) UploadProfileAvatar(w http.ResponseWriter, r *http.Request) {
 	l := s.logger.With("handler", "UploadProfileAvatar")
 	user := s.oauth.GetMultiAccountUser(r)
-	l = l.With("did", user.Active.Did)
+	l = l.With("did", user.Did)
 
 	// Parse multipart form (10MB max)
 	if err := r.ParseMultipartForm(10 << 20); err != nil {
···
 	l.Info("uploaded avatar blob", "cid", uploadBlobResp.Blob.Ref.String())
 
 	// get current profile record from PDS to get its CID for swap
-	getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Active.Did, "self")
+	getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
 	if err != nil {
 		l.Error("failed to get current profile record", "err", err)
 		s.pages.Notice(w, "avatar-error", "Failed to get current profile from your PDS")
···
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.ActorProfileNSID,
-		Repo:       user.Active.Did,
+		Repo:       user.Did,
 		Rkey:       "self",
 		Record:     &lexutil.LexiconTypeDecoder{Val: profileRecord},
 		SwapRecord: getRecordResp.Cid,
···
 
 	l.Info("successfully updated profile with avatar")
 
-	profile, err := db.GetProfile(s.db, user.Active.Did)
+	profile, err := db.GetProfile(s.db, user.Did)
 	if err != nil {
 		l.Warn("getting profile data from DB", "err", err)
-		profile = &models.Profile{Did: user.Active.Did}
+		profile = &models.Profile{Did: user.Did}
 	}
 	profile.Avatar = uploadBlobResp.Blob.Ref.String()
 
···
 func (s *State) RemoveProfileAvatar(w http.ResponseWriter, r *http.Request) {
 	l := s.logger.With("handler", "RemoveProfileAvatar")
 	user := s.oauth.GetMultiAccountUser(r)
-	l = l.With("did", user.Active.Did)
+	l = l.With("did", user.Did)
 
 	client, err := s.oauth.AuthorizedClient(r)
 	if err != nil {
···
 		return
 	}
 
-	getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Active.Did, "self")
+	getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
 	if err != nil {
 		l.Error("failed to get current profile record", "err", err)
 		s.pages.Notice(w, "avatar-error", "Failed to get current profile from your PDS")
···
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 		Collection: tangled.ActorProfileNSID,
-		Repo:       user.Active.Did,
+		Repo:       user.Did,
 		Rkey:       "self",
 		Record:     &lexutil.LexiconTypeDecoder{Val: profileRecord},
 		SwapRecord: getRecordResp.Cid,
···
 
 	l.Info("successfully removed avatar from PDS")
 
-	profile, err := db.GetProfile(s.db, user.Active.Did)
+	profile, err := db.GetProfile(s.db, user.Did)
 	if err != nil {
 		l.Warn("getting profile data from DB", "err", err)
-		profile = &models.Profile{Did: user.Active.Did}
+		profile = &models.Profile{Did: user.Did}
 	}
 	profile.Avatar = ""
 

appview/state/reaction.go

···
 		rkey := tid.TID()
 		resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.FeedReactionNSID,
-			Repo:       currentUser.Active.Did,
+			Repo:       currentUser.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &tangled.FeedReaction{
···
 			return
 		}
 
-		err = db.AddReaction(s.db, currentUser.Active.Did, subjectUri, reactionKind, rkey)
+		err = db.AddReaction(s.db, currentUser.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.Active.Did, subjectUri, reactionKind)
+		reaction, err := db.GetReaction(s.db, currentUser.Did, subjectUri, reactionKind)
 		if err != nil {
-			log.Println("failed to get reaction relationship for", currentUser.Active.Did, subjectUri)
+			log.Println("failed to get reaction relationship for", currentUser.Did, subjectUri)
 			return
 		}
 
 		_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
 			Collection: tangled.FeedReactionNSID,
-			Repo:       currentUser.Active.Did,
+			Repo:       currentUser.Did,
 			Rkey:       reaction.Rkey,
 		})
 
···
 			return
 		}
 
-		err = db.DeleteReactionByRkey(s.db, currentUser.Active.Did, reaction.Rkey)
+		err = db.DeleteReactionByRkey(s.db, currentUser.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

···
 		rkey := tid.TID()
 		resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.FeedStarNSID,
-			Repo:       currentUser.Active.Did,
+			Repo:       currentUser.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &tangled.FeedStar{
···
 		log.Println("created atproto record: ", resp.Uri)
 
 		star := &models.Star{
-			Did:    currentUser.Active.Did,
+			Did:    currentUser.Did,
 			RepoAt: subjectUri,
 			Rkey:   rkey,
 		}
···
 		return
 	case http.MethodDelete:
 		// find the record in the db
-		star, err := db.GetStar(s.db, currentUser.Active.Did, subjectUri)
+		star, err := db.GetStar(s.db, currentUser.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.Active.Did,
+			Repo:       currentUser.Did,
 			Rkey:       star.Rkey,
 		})
 
···
 			return
 		}
 
-		err = db.DeleteStarByRkey(s.db, currentUser.Active.Did, star.Rkey)
+		err = db.DeleteStarByRkey(s.db, currentUser.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

···
 
 	var userDid string
 	if user != nil {
-		userDid = user.Active.Did
+		userDid = user.Did
 	}
 	timeline, err := db.MakeTimeline(s.db, 50, userDid, filtered)
 	if err != nil {
···
 	}
 
 	l := s.logger.With("handler", "UpgradeBanner")
-	l = l.With("did", user.Active.Did)
+	l = l.With("did", user.Did)
 
 	regs, err := db.GetRegistrations(
 		s.db,
-		orm.FilterEq("did", user.Active.Did),
+		orm.FilterEq("did", user.Did),
 		orm.FilterEq("needs_upgrade", 1),
 	)
 	if err != nil {
···
 
 	spindles, err := db.GetSpindles(
 		s.db,
-		orm.FilterEq("owner", user.Active.Did),
+		orm.FilterEq("owner", user.Did),
 		orm.FilterEq("needs_upgrade", 1),
 	)
 	if err != nil {
···
 	switch r.Method {
 	case http.MethodGet:
 		user := s.oauth.GetMultiAccountUser(r)
-		knots, err := s.enforcer.GetKnotsForUser(user.Active.Did)
+		knots, err := s.enforcer.GetKnotsForUser(user.Did)
 		if err != nil {
 			s.pages.Notice(w, "repo", "Invalid user account.")
 			return
···
 		l := s.logger.With("handler", "NewRepo")
 
 		user := s.oauth.GetMultiAccountUser(r)
-		l = l.With("did", user.Active.Did)
+		l = l.With("did", user.Did)
 
 		// form validation
 		domain := r.FormValue("domain")
···
 		description := r.FormValue("description")
 
 		// ACL validation
-		ok, err := s.enforcer.E.Enforce(user.Active.Did, domain, domain, "repo:create")
+		ok, err := s.enforcer.E.Enforce(user.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.Active.Did),
+			orm.FilterEq("did", user.Did),
 			orm.FilterEq("name", repoName),
 		)
 		if err == nil && existingRepo != nil {
···
 		// create atproto record for this repo
 		rkey := tid.TID()
 		repo := &models.Repo{
-			Did:         user.Active.Did,
+			Did:         user.Did,
 			Name:        repoName,
 			Knot:        domain,
 			Rkey:        rkey,
···
 
 		atresp, err := comatproto.RepoPutRecord(r.Context(), atpClient, &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoNSID,
-			Repo:       user.Active.Did,
+			Repo:       user.Did,
 			Rkey:       rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &record,
···
 		}
 
 		// acls
-		p, _ := securejoin.SecureJoin(user.Active.Did, repoName)
-		err = s.enforcer.AddRepo(user.Active.Did, domain, p)
+		p, _ := securejoin.SecureJoin(user.Did, repoName)
+		err = s.enforcer.AddRepo(user.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.Active.Did, repoName))
+		s.pages.HxLocation(w, fmt.Sprintf("/%s/%s", user.Did, repoName))
 	}
 }
 

appview/strings/strings.go

···
 	user := s.OAuth.GetMultiAccountUser(r)
 	isStarred := false
 	if user != nil {
-		isStarred = db.GetStarStatus(s.Db, user.Active.Did, string.AtUri())
+		isStarred = db.GetStarStatus(s.Db, user.Did, string.AtUri())
 	}
 
 	s.Pages.SingleString(w, pages.SingleStringParams{
···
 	first := all[0]
 
 	// verify that the logged in user owns this string
-	if user.Active.Did != id.DID.String() {
-		l.Error("unauthorized request", "expected", id.DID, "got", user.Active.Did)
+	if user.Did != id.DID.String() {
+		l.Error("unauthorized request", "expected", id.DID, "got", user.Did)
 		w.WriteHeader(http.StatusUnauthorized)
 		return
 	}
···
 		s.Notifier.EditString(r.Context(), &entry)
 
 		// if that went okay, redir to the string
-		s.Pages.HxRedirect(w, "/strings/"+user.Active.Did+"/"+entry.Rkey)
+		s.Pages.HxRedirect(w, "/strings/"+user.Did+"/"+entry.Rkey)
 	}
 
 }
···
 		description := r.FormValue("description")
 
 		string := models.String{
-			Did:         syntax.DID(user.Active.Did),
+			Did:         syntax.DID(user.Did),
 			Rkey:        tid.TID(),
 			Filename:    filename,
 			Description: description,
···
 
 		resp, err := comatproto.RepoPutRecord(r.Context(), client, &atproto.RepoPutRecord_Input{
 			Collection: tangled.StringNSID,
-			Repo:       user.Active.Did,
+			Repo:       user.Did,
 			Rkey:       string.Rkey,
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &record,
···
 		s.Notifier.NewString(r.Context(), &string)
 
 		// successful
-		s.Pages.HxRedirect(w, "/strings/"+user.Active.Did+"/"+string.Rkey)
+		s.Pages.HxRedirect(w, "/strings/"+user.Did+"/"+string.Rkey)
 	}
 }
 
···
 		return
 	}
 
-	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()))
+	if user.Did != id.DID.String() {
+		fail("You cannot delete this string", fmt.Errorf("unauthorized deletion, %s != %s", user.Did, id.DID.String()))
 		return
 	}
 
 	if err := db.DeleteString(
 		s.Db,
-		orm.FilterEq("did", user.Active.Did),
+		orm.FilterEq("did", user.Did),
 		orm.FilterEq("rkey", rkey),
 	); err != nil {
 		fail("Failed to delete string.", err)
 		return
 	}
 
-	s.Notifier.DeleteString(r.Context(), user.Active.Did, rkey)
+	s.Notifier.DeleteString(r.Context(), user.Did, rkey)
 
-	s.Pages.HxRedirect(w, "/strings/"+user.Active.Did)
+	s.Pages.HxRedirect(w, "/strings/"+user.Did)
 }
 
 func (s *Strings) comment(w http.ResponseWriter, r *http.Request) {