Setup lets every part be chosen, each with its settings; three machines each run the gateway

The setup screens list the parts of an install: control plane, store, model
mirror, this machine as a node, starter model, pictures and 3D, the judge,
firewall, notifications, limits, on-demand turns and an offline bundle. Each
says what it is or what is missing without it. Space turns a part on or off;
Enter opens its settings in a dialog that explains it. A plan page lists what
is installed and what is left out, and the same install as a command. Every
setting is a server init flag too, written into server.yaml when init writes
it.

With three machines, the two database machines become control planes too,
standing by (server add's steps), with an optional floating address. The
mirror's management API answers all three control planes, so a standby that
comes to lead can still fetch models.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ilker ManapandClaude Opus 5.5 committed 2026-10-15 11:22:36 +02:00
1 parent 733e20924c
commit 94401e21e6
16 files changed
+2255 -483

No files matched your search

+60 -223
View File
@@ -4,7 +4,6 @@ import (
"context"
"fmt"
"io"
"net/mail"
"os"
"path/filepath"
"strings"
@@ -47,35 +46,16 @@ func (w *lineWriter) Write(p []byte) (int, error) {
}
// Form fields, in order.
const (
fAdmin = iota
fHosts
fWebhooks
fPostgres
fMirror
fNode
fModel
fGuard
fBundle
fBundleSHA
fStart
fCount
)
type initModel struct {
in *serverInit
found []string // this machine's addresses
// The form, until it is submitted.
form bool
focus int
admin textField
hosts textField
webhooks textField
bundle textField
bundleSHA textField
toggles [fCount]bool
formError string
// The parts to install, until they are chosen and the plan agreed to.
form bool
plan bool
choices *installForm
// scroll is how far the panel is scrolled, back to the top on each page.
scroll int
// Then the run.
running bool
@@ -95,43 +75,9 @@ type initModel struct {
}
func newInitModel(in *serverInit, found []string, askForm bool) initModel {
admin := newTextField()
admin.Placeholder = "you@example.com"
admin.SetValue(in.admin)
admin.CharLimit = 200
admin.Width = 40
hosts := newTextField()
hosts.Placeholder = "llm.example.com, 203.0.113.10"
hosts.SetValue(strings.Join(in.hosts, ", "))
hosts.CharLimit = 400
hosts.Width = 40
webhooks := newTextField()
webhooks.Placeholder = "https://hooks.slack.com/services/…"
webhooks.SetValue(strings.Join(in.webhooks, ", "))
webhooks.CharLimit = 800
webhooks.Width = 40
bundle := newTextField()
bundle.Placeholder = "/media/usb/llmgw-bundle.tar"
bundle.SetValue(in.bundle)
bundle.CharLimit = 400
bundle.Width = 40
bundleSHA := newTextField()
bundleSHA.Placeholder = "the sha256 'llmgw bundle create' printed"
bundleSHA.SetValue(in.bundleSHA)
bundleSHA.CharLimit = 64
bundleSHA.Width = 64
sp := newSpinner()
m := initModel{in: in, found: found, form: askForm, admin: admin, hosts: hosts, webhooks: webhooks,
bundle: bundle, bundleSHA: bundleSHA, spin: sp, width: 100}
m.toggles[fPostgres] = in.postgres
m.toggles[fMirror] = !in.noMirror
m.toggles[fNode] = !in.noNode
m.toggles[fModel] = !in.noModel
m.toggles[fGuard] = !in.noGuardModel
if askForm {
m.admin.Focus()
}
return m
host, _ := os.Hostname()
return initModel{in: in, found: found, form: askForm, choices: newInstallForm(in, host, found, false),
spin: newSpinner(), width: 100, height: 30}
}
func (m initModel) Init() tea.Cmd {
@@ -147,6 +93,7 @@ func (m initModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case tea.WindowSizeMsg:
m.width, m.height = msg.Width, msg.Height
m.choices.height = msg.Height
if m.framed {
m.width = msg.Width - navWidth - 6
}
@@ -209,118 +156,32 @@ func (m *initModel) addLine(l string) {
func (m initModel) formKey(k tea.KeyMsg) (tea.Model, tea.Cmd) {
switch k.Type {
case tea.KeyTab, tea.KeyDown:
m.moveFocus(1)
case tea.KeyPgDown:
m.scroll += max(1, m.height-8)
return m, nil
case tea.KeyShiftTab, tea.KeyUp:
m.moveFocus(-1)
case tea.KeyPgUp:
m.scroll = max(0, m.scroll-max(1, m.height-8))
return m, nil
case tea.KeyEnter:
if m.focus != fStart {
m.moveFocus(1)
return m, nil
}
admin := strings.TrimSpace(m.admin.Value())
if admin != "" {
if _, err := mail.ParseAddress(admin); err != nil {
m.formError = "the administrator's email is not an address"
m.focus = fAdmin
m.admin.Focus()
return m, nil
}
}
bundle, sum := strings.TrimSpace(m.bundle.Value()), strings.ToLower(strings.TrimSpace(m.bundleSHA.Value()))
switch {
case bundle != "" && sum == "":
m.formError = "give the bundle's sha256, as 'llmgw bundle create' printed it"
m.focus = fBundleSHA
m.moveFocus(0)
return m, nil
case bundle != "" && !m.toggles[fMirror] && m.in.mirrorURL == "":
m.formError = "an offline bundle goes into the model mirror: tick it"
m.focus = fMirror
m.moveFocus(0)
return m, nil
}
hooks := strings.TrimSpace(m.webhooks.Value())
if _, err := parseWebhooks([]string{hooks}); err != nil {
m.formError = err.Error()
m.focus = fWebhooks
m.moveFocus(0)
return m, nil
}
m.in.webhooks = nil
if hooks != "" {
m.in.webhooks = []string{hooks}
}
m.in.bundle, m.in.bundleSHA = bundle, sum
m.in.admin = admin
m.in.hosts = nil
for _, h := range strings.Split(m.hosts.Value(), ",") {
if h = strings.TrimSpace(h); h != "" {
m.in.hosts = append(m.in.hosts, h)
}
}
m.in.postgres = m.toggles[fPostgres]
m.in.noMirror = !m.toggles[fMirror]
m.in.noNode = !m.toggles[fNode]
m.in.noModel = !m.toggles[fModel]
m.in.noGuardModel = !m.toggles[fGuard]
m.form = false
return m, tea.Batch(m.spin.Tick, func() tea.Msg { return startInitMsg{} })
}
switch m.focus {
case fAdmin:
var cmd tea.Cmd
m.admin, cmd = m.admin.Update(k)
return m, cmd
case fHosts:
var cmd tea.Cmd
m.hosts, cmd = m.hosts.Update(k)
return m, cmd
case fWebhooks:
var cmd tea.Cmd
m.webhooks, cmd = m.webhooks.Update(k)
return m, cmd
case fBundle:
var cmd tea.Cmd
m.bundle, cmd = m.bundle.Update(k)
return m, cmd
case fBundleSHA:
var cmd tea.Cmd
m.bundleSHA, cmd = m.bundleSHA.Update(k)
return m, cmd
case fPostgres, fMirror, fNode, fModel, fGuard:
if k.String() == " " || k.String() == "x" {
m.toggles[m.focus] = !m.toggles[m.focus]
if m.plan {
switch k.Type {
case tea.KeyEsc:
m.plan, m.scroll = false, 0
case tea.KeyEnter:
m.form, m.plan, m.scroll = false, false, 0
return m, tea.Batch(m.spin.Tick, func() tea.Msg { return startInitMsg{} })
}
return m, nil
}
if m.choices.key(k, m.in) {
m.plan, m.scroll = true, 0
}
return m, nil
}
func (m *initModel) moveFocus(d int) {
m.focus = (m.focus + d + fCount) % fCount
// With --mirror there is no mirror to run here, so nothing to tick.
if m.focus == fMirror && m.in.mirrorURL != "" {
m.focus = (m.focus + d + fCount) % fCount
}
m.admin.Blur()
m.hosts.Blur()
m.webhooks.Blur()
m.bundle.Blur()
m.bundleSHA.Blur()
switch m.focus {
case fAdmin:
m.admin.Focus()
case fHosts:
m.hosts.Focus()
case fWebhooks:
m.webhooks.Focus()
case fBundle:
m.bundle.Focus()
case fBundleSHA:
m.bundleSHA.Focus()
}
// command is this install as a command line, for doing it again from a script.
func (in *serverInit) command() string {
return strings.Join(append([]string{"sudo llmgw server init"}, in.initFlags()...), " \\\n ")
}
func (m initModel) View() string {
@@ -331,27 +192,50 @@ func (m initModel) View() string {
if i := strings.Index(body, "\n\n"); i >= 0 {
body = body[i+1:]
}
steps := []navItem{{Label: "Start", State: "done"}, {Label: "Settings", State: "current"}, {Label: "Install", State: "todo"}}
keys := "Tab/↑↓ move · Space tick · Enter on Set up · Ctrl+C leave"
if !m.form {
steps := []navItem{{Label: "Start", State: "done"}, {Label: "Choices", State: "current"},
{Label: "Plan", State: "todo"}, {Label: "Install", State: "todo"}}
keys := m.choices.keys()
title := "What to install"
switch {
case m.form && m.plan:
steps[1].State, steps[2].State = "done", "current"
keys = "Ctrl+C stop"
keys, title = "Enter install · Esc back to the choices · PgUp/PgDn scroll · Ctrl+C leave", "Plan"
case !m.form:
steps[1].State, steps[2].State, steps[3].State = "done", "done", "current"
keys, title = "Ctrl+C stop", "Installing"
if m.done {
steps[2].State = "done"
steps[3].State = "done"
keys = "Enter close"
}
}
host, _ := os.Hostname()
return frame{Width: m.width + navWidth + 6, Height: m.height, Title: "llmgw setup", Where: host,
NavTitle: "Steps", Nav: steps, PanelTitle: "This machine as a control plane", Body: body, Keys: keys}.render()
f := frame{Width: m.width + navWidth + 6, Height: m.height, Title: "llmgw setup",
NavTitle: "Steps", Nav: steps, PanelTitle: title, Body: body, Keys: keys, Scroll: m.scroll}
if m.form && !m.plan {
f.DialogTitle, f.Dialog = m.choices.overlay()
}
f.Where, _ = os.Hostname()
return f.render()
}
// plainView is the screen as text, for a panel or a terminal that is not one.
func (m initModel) plainView() string {
var b strings.Builder
b.WriteString(sTitle.Render("llmgw · setting up this machine as a control plane") + "\n\n")
if m.form && m.plan {
b.WriteString(m.choices.planView(m.width))
b.WriteString("\n " + sDim.Render("The same from a script:") + "\n")
for _, l := range strings.Split(m.in.command(), "\n") {
b.WriteString(" " + l + "\n")
}
b.WriteString("\n" + button(true, "Enter to install") + "\n")
return b.String()
}
if m.form {
return b.String() + m.formView()
b.WriteString(m.choices.view(m.width))
if title, d := m.choices.overlay(); d != "" && !m.framed {
b.WriteString("\n" + sTitle.Render(title) + "\n" + d + "\n")
}
return b.String()
}
for _, l := range m.visibleLines() {
b.WriteString(m.lineView(l) + "\n")
@@ -411,53 +295,6 @@ func (m initModel) lineView(l string) string {
return " " + t
}
func (m initModel) formView() string {
var b strings.Builder
label := func(i int, s string) string {
if m.focus == i {
return sTitle.Render("› " + s)
}
return " " + s
}
check := func(i int, s, hint string) string {
box := "[ ]"
if m.toggles[i] {
box = "[" + sOK.Render("x") + "]"
}
return fmt.Sprintf("%s %s %s\n", label(i, box), s, sDim.Render(hint))
}
fmt.Fprintf(&b, "%s\n %s\n", label(fAdmin, "Administrator's email"), m.admin.View())
b.WriteString(" " + sDim.Render("A password is generated and shown once. Leave empty to create accounts later.") + "\n\n")
fmt.Fprintf(&b, "%s\n %s\n", label(fHosts, "Other names nodes will reach this machine by"), m.hosts.View())
found := "none found"
if len(m.found) > 0 {
found = strings.Join(m.found, ", ")
}
b.WriteString(" " + sDim.Render("Already in the certificate: "+found+". Add a DNS name or NAT address here.") + "\n\n")
fmt.Fprintf(&b, "%s\n %s\n", label(fWebhooks, "Notification webhooks"), m.webhooks.View())
b.WriteString(" " + sDim.Render("Where a parked model, a lost node or a spent budget is said: Slack, Mattermost, or any URL taking JSON. Comma-separated; a test is sent.") + "\n\n")
b.WriteString(check(fPostgres, "PostgreSQL", "rather than SQLite; installed here, for several control planes or a larger store"))
if m.in.mirrorURL != "" {
b.WriteString(" Model mirror " + sDim.Render("at "+m.in.mirrorURL+", from --mirror") + "\n")
} else {
b.WriteString(check(fMirror, "Model mirror", "downloads model files once for every node"))
}
b.WriteString(check(fNode, "This machine as a node", "serves models here too, on its GPUs or CPU"))
b.WriteString(check(fModel, "Starter model", "a small Qwen, so there is something to ask at once"))
b.WriteString(check(fGuard, "Guardrails' judge", "Llama Guard 3 1B on a CPU, refusing violent, criminal and abusive requests"))
fmt.Fprintf(&b, "\n%s\n %s\n", label(fBundle, "Offline bundle"), m.bundle.View())
b.WriteString(" " + sDim.Render("For a site with no internet: engines, releases and models from 'llmgw bundle create'. Empty downloads them.") + "\n")
fmt.Fprintf(&b, "%s\n %s\n", label(fBundleSHA, "Its sha256"), m.bundleSHA.View())
b.WriteString("\n" + label(fStart, lipgloss.NewStyle().Bold(true).Render("Set up")) + "\n")
if m.formError != "" {
b.WriteString("\n" + sBad.Render(m.formError) + "\n")
}
if !m.framed { // the frame's key bar says it
b.WriteString("\n" + sDim.Render("tab or ↑↓ to move · space to tick · enter on Set up to start · ctrl+c to leave") + "\n")
}
return b.String()
}
// runInitTUI runs init with the screen above, asking the form first when
// the flags left the administrator unset.
func (in *serverInit) runInitTUI(ctx context.Context, out io.Writer) error {