Returning an Errors from Bubbleteam Program

[kalensk]

I would like to bubble up errors from the bubbletea program back to my calling code to exit.

Is there a command like tea.Quit that can return an error back to tea.NewProgram to error and bubble up to my calling code?

program := tea.NewProgram(InitialScreen(), opts)
_, err = program.Run()
if err != nil {
    return err
}

In tea.go I see the following snippet which appears to not quite support what I am looking for?

// Run event loop, handle updates and draw.
model, err := p.eventLoop(model, cmds)
killed := p.ctx.Err() != nil
if killed {
	err = ErrProgramKilled
} else {
	// Ensure we rendered the final state of the model.
	p.renderer.write(model.View())
}

// Tear down.
p.cancel()

[KevM]

The Run method returns a model. The same model you are giving to NewProgram. You could add a Error field to your model and look at the resulting model on exit to communicate an error to your calling code.

[zychen5186]

I didn't find any way to do it in bubbletea, so this was my workaround

[meowgorithm]

Not sure I follow, but the way @KevM describes it is what we'd typically recommend.

[kalensk]

As far as I can tell @KevM way requires casting and is less than ideal. For example,

	program := tea.NewProgram(tui.NewScreenController(useConfigFile, &conf, screens), opts...)
	model, err := program.Run()
	if err != nil {
		return err
	}

	screenController, ok := model.(tui.ScreenController)
	if !ok {
		return fmt.Errorf("expected %T model, got %T", tui.ScreenController{}, model)
	}

	if screenController.Error() != nil {
		return screenController.Error()
	}

I am advocating for a message type very similar to tea.Quit that can be used within Bubbletea for a model to exit the event loop and bubble up any errors to program.Run() such that the calling code would just be:

	program := tea.NewProgram(tui.NewScreenController(useConfigFile, &conf, screens), opts...)
	_, err := program.Run()
	if err != nil {
		return err
	}

[zychen5186]

Hi I have the same question, it seems like p.errs in tea.go

case err := <-p.errs:
        return model, err

was never been used to capture error

[kalensk]

@meowgorithm Can we please add a new ErrMsg to the main event loop as this would easily solve this issue of returning an error from bubbletea to the calling program and exiting? Something like:

// ErrorCmd is a special command that tells the Bubble Tea program to exit.
func ErrorCmd(err error) Msg {
	return ErrorMsg{err: err}
}

// ErrorMsg signals that the program should quit. You can send a ErrorMsg with
// Error.
type ErrorMsg struct {
	err error
}


func (p *Program) eventLoop(model Model, cmds chan Cmd) (Model, error) {
// ...
case ErrorMsg:
    return model, msg.err
    
// ....
}				

[meowgorithm]

Hi @kalensk (and others)! I don't follow what you're trying to do exactly. If it's to surface an error you found within your program, why not do something like the following?

package main

import (
	"fmt"
	"net/http"
	"os"

	tea "github.com/charmbracelet/bubbletea"
)

func main() {
	p := tea.NewProgram(Model{})
	m, err := p.Run()
	if err != nil {
		fmt.Fprint(os.Stderr, "Error running program:", err)
	}

	// Check our model for any errors that may have occurred.
	model := m.(Model)
	if model.Error != nil {
		fmt.Fprint(os.Stderr, "When we ran that program there was quite an error!", model.Error.err)
	}
}

type Model struct {
	Status int
	Error  *HTTPErrorMsg
}

func (m Model) Init() tea.Cmd {
	return HTTPCmd("https://charm.sh/login")
}

func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "q", "esc", "ctrl+c":
			return m, tea.Quit
		}
	case HTTPStatusMsg:
		m.Status = int(msg)
		return m, tea.Quit
	case *HTTPErrorMsg:
		m.Error = msg
		 return m, tea.Quit
	}
	return m, nil
}

func (m Model) View() string {
	if m.Error != nil {
		return "Ugh!\n"
	}
	if m.Status == 0 {
		return "Hang on...\n"
	}
	return fmt.Sprintf("Done: %s (%d)\n", http.StatusText(m.Status), m.Status)
}

type HTTPStatusMsg int

type HTTPErrorMsg struct{ err error }

func (e HTTPErrorMsg) Error() string {
	return e.err.Error()
}

func HTTPCmd(url string) tea.Cmd {
	return func() tea.Msg {
		res, err := http.Get(url)
		if err != nil {
			return &HTTPErrorMsg{err}
		}
		return HTTPStatusMsg(res.StatusCode)
	}
}

If that's not what you're looking to do, can you produce a very small example to illustrate what you'd like to solve for?