Route logout through standard TUI event flow

gtsiolis · gtsiolis · commit cefce0ef7937 · 2026-02-24T13:45:49.000+02:00
diff --git a/cmd/logout.go b/cmd/logout.go
@@ -23,8 +23,7 @@ var logoutCmd = &cobra.Command{
 		}
 
 		if ui.IsInteractive() {
-			a := auth.New(nil, platformClient, tokenStorage, false)
-			return ui.RunLogout(cmd.Context(), version, a)
+			return ui.RunLogout(cmd.Context(), version, platformClient, tokenStorage)
 		}
 
 		// Non-interactive mode: auth emits events through the sink
diff --git a/internal/ui/components/spinner.go b/internal/ui/components/spinner.go
diff --git a/internal/ui/run_logout.go b/internal/ui/run_logout.go
@@ -3,147 +3,52 @@ package ui
 import (
 	"context"
 	"errors"
-	"time"
+	"os"
 
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/localstack/lstk/internal/api"
 	"github.com/localstack/lstk/internal/auth"
-	"github.com/localstack/lstk/internal/ui/components"
-	"github.com/localstack/lstk/internal/ui/styles"
+	"github.com/localstack/lstk/internal/output"
 )
 
-const minSpinnerDuration = 400 * time.Millisecond
+func RunLogout(parentCtx context.Context, version string, platformClient api.PlatformAPI, tokenStorage auth.AuthTokenStorage) error {
+	_, cancel := context.WithCancel(parentCtx)
+	defer cancel()
 
-type logoutSuccessMsg struct{}
-
-type logoutNotLoggedInMsg struct{}
-
-type logoutErrMsg struct {
-	err error
-}
-
-type logoutState int
-
-const (
-	logoutStateLoading logoutState = iota
-	logoutStateSuccess
-	logoutStateNotLoggedIn
-)
-
-type LogoutApp struct {
-	header  components.Header
-	spinner components.Spinner
-	state   logoutState
-	err     error
-}
-
-func NewLogoutApp(version string) LogoutApp {
-	return LogoutApp{
-		header:  components.NewHeader(version),
-		spinner: components.NewSpinner().Show("Logging out"),
-		state:   logoutStateLoading,
-	}
-}
-
-func (a LogoutApp) Init() tea.Cmd {
-	return a.spinner.Tick()
-}
-
-func (a LogoutApp) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.KeyMsg:
-		if msg.String() == "ctrl+c" || msg.String() == "q" {
-			return a, tea.Quit
-		}
-
-	case logoutSuccessMsg:
-		a.spinner = a.spinner.Hide()
-		a.state = logoutStateSuccess
-		return a, tea.Quit
-
-	case logoutNotLoggedInMsg:
-		a.spinner = a.spinner.Hide()
-		a.state = logoutStateNotLoggedIn
-		return a, tea.Quit
-
-	case logoutErrMsg:
-		a.spinner = a.spinner.Hide()
-		a.err = msg.err
-		return a, tea.Quit
-
-	default:
-		var cmd tea.Cmd
-		a.spinner, cmd = a.spinner.Update(msg)
-		return a, cmd
-	}
-
-	return a, nil
-}
-
-func (a LogoutApp) View() string {
-	var s string
-	s += a.header.View()
-	s += "\n"
-
-	if a.spinner.Visible() {
-		s += a.spinner.View() + "\n"
-	}
-
-	switch a.state {
-	case logoutStateSuccess:
-		s += renderLogoutSuccess() + "\n"
-	case logoutStateNotLoggedIn:
-		s += renderLogoutNotLoggedIn() + "\n"
-	}
-
-	return s
-}
-
-func renderLogoutSuccess() string {
-	prefix := styles.Secondary.Render("> ")
-	return prefix + styles.Success.Render("Success:") + " " + styles.Message.Render("Logged out successfully.")
-}
-
-func renderLogoutNotLoggedIn() string {
-	prefix := styles.Secondary.Render("> ")
-	return prefix + styles.Note.Render("Note:") + " " + styles.Message.Render("Not currently logged in.")
-}
-
-func (a LogoutApp) Err() error {
-	return a.err
-}
-
-func RunLogout(ctx context.Context, version string, a *auth.Auth) error {
-	app := NewLogoutApp(version)
-	p := tea.NewProgram(app)
+	app := NewApp(version, cancel)
+	p := tea.NewProgram(app, tea.WithInput(os.Stdin), tea.WithOutput(os.Stdout))
+	runErrCh := make(chan error, 1)
 
 	go func() {
-		start := time.Now()
+		a := auth.New(output.NewTUISink(programSender{p: p}), platformClient, tokenStorage, false)
 		err := a.Logout()
-
-		// Ensure spinner is visible for minimum duration
-		elapsed := time.Since(start)
-		if elapsed < minSpinnerDuration {
-			time.Sleep(minSpinnerDuration - elapsed)
-		}
-
 		if errors.Is(err, auth.ErrNotLoggedIn) {
-			p.Send(logoutNotLoggedInMsg{})
-			return
+			err = nil
 		}
+		runErrCh <- err
+
 		if err != nil {
-			p.Send(logoutErrMsg{err: err})
+			if errors.Is(err, context.Canceled) {
+				return
+			}
+			p.Send(runErrMsg{err: err})
 			return
 		}
-		p.Send(logoutSuccessMsg{})
+		p.Send(runDoneMsg{})
 	}()
 
 	model, err := p.Run()
 	if err != nil {
 		return err
 	}
 
-	if logoutApp, ok := model.(LogoutApp); ok && logoutApp.Err() != nil {
-		return logoutApp.Err()
+	if app, ok := model.(App); ok && app.Err() != nil {
+		return app.Err()
+	}
+
+	runErr := <-runErrCh
+	if runErr != nil && !errors.Is(runErr, context.Canceled) {
+		return runErr
 	}
 
 	return nil

Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,7 @@ var logoutCmd = &cobra.Command{`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`if ui.IsInteractive() {`
`26`		`- a := auth.New(nil, platformClient, tokenStorage, false)`
`27`		`- return ui.RunLogout(cmd.Context(), version, a)`
	`26`	`+ return ui.RunLogout(cmd.Context(), version, platformClient, tokenStorage)`
`28`	`27`	`}`
`29`	`28`
`30`	`29`	`// Non-interactive mode: auth emits events through the sink`