esync

app.go (9589B)

---

 package tui
 
 import (
 	"crypto/sha256"
 	"os"
 	"os/exec"
 
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/louloulibs/esync/internal/config"
 )
 
 // ---------------------------------------------------------------------------
 // View enum
 // ---------------------------------------------------------------------------
 
 type view int
 
 const (
 	viewDashboard view = iota
 	viewLogs
 )
 
 // SyncStatusMsg updates the header status without adding an event.
 type SyncStatusMsg string
 
 // ResyncRequestMsg signals that the user pressed 'r' for a full resync.
 type ResyncRequestMsg struct{}
 
 // OpenFileMsg signals that the user wants to open a file in their editor.
 type OpenFileMsg struct{ Path string }
 
 type editorFinishedMsg struct{ err error }
 
 // EditConfigMsg signals that the user wants to edit the config file.
 // Visual selects $VISUAL (GUI editor) instead of $EDITOR (terminal editor).
 type EditConfigMsg struct{ Visual bool }
 
 // editorConfigFinishedMsg is sent when the config editor exits.
 type editorConfigFinishedMsg struct{ err error }
 
 // ConfigReloadedMsg signals that the config was reloaded with new paths.
 type ConfigReloadedMsg struct {
 	Local  string
 	Remote string
 }
 
 // ---------------------------------------------------------------------------
 // AppModel — root Bubbletea model
 // ---------------------------------------------------------------------------
 
 // AppModel is the root Bubbletea model that switches between the dashboard
 // and log views.
 type AppModel struct {
 	dashboard  DashboardModel
 	logView    LogViewModel
 	current    view
 	syncEvents chan SyncEvent
 	logEntries chan LogEntry
 	resyncCh       chan struct{}
 	configReloadCh chan *config.Config
 
 	// Config editor state
 	configTempFile string
 	configChecksum [32]byte
 }
 
 // NewApp creates a new AppModel wired to the given local and remote paths.
 func NewApp(local, remote string) *AppModel {
 	return &AppModel{
 		dashboard:  NewDashboard(local, remote),
 		logView:    NewLogView(),
 		current:    viewDashboard,
 		syncEvents: make(chan SyncEvent, 64),
 		logEntries: make(chan LogEntry, 64),
 		resyncCh:       make(chan struct{}, 1),
 		configReloadCh: make(chan *config.Config, 1),
 	}
 }
 
 // SyncEventChan returns a send-only channel for pushing sync events into
 // the TUI from external code.
 func (m *AppModel) SyncEventChan() chan<- SyncEvent {
 	return m.syncEvents
 }
 
 // LogEntryChan returns a send-only channel for pushing log entries into
 // the TUI from external code.
 func (m *AppModel) LogEntryChan() chan<- LogEntry {
 	return m.logEntries
 }
 
 // ResyncChan returns a channel that receives when the user requests a full resync.
 func (m *AppModel) ResyncChan() <-chan struct{} {
 	return m.resyncCh
 }
 
 // ConfigReloadChan returns a channel that receives a new config when the user
 // edits and saves the config file from the TUI.
 func (m *AppModel) ConfigReloadChan() <-chan *config.Config {
 	return m.configReloadCh
 }
 
 // SetWarnings sets the warning count shown in the dashboard stats bar.
 // Call before Run() — no concurrency protection needed.
 func (m *AppModel) SetWarnings(n int) {
 	m.dashboard.totalWarnings = n
 }
 
 // ---------------------------------------------------------------------------
 // tea.Model interface
 // ---------------------------------------------------------------------------
 
 // Init returns a batch of the dashboard init command and the two channel
 // listener commands.
 func (m AppModel) Init() tea.Cmd {
 	return tea.Batch(
 		m.dashboard.Init(),
 		m.listenSyncEvents(),
 		m.listenLogEntries(),
 	)
 }
 
 // Update delegates messages to the active view and handles global keys.
 func (m AppModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 
 	case tea.KeyMsg:
 		// Global: quit from any view.
 		switch msg.String() {
 		case "q", "ctrl+c":
 			// Let the current view handle it if it's filtering.
 			if m.current == viewDashboard && m.dashboard.filtering {
 				break
 			}
 			if m.current == viewLogs && m.logView.filtering {
 				break
 			}
 			return m, tea.Quit
 		case "l":
 			// Toggle view (only when not filtering).
 			if m.current == viewDashboard && !m.dashboard.filtering {
 				m.current = viewLogs
 				return m, nil
 			}
 			if m.current == viewLogs && !m.logView.filtering {
 				m.current = viewDashboard
 				return m, nil
 			}
 		}
 
 	case SyncStatusMsg:
 		m.dashboard.status = string(msg)
 		return m, nil
 
 	case ResyncRequestMsg:
 		select {
 		case m.resyncCh <- struct{}{}:
 		default:
 		}
 		return m, nil
 
 	case OpenFileMsg:
 		editor := os.Getenv("EDITOR")
 		if editor == "" {
 			editor = "less"
 		}
 		c := exec.Command(editor, msg.Path)
 		return m, tea.ExecProcess(c, func(err error) tea.Msg {
 			return editorFinishedMsg{err}
 		})
 
 	case editorFinishedMsg:
 		// Editor exited; nothing to do on success.
 		return m, nil
 
 	case EditConfigMsg:
 		configPath := ".esync.toml"
 		var targetPath string
 
 		if _, err := os.Stat(configPath); err == nil {
 			// Existing file: checksum and edit in place
 			data, err := os.ReadFile(configPath)
 			if err != nil {
 				return m, nil
 			}
 			m.configChecksum = sha256.Sum256(data)
 			m.configTempFile = ""
 			targetPath = configPath
 		} else {
 			// New file: write template to temp file
 			tmpFile, err := os.CreateTemp("", "esync-*.toml")
 			if err != nil {
 				return m, nil
 			}
 			tmpl := config.EditTemplateTOML()
 			if _, err := tmpFile.WriteString(tmpl); err != nil {
 				tmpFile.Close()
 				os.Remove(tmpFile.Name())
 				return m, nil
 			}
 			tmpFile.Close()
 			m.configChecksum = sha256.Sum256([]byte(tmpl))
 			m.configTempFile = tmpFile.Name()
 			targetPath = tmpFile.Name()
 		}
 
 		editor := resolveEditor(msg.Visual)
 		c := exec.Command(editor, targetPath)
 		return m, tea.ExecProcess(c, func(err error) tea.Msg {
 			return editorConfigFinishedMsg{err}
 		})
 
 	case editorConfigFinishedMsg:
 		if msg.err != nil {
 			// Editor exited with error — discard
 			if m.configTempFile != "" {
 				os.Remove(m.configTempFile)
 				m.configTempFile = ""
 			}
 			return m, nil
 		}
 
 		configPath := ".esync.toml"
 		editedPath := configPath
 		if m.configTempFile != "" {
 			editedPath = m.configTempFile
 		}
 
 		data, err := os.ReadFile(editedPath)
 		if err != nil {
 			if m.configTempFile != "" {
 				os.Remove(m.configTempFile)
 				m.configTempFile = ""
 			}
 			return m, nil
 		}
 
 		newChecksum := sha256.Sum256(data)
 		if newChecksum == m.configChecksum {
 			// No changes
 			if m.configTempFile != "" {
 				os.Remove(m.configTempFile)
 				m.configTempFile = ""
 			}
 			return m, nil
 		}
 
 		// Changed — if temp, persist to .esync.toml
 		if m.configTempFile != "" {
 			if err := os.WriteFile(configPath, data, 0644); err != nil {
 				m.dashboard.status = "error: could not write " + configPath
 				os.Remove(m.configTempFile)
 				m.configTempFile = ""
 				return m, nil
 			}
 			os.Remove(m.configTempFile)
 			m.configTempFile = ""
 		}
 
 		// Parse the new config
 		cfg, err := config.Load(configPath)
 		if err != nil {
 			m.dashboard.status = "config error: " + err.Error()
 			return m, nil
 		}
 
 		// Send to reload channel (non-blocking)
 		select {
 		case m.configReloadCh <- cfg:
 		default:
 		}
 		return m, nil
 
 	case ConfigReloadedMsg:
 		m.updatePaths(msg.Local, msg.Remote)
 		return m, nil
 
 	case SyncEventMsg:
 		// Dispatch to dashboard and re-listen.
 		var cmd tea.Cmd
 		m.dashboard, cmd = m.dashboard.Update(msg)
 		return m, tea.Batch(cmd, m.listenSyncEvents())
 
 	case LogEntryMsg:
 		// Dispatch to log view and re-listen.
 		var cmd tea.Cmd
 		m.logView, cmd = m.logView.Update(msg)
 		return m, tea.Batch(cmd, m.listenLogEntries())
 
 	case tea.WindowSizeMsg:
 		// Propagate to both views.
 		m.dashboard, _ = m.dashboard.Update(msg)
 		m.logView, _ = m.logView.Update(msg)
 		return m, nil
 	}
 
 	// Delegate remaining messages to the active view.
 	switch m.current {
 	case viewDashboard:
 		var cmd tea.Cmd
 		m.dashboard, cmd = m.dashboard.Update(msg)
 		return m, cmd
 	case viewLogs:
 		var cmd tea.Cmd
 		m.logView, cmd = m.logView.Update(msg)
 		return m, cmd
 	}
 
 	return m, nil
 }
 
 // View renders the currently active view.
 func (m AppModel) View() string {
 	switch m.current {
 	case viewLogs:
 		return m.logView.View()
 	default:
 		return m.dashboard.View()
 	}
 }
 
 // ---------------------------------------------------------------------------
 // Channel listeners
 // ---------------------------------------------------------------------------
 
 // listenSyncEvents returns a Cmd that blocks until a SyncEvent arrives on
 // the channel, then wraps it as a SyncEventMsg.
 func (m AppModel) listenSyncEvents() tea.Cmd {
 	ch := m.syncEvents
 	return func() tea.Msg {
 		return SyncEventMsg(<-ch)
 	}
 }
 
 // listenLogEntries returns a Cmd that blocks until a LogEntry arrives on
 // the channel, then wraps it as a LogEntryMsg.
 func (m AppModel) listenLogEntries() tea.Cmd {
 	ch := m.logEntries
 	return func() tea.Msg {
 		return LogEntryMsg(<-ch)
 	}
 }
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
 // resolveEditor returns the user's preferred editor.
 // When visual is true it checks $VISUAL first (GUI editor like BBEdit);
 // otherwise it uses $EDITOR (terminal editor like Helix), falling back to "vi".
 func resolveEditor(visual bool) string {
 	if visual {
 		if e := os.Getenv("VISUAL"); e != "" {
 			return e
 		}
 	}
 	if e := os.Getenv("EDITOR"); e != "" {
 		return e
 	}
 	return "vi"
 }
 
 // updatePaths updates the local and remote paths displayed in the dashboard.
 func (m *AppModel) updatePaths(local, remote string) {
 	m.dashboard.local = local
 	m.dashboard.remote = remote
 }