Files
alan 8c1eea53a9 Report a stale client and refuse an unreadable newer server
Exchange a build/protocol identity so an older CLI can no longer talk to a
newer native server silently:

- protocol carries ProtocolVersion and every server frame (including the
  unsolicited welcome) is stamped with the server build and protocol, so a
  client that never pings still learns the server identity.
- buildinfo.Compare classifies the relationship as InSync/Warn/Refuse and
  names both builds; the client Watch reports one warning per connection and
  returns a hard error when the server speaks a newer, uninterpretable
  protocol so the caller never acts on the frame.
- client.ReceiveNotice decodes the raw frame so an unmodeled top-level field
  produces a one-time "unrecognized field(s)" notice instead of being dropped
  silently (the case that hid the artifacts field).
- CLI routes warnings to stderr, keeps machine JSON stdout clean and fails
  non-zero on a refused mismatch; ping/connection print the client/server
  relationship. The TUI surfaces the same notices through the shared log.
- scripts/setup-native.py now warns when an older `pipelines` earlier on PATH
  shadows prefix/bin/pipelines, naming both paths and versions, without
  installing or modifying anything else.
- Docs, the packaged debugging skill reference and README no longer imply the
  installed CLI always matches the server.

Tests cover the comparison table, unknown-field detection and caching, the
server identity stamping on pong and welcome, the CLI/TUI reporting paths and
the installer PATH shadowing warning.
2026-10-16 18:37:01 +01:00

212 lines
6.1 KiB
Go

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 := &noticeSink{}
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)
}