package cli import ( "bufio" "bytes" "context" "errors" "fmt" "io" "os" "runtime" "strings" "time" tea "github.com/charmbracelet/bubbletea" "github.com/charmbracelet/lipgloss" "github.com/mattn/go-isatty" "github.com/spf13/cobra" "gitea.mynodes.xyz/ilker/llmgw/internal/config" "gitea.mynodes.xyz/ilker/llmgw/internal/control/adminapi" ) // A bare `llmgw` in a terminal: the setup screens on a machine with nothing // installed, the console on a control plane. Anywhere else — a pipe, a // script, another operating system — it prints its help, as it always did. func interactive(cmd *cobra.Command) bool { return isTerminal(cmd.OutOrStdout()) && isatty.IsTerminal(os.Stdin.Fd()) } func runHome(cmd *cobra.Command) error { out := cmd.OutOrStdout() if runtime.GOOS != "linux" { fmt.Fprintln(out, "The setup and console screens run on the Linux machine they manage.") fmt.Fprintln(out) return cmd.Help() } if os.Geteuid() != 0 { return errors.New("run it as root — sudo llmgw — since it installs software and holds the certificate authority") } switch { // Installed is the service in place, not only its configuration: a setup // that stopped halfway has written server.yaml and nothing that runs, and // the setup screens are what finish it. case exists("/etc/llmgw/server.yaml") && exists("/etc/systemd/system/llmgw-server.service"): return runConsole(cmd.Context(), out) case exists("/etc/llmgw/agent.yaml"): fmt.Fprintln(out, "This machine is a node. Its cluster is managed from the control plane:") fmt.Fprintln(out, "run llmgw there. Here, `llmgw doctor` checks the machine.") return nil } return runSetupTUI(cmd.Context(), out) } func exists(p string) bool { _, err := os.Stat(p) return err == nil } // What the console asks to be done once its screen closes: each runs its own // screen, and the console comes back after. type consoleAction struct { kind string // "", "node", "patroni" targets []string } type summaryMsg struct { text string store bool err error } type consoleItem struct { label, command, ask string kind string n int // how many targets to ask for } type consoleModel struct { client *ctlClient summary string store bool err error focus int asking bool asked []string prompt textField action consoleAction width int spin spinnerModel loaded bool } func (m consoleModel) items() []consoleItem { its := []consoleItem{{label: "Add a node", kind: "node", n: 1, ask: "user@address of the machine", command: "sudo llmgw node add @
"}} if !m.store { its = append(its, consoleItem{label: "Replicate the store across two machines (Patroni)", kind: "patroni", n: 2, ask: "user@address of database machine", command: "sudo --preserve-env=SSH_AUTH_SOCK llmgw server init --patroni @ --patroni @ --no-mirror --no-node --no-model"}) } return append(its, consoleItem{label: "Leave", kind: "quit"}) } func (m consoleModel) fetch() tea.Msg { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() var s adminapi.Summary if err := m.client.get(ctx, "/api/v1/summary", &s); err != nil { return summaryMsg{err: err} } var b bytes.Buffer c := &cobra.Command{} c.SetOut(&b) printSummary(c, s) return summaryMsg{text: b.String(), store: len(s.Store) > 0} } func (m consoleModel) Init() tea.Cmd { return tea.Batch(m.fetch, m.spin.Tick) } func (m consoleModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) { switch msg := msg.(type) { case tea.WindowSizeMsg: m.width = msg.Width case spinTickMsg: var cmd tea.Cmd m.spin, cmd = m.spin.Update(msg) return m, cmd case summaryMsg: m.loaded = true m.err = msg.err if msg.err == nil { m.summary, m.store = msg.text, msg.store } return m, tea.Tick(5*time.Second, func(time.Time) tea.Msg { return m.fetch() }) case tea.KeyMsg: if msg.Type == tea.KeyCtrlC { return m, tea.Quit } its := m.items() if m.asking { switch msg.Type { case tea.KeyEsc: m.asking, m.asked = false, nil case tea.KeyEnter: v := strings.TrimSpace(m.prompt.Value()) if v == "" { return m, nil } m.asked = append(m.asked, v) m.prompt.SetValue("") if it := its[m.focus]; len(m.asked) == it.n { m.action = consoleAction{kind: it.kind, targets: m.asked} return m, tea.Quit } default: var cmd tea.Cmd m.prompt, cmd = m.prompt.Update(msg) return m, cmd } return m, nil } switch msg.String() { case "up", "k", "shift+tab": m.focus = (m.focus - 1 + len(its)) % len(its) case "down", "j", "tab": m.focus = (m.focus + 1) % len(its) case "q": return m, tea.Quit case "enter": it := its[m.focus] if it.kind == "quit" { return m, tea.Quit } m.asking, m.asked = true, nil m.prompt = newTextField() m.prompt.Placeholder, m.prompt.Width = "ubuntu@10.0.0.20", 40 m.prompt.Focus() } } return m, nil } func (m consoleModel) View() string { var b strings.Builder host, _ := os.Hostname() b.WriteString(sTitle.Render("llmgw · console") + " " + sDim.Render(host) + "\n\n") switch { case !m.loaded: b.WriteString(" " + m.spin.View() + " asking the control plane…\n") case m.err != nil: b.WriteString(sBad.Render("The control plane does not answer: ") + m.err.Error() + "\n" + sDim.Render("systemctl status llmgw-server says why.") + "\n") default: b.WriteString(m.summary) } b.WriteString("\n" + lipgloss.NewStyle().Bold(true).Render("Do") + "\n") for i, it := range m.items() { line := " " + it.label if i == m.focus { line = sTitle.Render("› " + it.label) } b.WriteString(line + "\n") if i == m.focus && it.command != "" { b.WriteString(" " + sDim.Render(it.command) + "\n") } } if m.asking { it := m.items()[m.focus] ask := it.ask if it.n > 1 { ask = fmt.Sprintf("%s %d of %d", ask, len(m.asked)+1, it.n) } b.WriteString("\n" + ask + "\n " + m.prompt.View() + "\n" + sDim.Render("enter · esc to cancel") + "\n") } else { b.WriteString("\n" + sDim.Render("↑↓ to choose · enter · q to leave · refreshed every five seconds") + "\n") } return b.String() } // runConsole shows the console, runs what is chosen on it, and comes back. func runConsole(ctx context.Context, out io.Writer) error { addr := "127.0.0.1:9090" if cfg, err := config.Load("/etc/llmgw/server.yaml"); err == nil && cfg.AdminListen != "" { addr = cfg.AdminListen if strings.HasPrefix(addr, ":") { addr = "127.0.0.1" + addr } } for { m := consoleModel{client: newCtlClient(addr), spin: newSpinner(), width: 100} final, err := tea.NewProgram(m, tea.WithOutput(out)).Run() if err != nil { return err } act := final.(consoleModel).action switch act.kind { case "": return nil case "node": c := newNodeAddCmd() c.SetArgs(act.targets) c.SetOut(out) err = c.ExecuteContext(ctx) case "patroni": in := newDefaultServerInit() in.patroni = act.targets // Already set up: only the store changes. in.noMirror, in.noNode, in.noModel = true, true, true err = in.runInitTUI(ctx, out) } if err != nil { fmt.Fprintln(out, sBad.Render("✗ ")+err.Error()) } fmt.Fprint(out, "\n"+sDim.Render("enter to go back to the console")+" ") _, _ = bufio.NewReader(os.Stdin).ReadString('\n') } }