package tui import ( "context" "fmt" "path/filepath" "strings" "time" "git.a-wan.net/alan/pipelines/internal/client" "git.a-wan.net/alan/pipelines/internal/draft" "git.a-wan.net/alan/pipelines/internal/protocol" tea "github.com/charmbracelet/bubbletea" "github.com/charmbracelet/x/ansi" ) type draftValidationMsg struct { path string notices []string err error } func (m Model) openDrafts() (tea.Model, tea.Cmd) { m.draftDeletingPath = "" m.draftOpen = true m.keys.drafts = true m.draftIndex = 0 m.draftTop = 0 m.draftError = "" items, err := draft.List() if err != nil { m.draftError = err.Error() } m.draftItems = items m.loadDraftPreview() return m, nil } func (m *Model) loadDraftPreview() { m.draftTop = 0 m.draftSource = "" m.draftNotice = "" if len(m.draftItems) == 0 { return } _, source, notice, err := m.readDraft(m.draftIndex) if err != nil { m.draftError = err.Error() return } m.draftSource = source m.draftNotice = notice } // readDraft loads one retained draft's metadata and source once, projecting it // onto the configured server. It returns the shared dual-URL notice when the // draft was created against a different server so no caller silently retargets // a foreign draft. func (m *Model) readDraft(index int) (draft.Draft, string, string, error) { d, err := draft.Load(m.draftItems[index].Path) if err != nil { return d, "", "", err } d, notice := d.Resolve(m.url) source, err := draft.Read(d.Path) return d, source, notice, err } func (m Model) selectedDraft() (draft.Draft, string, string, error) { if len(m.draftItems) == 0 { return draft.Draft{}, "", "", fmt.Errorf("no drafts") } return m.readDraft(m.draftIndex) } func (m Model) updateDrafts(msg tea.KeyMsg) (tea.Model, tea.Cmd) { if m.draftDeletingPath != "" { switch msg.String() { case "esc", "n": m.draftDeletingPath = "" return m, nil case "y": path := m.draftDeletingPath m.draftDeletingPath = "" if m.submitID != "" { m.draftError = "Wait for submission to finish before deleting drafts." return m, nil } if err := draft.Delete(path); err != nil { m.draftError = err.Error() return m, nil } if m.pendingDraft != nil && m.pendingDraft.path == path { m.pendingDraft = nil m.confirmOpen = false m.keys.confirm = false m.submitNotice = "" } return m.openDrafts() case "j", "down", "pgdown": m.draftDeletingTop++ case "k", "up", "pgup": m.draftDeletingTop = max(0, m.draftDeletingTop-1) } return m, nil } switch msg.String() { case "x": if len(m.draftItems) > 0 && m.submitID == "" { m.draftDeletingPath = m.draftItems[m.draftIndex].Path m.draftDeletingTop = 0 } return m, nil case "esc": m.draftOpen = false m.keys.drafts = false return m, nil case "r": return m.openDrafts() case "n", "right": if len(m.draftItems) > 0 { m.draftIndex = (m.draftIndex + 1) % len(m.draftItems) m.draftError = "" m.loadDraftPreview() } case "p", "left": if len(m.draftItems) > 0 { m.draftIndex = (m.draftIndex + len(m.draftItems) - 1) % len(m.draftItems) m.draftError = "" m.loadDraftPreview() } case "j", "down": m.draftTop++ case "k", "up": m.draftTop = max(0, m.draftTop-1) case "enter", "e", "s", "v": d, source, notice, err := m.selectedDraft() if err != nil { m.draftError = err.Error() return m, nil } m.draftNotice = notice switch msg.String() { case "enter", "e": return m.confirmMutation("Edit retained draft?", func() tea.Cmd { return editDraftMode(d.Name, source, true, d.CreateOnly, d) }) case "s": m.pendingDraft = &editedMsg{name: d.Name, path: d.Path, source: source, createOnly: d.CreateOnly, baseVersion: d.BaseVersion} m.confirmOpen = true m.keys.confirm = true m.submitNotice = "" return m, nil case "v": return m, func() tea.Msg { ctx, cancel := context.WithTimeout(m.ctx, 10*time.Second) defer cancel() c, err := client.Open(ctx, m.url) if err != nil { return draftValidationMsg{path: d.Path, err: err} } defer c.Close() sink := ¬iceSink{} c.Report(sink.report) _, err = c.Call(ctx, protocol.Message{Type: protocol.Validate, Source: source}) return draftValidationMsg{path: d.Path, notices: sink.drain(), err: err} } } } return m, nil } func (m Model) draftsView(height int) string { if m.draftDeletingPath != "" { name := filepath.Base(m.draftDeletingPath) for _, item := range m.draftItems { if item.Path == m.draftDeletingPath && item.Name != "" { name = item.Name + " · " + name break } } return wrappedDialog(m.width, height, 90, "Delete retained draft?", []string{name, "Only this draft and its metadata are deleted. Published pipelines/history stay intact.", "File: " + m.draftDeletingPath}, "y delete · n/Esc keep", m.draftDeletingTop) } if len(m.draftItems) == 0 { return fitBlock([]string{"Drafts", "No retained drafts.", m.draftError, "r refresh · Esc back"}, m.width, height) } d := m.draftItems[m.draftIndex] name := d.Name if name == "" { name = "Unnamed draft" } lines := []string{fmt.Sprintf("Drafts · %d/%d · %s", m.draftIndex+1, len(m.draftItems), name), d.Path, fmt.Sprintf("Create-only: %t · Base version: %d", d.CreateOnly, d.BaseVersion)} if m.draftNotice != "" { // Pre-wrap the dual-URL notice to the panel width: fitBlock truncates a // single long line, so an unwrapped notice would cut off the configured // endpoint and the TUI would not actually name both servers. lines = append(lines, strings.Split(ansi.Wrap("Warning: "+m.draftNotice, max(1, m.width), ""), "\n")...) } lines = append(lines, m.draftError, "") source := strings.Split(m.draftSource, "\n") rows := max(0, height-len(lines)-1) top := min(m.draftTop, max(0, len(source)-rows)) lines = append(lines, source[top:min(len(source), top+rows)]...) label := "create pipeline" if !d.CreateOnly && d.BaseVersion > 0 && (d.Server == "" || d.Server == m.url) { label = "update pipeline" } lines = append(lines, "n/p select · e edit · v validate · s "+label+" · x delete · r refresh · Esc back") for i := range lines { lines[i] = ansi.Strip(lines[i]) } return fitBlock(lines, m.width, height) }