// Package tui implements the interactive terminal interface. package tui import ( "context" "fmt" "path/filepath" "strings" "time" "github.com/charmbracelet/bubbles/textinput" tea "github.com/charmbracelet/bubbletea" "github.com/illustris/i-am-gcroot/internal/filter" "github.com/illustris/i-am-gcroot/internal/roots" ) type mode int const ( modeNormal mode = iota modeFilter modeConfirmDelete modeConfirmGC modeDetails modeResults modeHelp ) type Options struct { Query string Force bool WebURL string // shown in the status bar when the web UI runs alongside } type Model struct { ctx context.Context set *roots.Set opts Options changed chan struct{} all []roots.Root view []roots.Root cursor int offset int marks map[string]bool kinds map[roots.Kind]bool sortKey filter.SortKey desc bool hidden bool // show hidden (nix cache) roots input textinput.Model query *filter.Query queryErr string mode mode pending []roots.Root // roots awaiting delete confirmation collect bool // run a targeted GC after the pending delete dryRun bool results []roots.Result collected string status string statusOK bool busy string // long running operation, shown on the activity line since time.Time scanning bool width int height int quitting bool } func New(ctx context.Context, set *roots.Set, opts Options) *Model { ti := textinput.New() ti.Prompt = "/ " ti.Placeholder = "filter: text, /re/, kind:, owner:me, under:/tmp, older:30d, size>1G" ti.SetValue(opts.Query) m := &Model{ ctx: ctx, set: set, opts: opts, changed: make(chan struct{}, 1), marks: map[string]bool{}, kinds: defaultKinds(), input: ti, sortKey: filter.SortAge, } m.query, _ = filter.Parse(opts.Query) set.OnChange(func() { select { case m.changed <- struct{}{}: default: } }) return m } func defaultKinds() map[roots.Kind]bool { k := map[roots.Kind]bool{} for _, kind := range roots.AllKinds { k[kind] = kind != roots.KindRuntime } return k } type changedMsg struct{} type tickMsg struct{} type refreshedMsg struct{ err error } type deletedMsg struct { results []roots.Result dryRun bool collected string // summary of the targeted GC, if one ran } type gcMsg struct { summary string err error } func (m *Model) waitChange() tea.Cmd { return func() tea.Msg { select { case <-m.changed: return changedMsg{} case <-m.ctx.Done(): return nil } } } func (m *Model) refresh() tea.Cmd { m.scanning = true return func() tea.Msg { return refreshedMsg{m.set.Refresh(m.ctx)} } } // startBusy shows an operation on the activity line with a running timer. func (m *Model) startBusy(what string) tea.Cmd { m.busy, m.since = what, time.Now() return tick() } func tick() tea.Cmd { return tea.Tick(time.Second, func(time.Time) tea.Msg { return tickMsg{} }) } func (m *Model) setStatus(s string, ok bool) { m.status, m.statusOK = s, ok } func (m *Model) Init() tea.Cmd { return tea.Batch(m.refresh(), m.waitChange()) } func (m *Model) reload() { m.all = m.set.Snapshot() m.apply() } func (m *Model) apply() { var curLink string if m.cursor < len(m.view) { curLink = m.view[m.cursor].Link } m.view = filter.Apply(m.all, m.query, m.kinds, m.hidden, m.sortKey, m.desc) m.cursor = 0 for i := range m.view { if m.view[i].Link == curLink { m.cursor = i break } } // forget marks that are no longer present at all present := map[string]bool{} for _, r := range m.all { present[r.Link] = true } for l := range m.marks { if !present[l] { delete(m.marks, l) } } m.clamp() } // footerLines is the number of lines below the list: kinds/sort, key hints, // the activity line when there is something to report, and the filter. func (m *Model) footerLines() int { n := 2 if m.activity() != "" { n++ } if m.mode == modeFilter || m.input.Value() != "" { n++ } return n } func (m *Model) listHeight() int { h := m.height - 2 - m.footerLines() if h < 1 { h = 1 } return h } func (m *Model) clamp() { if m.cursor >= len(m.view) { m.cursor = len(m.view) - 1 } if m.cursor < 0 { m.cursor = 0 } h := m.listHeight() if m.cursor < m.offset { m.offset = m.cursor } if m.cursor >= m.offset+h { m.offset = m.cursor - h + 1 } if m.offset > max(0, len(m.view)-h) { m.offset = max(0, len(m.view)-h) } } // selection returns marked roots, or the root under the cursor if nothing is // marked. func (m *Model) selection() []roots.Root { var out []roots.Root for _, r := range m.all { if m.marks[r.Link] { out = append(out, r) } } if len(out) == 0 && m.cursor < len(m.view) { out = append(out, m.view[m.cursor]) } return out } func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) { switch msg := msg.(type) { case tea.WindowSizeMsg: m.width, m.height = msg.Width, msg.Height m.input.Width = max(10, msg.Width-4) m.clamp() return m, nil case changedMsg: m.reload() return m, m.waitChange() case tickMsg: if m.busy != "" { return m, tick() } return m, nil case refreshedMsg: m.scanning = false if msg.err != nil { m.setStatus("scan failed: "+msg.err.Error(), false) } m.reload() return m, nil case deletedMsg: m.busy = "" m.results = msg.results m.dryRun = msg.dryRun m.collected = msg.collected m.setStatus(m.summarize(msg), true) if !msg.dryRun { gone := map[string]bool{} for _, r := range msg.results { if r.OK() { gone[r.Link] = true delete(m.marks, r.Link) } else { m.statusOK = false } } m.set.Remove(gone) } return m, nil case gcMsg: m.busy = "" if msg.err != nil { m.setStatus("gc failed: "+msg.err.Error(), false) } else { m.setStatus("gc: "+msg.summary, true) } return m, m.refresh() case tea.KeyMsg: return m.handleKey(msg) } return m, nil } func (m *Model) handleKey(k tea.KeyMsg) (tea.Model, tea.Cmd) { key := k.String() if key == "ctrl+c" { m.quitting = true return m, tea.Quit } switch m.mode { case modeFilter: switch key { case "enter", "esc": m.mode = modeNormal m.input.Blur() return m, nil } var cmd tea.Cmd m.input, cmd = m.input.Update(k) q, err := filter.Parse(m.input.Value()) if err != nil { m.queryErr = err.Error() } else { m.queryErr = "" m.query = q m.apply() } return m, cmd case modeConfirmDelete: switch key { case "y", "Y": m.mode = modeNormal rs, opts, collect := m.pending, roots.DeleteOpts{Force: m.opts.Force}, m.collect what := fmt.Sprintf("deleting %d root(s)", len(rs)) if collect { what += " and collecting their garbage" } return m, tea.Batch(m.startBusy(what), func() tea.Msg { res := roots.Delete(m.ctx, m.set.Cfg, rs, opts) msg := deletedMsg{results: res} if collect { c, err := roots.Collect(m.ctx, m.set.Cfg, roots.CollectedTargets(res)) msg.collected = c.String() if err != nil { msg.collected += "; gc error: " + err.Error() } } // rebuild the list from disk rather than trusting in-memory state _ = m.set.Refresh(m.ctx) return msg }) case "n", "N", "esc", "q": m.mode = modeNormal } return m, nil case modeConfirmGC: switch key { case "y", "Y": m.mode = modeNormal return m, tea.Batch(m.startBusy("running nix-store --gc"), func() tea.Msg { s, err := roots.GC(m.ctx, m.set.Cfg) return gcMsg{s, err} }) case "n", "N", "esc", "q": m.mode = modeNormal } return m, nil case modeDetails, modeResults, modeHelp: switch key { case "esc", "q", "enter", "?": m.mode = modeNormal } return m, nil } switch key { case "q": m.quitting = true return m, tea.Quit case "esc": if m.input.Value() != "" { m.input.SetValue("") m.query, _ = filter.Parse("") m.apply() } case "/": m.mode = modeFilter return m, m.input.Focus() case "up", "k": m.cursor-- case "down", "j": m.cursor++ case "pgup", "ctrl+b": m.cursor -= m.listHeight() case "pgdown", "ctrl+f": m.cursor += m.listHeight() case "home": m.cursor = 0 case "end", "G": m.cursor = len(m.view) - 1 case " ", "x": if m.cursor < len(m.view) { r := m.view[m.cursor] if r.Deletable() { if m.marks[r.Link] { delete(m.marks, r.Link) } else { m.marks[r.Link] = true } } } case "a": for _, r := range m.view { if r.Deletable() && !r.Protected { m.marks[r.Link] = true } } case "A": m.marks = map[string]bool{} case "1", "2", "3", "4", "5": kind := roots.AllKinds[int(key[0]-'1')] m.kinds[kind] = !m.kinds[kind] if kind == roots.KindRuntime && m.kinds[kind] && !m.set.Status().Runtime { m.set.SetRuntime(true) m.apply() return m, m.refresh() } m.apply() case "0": m.kinds = defaultKinds() m.apply() case "s": m.sortKey = (m.sortKey + 1) % filter.SortKey(len(filter.SortNames)) m.apply() case "S": m.desc = !m.desc m.apply() case "r": return m, m.refresh() case "enter": if m.cursor < len(m.view) { m.mode = modeDetails } case "d", "D", "X": sel := m.selection() if len(sel) == 0 { return m, nil } if key == "D" { return m, func() tea.Msg { return deletedMsg{results: roots.Delete(m.ctx, m.set.Cfg, sel, roots.DeleteOpts{DryRun: true, Force: m.opts.Force}), dryRun: true} } } if m.busy != "" { m.setStatus("wait for "+m.busy+" to finish", false) return m, nil } m.pending = sel m.collect = key == "X" m.mode = modeConfirmDelete case "h": m.hidden = !m.hidden m.apply() case "g": if m.busy != "" { m.setStatus("wait for "+m.busy+" to finish", false) return m, nil } m.mode = modeConfirmGC case "R": if m.results != nil { m.mode = modeResults } case "?": m.mode = modeHelp } m.clamp() return m, nil } func kindList(kinds map[roots.Kind]bool) string { var parts []string for i, k := range roots.AllKinds { mark := " " if kinds[k] { mark = "x" } parts = append(parts, fmt.Sprintf("%d[%s]%s", i+1, mark, k)) } return strings.Join(parts, " ") } // summarize turns a delete outcome into one status line; R shows the rest. func (m *Model) summarize(msg deletedMsg) string { var ok, failed []roots.Result for _, r := range msg.results { if r.OK() { ok = append(ok, r) } else { failed = append(failed, r) } } var s string if msg.dryRun { s = fmt.Sprintf("dry run: %d action(s)", len(ok)) if len(ok) > 0 { s += ", e.g. " + ok[0].Action } if len(failed) > 0 { s += fmt.Sprintf("; %d would fail", len(failed)) } } else { s = fmt.Sprintf("deleted %d/%d root(s)", len(ok), len(msg.results)) if msg.collected != "" { s += "; " + msg.collected } else if len(ok) > 0 { s += "; g to collect garbage" } } if len(failed) > 0 { s += fmt.Sprintf("; failed %s: %s", filepath.Base(failed[0].Link), failed[0].Err) if len(failed) > 1 { s += fmt.Sprintf(" (+%d more)", len(failed)-1) } } return s + " [R details]" }