app.go

package main

import (
	"flag"
	"fmt"
	"io"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"sync"

	"github.com/charmbracelet/bubbles/list"
	"github.com/charmbracelet/bubbles/textinput"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
	"gopkg.in/yaml.v3"
)

type AppEntry struct {
	Name      string
	Command   string
	Desc      string
	Favorite  bool
	Available bool
}

type itemDelegate struct{}

func (d itemDelegate) Height() int                               { return 1 }
func (d itemDelegate) Spacing() int                              { return 1 }
func (d itemDelegate) Update(msg tea.Msg, m *list.Model) tea.Cmd { return nil }
func (d itemDelegate) Render(w io.Writer, m list.Model, index int, item list.Item) {
	e, ok := item.(AppEntry)
	if !ok {
		return
	}

	suffix := ""
	if e.Favorite {
		suffix = " ★"
	}

	isSelected := index == m.Cursor()
	cursor := ""
	if isSelected {
		cursor = "▶ "
	}

	name := e.Name
	if !e.Available {
		name = name + " *"
	}

	fmt.Fprintln(w, cursor+name+suffix)
}

type AddForm struct {
	name        textinput.Model
	command     textinput.Model
	description textinput.Model
	focused     int
}

type Model struct {
	list           *list.Model
	entries        []AppEntry
	filtered       []AppEntry
	searchQuery    string
	statusMessage  string
	width          int
	height         int
	showAddModal   bool
	showDelModal   bool
	showEditModal  bool
	delEntryName   string
	editEntryName  string
	addForm        AddForm
	editForm       AddForm
	quitting       bool
	pendingCommand string
}

func NewModel() *Model {
	entries := loadConfig()

	items := make([]list.Item, len(entries))
	for i, e := range entries {
		items[i] = e
	}

	l := list.New(items, itemDelegate{}, 60, 18)
	l.SetShowTitle(false)
	l.SetShowStatusBar(false)
	l.SetShowPagination(false)
	l.DisableQuitKeybindings()
	l.Select(0)

	m := &Model{
		list:     &l,
		entries:  entries,
		filtered: entries,
		quitting: false,
	}
	m.updateFiltered()

	filteredItems := make([]list.Item, len(m.filtered))
	for i, e := range m.filtered {
		filteredItems[i] = e
	}
	l.SetItems(filteredItems)

	m.initAddForm()

	return m
}

func (m *Model) updateFiltered() {
	query := m.searchQuery
	m.filtered = make([]AppEntry, 0)

	for _, e := range m.entries {
		if e.Favorite && matchesQuery(e, query) {
			m.filtered = append(m.filtered, e)
		}
	}
	for _, e := range m.entries {
		if !e.Favorite && matchesQuery(e, query) {
			m.filtered = append(m.filtered, e)
		}
	}
}

func matchesQuery(e AppEntry, query string) bool {
	if query == "" {
		return true
	}
	lower := query
	return containsCI(e.Name, lower) || containsCI(e.Desc, lower) || containsCI(e.Command, lower)
}

func containsCI(s, substr string) bool {
	for i := 0; i <= len(s)-len(substr); i++ {
		if equalCI(s[i:i+len(substr)], substr) {
			return true
		}
	}
	return false
}

func equalCI(a, b string) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		ca := a[i]
		cb := b[i]
		if ca >= 'A' && ca <= 'Z' {
			ca = ca - 'A' + 'a'
		}
		if cb >= 'A' && cb <= 'Z' {
			cb = cb - 'A' + 'a'
		}
		if ca != cb {
			return false
		}
	}
	return true
}

func (m *Model) initAddForm() {
	nameInput := textinput.New()
	nameInput.Placeholder = "Display name"
	nameInput.Focus()
	nameInput.Width = 30

	cmdInput := textinput.New()
	cmdInput.Placeholder = "Command (e.g., lazygit -u)"
	cmdInput.Width = 30

	descInput := textinput.New()
	descInput.Placeholder = "Description (optional)"
	descInput.Width = 30

	m.addForm = AddForm{
		name:        nameInput,
		command:     cmdInput,
		description: descInput,
		focused:     0,
	}
}

func (m *Model) initEditForm(entry AppEntry) {
	nameInput := textinput.New()
	nameInput.Placeholder = "Display name"
	nameInput.Focus()
	nameInput.Width = 30
	nameInput.SetValue(entry.Name)

	cmdInput := textinput.New()
	cmdInput.Placeholder = "Command (e.g., lazygit -u)"
	cmdInput.Width = 30
	cmdInput.SetValue(entry.Command)

	descInput := textinput.New()
	descInput.Placeholder = "Description (optional)"
	descInput.Width = 30
	descInput.SetValue(entry.Desc)

	m.editForm = AddForm{
		name:        nameInput,
		command:     cmdInput,
		description: descInput,
		focused:     0,
	}
}

func (m *Model) Init() tea.Cmd {
	return nil
}

func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.WindowSizeMsg:
		m.width = msg.Width
		m.height = msg.Height
		listHeight := msg.Height - 6
		if listHeight < 1 {
			listHeight = 1
		}
		m.list.SetSize(msg.Width, listHeight)

	case tea.KeyMsg:
		if m.showAddModal {
			cmd := m.updateAddModal(msg)
			return m, cmd
		}
		if m.showEditModal {
			cmd := m.updateEditModal(msg)
			return m, cmd
		}
		if m.showDelModal {
			cmd := m.updateDelModal(msg)
			return m, cmd
		}

		switch msg.String() {
		case "ctrl+c", "esc":
			m.quitting = true
			return m, tea.Quit

		case "ctrl+a":
			m.showAddModal = true
			m.initAddForm()
			return m, nil

		case "ctrl+d":
			if len(m.filtered) > 0 && m.list.Cursor() < len(m.filtered) {
				m.showDelModal = true
				m.delEntryName = m.filtered[m.list.Cursor()].Name
			}
			return m, nil

		case "ctrl+e":
			if len(m.filtered) > 0 && m.list.Cursor() < len(m.filtered) {
				m.showEditModal = true
				entry := m.filtered[m.list.Cursor()]
				m.editEntryName = entry.Name
				m.initEditForm(entry)
			}
			return m, nil

		case "ctrl+f":
			if len(m.filtered) > 0 && m.list.Cursor() < len(m.filtered) {
				m.toggleFavorite(m.filtered[m.list.Cursor()])
				saveConfig(m.entries)
				m.updateFiltered()
				m.updateListItems()
			}
			return m, nil

		case "up":
			if m.list.Cursor() > 0 {
				m.list.CursorUp()
			}

		case "down":
			if m.list.Cursor() < len(m.filtered)-1 {
				m.list.CursorDown()
			}

		case "enter":
			if len(m.filtered) > 0 && m.list.Cursor() < len(m.filtered) {
				entry := m.filtered[m.list.Cursor()]
				if entry.Available {
					m.quitting = true
					m.pendingCommand = entry.Command
					return m, tea.Quit
				}
			}

		case "1", "2", "3", "4", "5", "6", "7", "8", "9":
			num := int(msg.String()[0] - '1')
			favorites := m.getFavorites()
			if num < len(favorites) {
				entry := favorites[num]
				if entry.Available {
					m.quitting = true
					m.pendingCommand = entry.Command
					return m, tea.Quit
				}
			}

		case "backspace":
			if len(m.searchQuery) > 0 {
				m.searchQuery = m.searchQuery[:len(m.searchQuery)-1]
				m.updateFiltered()
				m.updateListItems()
				if m.list.Cursor() >= len(m.filtered) {
					newPos := max(0, len(m.filtered)-1)
					m.list.Select(newPos)
				}
			}

		default:
			if msg.Type == tea.KeyRunes {
				m.searchQuery += msg.String()
				m.updateFiltered()
				m.updateListItems()
				m.list.Select(0)
				if len(m.filtered) == 0 {
					m.searchQuery = m.searchQuery[:len(m.searchQuery)-1]
					m.updateFiltered()
					m.updateListItems()
				}
			}
		}
	}
	return m, nil
}

func (m *Model) updateListItems() {
	items := make([]list.Item, len(m.filtered))
	for i, e := range m.filtered {
		items[i] = e
	}
	m.list.SetItems(items)
}

func (m *Model) updateDelModal(msg tea.Msg) tea.Cmd {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "y", "Y":
			m.deleteSelected()
			saveConfig(m.entries)
			m.updateFiltered()
			m.updateListItems()
			m.statusMessage = "Entry deleted"
			m.showDelModal = false
			m.list.Select(0)
			m.list.Select(0)
			return nil

		case "n", "N", "esc", "ctrl+c":
			m.showDelModal = false
			return nil
		}
	}
	return nil
}

func (m *Model) updateAddModal(msg tea.Msg) tea.Cmd {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+c", "esc":
			m.showAddModal = false
			m.searchQuery = ""
			m.updateFiltered()
			m.updateListItems()
			return nil

		case "tab":
			m.addForm.focused = (m.addForm.focused + 1) % 3
			m.updateAddFormFocus()
			return nil

		case "shift+tab":
			m.addForm.focused = (m.addForm.focused + 2) % 3
			m.updateAddFormFocus()
			return nil

		case "enter":
			if m.addForm.focused < 2 {
				m.addForm.focused++
				m.updateAddFormFocus()
				return nil
			}

			name := m.addForm.name.Value()
			command := m.addForm.command.Value()
			if name != "" && command != "" {
				description := m.addForm.description.Value()
				if description == "" {
					description = "TUI application"
				}
				m.addEntry(name, command, description)
				m.statusMessage = "Entry added"
				saveConfig(m.entries)
				m.updateFiltered()
				m.updateListItems()
			}
			m.showAddModal = false
			m.searchQuery = ""
			m.list.Select(0)
			return nil
		}

		var cmd tea.Cmd
		m.addForm.name, cmd = m.addForm.name.Update(msg)
		if m.addForm.focused == 0 {
			return cmd
		}
		m.addForm.command, cmd = m.addForm.command.Update(msg)
		if m.addForm.focused == 1 {
			return cmd
		}
		m.addForm.description, cmd = m.addForm.description.Update(msg)
		return cmd
	}
	return nil
}

func (m *Model) updateAddFormFocus() {
	m.addForm.name.Blur()
	m.addForm.command.Blur()
	m.addForm.description.Blur()
	if m.addForm.focused == 0 {
		m.addForm.name.Focus()
	} else if m.addForm.focused == 1 {
		m.addForm.command.Focus()
	} else if m.addForm.focused == 2 {
		m.addForm.description.Focus()
	}
}

func (m *Model) updateEditModal(msg tea.Msg) tea.Cmd {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+c", "esc":
			m.showEditModal = false
			m.searchQuery = ""
			m.updateFiltered()
			m.updateListItems()
			return nil

		case "tab":
			m.editForm.focused = (m.editForm.focused + 1) % 3
			m.updateEditFormFocus()
			return nil

		case "shift+tab":
			m.editForm.focused = (m.editForm.focused + 2) % 3
			m.updateEditFormFocus()
			return nil

		case "enter":
			if m.editForm.focused < 2 {
				m.editForm.focused++
				m.updateEditFormFocus()
				return nil
			}

			name := m.editForm.name.Value()
			command := m.editForm.command.Value()
			if name != "" && command != "" {
				description := m.editForm.description.Value()
				if description == "" {
					description = "TUI application"
				}
				m.saveEditedEntry(name, command, description)
				m.statusMessage = "Entry updated"
				saveConfig(m.entries)
				m.updateFiltered()
				m.updateListItems()
			}
			m.showEditModal = false
			m.searchQuery = ""
			m.list.Select(0)
			return nil
		}

		var cmd tea.Cmd
		m.editForm.name, cmd = m.editForm.name.Update(msg)
		if m.editForm.focused == 0 {
			return cmd
		}
		m.editForm.command, cmd = m.editForm.command.Update(msg)
		if m.editForm.focused == 1 {
			return cmd
		}
		m.editForm.description, cmd = m.editForm.description.Update(msg)
		return cmd
	}
	return nil
}

func (m *Model) updateEditFormFocus() {
	m.editForm.name.Blur()
	m.editForm.command.Blur()
	m.editForm.description.Blur()
	if m.editForm.focused == 0 {
		m.editForm.name.Focus()
	} else if m.editForm.focused == 1 {
		m.editForm.command.Focus()
	} else if m.editForm.focused == 2 {
		m.editForm.description.Focus()
	}
}

func (m *Model) addEntry(name, command, description string) {
	entry := AppEntry{
		Name:      name,
		Command:   command,
		Desc:      description,
		Favorite:  false,
		Available: isCommandAvailable(command),
	}
	m.entries = append(m.entries, entry)
}

func (m *Model) saveEditedEntry(name, command, description string) {
	for _, e := range m.entries {
		if e.Name == name && name != m.editEntryName {
			m.statusMessage = "An entry with this name already exists"
			return
		}
	}
	for i := range m.entries {
		if m.entries[i].Name == m.editEntryName {
			m.entries[i].Name = name
			m.entries[i].Command = command
			m.entries[i].Desc = description
			m.entries[i].Available = isCommandAvailable(command)
			break
		}
	}
}

func (m *Model) deleteSelected() {
	if m.list.Cursor() < len(m.filtered) {
		nameToDelete := m.filtered[m.list.Cursor()].Name
		newEntries := make([]AppEntry, 0)
		for _, e := range m.entries {
			if e.Name != nameToDelete {
				newEntries = append(newEntries, e)
			}
		}
		m.entries = newEntries
	}
}

func (m *Model) toggleFavorite(entry AppEntry) {
	for i := range m.entries {
		if m.entries[i].Name == entry.Name {
			m.entries[i].Favorite = !m.entries[i].Favorite
			break
		}
	}
}

func (m *Model) getFavorites() []AppEntry {
	favs := make([]AppEntry, 0)
	for _, e := range m.entries {
		if e.Favorite {
			favs = append(favs, e)
		}
	}
	return favs
}

func (m *Model) View() string {
	if m.quitting {
		return ""
	}

	if m.showAddModal {
		return m.renderAddModal()
	}
	if m.showEditModal {
		return m.renderEditModal()
	}
	if m.showDelModal {
		return m.renderDelModal()
	}
	return m.renderMain()
}

var (
	frameStyle = lipgloss.NewStyle().
			Border(lipgloss.RoundedBorder()).
			BorderForeground(lipgloss.Color("63")).
			Padding(1, 2)

	headerStyle = lipgloss.NewStyle().
			Bold(true).
			Foreground(lipgloss.Color("228"))

	searchStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("212"))

	itemStyle = lipgloss.NewStyle().
			Width(38)

	selectedItemStyle = lipgloss.NewStyle().
				Foreground(lipgloss.Color("228"))

	footerStyle = lipgloss.NewStyle().
			Faint(true).
			Width(38)

	modalStyle = lipgloss.NewStyle().
			Border(lipgloss.RoundedBorder()).
			BorderForeground(lipgloss.Color("63")).
			Padding(1, 2).
			Align(lipgloss.Center)
)

func (m *Model) renderMain() string {
	width := m.width
	height := m.height
	if width == 0 {
		width = 80
	}
	if height == 0 {
		height = 24
	}

	borderWidth := 42

	headerContent := fmt.Sprintf("App Launcher")

	searchContent := fmt.Sprintf("Search: %s", m.searchQuery+"_")

	var itemsContent strings.Builder
	for i, e := range m.filtered {
		suffix := ""
		if e.Favorite {
			suffix = " ★"
		}
		cursor := ""
		if i == m.list.Cursor() {
			cursor = "▶ "
		}
		name := e.Name
		if !e.Available {
			name = name + " *"
		}
		line := fmt.Sprintf("%s%s%s", cursor, name, suffix)
		if i == m.list.Cursor() {
			itemsContent.WriteString(selectedItemStyle.Render(line) + "\n")
		} else {
			itemsContent.WriteString(itemStyle.Render(line) + "\n")
		}
	}

	footerContent := "↑↓:select enter:run 1-9:fav ctrl+a:add ctrl+e:edit ctrl+d:del"

	frame := frameStyle.Width(borderWidth)

	mainContent := fmt.Sprintf("%s\n%s\n%s\n%s",
		headerStyle.Render(headerContent),
		searchStyle.Render(searchContent),
		itemsContent.String(),
		footerStyle.Render(footerContent),
	)

	centeredContent := lipgloss.Place(width, height, lipgloss.Center, lipgloss.Center, frame.Render(mainContent))

	return centeredContent
}

func (m *Model) renderAddModal() string {
	width := m.width
	height := m.height
	if width == 0 {
		width = 80
	}
	if height == 0 {
		height = 24
	}

	nameLabel := "Name"
	if m.addForm.focused == 0 {
		nameLabel = "[Name]"
	}
	cmdLabel := "Command"
	if m.addForm.focused == 1 {
		cmdLabel = "[Command]"
	}
	descLabel := "Description"
	if m.addForm.focused == 2 {
		descLabel = "[Description]"
	}

	nameView := m.addForm.name.View()
	cmdView := m.addForm.command.View()
	descView := m.addForm.description.View()

	helpText := "Enter:save Tab:next Esc:cancel"

	content := fmt.Sprintf("Add New Entry\n\n%s\n%s\n\n%s\n%s\n\n%s\n%s\n\n%s",
		nameLabel, nameView,
		cmdLabel, cmdView,
		descLabel, descView,
		helpText,
	)

	modalFrame := modalStyle.Width(50).Height(18)
	centeredContent := lipgloss.Place(width, height, lipgloss.Center, lipgloss.Center, modalFrame.Render(content))

	return centeredContent
}

func (m *Model) renderEditModal() string {
	width := m.width
	height := m.height
	if width == 0 {
		width = 80
	}
	if height == 0 {
		height = 24
	}

	nameLabel := "Name"
	if m.editForm.focused == 0 {
		nameLabel = "[Name]"
	}
	cmdLabel := "Command"
	if m.editForm.focused == 1 {
		cmdLabel = "[Command]"
	}
	descLabel := "Description"
	if m.editForm.focused == 2 {
		descLabel = "[Description]"
	}

	nameView := m.editForm.name.View()
	cmdView := m.editForm.command.View()
	descView := m.editForm.description.View()

	helpText := "Enter:save Tab:next Esc:cancel"

	content := fmt.Sprintf("Edit Entry\n\n%s\n%s\n\n%s\n%s\n\n%s\n%s\n\n%s",
		nameLabel, nameView,
		cmdLabel, cmdView,
		descLabel, descView,
		helpText,
	)

	modalFrame := modalStyle.Width(50).Height(18)
	centeredContent := lipgloss.Place(width, height, lipgloss.Center, lipgloss.Center, modalFrame.Render(content))

	return centeredContent
}

func (m *Model) renderDelModal() string {
	width := m.width
	height := m.height
	if width == 0 {
		width = 80
	}
	if height == 0 {
		height = 24
	}

	modalWidth := 40
	modalHeight := 8

	content := fmt.Sprintf("Delete '%s'?\n\nY:confirm N/Esc:cancel", m.delEntryName)

	modalFrame := modalStyle.Width(modalWidth).Height(modalHeight)
	centeredContent := lipgloss.Place(width, height, lipgloss.Center, lipgloss.Center, modalFrame.Render(content))

	return centeredContent
}

func (e AppEntry) Title() string       { return e.Name }
func (e AppEntry) Description() string { return e.Desc }
func (e AppEntry) FilterValue() string { return e.Name + " " + e.Command + " " + e.Desc }

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func getConfigPath() string {
	home, _ := os.UserHomeDir()
	if home == "" {
		return ".applaunch.yaml"
	}
	return filepath.Join(home, ".config", "applaunch", "config.yaml")
}

func loadConfig() []AppEntry {
	path := getConfigPath()
	data, err := os.ReadFile(path)
	if err != nil {
		if os.IsNotExist(err) {
			return []AppEntry{}
		}
		return []AppEntry{}
	}

	var config struct {
		Entries []struct {
			Name        string `yaml:"name"`
			Command     string `yaml:"command"`
			Description string `yaml:"description"`
			Favorite    bool   `yaml:"favorite"`
		} `yaml:"entries"`
	}

	if err := yaml.Unmarshal(data, &config); err != nil {
		return []AppEntry{}
	}

	entries := make([]AppEntry, len(config.Entries))
	var wg sync.WaitGroup
	var mu sync.Mutex

	for i, e := range config.Entries {
		wg.Add(1)
		go func(idx int, entry struct {
			Name        string `yaml:"name"`
			Command     string `yaml:"command"`
			Description string `yaml:"description"`
			Favorite    bool   `yaml:"favorite"`
		}) {
			defer wg.Done()
			available := isCommandAvailable(entry.Command)
			mu.Lock()
			entries[idx] = AppEntry{
				Name:      entry.Name,
				Command:   entry.Command,
				Desc:      entry.Description,
				Favorite:  entry.Favorite,
				Available: available,
			}
			mu.Unlock()
		}(i, e)
	}
	wg.Wait()
	return entries
}

func saveConfig(entries []AppEntry) {
	path := getConfigPath()
	_ = os.MkdirAll(filepath.Dir(path), 0755)

	var config struct {
		Entries []struct {
			Name        string `yaml:"name"`
			Command     string `yaml:"command"`
			Description string `yaml:"description"`
			Favorite    bool   `yaml:"favorite"`
		} `yaml:"entries"`
	}

	for _, e := range entries {
		config.Entries = append(config.Entries, struct {
			Name        string `yaml:"name"`
			Command     string `yaml:"command"`
			Description string `yaml:"description"`
			Favorite    bool   `yaml:"favorite"`
		}{
			Name:        e.Name,
			Command:     e.Command,
			Description: e.Desc,
			Favorite:    e.Favorite,
		})
	}

	data, _ := yaml.Marshal(config)
	_ = os.WriteFile(path, data, 0644)
}

func isCommandAvailable(command string) bool {
	parts := strings.Fields(command)
	if len(parts) == 0 {
		return false
	}
	cmd := parts[0]
	_, err := exec.LookPath(cmd)
	return err == nil
}

func expandTilde(path string) string {
	if !strings.HasPrefix(path, "~/") {
		return path
	}
	home, err := os.UserHomeDir()
	if err != nil {
		return path
	}
	return filepath.Join(home, path[2:])
}

func runCommand(command string) {
	parts := strings.Fields(command)
	if len(parts) == 0 {
		return
	}

	for i := range parts {
		parts[i] = expandTilde(parts[i])
	}

	cmd := exec.Command(parts[0], parts[1:]...)
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	_ = cmd.Run()
}

func main() {
	updateFlag := flag.Bool("update", false, "")
	uFlag := flag.Bool("u", false, "")
	versionFlag := flag.Bool("version", false, "")
	flag.Parse()

	if *versionFlag {
		fmt.Printf("applaunch %s\n", currentVersion())
		return
	}

	if !supportsUpdate() {
		fmt.Println("Error: applaunch does not support automatic updates on this platform")
		fmt.Println("Please download the latest version from:")
		fmt.Printf("  https://github.com/%s/%s/releases\n", repoOwner, repoName)
		os.Exit(1)
	}

	if *updateFlag || *uFlag {
		fmt.Printf("Current version: %s\n", currentVersion())

		latest, err := latestVersion()
		if err != nil {
			fmt.Printf("Error checking for updates: %v\n", err)
			os.Exit(1)
		}
		fmt.Printf("Latest version: %s\n", latest)

		if latest == currentVersion() {
			fmt.Println("Already on the latest version")
			return
		}

		fmt.Printf("Downloading %s...\n", latest)
		if err := downloadUpdate(latest); err != nil {
			fmt.Printf("Error downloading update: %v\n", err)
			os.Exit(1)
		}
		fmt.Println("Update downloaded. Run applaunch to apply the update.")
		return
	}

	if hasPendingUpdate() {
		pendingVersion := getPendingVersion()
		fmt.Printf("Applying update to %s...\n", pendingVersion)
		if err := applyPendingUpdate(); err != nil {
			fmt.Printf("Error applying update: %v\n", err)
		} else {
			fmt.Println("Update applied successfully!")
		}
	}

	m := NewModel()
	p := tea.NewProgram(m)
	if err := p.Start(); err != nil {
		os.Exit(1)
	}
	if m.pendingCommand != "" {
		runCommand(m.pendingCommand)
	}
}