Files
pipelines/internal/tui/drafts.go
T
alan 914345cb31 Move harness profiles between host and Docker and stop silent draft retargeting
Native installs left Docker-era harness profiles in harnesses.json, so every
authoring launch failed trying to reach a Docker service, and a retained draft
bound to the old Docker server was silently projected onto the configured one.

- harness: add Profile.Mode and VerifyDockerLink as the single mode/verification
  helpers. `harness setup --host` configures or converts a host profile and
  clears docker_directory; reconfiguring a Docker-linked profile re-verifies the
  recorded directory still owns compose.yaml and fails naming it instead of
  saving a link that cannot launch. Setup's summary and `harness list` (via the
  new List/ListView shape) report the resulting mode and, for Docker, the
  directory, without changing the stored Config schema.
- setup-native.py: after build/install-skill it writes host (no docker_directory)
  profiles for the detected harnesses, defaulting to the detected OpenCode profile
  rather than a stale pi default, taking models from --model or the existing valid
  profile and never inventing one; it clears a stale Docker link and preserves
  unrelated keys/profiles. Detection-only: no harness install, upgrade or download.
- draft: add Draft.Resolve, the shared mismatch helper, which projects a draft
  onto the configured server and returns a dual-URL notice. CLI validate/submit
  and the TUI draft browser use it so a foreign draft is never silently
  retargeted; the TUI pre-wraps the notice to the panel width.
- Tests cover the Docker->host and host->host transitions, the missing-directory
  failure, installer write/migration (Python), and the CLI/TUI notice, using the
  real config file path in a temp dir.
- Update help text, README, docs and the packaged authoring skill reference to
  describe host as the default and the Docker-linked case.
2026-10-15 19:53:10 +01:00

209 lines
6.0 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
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()
_, err = c.Call(ctx, protocol.Message{Type: protocol.Validate, Source: source})
return draftValidationMsg{path: d.Path, 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)
}