Something went wrong. Try again.
Monorepo for Tangled
Something went wrong. Try again.
Go
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450package ssh
import ( "encoding/json" "fmt" "strings" "time"
"github.com/charmbracelet/bubbles/spinner" "github.com/charmbracelet/bubbles/viewport" tea "github.com/charmbracelet/bubbletea" "github.com/charmbracelet/lipgloss" "github.com/gorilla/websocket" "tangled.org/core/appview/db" "tangled.org/core/appview/models" "tangled.org/core/appview/pipelines" "tangled.org/core/orm" spindlemodel "tangled.org/core/spindle/models")
var ( colorFg lipgloss.NoColor = lipgloss.NoColor{} colorBlue lipgloss.ANSIColor = 4 colorBrightBlack lipgloss.ANSIColor = 8)
type tickMsg time.Time
type statusUpdateMsg struct { pipeline models.Pipeline}
type statusUpdateErrMsg struct{ err error }
type pipelineModel struct { renderer *lipgloss.Renderer server *Server pipeline models.Pipeline workflows []string selected int logs map[string]*workflowLogs statusCh chan struct{} spinner spinner.Model width int height int}
type workflowLogs struct { steps []step stepIndex map[int]int vp viewport.Model ready bool done bool err error}
func newPipelineModel(renderer *lipgloss.Renderer, s *Server, pipeline models.Pipeline, width, height int) *pipelineModel { workflows := pipeline.Workflows() logs := make(map[string]*workflowLogs, len(workflows)) for _, wf := range workflows { logs[wf] = &workflowLogs{stepIndex: make(map[int]int)} } statusCh := s.pipelineNotifier.Subscribe(pipeline.AtUri()) sp := spinner.New(spinner.WithSpinner(spinner.Line)) return &pipelineModel{ renderer: renderer, server: s, pipeline: pipeline, workflows: workflows, logs: logs, statusCh: statusCh, spinner: sp, width: width, height: height, }}
func (m *pipelineModel) Init() tea.Cmd { cmds := []tea.Cmd{tick(), m.spinner.Tick, m.waitForStatusUpdate(m.statusCh)} for _, wf := range m.workflows { cmds = append(cmds, m.connectCmd(wf)) } return tea.Batch(cmds...)}
func tick() tea.Cmd { return tea.Tick(time.Second, func(t time.Time) tea.Msg { return tickMsg(t) })}
// waitForStatusUpdate blocks on the notifier channel, re-fetches pipeline statuses, and returns the result as a tea.Msg.func (m *pipelineModel) waitForStatusUpdate(ch chan struct{}) tea.Cmd { knot := m.pipeline.Knot rkey := m.pipeline.Rkey return func() tea.Msg { if _, ok := <-ch; !ok { return nil } ps, err := db.GetPipelineStatuses(m.server.db, 1, orm.FilterEq("p.knot", knot), orm.FilterEq("p.rkey", rkey), ) if err != nil || len(ps) == 0 { return statusUpdateErrMsg{err: fmt.Errorf("refreshing pipeline: %w", err)} } return statusUpdateMsg{pipeline: ps[0]} }}
// connectCmd dials the spindle websocket for the given workflow and starts streaming log events.func (m *pipelineModel) connectCmd(workflow string) tea.Cmd { return func() tea.Msg { ws, ok := m.pipeline.Statuses[workflow] if !ok || len(ws.Data) == 0 { return logDoneMsg{workflow: workflow} } url := pipelines.SpindleURL(ws.Data[0].Spindle, m.pipeline.Knot, m.pipeline.Rkey, workflow) conn, _, err := websocket.DefaultDialer.Dial(url, nil) if err != nil { return logDoneMsg{workflow: workflow, err: fmt.Errorf("connecting to spindle: %w", err)} } ch := make(chan pipelines.LogEvent, 100) go pipelines.ReadLogs(conn, ch) return readNextLogEvent(workflow, conn, ch) }}
func (m *pipelineModel) vpHeight() int { return max(m.height-2, 1) // topbar + empty line take 2 lines}
// resizeViewports updates all viewport dimensions and re-renders their content after a terminal resize.//// TODO: can be tedious if we have logs of logsfunc (m *pipelineModel) resizeViewports() { for _, wl := range m.logs { if !wl.ready { continue } atBottom := wl.vp.AtBottom() wl.vp.Width = m.width wl.vp.Height = m.vpHeight() wl.vp.SetContent(renderLogs(m.renderer, wl, m.width)) if atBottom { wl.vp.GotoBottom() } }}
func (m *pipelineModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) { switch msg := msg.(type) { case tea.WindowSizeMsg: m.width, m.height = msg.Width, msg.Height m.resizeViewports()
case tickMsg: return m, tick()
case spinner.TickMsg: var cmd tea.Cmd m.spinner, cmd = m.spinner.Update(msg) return m, cmd
case tea.KeyMsg: switch msg.String() { case "q", "ctrl+c": m.server.pipelineNotifier.Unsubscribe(m.pipeline.AtUri(), m.statusCh) return m, tea.Quit case "tab", "right", "l": m.selected = (m.selected + 1) % len(m.workflows) return m, nil case "shift+tab", "left", "h": m.selected = (m.selected - 1 + len(m.workflows)) % len(m.workflows) return m, nil } if wl := m.selectedLogs(); wl != nil && wl.ready { switch msg.String() { case "g": wl.vp.GotoTop() return m, nil case "G": wl.vp.GotoBottom() return m, nil case "ctrl+e": wl.vp.ScrollDown(1) return m, nil case "ctrl+y": wl.vp.ScrollUp(1) return m, nil } var cmd tea.Cmd wl.vp, cmd = wl.vp.Update(msg) return m, cmd }
case logEventMsg: return m, m.handleLogEvent(msg)
case logDoneMsg: if wl, ok := m.logs[msg.workflow]; ok { wl.done, wl.err = true, msg.err m.initViewport(wl) wl.vp.SetContent(renderLogs(m.renderer, wl, m.width)) wl.vp.GotoBottom() }
case statusUpdateMsg: // detect any workflows that are new since the last update known := make(map[string]bool, len(m.workflows)) for _, wf := range m.workflows { known[wf] = true } m.pipeline = msg.pipeline var newCmds []tea.Cmd for _, wf := range msg.pipeline.Workflows() { if !known[wf] { m.workflows = append(m.workflows, wf) m.logs[wf] = &workflowLogs{stepIndex: make(map[int]int)} newCmds = append(newCmds, m.connectCmd(wf)) } } // re-subscribe for the next update newCmds = append(newCmds, m.waitForStatusUpdate(m.statusCh)) return m, tea.Batch(newCmds...)
case statusUpdateErrMsg: // re-subscribe even on error so we don't stop listening return m, m.waitForStatusUpdate(m.statusCh) }
return m, nil}
func (m *pipelineModel) selectedLogs() *workflowLogs { if len(m.workflows) == 0 { return nil } return m.logs[m.workflows[m.selected]]}
func (m *pipelineModel) initViewport(wl *workflowLogs) { if wl.ready { return } wl.vp = viewport.New(m.width, m.vpHeight()) wl.ready = true}
// handleLogEvent processes a single log event, updates the step state, and re-renders the viewport.func (m *pipelineModel) handleLogEvent(msg logEventMsg) tea.Cmd { wl, ok := m.logs[msg.workflow] if !ok { return nil } if msg.ev.Err != nil { wl.done = true if !msg.ev.IsCloseError() { wl.err = msg.ev.Err } m.initViewport(wl) wl.vp.SetContent(renderLogs(m.renderer, wl, m.width)) return nil } var line spindlemodel.LogLine if err := json.Unmarshal(msg.ev.Msg, &line); err != nil { return readNextCmd(msg.workflow, msg.conn, msg.ch) } applyLogLine(wl, line) m.initViewport(wl) atBottom := wl.vp.AtBottom() wl.vp.SetContent(renderLogs(m.renderer, wl, m.width)) if atBottom { wl.vp.GotoBottom() } return readNextCmd(msg.workflow, msg.conn, msg.ch)}
// applyLogLine mutates wl by appending the log line to the appropriate step.func applyLogLine(wl *workflowLogs, line spindlemodel.LogLine) { switch line.Kind { case spindlemodel.LogKindControl: switch line.StepStatus { case spindlemodel.StepStatusStart: idx := len(wl.steps) wl.stepIndex[line.StepId] = idx wl.steps = append(wl.steps, step{ id: line.StepId, name: line.Content, command: line.StepCommand, kind: line.StepKind, startTime: line.Time, }) case spindlemodel.StepStatusEnd: if idx, ok := wl.stepIndex[line.StepId]; ok { wl.steps[idx].endTime, wl.steps[idx].finished = line.Time, true } } case spindlemodel.LogKindData: if idx, ok := wl.stepIndex[line.StepId]; ok { wl.steps[idx].lines = append(wl.steps[idx].lines, line.Content) } }}
// renderLogs builds the full log content string for a workflow, used as viewport content.func renderLogs(r *lipgloss.Renderer, wl *workflowLogs, width int) string { headerStyle := r.NewStyle().Foreground(colorFg).Bold(true) cmdStyle := r.NewStyle().Foreground(colorBlue).Width(width) dimStyle := r.NewStyle().Faint(true) now := time.Now() var sb strings.Builder for i := range wl.steps { st := &wl.steps[i] dur := "" if st.finished { dur = st.endTime.Sub(st.startTime).Round(time.Millisecond).String() } else if !st.startTime.IsZero() { dur = now.Sub(st.startTime).Round(time.Second).String() } // build overlay: "── name ──...── dur ──" nameStr := headerStyle.Render(st.name + " ") durStr := headerStyle.Render(" " + dur + " ") nameW := lipgloss.Width(nameStr) durW := lipgloss.Width(durStr) fillW := max(width-nameW-durW, 0) fill := dimStyle.Render(strings.Repeat("─", fillW)) header := nameStr + fill + durStr sb.WriteString(header + "\n") if st.command != "" { sb.WriteString(cmdStyle.Render(st.command) + "\n") } for _, l := range st.lines { sb.WriteString(l + "\n") } sb.WriteString("\n") } if wl.done && wl.err != nil { sb.WriteString("error: " + wl.err.Error() + "\n") } return sb.String()}
func (m *pipelineModel) View() string { body := "" if wl := m.selectedLogs(); wl != nil && wl.ready { body = wl.vp.View() } return lipgloss.JoinVertical(lipgloss.Left, m.topbarView(), "", body)}
// topbarView renders the single-line tab bar with workflow tabs left and trigger info + help right.func (m *pipelineModel) topbarView() string { r := m.renderer activeStyle := r.NewStyle().Background(colorBlue).Foreground(colorFg).Bold(true)
now := time.Now()
var tabs strings.Builder for i, wf := range m.workflows { status := spindlemodel.StatusKindPending elapsed := "" if ws, ok := m.pipeline.Statuses[wf]; ok { latest := ws.Latest() status = latest.Status if t := ws.TimeTaken(); t > 0 { elapsed = t.Round(time.Second).String() } else { elapsed = now.Sub(latest.Created).Round(time.Second).String() } } dim := r.NewStyle().Faint(true) base := " " + statusIcon(status, m.spinner.View()) + " " + wf if i == m.selected { tab := base if elapsed != "" { tab += " " + elapsed } tab += " " tabs.WriteString(activeStyle.Render(tab)) } else { tabs.WriteString(base) if elapsed != "" { tabs.WriteString(" " + dim.Render(elapsed)) } tabs.WriteString(" ") } }
tabsStr := tabs.String() infoStr := triggerLine(r, m.pipeline.Trigger, m.pipeline.Sha) + " · " + helpText(r)
gap := max(m.width-lipgloss.Width(tabsStr)-lipgloss.Width(infoStr), 1)
return tabsStr + strings.Repeat(" ", gap) + infoStr}
func helpText(r *lipgloss.Renderer) string { key := r.NewStyle().Foreground(colorFg) action := r.NewStyle().Faint(true) sep := action.Render(" · ")
items := []string{ key.Render("←/→") + " " + action.Render("switch"), key.Render("↑/↓") + " " + action.Render("scroll"), key.Render("q") + " " + action.Render("quit"), } return strings.Join(items, sep)}
func shortSha(sha string) string { if len(sha) >= 8 { return sha[:8] } return sha}
func triggerLine(r *lipgloss.Renderer, t *models.Trigger, sha string) string { hash := shortSha(sha) dim := r.NewStyle().Faint(true) if t == nil { return dim.Render(hash) } if t.IsPush() { return t.TargetRef() + dim.Render("@"+hash) + dim.Render(" (push)") } if t.IsPullRequest() { source := "" if t.PRSourceBranch != nil { source = *t.PRSourceBranch } return t.TargetRef() + dim.Render(" <- "+source+"@"+hash) + dim.Render(" (pull-request)") } return dim.Render(hash)}
func statusIcon(status spindlemodel.StatusKind, spinnerFrame string) string { switch status { case spindlemodel.StatusKindSuccess: return "✓" case spindlemodel.StatusKindFailed: return "×" case spindlemodel.StatusKindRunning: return spinnerFrame case spindlemodel.StatusKindPending: return "·" case spindlemodel.StatusKindTimeout: return "⌀" case spindlemodel.StatusKindCancelled: return "-" default: return "?" }}