Files
alan 05ae530442 Make Pipelines Docker-only with OpenCode and Pi
Install current verified harness releases inside Docker, preserve persistent accounts and settings, and provide separate interactive and pipeline model defaults with terminal onboarding and fuzzy pickers.

Add Docker-aware authoring transport, Pi stage execution, bounded workflow controls, reliable final-result readback and usage settlement, and finite short-lived CLI pipe draining. Keep dated installation evidence and packaged authoring guidance consistent.

Verified with a real Docker installation, both harness stages and interactive authors, the built-in plan/implement/review starter, independent host race/vet checks, installer tests, and packaged skill tests. Generated release receipts stay ignored in clean checkouts.
2026-10-11 23:00:25 +01:00

146 lines
4.4 KiB
Go

package tui
import (
"context"
"fmt"
"os"
"os/exec"
"strings"
"time"
tea "github.com/charmbracelet/bubbletea"
"git.a-wan.net/alan/pipelines/internal/author"
"git.a-wan.net/alan/pipelines/internal/client"
"git.a-wan.net/alan/pipelines/internal/draft"
"git.a-wan.net/alan/pipelines/internal/harness"
"git.a-wan.net/alan/pipelines/internal/protocol"
"git.a-wan.net/alan/pipelines/internal/runinspect"
)
type editedMsg struct {
name, path, source string
err error
confirm bool
unchanged bool
createOnly bool
baseVersion int
}
func (m Model) send(request protocol.Message) tea.Cmd {
return func() tea.Msg {
ctx, cancel := context.WithTimeout(m.ctx, 10*time.Second)
defer cancel()
if err := client.Send(ctx, m.conn, request); err != nil {
return errorMsg{err: err, conn: m.conn}
}
return sentMsg{request.ID}
}
}
func editDraft(name, source string, confirm ...bool) tea.Cmd {
needsConfirm := len(confirm) > 0 && confirm[0]
return editDraftMode(name, source, needsConfirm, false)
}
func editDraftMode(name, source string, needsConfirm, fresh bool, metadata ...draft.Draft) tea.Cmd {
return editDraftUsing("", name, source, needsConfirm, fresh, metadata...)
}
func editDraftUsing(choice, name, source string, needsConfirm, fresh bool, metadata ...draft.Draft) tea.Cmd {
var meta draft.Draft
if len(metadata) > 0 {
meta = metadata[0]
}
d := meta
var err error
if d.Path == "" {
d, err = draft.Create(name, source, meta.Server, fresh, meta.BaseVersion)
}
path := d.Path
if err != nil {
return func() tea.Msg { return editedMsg{name: name, path: path, err: err} }
}
var command *exec.Cmd
if choice == "nvim" {
command = exec.Command("nvim", path)
} else if choice == "" && name != "" && (strings.TrimSpace(os.Getenv("VISUAL")) != "" || strings.TrimSpace(os.Getenv("EDITOR")) != "") {
editor, args, editorErr := draftEditor()
if editorErr != nil {
return func() tea.Msg { return editedMsg{name: name, path: path, err: editorErr} }
}
command = exec.Command(editor, append(args, path)...)
} else {
executable, exeErr := os.Executable()
if exeErr != nil {
return func() tea.Msg { return editedMsg{name: name, path: path, err: exeErr} }
}
if cli, lookupErr := runinspect.CLIExecutable(); lookupErr == nil {
executable = cli
} else if choice == "opencode" || choice == "pi" {
return func() tea.Msg {
return editedMsg{name: name, path: path, err: fmt.Errorf("pipelines CLI is required for harness editing: %w", lookupErr)}
}
}
prefix, prefixErr := harness.CLIPrefixFor(choice, meta.Server, executable)
if prefixErr != nil {
return func() tea.Msg { return editedMsg{name: name, path: path, err: prefixErr} }
}
command, err = author.HarnessCommand(context.Background(), choice, d, "", prefix)
if err != nil {
return func() tea.Msg { return editedMsg{name: name, path: path, err: err} }
}
}
return tea.ExecProcess(command, func(err error) tea.Msg {
result := readEditedDraft(name, path, source, needsConfirm, err)
if name == "" {
if updated, loadErr := draft.Load(path); loadErr == nil {
result.name = updated.Name
}
}
result.baseVersion = meta.BaseVersion
if fresh {
result.unchanged = false
result.createOnly = true
}
return result
})
}
func draftEditor() (string, []string, error) {
for _, name := range []string{"VISUAL", "EDITOR"} {
if value := strings.TrimSpace(os.Getenv(name)); value != "" {
shell, err := exec.LookPath("sh")
return shell, []string{"-c", value + ` "$1"`, "pipelines-editor"}, err
}
}
for _, name := range []string{"nvim", "vim", "vi", "nano"} {
if path, err := exec.LookPath(name); err == nil {
return path, nil, nil
}
}
return "", nil, fmt.Errorf("no editor found; set VISUAL or EDITOR, or install vim/nano")
}
func readEditedDraft(name, path, original string, confirm bool, editorErr error) editedMsg {
result := editedMsg{name: name, path: path, err: editorErr, confirm: confirm}
if editorErr != nil {
return result
}
info, err := os.Stat(path)
if err != nil {
result.err = err
return result
}
if info.Size() > 1<<20 {
result.err = fmt.Errorf("file exceeds 1 MiB")
return result
}
data, err := os.ReadFile(path)
result.source, result.err = string(data), err
// A new pipeline still needs its initial submission even if its template
// was left untouched. Existing edits require actual byte-for-byte changes.
result.unchanged = err == nil && confirm && result.source == original
return result
}