727 lines
23 KiB
Go
727 lines
23 KiB
Go
package tui
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/charmbracelet/bubbles/help"
|
|
"github.com/charmbracelet/bubbles/key"
|
|
"github.com/charmbracelet/bubbles/spinner"
|
|
"github.com/charmbracelet/bubbles/textarea"
|
|
"github.com/charmbracelet/bubbles/textinput"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
"github.com/charmbracelet/x/ansi"
|
|
"github.com/coder/websocket"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/client"
|
|
"git.a-wan.net/alan/pipelines/internal/draft"
|
|
"git.a-wan.net/alan/pipelines/internal/pipeline"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
type connectedMsg struct{ conn *websocket.Conn }
|
|
type receivedMsg protocol.Message
|
|
type sentMsg struct{ id string }
|
|
type errorMsg struct {
|
|
err error
|
|
conn *websocket.Conn
|
|
}
|
|
type socketMsg struct {
|
|
conn *websocket.Conn
|
|
message protocol.Message
|
|
}
|
|
type reconnectMsg struct{}
|
|
|
|
type keyMap struct {
|
|
ping key.Binding
|
|
quit key.Binding
|
|
create key.Binding
|
|
enter key.Binding
|
|
cancel key.Binding
|
|
commands key.Binding
|
|
logs bool
|
|
palette bool
|
|
search key.Binding
|
|
detail bool
|
|
versions bool
|
|
confirm bool
|
|
runs bool
|
|
retryAvailable bool
|
|
templates bool
|
|
drafts bool
|
|
}
|
|
|
|
func (k keyMap) ShortHelp() []key.Binding {
|
|
if k.confirm {
|
|
return []key.Binding{key.NewBinding(key.WithKeys("s"), key.WithHelp("s", "submit")), key.NewBinding(key.WithKeys("e"), key.WithHelp("e", "edit")), k.cancel}
|
|
}
|
|
if k.drafts {
|
|
return []key.Binding{key.NewBinding(key.WithKeys("n", "p"), key.WithHelp("n/p", "draft")), key.NewBinding(key.WithKeys("e"), key.WithHelp("e", "edit")), key.NewBinding(key.WithKeys("v"), key.WithHelp("v", "validate")), key.NewBinding(key.WithKeys("s"), key.WithHelp("s", "submit")), k.cancel}
|
|
}
|
|
if k.versions {
|
|
return []key.Binding{key.NewBinding(key.WithKeys("j", "k"), key.WithHelp("j/k", "select")), k.enter, k.cancel}
|
|
}
|
|
if k.logs {
|
|
return []key.Binding{key.NewBinding(key.WithKeys("j", "k"), key.WithHelp("j/k", "line")), key.NewBinding(key.WithKeys("h", "l"), key.WithHelp("h/l", "half page")), k.cancel}
|
|
}
|
|
if k.palette {
|
|
return []key.Binding{k.enter, k.cancel}
|
|
}
|
|
if k.templates {
|
|
return []key.Binding{key.NewBinding(key.WithKeys("n", "p"), key.WithHelp("n/p", "template")), key.NewBinding(key.WithKeys("v"), key.WithHelp("v", "render/source")), key.NewBinding(key.WithKeys("enter"), key.WithHelp("Enter", "use template")), k.cancel}
|
|
}
|
|
if k.runs {
|
|
bindings := []key.Binding{k.commands, key.NewBinding(key.WithKeys("g"), key.WithHelp("g", "graph")), key.NewBinding(key.WithKeys("D"), key.WithHelp("D", "debug")), key.NewBinding(key.WithKeys("p"), key.WithHelp("p", "pipeline"))}
|
|
if k.retryAvailable {
|
|
bindings = append(bindings, key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "retry failed")))
|
|
}
|
|
return append(bindings, key.NewBinding(key.WithKeys("tab"), key.WithHelp("Tab", "pane")), key.NewBinding(key.WithKeys("j", "k"), key.WithHelp("j/k", "select/scroll")), key.NewBinding(key.WithKeys("esc"), key.WithHelp("Esc", "back")))
|
|
}
|
|
if k.detail {
|
|
return []key.Binding{k.commands, k.search, key.NewBinding(key.WithKeys("n", "p"), key.WithHelp("n/p", "next/prev stage")), key.NewBinding(key.WithKeys("tab"), key.WithHelp("Tab", "pane")), key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "runs")), key.NewBinding(key.WithKeys("j", "k"), key.WithHelp("j/k", "scroll")), key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "home"))}
|
|
}
|
|
return []key.Binding{k.commands, k.search, k.create, key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "all runs")), key.NewBinding(key.WithKeys("d"), key.WithHelp("d", "drafts")), key.NewBinding(key.WithKeys("b"), key.WithHelp("b", "templates")), k.ping, k.quit}
|
|
}
|
|
func (k keyMap) FullHelp() [][]key.Binding { return [][]key.Binding{k.ShortHelp()} }
|
|
|
|
type Model struct {
|
|
editorCheckGeneration uint64
|
|
editorChecking bool
|
|
statusOpen bool
|
|
statusTop int
|
|
statusRequest, statusError string
|
|
systemStatus *protocol.SystemStatus
|
|
usage *protocol.UsageStats
|
|
draftOpen bool
|
|
draftItems []draft.Draft
|
|
draftIndex, draftTop int
|
|
draftError, draftSource string
|
|
ctx context.Context
|
|
url string
|
|
conn *websocket.Conn
|
|
status string
|
|
nextID uint64
|
|
lines []string
|
|
width int
|
|
height int
|
|
help help.Model
|
|
keys keyMap
|
|
pipelines []protocol.PipelineSummary
|
|
loaded bool
|
|
notificationEndpoints []protocol.NotificationEndpoint
|
|
logSeen []bool
|
|
unread int
|
|
logOpen bool
|
|
logTop int
|
|
paletteOpen bool
|
|
commandInput textinput.Model
|
|
commandIndex int
|
|
homeTop int
|
|
searchOpen bool
|
|
detail *protocol.PipelineDetail
|
|
detailRequest string
|
|
detailLoading bool
|
|
detailError string
|
|
pipelineTop int
|
|
graphPan int
|
|
versionsOpen bool
|
|
versionIndex int
|
|
confirmOpen bool
|
|
actionConfirm *protocol.Message
|
|
pendingDraft *editedMsg
|
|
submitID string
|
|
submitNotice string
|
|
stageIndex int
|
|
stageTop int
|
|
stageFocus bool
|
|
reconnecting bool
|
|
requestedPipelineID int64
|
|
requestedVersion int
|
|
runs []protocol.RunSummary
|
|
runDetail *protocol.RunDetail
|
|
runOpen bool
|
|
runForm int
|
|
runInput textinput.Model
|
|
runPrompt textarea.Model
|
|
runWorkspace string
|
|
cliRun, cliStarted, runPicker bool
|
|
cliOptions RunOptions
|
|
runPickerIndex int
|
|
runPickerInput textinput.Model
|
|
runTask string
|
|
runPaths []string
|
|
runIndex, runTop int
|
|
requestedRunID int64
|
|
runStartRequest string
|
|
runStepIndex int
|
|
runDetailFocus bool
|
|
runCollapsed map[string]bool
|
|
runError string
|
|
runPipelineID int64
|
|
runFailedOnly bool
|
|
runGraphFocus bool
|
|
runGraphTop int
|
|
runGraphPan int
|
|
editorOpen bool
|
|
editorInput textinput.Model
|
|
editorIndex int
|
|
editorDraft *editedMsg
|
|
draftDeletingPath string
|
|
runSpinner spinner.Model
|
|
templates []protocol.Template
|
|
templateOpen, templateRaw bool
|
|
templateIndex, templateTop int
|
|
templateLines []string
|
|
templateRequest, templateError string
|
|
}
|
|
|
|
func New(ctx context.Context, url string) Model {
|
|
return Model{
|
|
ctx: ctx, url: url, status: "Connecting…", width: 80, height: 24,
|
|
help: newHelp(),
|
|
runPrompt: textarea.New(),
|
|
runSpinner: spinner.New(spinner.WithSpinner(spinner.Spinner{Frames: []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}, FPS: time.Second / 12}), spinner.WithStyle(lipgloss.NewStyle().Foreground(themeAccent))),
|
|
keys: keyMap{
|
|
commands: key.NewBinding(key.WithKeys(":"), key.WithHelp(":", "commands")),
|
|
search: key.NewBinding(key.WithKeys("/"), key.WithHelp("/", "search")),
|
|
create: key.NewBinding(key.WithKeys("n"), key.WithHelp("n", "new pipeline")),
|
|
enter: key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "continue")),
|
|
cancel: key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "cancel")),
|
|
ping: key.NewBinding(key.WithKeys("t"), key.WithHelp("t", "test ping")),
|
|
quit: key.NewBinding(key.WithKeys(":quit"), key.WithHelp(":quit", "quit")),
|
|
},
|
|
}
|
|
}
|
|
|
|
func (m Model) Init() tea.Cmd {
|
|
return tea.Batch(m.connect(), runPoll(), m.runSpinner.Tick)
|
|
}
|
|
|
|
func (m Model) connect() tea.Cmd {
|
|
return func() tea.Msg {
|
|
ctx, cancel := context.WithTimeout(m.ctx, 5*time.Second)
|
|
defer cancel()
|
|
conn, err := client.Dial(ctx, m.url)
|
|
if err != nil {
|
|
return errorMsg{err: err}
|
|
}
|
|
// Ensure quitting also closes an idle connection.
|
|
go func() {
|
|
<-m.ctx.Done()
|
|
conn.CloseNow()
|
|
}()
|
|
return connectedMsg{conn}
|
|
}
|
|
}
|
|
|
|
func (m Model) read() tea.Cmd {
|
|
return func() tea.Msg {
|
|
response, err := client.Receive(m.ctx, m.conn)
|
|
if err != nil {
|
|
return errorMsg{err: err, conn: m.conn}
|
|
}
|
|
return socketMsg{conn: m.conn, message: response}
|
|
}
|
|
}
|
|
|
|
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case debugClosedMsg:
|
|
if msg.err != nil {
|
|
m.appendLine("OpenCode debug: " + msg.err.Error())
|
|
}
|
|
return m, nil
|
|
case spinner.TickMsg:
|
|
var cmd tea.Cmd
|
|
m.runSpinner, cmd = m.runSpinner.Update(msg)
|
|
return m, cmd
|
|
case runTick:
|
|
if m.conn == nil {
|
|
return m, runPoll()
|
|
}
|
|
request := protocol.Message{Type: protocol.ListRuns}
|
|
if m.runOpen && m.requestedRunID > 0 {
|
|
request.Type = protocol.GetRun
|
|
request.RunID = m.requestedRunID
|
|
}
|
|
if m.runOpen && m.runDetail != nil {
|
|
request.Type = protocol.GetRun
|
|
request.RunID = m.runDetail.ID
|
|
}
|
|
updated, cmd := m.runRequest(request)
|
|
return updated, tea.Batch(cmd, runPoll())
|
|
case tea.WindowSizeMsg:
|
|
m.width = max(1, msg.Width)
|
|
m.height = max(1, msg.Height)
|
|
m.help.Width = m.width
|
|
if m.runForm == 1 {
|
|
m.runPrompt.SetWidth(max(1, min(96, m.width-12)))
|
|
m.runPrompt.SetHeight(max(1, min(10, m.height-14)))
|
|
}
|
|
if m.templateOpen {
|
|
oldTop := m.templateTop
|
|
m.renderTemplate()
|
|
m.templateTop = oldTop
|
|
}
|
|
if m.keys.detail {
|
|
m.clampPipelineScroll()
|
|
}
|
|
if m.logOpen {
|
|
m.logTop = min(m.logTop, max(0, len(m.lines)-m.logPageSize()))
|
|
m.markVisibleLogs()
|
|
}
|
|
case connectedMsg:
|
|
m.notificationEndpoints = nil
|
|
if m.conn != nil && m.conn != msg.conn {
|
|
m.conn.CloseNow()
|
|
}
|
|
m.conn = msg.conn
|
|
m.reconnecting = false
|
|
m.status = m.url
|
|
if endpoint, err := url.Parse(m.url); err == nil {
|
|
m.status = endpoint.Host
|
|
}
|
|
if m.keys.detail && m.requestedPipelineID > 0 {
|
|
updated, send := m.requestPipeline(m.requestedPipelineID, m.requestedVersion)
|
|
m = updated.(Model)
|
|
return m, tea.Batch(m.read(), send)
|
|
}
|
|
return m, m.read()
|
|
case reconnectMsg:
|
|
if m.conn != nil || m.ctx.Err() != nil {
|
|
return m, nil
|
|
}
|
|
return m, m.connect()
|
|
case socketMsg:
|
|
if msg.conn != m.conn {
|
|
return m, nil
|
|
}
|
|
return m.Update(receivedMsg(msg.message))
|
|
case receivedMsg:
|
|
if msg.Type == protocol.Status && msg.ID == m.statusRequest {
|
|
m.systemStatus = msg.Status
|
|
m.statusError = ""
|
|
m.statusRequest = ""
|
|
return m, m.read()
|
|
}
|
|
if msg.Type == protocol.Error && msg.ID != "" && msg.ID == m.statusRequest {
|
|
m.statusError = msg.Error
|
|
m.statusRequest = ""
|
|
}
|
|
if msg.Type == protocol.PipelineList || msg.Type == protocol.Submitted {
|
|
m.notificationEndpoints = msg.NotificationEndpoints
|
|
}
|
|
if msg.Type == protocol.Templates && msg.ID == m.templateRequest {
|
|
m.templates = msg.Templates
|
|
m.templateIndex = 0
|
|
m.renderTemplate()
|
|
} else if msg.Type == protocol.Runs {
|
|
m.usage = msg.Usage
|
|
m.runs = msg.Runs
|
|
m.runIndex = min(m.runIndex, max(0, len(m.visibleRuns())-1))
|
|
} else if msg.Type == protocol.Run || msg.Type == protocol.RunStarted {
|
|
accepted := m.runOpen && msg.RunDetail != nil && ((msg.Type == protocol.Run && msg.RunDetail.ID == m.requestedRunID) || (msg.Type == protocol.RunStarted && msg.ID == m.runStartRequest))
|
|
if accepted {
|
|
if msg.Type == protocol.RunStarted {
|
|
m.runStartRequest = ""
|
|
}
|
|
m.keys.runs = true
|
|
m.runDetail = msg.RunDetail
|
|
m.requestedRunID = msg.RunDetail.ID
|
|
m.runError = ""
|
|
m.runStepIndex = min(m.runStepIndex, len(msg.RunDetail.Steps))
|
|
}
|
|
} else if msg.Type == protocol.Pong {
|
|
m.appendLine(fmt.Sprintf("pong #%s: %s", msg.ID, msg.Time))
|
|
} else if msg.Type == protocol.Error {
|
|
m.appendLine(fmt.Sprintf("server error #%s: %s", msg.ID, msg.Error))
|
|
if msg.ID == m.templateRequest {
|
|
m.templateError = msg.Error
|
|
}
|
|
if strings.HasPrefix(msg.ID, "run-") && m.runOpen {
|
|
m.runError = msg.Error
|
|
if msg.ID == m.runStartRequest {
|
|
m.runStartRequest = ""
|
|
}
|
|
}
|
|
if msg.ID != "" && msg.ID == m.detailRequest {
|
|
m.detailLoading = false
|
|
m.detailError = msg.Error
|
|
}
|
|
if msg.ID != "" && msg.ID == m.submitID {
|
|
m.submitID = ""
|
|
m.submitNotice = msg.Error
|
|
if m.pendingDraft != nil {
|
|
m.confirmOpen = true
|
|
m.keys.confirm = true
|
|
}
|
|
}
|
|
} else if msg.Type == protocol.Submitted {
|
|
m.draftOpen = false
|
|
m.keys.drafts = false
|
|
m.templateOpen = false
|
|
m.keys.templates = false
|
|
m.appendLine(fmt.Sprintf("Submitted %s: version %d", msg.Name, msg.Version))
|
|
m.pipelines = msg.Pipelines
|
|
m.loaded = true
|
|
if msg.ID == m.submitID {
|
|
m.submitID = ""
|
|
m.pendingDraft = nil
|
|
m.confirmOpen = false
|
|
m.keys.confirm = false
|
|
m.submitNotice = fmt.Sprintf("Submitted version %d", msg.Version)
|
|
}
|
|
if msg.Detail != nil {
|
|
m.detail = msg.Detail
|
|
m.keys.detail = true
|
|
m.detailLoading = false
|
|
m.detailRequest = ""
|
|
m.detailError = ""
|
|
m.resetPipelineView()
|
|
m.requestedPipelineID = msg.Detail.ID
|
|
m.requestedVersion = msg.Detail.Version
|
|
}
|
|
} else if msg.Type == protocol.Pipeline {
|
|
if msg.ID == m.detailRequest {
|
|
if msg.Detail == nil || (m.requestedPipelineID > 0 && msg.Detail.ID != m.requestedPipelineID) || (m.requestedVersion > 0 && msg.Detail.Version != m.requestedVersion) {
|
|
m.detailLoading = false
|
|
m.detailError = "Server returned a different pipeline or version than requested"
|
|
return m, m.read()
|
|
}
|
|
m.detail = msg.Detail
|
|
m.keys.detail = true
|
|
m.detailLoading = false
|
|
m.detailError = ""
|
|
m.resetPipelineView()
|
|
if m.cliRun && !m.cliStarted {
|
|
updated, cmd := m.configureCLIRun()
|
|
return updated, tea.Batch(m.read(), cmd)
|
|
}
|
|
}
|
|
} else if msg.Type == protocol.PipelineList {
|
|
m.pipelines = msg.Pipelines
|
|
m.loaded = true
|
|
if m.cliRun && !m.cliStarted && m.cliOptions.Pipeline != "" {
|
|
for _, p := range m.pipelines {
|
|
if p.Name == m.cliOptions.Pipeline {
|
|
m.runPicker = false
|
|
updated, send := m.requestPipeline(p.ID, p.Version)
|
|
return updated, tea.Batch(m.read(), send)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
m.appendLine("unexpected response: " + msg.Type)
|
|
}
|
|
return m, m.read()
|
|
case draftValidationMsg:
|
|
if len(m.draftItems) > 0 && m.draftItems[m.draftIndex].Path == msg.path {
|
|
m.draftError = "Validation passed (structure only)."
|
|
if msg.err != nil {
|
|
m.draftError = "Validation: " + msg.err.Error()
|
|
}
|
|
}
|
|
return m, nil
|
|
case sentMsg:
|
|
// Responses are displayed by the independent read loop.
|
|
case editedMsg:
|
|
m.appendLine("Draft: " + msg.path)
|
|
if msg.err != nil {
|
|
m.appendLine("editor: " + msg.err.Error())
|
|
return m, nil
|
|
}
|
|
if m.conn != nil {
|
|
m.editorCheckGeneration++
|
|
m.editorChecking = true
|
|
m.confirmOpen = false
|
|
m.keys.confirm = false
|
|
m.submitNotice = "Checking whether edits were published…"
|
|
return m, checkEditorPublication(m.ctx, m.url, msg, m.editorCheckGeneration)
|
|
}
|
|
if msg.unchanged {
|
|
m.confirmOpen = false
|
|
m.keys.confirm = false
|
|
m.submitNotice = "No changes."
|
|
m.appendLine("No changes; nothing to submit.")
|
|
return m, nil
|
|
}
|
|
// Editor completion is never approval to publish, for either new or existing drafts.
|
|
m.pendingDraft = &msg
|
|
m.confirmOpen = true
|
|
m.keys.confirm = true
|
|
m.submitNotice = ""
|
|
return m, nil
|
|
case editorPublicationMsg:
|
|
return m.finishEditorPublication(msg)
|
|
case errorMsg:
|
|
if msg.conn != nil && msg.conn != m.conn {
|
|
return m, nil
|
|
}
|
|
if msg.conn == nil && m.conn != nil {
|
|
return m, nil
|
|
}
|
|
m.status = "Reconnecting…"
|
|
if m.statusOpen {
|
|
m.statusError = "Connection lost; reconnecting. Press r to refresh after reconnect."
|
|
m.statusRequest = ""
|
|
}
|
|
m.appendLine("error: " + msg.err.Error())
|
|
m.detailRequest = ""
|
|
m.detailLoading = m.keys.detail && m.requestedPipelineID > 0
|
|
m.submitID = ""
|
|
if m.pendingDraft != nil {
|
|
m.submitNotice = "Connection lost; submission outcome unknown. Draft retained."
|
|
}
|
|
if m.conn != nil {
|
|
m.conn.CloseNow()
|
|
m.conn = nil
|
|
}
|
|
m.reconnecting = true
|
|
return m, tea.Tick(time.Second, func(time.Time) tea.Msg { return reconnectMsg{} })
|
|
case tea.KeyMsg:
|
|
if msg.String() == "ctrl+c" {
|
|
return m, tea.Quit
|
|
}
|
|
if m.actionConfirm != nil {
|
|
return m.updateActionConfirm(msg)
|
|
}
|
|
if m.editorChecking {
|
|
return m, nil
|
|
}
|
|
if m.editorOpen {
|
|
return m.updateEditorPicker(msg)
|
|
}
|
|
if m.statusOpen {
|
|
return m.updateStatus(msg)
|
|
}
|
|
if m.logOpen {
|
|
return m.updateLogs(msg)
|
|
}
|
|
if m.paletteOpen {
|
|
return m.updatePalette(msg)
|
|
}
|
|
if m.confirmOpen {
|
|
return m.updateConfirm(msg)
|
|
}
|
|
if m.draftOpen {
|
|
return m.updateDrafts(msg)
|
|
}
|
|
if m.runPicker {
|
|
return m.updateRunPicker(msg)
|
|
}
|
|
if m.runForm != 0 {
|
|
return m.updateRunForm(msg)
|
|
}
|
|
if m.runOpen && msg.String() != ":" {
|
|
return m.updateRuns(msg)
|
|
}
|
|
if m.versionsOpen {
|
|
return m.updateVersions(msg)
|
|
}
|
|
if m.templateOpen {
|
|
return m.updateTemplates(msg)
|
|
}
|
|
switch {
|
|
case m.homePage() && msg.String() == "r":
|
|
m.closeRuns()
|
|
m.runFailedOnly = false
|
|
m.runOpen = true
|
|
m.keys.runs = true
|
|
m.runIndex = 0
|
|
return m.runRequest(protocol.Message{Type: protocol.ListRuns})
|
|
case m.homePage() && msg.String() == "d":
|
|
return m.openDrafts()
|
|
case m.homePage() && msg.String() == "b":
|
|
return m.openTemplates()
|
|
case key.Matches(msg, m.keys.commands), key.Matches(msg, m.keys.search):
|
|
m.paletteOpen = true
|
|
m.searchOpen = key.Matches(msg, m.keys.search)
|
|
m.keys.palette = true
|
|
m.commandIndex = 0
|
|
m.commandInput = newInput()
|
|
if m.searchOpen {
|
|
m.commandInput.Placeholder = "Search pipelines…"
|
|
} else {
|
|
m.commandInput.Placeholder = ":logs"
|
|
m.commandInput.SetValue(":")
|
|
}
|
|
return m, m.commandInput.Focus()
|
|
case m.homePage() && key.Matches(msg, m.keys.create):
|
|
if m.conn == nil {
|
|
m.appendLine("not connected")
|
|
return m, nil
|
|
}
|
|
return m.newPipeline(pipeline.Template([]string{"worker"}, true))
|
|
case m.homePage() && key.Matches(msg, m.keys.ping):
|
|
if m.conn == nil {
|
|
m.appendLine("not connected")
|
|
return m, nil
|
|
}
|
|
m.nextID++
|
|
id := strconv.FormatUint(m.nextID, 10)
|
|
m.appendLine("ping #" + id)
|
|
return m, func() tea.Msg {
|
|
ctx, cancel := context.WithTimeout(m.ctx, 5*time.Second)
|
|
defer cancel()
|
|
if err := client.Send(ctx, m.conn, protocol.Message{Type: protocol.Ping, ID: id}); err != nil {
|
|
return errorMsg{err: err, conn: m.conn}
|
|
}
|
|
return sentMsg{id}
|
|
}
|
|
case m.keys.detail:
|
|
return m.updatePipeline(msg)
|
|
case msg.String() == "j" || msg.String() == "down":
|
|
m.homeTop = min(m.homeTop+1, max(0, len(m.homeLines())-max(1, m.height-4)))
|
|
case msg.String() == "k" || msg.String() == "up":
|
|
m.homeTop = max(0, m.homeTop-1)
|
|
}
|
|
}
|
|
if m.runForm != 0 {
|
|
var cmd tea.Cmd
|
|
if m.runForm == 1 {
|
|
m.runPrompt, cmd = m.runPrompt.Update(msg)
|
|
return m, cmd
|
|
}
|
|
m.runInput, cmd = m.runInput.Update(msg)
|
|
return m, cmd
|
|
}
|
|
if m.paletteOpen {
|
|
var cmd tea.Cmd
|
|
m.commandInput, cmd = m.commandInput.Update(msg)
|
|
return m, cmd
|
|
}
|
|
if m.runPicker {
|
|
var cmd tea.Cmd
|
|
m.runPickerInput, cmd = m.runPickerInput.Update(msg)
|
|
return m, cmd
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (m *Model) appendLine(line string) {
|
|
follow := m.logOpen && m.logTop >= max(0, len(m.lines)-m.logPageSize())
|
|
for _, part := range strings.Split(line, "\n") {
|
|
m.lines = append(m.lines, ansi.Strip(part))
|
|
m.logSeen = append(m.logSeen, false)
|
|
m.unread++
|
|
}
|
|
if m.logOpen {
|
|
if follow {
|
|
m.logTop = max(0, len(m.lines)-m.logPageSize())
|
|
}
|
|
m.markVisibleLogs()
|
|
}
|
|
}
|
|
|
|
func (m Model) View() string {
|
|
connection := m.status
|
|
if m.conn == nil {
|
|
connection = m.loading(connection)
|
|
}
|
|
if len(m.notificationEndpoints) > 0 {
|
|
endpoint := m.notificationEndpoints[0]
|
|
address := endpoint.ServerURL
|
|
if address == "" {
|
|
address = "not configured"
|
|
}
|
|
connection += " · ntfy " + address + " · topic " + endpoint.Topic
|
|
if m.width < 100 {
|
|
connection = m.status + " · ntfy " + address + "/" + endpoint.Topic
|
|
}
|
|
}
|
|
status := ansi.Truncate(connection, max(0, m.width-min(24, m.width/4)), "…")
|
|
title := ""
|
|
if titleWidth := m.width - lipgloss.Width(status) - 1; titleWidth > 0 {
|
|
name := "Pipelines"
|
|
if m.keys.detail && m.detail != nil {
|
|
name = fmt.Sprintf("%s · v%d", m.detail.Name, m.detail.Version)
|
|
}
|
|
if m.detailLoading {
|
|
name = "Loading pipeline"
|
|
if m.requestedVersion > 0 {
|
|
name = fmt.Sprintf("Loading v%d", m.requestedVersion)
|
|
}
|
|
}
|
|
if m.runOpen {
|
|
name = "Runs"
|
|
if m.requestedRunID > 0 {
|
|
name = fmt.Sprintf("Run #%d", m.requestedRunID)
|
|
}
|
|
}
|
|
if m.templateOpen {
|
|
name = "Templates"
|
|
}
|
|
if m.draftOpen {
|
|
name = "Drafts"
|
|
}
|
|
title = ansi.Truncate(name, titleWidth, "…")
|
|
}
|
|
gap := max(0, m.width-lipgloss.Width(title)-lipgloss.Width(status))
|
|
headerLine := lipgloss.NewStyle().Bold(true).Foreground(themeAccent).Render(title) + strings.Repeat(" ", gap) + lipgloss.NewStyle().Foreground(themeMuted).Render(status)
|
|
header := lipgloss.NewStyle().Background(themeSurface).Foreground(themeText).
|
|
Width(m.width).Render(surfaceContent(headerLine, themeSurface)) + "\n"
|
|
footer := "\n" + lipgloss.NewStyle().Width(m.width).Render(m.footerContent())
|
|
if m.height < 4 {
|
|
return lipgloss.NewStyle().MaxHeight(m.height).Render(header + "\n" + footer)
|
|
}
|
|
bodyHeight := max(0, m.height-lipgloss.Height(header)-lipgloss.Height(footer))
|
|
lines := m.homeLines()
|
|
top := m.homeTop
|
|
top = min(top, max(0, len(lines)-bodyHeight))
|
|
lines = lines[top:min(len(lines), top+bodyHeight)]
|
|
body := make([]string, bodyHeight)
|
|
for i, line := range lines {
|
|
body[i] = ansi.Truncate(line, m.width, "…")
|
|
}
|
|
parts := []string{header}
|
|
if bodyHeight > 0 {
|
|
content := strings.Join(body, "\n")
|
|
if m.keys.detail {
|
|
content = m.pipelineView(bodyHeight)
|
|
}
|
|
if m.runOpen {
|
|
content = m.runsView(bodyHeight)
|
|
}
|
|
if m.templateOpen {
|
|
content = m.templatesView(bodyHeight)
|
|
}
|
|
if m.draftOpen {
|
|
content = m.draftsView(bodyHeight)
|
|
}
|
|
if m.runForm != 0 {
|
|
content = m.runFormView(bodyHeight)
|
|
}
|
|
if m.runPicker {
|
|
content = m.runPickerView(bodyHeight)
|
|
}
|
|
if m.logOpen {
|
|
content = m.logsView(bodyHeight)
|
|
} else if m.paletteOpen {
|
|
content = m.paletteView(bodyHeight)
|
|
} else if m.versionsOpen {
|
|
content = m.versionsView(bodyHeight)
|
|
} else if m.confirmOpen {
|
|
content = m.confirmView(bodyHeight)
|
|
}
|
|
if m.editorOpen {
|
|
content = m.editorPickerView(bodyHeight)
|
|
}
|
|
if m.statusOpen {
|
|
content = m.statusView(bodyHeight)
|
|
}
|
|
if m.actionConfirm != nil {
|
|
content = m.actionConfirmView(bodyHeight)
|
|
}
|
|
if m.editorChecking {
|
|
content = popup(m.width, bodyHeight, 76, []string{"Checking published edits", m.loading("Refreshing pipeline information…"), "Local draft remains retained."})
|
|
}
|
|
parts = append(parts, content)
|
|
}
|
|
return strings.Join(append(parts, footer), "\n")
|
|
}
|