gotextlog

model.go (32074B)

---

 package tui
 
 import (
 	"context"
 	"errors"
 	"fmt"
 	"strings"
 	"time"
 	"unicode/utf8"
 
 	"github.com/charmbracelet/bubbles/spinner"
 	tea "github.com/charmbracelet/bubbletea"
 
 	"git.ryansepassi.com/git/gotextlog.git/internal/config"
 	"git.ryansepassi.com/git/gotextlog.git/internal/domain"
 	"git.ryansepassi.com/git/gotextlog.git/internal/sshkey"
 	"git.ryansepassi.com/git/gotextlog.git/internal/textlog"
 )
 
 type screenKind string
 
 const (
 	screenFeed     screenKind = "feed"
 	screenSearch   screenKind = "search"
 	screenPost     screenKind = "post"
 	screenProfile  screenKind = "profile"
 	screenTag      screenKind = "tag"
 	screenLive     screenKind = "live"
 	screenCompose  screenKind = "compose"
 	screenLogin    screenKind = "login"
 	screenAccount  screenKind = "account"
 	screenSettings screenKind = "settings"
 	screenHelp     screenKind = "help"
 )
 
 type screen struct {
 	serial                              int
 	kind                                screenKind
 	feed                                string
 	id                                  int
 	handle, tag, query, input, phase    string
 	loading                             bool
 	err                                 string
 	posts, notes                        []textlog.Post
 	entries                             []ActivityEntry
 	depths, more                        []int
 	thread                              []domain.ThreadItem
 	folded                              map[int]bool
 	selected, target, page              int
 	cursors                             []string
 	nextCursor                          string
 	profile                             *textlog.Profile
 	users, following, followers, blocks []textlog.UserReference
 	tags, followingTags                 []textlog.TagReference
 	replies                             []textlog.Reply
 	keys                                []sshkey.Key
 	activeTab                           int
 	parent, edit                        *textlog.Post
 	preview                             bool
 	menu                                []string
 	menuSelected                        int
 	paused                              bool
 	streamPosts                         <-chan textlog.Post
 	streamErrors                        <-chan error
 	streamCancel                        context.CancelFunc
 	streamState                         string
 }
 
 type Options struct {
 	SaveConfig func(config.Config) error
 	OpenURL    func(string) error
 	Context    context.Context
 }
 
 type Model struct {
 	backend                   Backend
 	config                    config.Config
 	options                   Options
 	stack                     []*screen
 	me                        *textlog.CurrentUser
 	status                    string
 	statusError               bool
 	width, height, nextSerial int
 	spinner                   spinner.Model
 }
 
 type loadedMsg struct {
 	serial int
 	op     Operation
 	result Result
 	err    error
 }
 type savedMsg struct {
 	cfg    config.Config
 	status string
 	err    error
 }
 type openedMsg struct{ err error }
 type streamStartedMsg struct {
 	serial int
 	posts  <-chan textlog.Post
 	errs   <-chan error
 	cancel context.CancelFunc
 }
 type liveMsg struct {
 	serial int
 	post   *textlog.Post
 	err    error
 	closed bool
 }
 type reconnectMsg struct{ serial int }
 
 func New(backend Backend, cfg config.Config, options Options) Model {
 	if options.Context == nil {
 		options.Context = context.Background()
 	}
 	if options.SaveConfig == nil {
 		options.SaveConfig = func(c config.Config) error { return config.Save(c, nil) }
 	}
 	if options.OpenURL == nil {
 		options.OpenURL = openBrowser
 	}
 	m := Model{backend: backend, config: cfg, options: options, width: 80, height: 24, nextSerial: 1,
 		spinner: spinner.New(spinner.WithSpinner(spinner.MiniDot))}
 	s := m.newScreen(screenFeed)
 	s.feed = string(config.FeedLatest)
 	if cfg.Token != "" && cfg.LastTab != "" {
 		s.feed = string(cfg.LastTab)
 	}
 	s.loading, s.cursors = true, []string{""}
 	m.stack = []*screen{s}
 	return m
 }
 
 func (m *Model) newScreen(kind screenKind) *screen {
 	s := &screen{serial: m.nextSerial, kind: kind, target: -1, streamState: "connecting"}
 	m.nextSerial++
 	return s
 }
 func (m Model) current() *screen { return m.stack[len(m.stack)-1] }
 func (m *Model) find(serial int) *screen {
 	for _, s := range m.stack {
 		if s.serial == serial {
 			return s
 		}
 	}
 	return nil
 }
 
 func (m Model) Init() tea.Cmd {
 	cmds := []tea.Cmd{m.command(m.current(), Operation{Kind: OpFeed, Feed: m.current().feed}), m.spinner.Tick}
 	if m.config.Token != "" {
 		cmds = append(cmds, m.command(nil, Operation{Kind: OpMe}))
 	}
 	return tea.Batch(cmds...)
 }
 func (m Model) command(s *screen, op Operation) tea.Cmd {
 	serial := 0
 	if s != nil {
 		serial = s.serial
 	}
 	return func() tea.Msg {
 		result, err := m.backend.Execute(m.options.Context, op)
 		return loadedMsg{serial, op, result, err}
 	}
 }
 
 func (m Model) Update(message tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := message.(type) {
 	case tea.WindowSizeMsg:
 		m.width, m.height = msg.Width, msg.Height
 	case spinner.TickMsg:
 		var cmd tea.Cmd
 		m.spinner, cmd = m.spinner.Update(msg)
 		return m, cmd
 	case loadedMsg:
 		return m.applyLoaded(msg)
 	case savedMsg:
 		if msg.err != nil {
 			m.setStatus(msg.err.Error(), true)
 		} else {
 			m.config = msg.cfg
 			if backend, ok := m.backend.(interface{ Configure(config.Config) }); ok {
 				backend.Configure(msg.cfg)
 			}
 			if msg.status != "" {
 				m.setStatus(msg.status, false)
 			}
 		}
 	case openedMsg:
 		if msg.err != nil {
 			m.setStatus(msg.err.Error(), true)
 		}
 	case streamStartedMsg:
 		s := m.find(msg.serial)
 		if s == nil {
 			msg.cancel()
 			break
 		}
 		s.streamPosts, s.streamErrors, s.streamCancel, s.streamState = msg.posts, msg.errs, msg.cancel, "live"
 		return m, waitLive(s)
 	case liveMsg:
 		s := m.find(msg.serial)
 		if s == nil {
 			break
 		}
 		if s.paused {
 			s.streamState = "paused"
 			return m, nil
 		}
 		if msg.post != nil {
 			s.posts = prependUnique(s.posts, *msg.post, 100)
 			return m, waitLive(s)
 		}
 		s.streamState = "disconnected · retrying"
 		if !s.paused {
 			return m, tea.Tick(time.Second, func(time.Time) tea.Msg { return reconnectMsg{s.serial} })
 		}
 	case reconnectMsg:
 		if s := m.find(msg.serial); s != nil && !s.paused {
 			return m, m.startStream(s)
 		}
 	case tea.KeyMsg:
 		return m.key(msg)
 	}
 	return m, nil
 }
 
 func (m Model) applyLoaded(msg loadedMsg) (tea.Model, tea.Cmd) {
 	if msg.serial == 0 && msg.op.Kind == OpMe {
 		if msg.err == nil {
 			m.me = msg.result.Me
 		} else {
 			m.setStatus(errorText(msg.err), true)
 		}
 		return m, nil
 	}
 	s := m.find(msg.serial)
 	if s == nil {
 		return m, nil
 	}
 	s.loading = false
 	if msg.err != nil {
 		s.err = errorText(msg.err)
 		return m, nil
 	}
 	s.err = ""
 	switch msg.op.Kind {
 	case OpFeed, OpSearch:
 		s.posts, s.entries, s.nextCursor = msg.result.Posts, msg.result.Entries, msg.result.NextCursor
 		if len(s.entries) > 0 {
 			s.posts = make([]textlog.Post, len(s.entries))
 			for i := range s.entries {
 				s.posts[i] = s.entries[i].Post
 			}
 		}
 		s.selected, s.target = 0, -1
 	case OpThread:
 		m.setThread(s, msg.result)
 	case OpProfile:
 		s.profile, s.notes, s.posts, s.replies = msg.result.Profile, msg.result.Posts, msg.result.Posts, msg.result.Replies
 		s.following, s.followingTags, s.followers, s.blocks = msg.result.Following, msg.result.FollowingTags, msg.result.Followers, msg.result.Blocks
 		s.users, s.tags = s.following, s.followingTags
 	case OpTag:
 		s.posts, s.users = msg.result.Posts, msg.result.Followers
 		if len(msg.result.Tags) > 0 {
 			s.tags = []textlog.TagReference{msg.result.Tags[0]}
 		}
 	case OpRequestCode:
 		s.phase, s.query, s.input = "code", msg.op.Email, ""
 		m.setStatus("Check your email for the six-digit code", false)
 	case OpListKeys:
 		s.phase, s.keys, s.selected = "key", msg.result.Keys, 0
 		if len(s.keys) == 0 {
 			m.setStatus("No Ed25519 SSH public keys found in ~/.ssh", true)
 		}
 	case OpVerifyCode, OpKeyLogin:
 		if msg.result.Session != nil {
 			m.me, m.config.Token = msg.result.Me, msg.result.Session.Token
 			m.pop()
 			return m, m.saveCmd(m.config, "Signed in as @"+msg.result.Session.User.Handle)
 		}
 	case OpRevoke:
 		m.me, m.config.Token = nil, ""
 		m.pop()
 		return m, m.saveCmd(m.config, "Signed out")
 	case OpUpdateBio:
 		m.me, s.phase = msg.result.Me, ""
 		m.setStatus("Bio updated", false)
 	case OpCreatePost:
 		if msg.result.Post != nil {
 			m.setStatus("Note posted", false)
 			m.pop()
 			next := m.newScreen(screenPost)
 			next.id, next.loading = msg.result.Post.ID, true
 			m.stack = append(m.stack, next)
 			return m, m.command(next, Operation{Kind: OpThread, ID: next.id})
 		}
 	case OpEditPost:
 		m.setStatus("Note updated", false)
 		m.pop()
 	case OpDeletePost:
 		m.setStatus("Note deleted", false)
 		m.pop()
 	case OpFollow:
 		verb := "Following @"
 		if !msg.op.Enabled {
 			verb = "Unfollowed @"
 		}
 		m.setStatus(verb+msg.op.Handle, false)
 	case OpBlock:
 		verb := "Blocked @"
 		if !msg.op.Enabled {
 			verb = "Unblocked @"
 		}
 		m.setStatus(verb+msg.op.Handle, false)
 	case OpReport:
 		m.setStatus("Report submitted", false)
 		s.menu = nil
 	}
 	return m, nil
 }
 
 func (m Model) key(key tea.KeyMsg) (tea.Model, tea.Cmd) {
 	s := m.current()
 	if len(s.menu) > 0 {
 		return m.menuKey(key)
 	}
 	if s.kind == screenCompose {
 		return m.composeKey(key)
 	}
 	if s.kind == screenLogin {
 		return m.loginKey(key)
 	}
 	if s.kind == screenSearch && s.phase == "input" {
 		return m.searchKey(key)
 	}
 	if s.kind == screenAccount && s.phase == "bio" {
 		return m.bioKey(key)
 	}
 	if s.kind == screenSettings && s.phase == "url" {
 		return m.urlKey(key)
 	}
 	if s.loading {
 		if key.String() == "q" || key.Type == tea.KeyEsc {
 			m.pop()
 		}
 		return m, nil
 	}
 	if cmd, ok := m.screenKey(s, key); ok {
 		return m, cmd
 	}
 	return m.globalKey(key)
 }
 
 func (m *Model) screenKey(s *screen, key tea.KeyMsg) (tea.Cmd, bool) {
 	k := key.String()
 	switch s.kind {
 	case screenFeed, screenSearch:
 		if cmd, ok := m.listKey(s, key); ok {
 			return cmd, true
 		}
 		if k == "R" {
 			s.loading = true
 			return m.reloadList(s), true
 		}
 		if k == "n" && s.nextCursor != "" {
 			s.page++
 			s.cursors = append(s.cursors, s.nextCursor)
 			s.loading = true
 			return m.reloadList(s), true
 		}
 		if k == "p" && s.page > 0 {
 			s.page--
 			s.loading = true
 			return m.reloadList(s), true
 		}
 	case screenPost:
 		if k == " " {
 			m.toggleThreadFold(s)
 			return nil, true
 		}
 		if cmd, ok := m.listKey(s, key); ok {
 			return cmd, true
 		}
 		p := selectedPost(s)
 		if p == nil {
 			return nil, false
 		}
 		switch k {
 		case "T":
 			if p.TopID != nil {
 				return m.openPost(*p.TopID), true
 			}
 		case "P":
 			if p.ParentID != nil {
 				return m.openPost(*p.ParentID), true
 			}
 		case "e":
 			if m.owns(*p) {
 				m.openCompose(nil, p)
 				return nil, true
 			}
 		case "d":
 			if m.owns(*p) {
 				s.menu = []string{"delete note", "cancel"}
 				return nil, true
 			}
 		case "!":
 			if !m.owns(*p) {
 				s.menu = []string{"report harassment", "report spam", "report impersonation", "report other", "cancel"}
 				return nil, true
 			}
 		case "f", "F":
 			return m.action(s, Operation{Kind: OpFollow, Handle: p.Author.Handle, Enabled: k == "f"}), true
 		case "b", "B":
 			return m.action(s, Operation{Kind: OpBlock, Handle: p.Author.Handle, Enabled: k == "b"}), true
 		}
 	case screenProfile:
 		if k == "tab" || k == "right" {
 			s.activeTab = (s.activeTab + 1) % m.profileTabCount(s)
 			m.setProfileTab(s)
 			return nil, true
 		}
 		if k == "shift+tab" || k == "left" {
 			s.activeTab = (s.activeTab + m.profileTabCount(s) - 1) % m.profileTabCount(s)
 			m.setProfileTab(s)
 			return nil, true
 		}
 		if s.activeTab < 2 {
 			if cmd, ok := m.listKey(s, key); ok {
 				return cmd, true
 			}
 		} else if cmd, ok := m.referenceKey(s, key); ok {
 			return cmd, true
 		}
 		if k == "o" && s.profile != nil {
 			return m.openURL(s.profile.URL), true
 		}
 		if k == "f" || k == "F" {
 			return m.action(s, Operation{Kind: OpFollow, Handle: s.handle, Enabled: k == "f"}), true
 		}
 		if k == "b" || k == "B" {
 			return m.action(s, Operation{Kind: OpBlock, Handle: s.handle, Enabled: k == "b"}), true
 		}
 	case screenTag:
 		if k == "tab" || k == "shift+tab" || k == "left" || k == "right" {
 			s.activeTab = 1 - s.activeTab
 			s.selected = 0
 			return nil, true
 		}
 		if s.activeTab == 0 {
 			if cmd, ok := m.listKey(s, key); ok {
 				return cmd, true
 			}
 		} else if cmd, ok := m.referenceKey(s, key); ok {
 			return cmd, true
 		}
 	case screenLive:
 		if k == " " {
 			s.paused = !s.paused
 			if s.paused {
 				if s.streamCancel != nil {
 					s.streamCancel()
 				}
 				s.streamState = "paused"
 				return nil, true
 			}
 			s.streamState = "connecting"
 			return m.startStream(s), true
 		}
 		if cmd, ok := m.listKey(s, key); ok {
 			return cmd, true
 		}
 	case screenAccount:
 		if m.me == nil {
 			return nil, false
 		}
 		switch k {
 		case "e":
 			s.phase, s.input = "bio", m.me.Bio
 			return nil, true
 		case "s":
 			s.loading = true
 			return m.command(s, Operation{Kind: OpRevoke}), true
 		case "u":
 			return m.openProfile(m.me.Handle), true
 		case ",":
 			m.stack = append(m.stack, m.newScreen(screenSettings))
 			return nil, true
 		}
 	case screenSettings:
 		switch k {
 		case "j", "down":
 			s.menuSelected = min(3, s.menuSelected+1)
 			return nil, true
 		case "k", "up":
 			s.menuSelected = max(0, s.menuSelected-1)
 			return nil, true
 		case "t":
 			s.menuSelected = 0
 		case "u":
 			s.menuSelected = 1
 		case "o":
 			s.menuSelected = 2
 		case "enter":
 		default:
 			return nil, false
 		}
 		switch s.menuSelected {
 		case 0:
 			m.cycleTheme()
 			return m.saveCmd(m.config, "Theme updated"), true
 		case 1:
 			s.phase, s.input = "url", m.config.BaseURL
 			return nil, true
 		case 2:
 			return m.openURL(m.config.BaseURL), true
 		default:
 			m.pop()
 			return nil, true
 		}
 	}
 	return nil, false
 }
 
 func (m *Model) listKey(s *screen, key tea.KeyMsg) (tea.Cmd, bool) {
 	switch key.String() {
 	case "j", "down":
 		s.selected, s.target = clamp(s.selected+1, len(s.posts)), -1
 		return nil, true
 	case "k", "up":
 		s.selected, s.target = clamp(s.selected-1, len(s.posts)), -1
 		return nil, true
 	case "g":
 		s.selected, s.target = 0, -1
 		return nil, true
 	case "G":
 		s.selected, s.target = max(0, len(s.posts)-1), -1
 		return nil, true
 	case "tab":
 		targets := targetsFor(selectedPost(s))
 		if len(targets) > 0 {
 			s.target = (s.target + 1) % len(targets)
 		}
 		return nil, true
 	case "shift+tab":
 		targets := targetsFor(selectedPost(s))
 		if len(targets) > 0 {
 			s.target--
 			if s.target < 0 {
 				s.target = len(targets) - 1
 			}
 		}
 		return nil, true
 	case "enter", "l", "right":
 		p := selectedPost(s)
 		if p == nil {
 			return nil, true
 		}
 		if s.target >= 0 {
 			return m.activate(*p, s.target), true
 		}
 		if p.ID < 0 {
 			return m.openProfile(p.Author.Handle), true
 		}
 		return m.openPost(p.ID), true
 	case "r":
 		p := selectedPost(s)
 		if p != nil {
 			if m.me == nil {
 				return m.openLogin(), true
 			}
 			m.openCompose(p, nil)
 		}
 		return nil, true
 	case "u":
 		p := selectedPost(s)
 		if p != nil {
 			return m.openProfile(p.Author.Handle), true
 		}
 		return nil, true
 	case "t":
 		p := selectedPost(s)
 		if p != nil && len(p.Tags) > 0 {
 			return m.openTag(p.Tags[0]), true
 		}
 		return nil, true
 	case "o":
 		p := selectedPost(s)
 		if p != nil {
 			return m.openURL(p.URL), true
 		}
 		return nil, true
 	}
 	return nil, false
 }
 
 func (m *Model) globalKey(key tea.KeyMsg) (tea.Model, tea.Cmd) {
 	k := key.String()
 	if k == "q" || k == "esc" || k == "h" || k == "left" {
 		if len(m.stack) > 1 {
 			m.pop()
 			return *m, nil
 		}
 		return *m, tea.Quit
 	}
 	switch k {
 	case "?":
 		m.stack = append(m.stack, m.newScreen(screenHelp))
 	case "/":
 		s := m.newScreen(screenSearch)
 		s.phase = "input"
 		m.stack = append(m.stack, s)
 	case "w":
 		if m.me == nil {
 			return *m, m.openLogin()
 		}
 		m.openCompose(nil, nil)
 	case "a":
 		if m.me == nil {
 			return *m, m.openLogin()
 		}
 		m.stack = append(m.stack, m.newScreen(screenAccount))
 	case "0":
 		if m.me != nil {
 			return *m, m.openProfile(m.me.Handle)
 		}
 	case "1":
 		if m.config.Token != "" {
 			return *m, m.openFeed("for-you")
 		}
 		return *m, m.openFeed("hot")
 	case "2":
 		if m.config.Token != "" {
 			return *m, m.openFeed("to-me")
 		}
 		return *m, m.openFeed("latest")
 	case "3":
 		if m.config.Token != "" {
 			return *m, m.openFeed("hot")
 		}
 		return *m, m.openLive()
 	case "4":
 		if m.config.Token != "" {
 			return *m, m.openFeed("latest")
 		}
 	case "5":
 		if m.config.Token != "" {
 			return *m, m.openLive()
 		}
 	}
 	return *m, nil
 }
 
 func (m *Model) composeKey(key tea.KeyMsg) (tea.Model, tea.Cmd) {
 	s := m.current()
 	k := key.String()
 	if s.preview {
 		switch k {
 		case "j", "down":
 			s.menuSelected = min(2, s.menuSelected+1)
 		case "k", "up":
 			s.menuSelected = max(0, s.menuSelected-1)
 		case "esc":
 			s.preview = false
 		case "enter":
 			if s.menuSelected == 0 {
 				op := Operation{Kind: OpCreatePost, Text: s.input}
 				if s.parent != nil {
 					op.ParentID = &s.parent.ID
 				}
 				if s.edit != nil {
 					op.Kind, op.ID = OpEditPost, s.edit.ID
 				}
 				s.loading = true
 				return *m, m.command(s, op)
 			} else if s.menuSelected == 1 {
 				s.preview = false
 			} else {
 				m.pop()
 			}
 		}
 		return *m, nil
 	}
 	if k == "esc" {
 		m.pop()
 		return *m, nil
 	}
 	if k == "ctrl+s" {
 		if problem := domain.ValidatePost(s.input); problem != "" {
 			m.setStatus(problem, true)
 		} else {
 			s.preview = true
 		}
 		return *m, nil
 	}
 	if key.Type == tea.KeyEnter {
 		if strings.Count(s.input, "\n") < 9 {
 			s.input += "\n"
 		}
 		return *m, nil
 	}
 	edit(&s.input, key, 280)
 	return *m, nil
 }
 func (m *Model) loginKey(key tea.KeyMsg) (tea.Model, tea.Cmd) {
 	s := m.current()
 	k := key.String()
 	if k == "tab" {
 		if s.phase == "email" || s.phase == "code" {
 			s.phase, s.input, s.err, s.loading = "key", "", "", true
 			return *m, m.command(s, Operation{Kind: OpListKeys})
 		}
 		s.phase, s.input, s.err = "email", "", ""
 		return *m, nil
 	}
 	if k == "esc" {
 		switch s.phase {
 		case "code":
 			s.phase, s.input = "email", ""
 		case "handle":
 			s.phase, s.input = "key", ""
 		default:
 			m.pop()
 		}
 		return *m, nil
 	}
 	if s.phase == "key" {
 		switch k {
 		case "j", "down":
 			s.selected = clamp(s.selected+1, len(s.keys))
 		case "k", "up":
 			s.selected = clamp(s.selected-1, len(s.keys))
 		case "enter":
 			if len(s.keys) == 0 {
 				m.setStatus("No Ed25519 SSH public keys found in ~/.ssh", true)
 				return *m, nil
 			}
 			s.phase, s.input = "handle", ""
 		}
 		return *m, nil
 	}
 	if key.Type == tea.KeyEnter {
 		if s.phase == "email" {
 			if !strings.Contains(s.input, "@") || !strings.Contains(s.input, ".") {
 				m.setStatus("Enter a valid email address", true)
 				return *m, nil
 			}
 			s.loading = true
 			return *m, m.command(s, Operation{Kind: OpRequestCode, Email: s.input})
 		}
 		if s.phase == "handle" {
 			if len(s.keys) == 0 {
 				m.setStatus("Select an Ed25519 SSH key", true)
 				return *m, nil
 			}
 			s.loading = true
 			return *m, m.command(s, Operation{Kind: OpKeyLogin, Key: s.keys[s.selected], Handle: strings.TrimSpace(s.input)})
 		}
 		validCode := len(s.input) == 6
 		for _, digit := range s.input {
 			validCode = validCode && digit >= '0' && digit <= '9'
 		}
 		if !validCode {
 			m.setStatus("Enter the six-digit code", true)
 			return *m, nil
 		}
 		s.loading = true
 		return *m, m.command(s, Operation{Kind: OpVerifyCode, Email: s.query, Code: s.input})
 	}
 	edit(&s.input, key, 320)
 	return *m, nil
 }
 func (m *Model) searchKey(key tea.KeyMsg) (tea.Model, tea.Cmd) {
 	s := m.current()
 	if key.String() == "esc" {
 		m.pop()
 		return *m, nil
 	}
 	if key.Type == tea.KeyEnter && strings.TrimSpace(s.input) != "" {
 		s.query, s.phase, s.loading = strings.TrimSpace(s.input), "results", true
 		s.cursors = []string{""}
 		return *m, m.command(s, Operation{Kind: OpSearch, Query: s.query})
 	}
 	edit(&s.input, key, 200)
 	return *m, nil
 }
 func (m *Model) bioKey(key tea.KeyMsg) (tea.Model, tea.Cmd) {
 	s := m.current()
 	if key.String() == "esc" {
 		s.phase = ""
 		return *m, nil
 	}
 	if key.String() == "ctrl+s" {
 		s.loading = true
 		return *m, m.command(s, Operation{Kind: OpUpdateBio, Text: s.input})
 	}
 	if key.Type == tea.KeyEnter {
 		s.input += "\n"
 	} else {
 		edit(&s.input, key, 1000)
 	}
 	return *m, nil
 }
 func (m *Model) urlKey(key tea.KeyMsg) (tea.Model, tea.Cmd) {
 	s := m.current()
 	if key.String() == "esc" {
 		s.phase = ""
 		return *m, nil
 	}
 	if key.Type == tea.KeyEnter {
 		value, err := config.NormalizeBaseURL(s.input)
 		if err != nil {
 			m.setStatus(err.Error(), true)
 			return *m, nil
 		}
 		m.config.BaseURL = value
 		s.phase = ""
 		return *m, m.saveCmd(m.config, "Instance updated")
 	}
 	edit(&s.input, key, 500)
 	return *m, nil
 }
 
 func (m *Model) menuKey(key tea.KeyMsg) (tea.Model, tea.Cmd) {
 	s := m.current()
 	switch key.String() {
 	case "j", "down":
 		s.menuSelected = (s.menuSelected + 1) % len(s.menu)
 	case "k", "up":
 		s.menuSelected = (s.menuSelected + len(s.menu) - 1) % len(s.menu)
 	case "q", "esc":
 		s.menu = nil
 	case "enter":
 		p := selectedPost(s)
 		if s.menu[s.menuSelected] == "cancel" {
 			s.menu = nil
 			return *m, nil
 		}
 		s.loading = true
 		if s.menu[s.menuSelected] == "delete note" {
 			s.menu = nil
 			return *m, m.command(s, Operation{Kind: OpDeletePost, ID: p.ID})
 		}
 		reasons := []textlog.ReportReason{textlog.ReportHarassment, textlog.ReportSpam, textlog.ReportImpersonation, textlog.ReportOther}
 		return *m, m.command(s, Operation{Kind: OpReport, ID: p.ID, Reason: reasons[s.menuSelected]})
 	}
 	return *m, nil
 }
 
 func (m *Model) reloadList(s *screen) tea.Cmd {
 	cursor := ""
 	if s.page < len(s.cursors) {
 		cursor = s.cursors[s.page]
 	}
 	if s.kind == screenSearch {
 		return m.command(s, Operation{Kind: OpSearch, Query: s.query, Cursor: cursor})
 	}
 	return m.command(s, Operation{Kind: OpFeed, Feed: s.feed, Cursor: cursor, Page: s.page})
 }
 func (m *Model) openFeed(feed string) tea.Cmd {
 	s := m.newScreen(screenFeed)
 	s.feed, s.loading, s.cursors = feed, true, []string{""}
 	m.stack[len(m.stack)-1] = s
 	load := m.command(s, Operation{Kind: OpFeed, Feed: feed})
 	if m.config.Token != "" && m.config.LastTab != config.FeedKind(feed) {
 		m.config.LastTab = config.FeedKind(feed)
 		return tea.Batch(load, m.saveCmd(m.config, ""))
 	}
 	return load
 }
 func (m *Model) openPost(id int) tea.Cmd {
 	s := m.newScreen(screenPost)
 	s.id, s.loading = id, true
 	m.stack = append(m.stack, s)
 	return m.command(s, Operation{Kind: OpThread, ID: id})
 }
 func (m *Model) openProfile(handle string) tea.Cmd {
 	s := m.newScreen(screenProfile)
 	s.handle, s.loading = handle, true
 	m.stack = append(m.stack, s)
 	return m.command(s, Operation{Kind: OpProfile, Handle: handle, Enabled: m.me != nil && strings.EqualFold(m.me.Handle, handle)})
 }
 func (m *Model) openTag(tag string) tea.Cmd {
 	s := m.newScreen(screenTag)
 	s.tag, s.loading = strings.TrimPrefix(tag, "#"), true
 	m.stack = append(m.stack, s)
 	return m.command(s, Operation{Kind: OpTag, Tag: s.tag})
 }
 func (m *Model) openLogin() tea.Cmd {
 	s := m.newScreen(screenLogin)
 	s.phase = "email"
 	m.stack = append(m.stack, s)
 	return nil
 }
 func (m *Model) openLive() tea.Cmd {
 	s := m.newScreen(screenLive)
 	m.stack = append(m.stack, s)
 	return m.startStream(s)
 }
 func (m *Model) openCompose(parent, edit *textlog.Post) {
 	s := m.newScreen(screenCompose)
 	s.parent, s.edit = parent, edit
 	if edit != nil {
 		s.input = edit.Body
 	}
 	m.stack = append(m.stack, s)
 }
 func (m *Model) pop() {
 	if len(m.stack) > 1 {
 		s := m.current()
 		if s.streamCancel != nil {
 			s.streamCancel()
 		}
 		m.stack = m.stack[:len(m.stack)-1]
 	}
 }
 
 func (m *Model) action(s *screen, op Operation) tea.Cmd {
 	if m.me == nil {
 		return m.openLogin()
 	}
 	s.loading = true
 	return m.command(s, op)
 }
 func (m Model) saveCmd(cfg config.Config, status string) tea.Cmd {
 	return func() tea.Msg { return savedMsg{cfg: cfg, status: status, err: m.options.SaveConfig(cfg)} }
 }
 func (m Model) openURL(url string) tea.Cmd {
 	return func() tea.Msg {
 		if url == "" {
 			return openedMsg{errors.New("no browser URL available")}
 		}
 		return openedMsg{m.options.OpenURL(url)}
 	}
 }
 func (m Model) startStream(s *screen) tea.Cmd {
 	return func() tea.Msg {
 		ctx, cancel := context.WithCancel(m.options.Context)
 		posts, errs := m.backend.Firehose(ctx)
 		return streamStartedMsg{s.serial, posts, errs, cancel}
 	}
 }
 func waitLive(s *screen) tea.Cmd {
 	return func() tea.Msg {
 		select {
 		case p, ok := <-s.streamPosts:
 			if !ok {
 				return liveMsg{serial: s.serial, closed: true}
 			}
 			return liveMsg{serial: s.serial, post: &p}
 		case err, ok := <-s.streamErrors:
 			if !ok {
 				return liveMsg{serial: s.serial, closed: true}
 			}
 			return liveMsg{serial: s.serial, err: err}
 		}
 	}
 }
 
 func (m *Model) setStatus(text string, isError bool) { m.status, m.statusError = text, isError }
 func (m Model) owns(p textlog.Post) bool {
 	return m.me != nil && strings.EqualFold(m.me.Handle, p.Author.Handle)
 }
 func (m *Model) cycleTheme() {
 	themes := []config.Theme{config.ThemeAuto, config.ThemeLight, config.ThemeDark}
 	for i, t := range themes {
 		if t == m.config.Theme {
 			m.config.Theme = themes[(i+1)%len(themes)]
 			return
 		}
 	}
 }
 func edit(value *string, key tea.KeyMsg, limit int) {
 	if key.Type == tea.KeyBackspace || key.Type == tea.KeyDelete {
 		if *value != "" {
 			_, n := utf8.DecodeLastRuneInString(*value)
 			*value = (*value)[:len(*value)-n]
 		}
 		return
 	}
 	if key.Type == tea.KeySpace && utf8.RuneCountInString(*value) < limit {
 		*value += " "
 		return
 	}
 	if key.Type == tea.KeyRunes && utf8.RuneCountInString(*value)+len(key.Runes) <= limit {
 		*value += string(key.Runes)
 	}
 }
 func clamp(value, length int) int {
 	if length <= 0 || value < 0 {
 		return 0
 	}
 	if value >= length {
 		return length - 1
 	}
 	return value
 }
 func selectedPost(s *screen) *textlog.Post {
 	if len(s.posts) == 0 {
 		return nil
 	}
 	s.selected = clamp(s.selected, len(s.posts))
 	return &s.posts[s.selected]
 }
 func prependUnique(posts []textlog.Post, p textlog.Post, limit int) []textlog.Post {
 	out := []textlog.Post{p}
 	for _, old := range posts {
 		if old.ID != p.ID {
 			out = append(out, old)
 		}
 	}
 	if len(out) > limit {
 		out = out[:limit]
 	}
 	return out
 }
 
 func (m *Model) setThread(s *screen, result Result) {
 	if result.Post == nil {
 		s.posts, s.thread = nil, nil
 		return
 	}
 	root := result.Post
 	if result.Root != nil {
 		root = result.Root
 	}
 	replies := append([]textlog.Reply(nil), result.Replies...)
 	if result.Post.ID != root.ID {
 		found := false
 		for _, reply := range replies {
 			if reply.ID == result.Post.ID {
 				found = true
 				break
 			}
 		}
 		if !found {
 			replies = append(replies, textlog.Reply{Post: *result.Post})
 		}
 	}
 	s.thread = domain.BuildReplyThread(*root, replies)
 	s.folded = make(map[int]bool)
 	m.rebuildThread(s, result.Post.ID)
 }
 
 func (m *Model) toggleThreadFold(s *screen) {
 	post := selectedPost(s)
 	if post == nil || !threadHasChildren(s.thread, post.ID) {
 		return
 	}
 	s.folded[post.ID] = !s.folded[post.ID]
 	m.rebuildThread(s, post.ID)
 }
 
 func (m *Model) rebuildThread(s *screen, selectedID int) {
 	byID := make(map[int]textlog.Post, len(s.thread))
 	for _, item := range s.thread {
 		byID[item.Post.ID] = item.Post
 	}
 	s.posts, s.depths, s.more = nil, nil, nil
 	for _, item := range s.thread {
 		if threadItemHidden(item.Post, byID, s.folded) {
 			continue
 		}
 		s.posts = append(s.posts, item.Post)
 		s.depths = append(s.depths, item.Depth)
 		more := item.MoreCount
 		if s.folded[item.Post.ID] {
 			more = threadDescendantCount(s.thread, item.Post.ID)
 		}
 		s.more = append(s.more, more)
 		if item.Post.ID == selectedID {
 			s.selected = len(s.posts) - 1
 		}
 	}
 	s.target = -1
 }
 
 func threadItemHidden(post textlog.Post, byID map[int]textlog.Post, folded map[int]bool) bool {
 	seen := make(map[int]bool)
 	for post.ParentID != nil {
 		parentID := *post.ParentID
 		if folded[parentID] {
 			return true
 		}
 		if seen[parentID] {
 			return false
 		}
 		seen[parentID] = true
 		parent, ok := byID[parentID]
 		if !ok {
 			return false
 		}
 		post = parent
 	}
 	return false
 }
 
 func threadHasChildren(thread []domain.ThreadItem, id int) bool {
 	for _, item := range thread {
 		if item.Post.ParentID != nil && *item.Post.ParentID == id {
 			return true
 		}
 	}
 	return false
 }
 
 func threadDescendantCount(thread []domain.ThreadItem, id int) int {
 	byParent := make(map[int][]int)
 	for _, item := range thread {
 		if item.Post.ParentID != nil {
 			byParent[*item.Post.ParentID] = append(byParent[*item.Post.ParentID], item.Post.ID)
 		}
 	}
 	count := 0
 	seen := map[int]bool{id: true}
 	var visit func(int)
 	visit = func(parent int) {
 		for _, child := range byParent[parent] {
 			if seen[child] {
 				continue
 			}
 			seen[child] = true
 			count++
 			visit(child)
 		}
 	}
 	visit(id)
 	return count
 }
 func (m *Model) profileTabCount(s *screen) int {
 	if m.me != nil && strings.EqualFold(m.me.Handle, s.handle) {
 		return 6
 	}
 	return 5
 }
 func (m *Model) setProfileTab(s *screen) {
 	s.selected, s.target = 0, -1
 	switch s.activeTab {
 	case 0:
 		s.posts = s.notes
 	case 1:
 		s.posts = make([]textlog.Post, len(s.replies))
 		for i := range s.replies {
 			s.posts[i] = s.replies[i].Post
 		}
 	case 2:
 		s.users = s.following
 	case 3:
 		s.tags = s.followingTags
 	case 4:
 		s.users = s.followers
 	case 5:
 		s.users = s.blocks
 	}
 }
 func (m Model) profileReferences(s *screen) []textlog.UserReference {
 	if s.kind == screenTag {
 		return s.users
 	}
 	switch s.activeTab {
 	case 2:
 		return s.following
 	case 4:
 		return s.followers
 	case 5:
 		return s.blocks
 	}
 	return nil
 }
 func (m *Model) referenceKey(s *screen, key tea.KeyMsg) (tea.Cmd, bool) {
 	if s.kind == screenProfile && s.activeTab == 3 {
 		items := s.followingTags
 		switch key.String() {
 		case "j", "down":
 			s.selected = clamp(s.selected+1, len(items))
 			return nil, true
 		case "k", "up":
 			s.selected = clamp(s.selected-1, len(items))
 			return nil, true
 		case "g":
 			s.selected = 0
 			return nil, true
 		case "G":
 			s.selected = max(0, len(items)-1)
 			return nil, true
 		case "enter", "l", "right":
 			if len(items) > 0 {
 				return m.openTag(items[s.selected].Tag), true
 			}
 		case "o":
 			if len(items) > 0 {
 				return m.openURL(items[s.selected].URL), true
 			}
 		}
 		return nil, false
 	}
 	items := m.profileReferences(s)
 	switch key.String() {
 	case "j", "down":
 		s.selected = clamp(s.selected+1, len(items))
 		return nil, true
 	case "k", "up":
 		s.selected = clamp(s.selected-1, len(items))
 		return nil, true
 	case "g":
 		s.selected = 0
 		return nil, true
 	case "G":
 		s.selected = max(0, len(items)-1)
 		return nil, true
 	case "enter", "l", "right":
 		if len(items) > 0 {
 			return m.openProfile(items[s.selected].Handle), true
 		}
 	case "o":
 		if len(items) > 0 {
 			return m.openURL(items[s.selected].URL), true
 		}
 	}
 	return nil, false
 }
 
 type target struct{ kind, value string }
 
 func targetsFor(p *textlog.Post) []target {
 	if p == nil {
 		return nil
 	}
 	out := []target{{"author", p.Author.Handle}, {"thread", fmt.Sprint(p.ID)}, {"reply", fmt.Sprint(p.ID)}}
 	if domain.IsASCIIArt(p.Body, p.Tags) {
 		return out
 	}
 	for _, token := range domain.TokenizeRichText(p.Body) {
 		if token.Kind == domain.TokenLink {
 			out = append(out, target{"link", token.URL})
 		}
 		if token.Kind == domain.TokenReference {
 			if strings.HasPrefix(token.Text, "#") {
 				out = append(out, target{"tag", strings.TrimPrefix(token.Text, "#")})
 			} else {
 				out = append(out, target{"mention", strings.TrimPrefix(token.Text, "@")})
 			}
 		}
 	}
 	return out
 }
 func (m *Model) activate(p textlog.Post, index int) tea.Cmd {
 	targets := targetsFor(&p)
 	if index < 0 || index >= len(targets) {
 		return m.openPost(p.ID)
 	}
 	t := targets[index]
 	switch t.kind {
 	case "author":
 		return m.openProfile(p.Author.Handle)
 	case "thread":
 		return m.openPost(p.ID)
 	case "reply":
 		if m.me == nil {
 			return m.openLogin()
 		}
 		m.openCompose(&p, nil)
 	case "link":
 		return m.openURL(t.value)
 	case "tag":
 		return m.openTag(t.value)
 	case "mention":
 		return m.openProfile(t.value)
 	}
 	return nil
 }
 func errorText(err error) string {
 	var api *textlog.APIError
 	if errors.As(err, &api) && api.RetryAfter > 0 {
 		return fmt.Sprintf("%s (retry in %ds)", api.Message, api.RetryAfter)
 	}
 	return err.Error()
 }