Simplify update notification flow

Author: gtsiolis

cmd/root.go

@@ -121,9 +121,8 @@ func startEmulator(ctx context.Context, rt runtime.Runtime, cfg *env.Env, tel *t
 	}
 
 	notifyOpts := update.NotifyOptions{
-		GitHubToken:    cfg.GitHubToken,
-		UpdatePrompt:   appConfig.UpdatePrompt,
-		PersistDisable: config.DisableUpdatePrompt,
+		GitHubToken:  cfg.GitHubToken,
+		UpdatePrompt: appConfig.CLI.UpdatePrompt,
 	}
 
 	if isInteractiveMode(cfg) {

internal/config/config.go

@@ -13,10 +13,15 @@ import (
 //go:embed default_config.toml
 var defaultConfigTemplate string
 
+type CLIConfig struct {
+	UpdatePrompt         bool   `mapstructure:"update_prompt"`
+	UpdateSkippedVersion string `mapstructure:"update_skipped_version"`
+}
+
 type Config struct {
-	Containers   []ContainerConfig            `mapstructure:"containers"`
-	Env          map[string]map[string]string `mapstructure:"env"`
-	UpdatePrompt bool                          `mapstructure:"update_prompt"`
+	Containers []ContainerConfig            `mapstructure:"containers"`
+	Env        map[string]map[string]string `mapstructure:"env"`
+	CLI        CLIConfig                    `mapstructure:"cli"`
 }
 
 func setDefaults() {
@@ -27,7 +32,8 @@ func setDefaults() {
 			"port": "4566",
 		},
 	})
-	viper.SetDefault("update_prompt", true)
+	viper.SetDefault("cli.update_prompt", true)
+	viper.SetDefault("cli.update_skipped_version", "")
 }
 
 func loadConfig(path string) error {
@@ -110,14 +116,28 @@ func Set(key string, value any) error {
 }
 
 func DisableUpdatePrompt() error {
-	return Set("update_prompt", false)
+	return Set("cli.update_prompt", false)
+}
+
+func SetUpdateSkippedVersion(version string) error {
+	return Set("cli.update_skipped_version", version)
+}
+
+func GetUpdateSkippedVersion() string {
+	return viper.GetString("cli.update_skipped_version")
 }
 
 func Get() (*Config, error) {
 	var cfg Config
 	if err := viper.Unmarshal(&cfg); err != nil {
 		return nil, fmt.Errorf("failed to unmarshal config: %w", err)
 	}
+	if !viper.IsSet("cli.update_prompt") && viper.IsSet("update_prompt") {
+		cfg.CLI.UpdatePrompt = viper.GetBool("update_prompt")
+	}
+	if !viper.IsSet("cli.update_skipped_version") && viper.IsSet("update_skipped_version") {
+		cfg.CLI.UpdateSkippedVersion = viper.GetString("update_skipped_version")
+	}
 	for i := range cfg.Containers {
 		if err := cfg.Containers[i].Validate(); err != nil {
 			return nil, fmt.Errorf("invalid container config: %w", err)

internal/config/default_config.toml

@@ -1,6 +1,10 @@
 # lstk configuration file
 # Run 'lstk config path' to see where this file lives.
 
+# CLI settings
+[cli]
+update_prompt = true
+
 # Each [[containers]] block defines an emulator instance.
 # You can define multiple to run them side by side.
 [[containers]]

internal/ui/app.go

@@ -95,6 +95,26 @@ func (a App) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return a, tea.Quit
 		}
 		if a.pendingInput != nil {
+			if componentsUsesVerticalPrompt(a.inputPrompt, a.pendingInput.Options) {
+				switch msg.Type {
+				case tea.KeyUp:
+					a.inputPrompt = a.inputPrompt.SetSelectedIndex(a.inputPrompt.SelectedIndex() - 1)
+					return a, nil
+				case tea.KeyDown:
+					a.inputPrompt = a.inputPrompt.SetSelectedIndex(a.inputPrompt.SelectedIndex() + 1)
+					return a, nil
+				case tea.KeyEnter:
+					idx := a.inputPrompt.SelectedIndex()
+					if idx >= 0 && idx < len(a.pendingInput.Options) {
+						opt := a.pendingInput.Options[idx]
+						a.lines = appendLine(a.lines, styledLine{text: formatResolvedInput(*a.pendingInput, opt.Key)})
+						responseCmd := sendInputResponseCmd(a.pendingInput.ResponseCh, output.InputResponse{SelectedKey: opt.Key})
+						a.pendingInput = nil
+						a.inputPrompt = a.inputPrompt.Hide()
+						return a, responseCmd
+					}
+				}
+			}
 			if opt := resolveOption(a.pendingInput.Options, msg); opt != nil {
 				a.lines = appendLine(a.lines, styledLine{text: formatResolvedInput(*a.pendingInput, opt.Key)})
 				responseCmd := sendInputResponseCmd(a.pendingInput.ResponseCh, output.InputResponse{SelectedKey: opt.Key})
@@ -296,6 +316,19 @@ func (a *App) flushBufferedLines() {
 }
 
 func formatResolvedInput(req output.UserInputRequestEvent, selectedKey string) string {
+	// Special handling for lstk update prompt
+	if len(req.Options) > 0 && strings.Contains(req.Options[0].Label, "Update now") {
+		checkmark := styles.Success.Render(output.SuccessMarker())
+		switch selectedKey {
+		case "u":
+			return checkmark + " Updating lstk..."
+		case "s":
+			return checkmark + " Skipped this version"
+		case "n":
+			return checkmark + " Won't ask again"
+		}
+	}
+
 	formatted := output.FormatPrompt(req.Prompt, req.Options)
 	firstLine := strings.Split(formatted, "\n")[0]
 
@@ -316,6 +349,10 @@ func formatResolvedInput(req output.UserInputRequestEvent, selectedKey string) s
 	return fmt.Sprintf("%s %s", firstLine, selected)
 }
 
+func componentsUsesVerticalPrompt(prompt components.InputPrompt, options []output.InputOption) bool {
+	return prompt.Visible() && len(options) > 1 && strings.Contains(options[0].Label, "[")
+}
+
 // resolveOption finds the best matching option for a key event, in priority order:
 //  1. "any" — matches any keypress
 //  2. "enter" — matches the Enter key explicitly

internal/ui/app_test.go

@@ -410,6 +410,47 @@ func TestAppEnterDoesNothingWithNonLetterLabel(t *testing.T) {
 	}
 }
 
+func TestAppEnterSelectsHighlightedVerticalOption(t *testing.T) {
+	t.Parallel()
+
+	app := NewApp("dev", "", "", nil)
+	responseCh := make(chan output.InputResponse, 1)
+
+	model, _ := app.Update(output.UserInputRequestEvent{
+		Prompt: "Update lstk to latest version?",
+		Options: []output.InputOption{
+			{Key: "u", Label: "Update now [U]"},
+			{Key: "s", Label: "Skip this version [S]"},
+			{Key: "n", Label: "Never ask again [N]"},
+		},
+		ResponseCh: responseCh,
+	})
+	app = model.(App)
+
+	model, _ = app.Update(tea.KeyMsg{Type: tea.KeyDown})
+	app = model.(App)
+
+	model, cmd := app.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	app = model.(App)
+	if cmd == nil {
+		t.Fatal("expected response command when enter is pressed on vertical prompt")
+	}
+	cmd()
+
+	select {
+	case resp := <-responseCh:
+		if resp.SelectedKey != "s" {
+			t.Fatalf("expected s key, got %q", resp.SelectedKey)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("timed out waiting for response on channel")
+	}
+
+	if app.inputPrompt.Visible() {
+		t.Fatal("expected input prompt to be hidden after response")
+	}
+}
+
 func TestAppAnyKeyOptionResolvesOnAnyKeypress(t *testing.T) {
 	t.Parallel()
 

internal/ui/components/input_prompt.go

@@ -8,9 +8,10 @@ import (
 )
 
 type InputPrompt struct {
-	prompt  string
-	options []output.InputOption
-	visible bool
+	prompt        string
+	options       []output.InputOption
+	visible       bool
+	selectedIndex int
 }
 
 func NewInputPrompt() InputPrompt {
@@ -21,6 +22,7 @@ func (p InputPrompt) Show(prompt string, options []output.InputOption) InputProm
 	p.prompt = prompt
 	p.options = options
 	p.visible = true
+	p.selectedIndex = 0
 	return p
 }
 
@@ -33,20 +35,31 @@ func (p InputPrompt) Visible() bool {
 	return p.visible
 }
 
+func (p InputPrompt) SelectedIndex() int {
+	return p.selectedIndex
+}
+
+func (p InputPrompt) SetSelectedIndex(idx int) InputPrompt {
+	if idx >= 0 && idx < len(p.options) {
+		p.selectedIndex = idx
+	}
+	return p
+}
+
 func (p InputPrompt) View() string {
 	if !p.visible {
 		return ""
 	}
 
-	lines := strings.Split(p.prompt, "\n")
+	if usesVerticalOptions(p.options) {
+		return p.viewVertical()
+	}
 
+	lines := strings.Split(p.prompt, "\n")
 	firstLine := lines[0]
 
 	var sb strings.Builder
-
-	// "?" prefix in secondary color
 	sb.WriteString(styles.Secondary.Render("? "))
-
 	sb.WriteString(styles.Message.Render(firstLine))
 
 	if suffix := output.FormatPromptLabels(p.options); suffix != "" {
@@ -60,3 +73,36 @@ func (p InputPrompt) View() string {
 
 	return sb.String()
 }
+
+func (p InputPrompt) viewVertical() string {
+	var sb strings.Builder
+
+	if p.prompt != "" {
+		sb.WriteString(styles.Secondary.Render("? "))
+		sb.WriteString(styles.Message.Render(strings.TrimPrefix(p.prompt, "? ")))
+		sb.WriteString("\n")
+	}
+
+	for _, opt := range p.options {
+		if p.options[p.selectedIndex].Key == opt.Key {
+			sb.WriteString(styles.NimboMid.Render("● " + opt.Label))
+		} else {
+			sb.WriteString(styles.Secondary.Render("○ " + opt.Label))
+		}
+		sb.WriteString("\n")
+	}
+
+	return sb.String()
+}
+
+func usesVerticalOptions(options []output.InputOption) bool {
+	if len(options) < 2 {
+		return false
+	}
+	for _, opt := range options {
+		if strings.Contains(opt.Label, "[") && strings.Contains(opt.Label, "]") {
+			return true
+		}
+	}
+	return false
+}

internal/ui/components/message.go

@@ -14,20 +14,22 @@ func RenderMessage(e output.MessageEvent) string {
 
 func RenderWrappedMessage(e output.MessageEvent, width int) string {
 	prefixText, prefix := messagePrefix(e)
+	text := e.Text
+
 	if prefixText == "" {
 		style := styles.Message
 		if e.Severity == output.SeveritySecondary {
 			style = styles.SecondaryMessage
 		}
-		return style.Render(strings.Join(wrap.SoftWrap(e.Text, width), "\n"))
+		return style.Render(strings.Join(wrap.SoftWrap(text, width), "\n"))
 	}
 
 	if width <= len([]rune(prefixText))+1 {
-		return prefix + " " + styles.Message.Render(e.Text)
+		return prefix + " " + styles.Message.Render(text)
 	}
 
 	availableWidth := width - len([]rune(prefixText)) - 1
-	lines := wrap.SoftWrap(e.Text, availableWidth)
+	lines := wrap.SoftWrap(text, availableWidth)
 	if len(lines) == 0 {
 		return prefix
 	}

internal/update/github.go

@@ -37,22 +37,30 @@ func githubRequest(ctx context.Context, url, token string) (*http.Response, erro
 	return http.DefaultClient.Do(req)
 }
 
-func fetchLatestVersion(ctx context.Context, token string) (string, error) {
+func fetchLatestRelease(ctx context.Context, token string) (*githubRelease, error) {
 	resp, err := githubRequest(ctx, latestReleaseURL, token)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
 	defer func() { _ = resp.Body.Close() }()
 
 	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("GitHub API returned %s", resp.Status)
+		return nil, fmt.Errorf("GitHub API returned %s", resp.Status)
 	}
 
 	var release githubRelease
 	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
-		return "", err
+		return nil, err
 	}
 
+	return &release, nil
+}
+
+func fetchLatestVersion(ctx context.Context, token string) (string, error) {
+	release, err := fetchLatestRelease(ctx, token)
+	if err != nil {
+		return "", err
+	}
 	return release.TagName, nil
 }