Add startup session restore and yt-dlp resume support

Author: pythrick

config.toml.example

@@ -13,6 +13,9 @@ shuffle = false
 # Start with mono output (L+R downmix)
 mono = false
 
+# Restore last playlist/track/position when reopening with no CLI args
+resume_session = true
+
 # Shift+Left/Right seek jump in seconds (6-600)
 seek_large_step_sec = 30
 

config/config.go

@@ -108,10 +108,10 @@ func (y YouTubeMusicConfig) ResolveCredentials(fallbackFn func() (string, string
 
 // Config holds user preferences loaded from the config file.
 type Config struct {
-	Volume          float64            // dB, range [-30, +6]
-	EQ              [10]float64        // per-band gain in dB, range [-12, +12]
-	EQPreset        string             // preset name, or "" for custom
-	Repeat          string             // "off", "all", or "one"
+	Volume          float64     // dB, range [-30, +6]
+	EQ              [10]float64 // per-band gain in dB, range [-12, +12]
+	EQPreset        string      // preset name, or "" for custom
+	Repeat          string      // "off", "all", or "one"
 	Shuffle         bool
 	Mono            bool
 	SeekStepLarge   int                // seconds for Shift+Left/Right seek jumps
@@ -123,6 +123,7 @@ type Config struct {
 	ResampleQuality int                // beep resample quality factor (1–4)
 	BitDepth        int                // PCM bit depth for FFmpeg output: 16 or 32
 	Compact         bool               // compact mode: cap frame width at 80 columns
+	ResumeSession   bool               // restore last playlist/index/position on startup when no args
 	Navidrome       NavidromeConfig    // optional Navidrome/Subsonic server credentials
 	Spotify         SpotifyConfig      // optional Spotify provider (requires Premium)
 	YouTubeMusic    YouTubeMusicConfig // optional YouTube Music provider
@@ -136,6 +137,7 @@ func Default() Config {
 	return Config{
 		Repeat:          "off",
 		SeekStepLarge:   30,
+		ResumeSession:   true,
 		SampleRate:      0,
 		BufferMs:        100,
 		ResampleQuality: 4,
@@ -271,6 +273,8 @@ func Load() (Config, error) {
 				}
 			case "compact":
 				cfg.Compact = val == "true"
+			case "resume_session":
+				cfg.ResumeSession = val == "true"
 			}
 		}
 	}

docs/configuration.md

@@ -22,6 +22,9 @@ shuffle = false
 # Start with mono output (L+R downmix)
 mono = false
 
+# Restore last playlist/track/position when reopening with no CLI args
+resume_session = true
+
 # Shift+Left/Right seek jump in seconds
 seek_large_step_sec = 30
 

internal/resume/resume.go

@@ -6,14 +6,20 @@ import (
 	"encoding/json"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"cliamp/internal/appdir"
+	"cliamp/playlist"
 )
 
 // State holds enough information to resume a previous playback session.
 type State struct {
-	Path        string `json:"path"`
-	PositionSec int    `json:"position_sec"`
+	Path         string           `json:"path"`
+	PositionSec  int              `json:"position_sec"`
+	Tracks       []playlist.Track `json:"tracks,omitempty"`
+	CurrentIndex int              `json:"current_index,omitempty"`
+	Shuffle      bool             `json:"shuffle,omitempty"`
+	Repeat       string           `json:"repeat,omitempty"` // "off", "all", "one"
 }
 
 func stateFile() (string, error) {
@@ -31,11 +37,24 @@ func Save(path string, positionSec int) {
 	if path == "" || positionSec <= 0 {
 		return
 	}
+	SaveState(State{Path: path, PositionSec: positionSec})
+}
+
+// SaveState writes the full resume/session state to disk.
+// It no-ops only when there is no meaningful data to persist.
+func SaveState(s State) {
+	if s.Path == "" && len(s.Tracks) == 0 {
+		f, err := stateFile()
+		if err == nil {
+			_ = os.Remove(f)
+		}
+		return
+	}
 	f, err := stateFile()
 	if err != nil {
 		return
 	}
-	data, err := json.Marshal(State{Path: path, PositionSec: positionSec})
+	data, err := json.Marshal(s)
 	if err != nil {
 		return
 	}
@@ -58,5 +77,12 @@ func Load() State {
 	if err := json.Unmarshal(data, &s); err != nil {
 		return State{}
 	}
+	// Normalize repeat for older/corrupt files.
+	s.Repeat = strings.ToLower(s.Repeat)
+	switch s.Repeat {
+	case "off", "all", "one":
+	default:
+		s.Repeat = ""
+	}
 	return s
 }

main.go

@@ -128,6 +128,15 @@ func run(overrides config.Overrides, positional []string) error {
 	if err != nil {
 		return err
 	}
+	resumeState := resume.State{}
+	if cfg.ResumeSession {
+		resumeState = resume.Load()
+	}
+	restoredSession := false
+	if cfg.ResumeSession && len(positional) == 0 && len(resolved.Tracks) == 0 && len(resolved.Pending) == 0 && len(resumeState.Tracks) > 0 {
+		resolved.Tracks = append(resolved.Tracks, resumeState.Tracks...)
+		restoredSession = true
+	}
 
 	// Determine default provider key.
 	defaultProvider := cfg.Provider
@@ -136,7 +145,7 @@ func run(overrides config.Overrides, positional []string) error {
 	}
 
 	// No args + radio provider: stream the built-in radio directly.
-	if len(positional) == 0 && defaultProvider == "radio" {
+	if len(positional) == 0 && defaultProvider == "radio" && !restoredSession {
 		resolved.Pending = append(resolved.Pending, "https://radio.cliamp.stream/streams.m3u")
 	}
 
@@ -174,6 +183,11 @@ func run(overrides config.Overrides, positional []string) error {
 
 	cfg.ApplyPlayer(p)
 	cfg.ApplyPlaylist(pl)
+	if restoredSession {
+		pl.SetShuffle(resumeState.Shuffle)
+		pl.SetRepeat(repeatModeFromSaved(resumeState.Repeat))
+		pl.SetIndex(resumeState.CurrentIndex)
+	}
 
 	themes := theme.LoadAll()
 
@@ -200,8 +214,8 @@ func run(overrides config.Overrides, positional []string) error {
 	}
 
 	// PositionSec == 0 is indistinguishable from "never played"; skip resume.
-	if rs := resume.Load(); rs.Path != "" && rs.PositionSec > 0 {
-		m.SetResume(rs.Path, rs.PositionSec)
+	if cfg.ResumeSession && resumeState.Path != "" && resumeState.PositionSec > 0 {
+		m.SetResume(resumeState.Path, resumeState.PositionSec)
 	}
 
 	prog := tea.NewProgram(m, tea.WithAltScreen())
@@ -224,14 +238,37 @@ func run(overrides config.Overrides, positional []string) error {
 		}
 		_ = config.Save("theme", fmt.Sprintf("%q", themeName))
 
-		if path, secs := fm.ResumeState(); path != "" && secs > 0 {
-			resume.Save(path, secs)
+		if cfg.ResumeSession {
+			path, secs := fm.ResumeState()
+			tracks, idx, shuffle, repeat := fm.SessionState()
+			if len(tracks) == 0 {
+				tracks, idx, shuffle, repeat = fm.CurrentSessionState()
+			}
+			resume.SaveState(resume.State{
+				Path:         path,
+				PositionSec:  secs,
+				Tracks:       tracks,
+				CurrentIndex: idx,
+				Shuffle:      shuffle,
+				Repeat:       repeat.String(),
+			})
 		}
 	}
 
 	return nil
 }
 
+func repeatModeFromSaved(v string) playlist.RepeatMode {
+	switch strings.ToLower(v) {
+	case "all":
+		return playlist.RepeatAll
+	case "one":
+		return playlist.RepeatOne
+	default:
+		return playlist.RepeatOff
+	}
+}
+
 const helpText = `cliamp — retro terminal music player
 
 Usage: cliamp [flags] <file|folder|url> [...]

playlist/playlist.go

@@ -481,6 +481,14 @@ func (p *Playlist) ToggleShuffle() {
 	p.pos = cur
 }
 
+// SetShuffle enables or disables shuffle mode.
+func (p *Playlist) SetShuffle(enabled bool) {
+	if p.shuffle == enabled {
+		return
+	}
+	p.ToggleShuffle()
+}
+
 func (p *Playlist) doShuffle() {
 	cur := p.order[p.pos]
 	others := make([]int, 0, len(p.tracks)-1)
@@ -504,6 +512,16 @@ func (p *Playlist) CycleRepeat() {
 	p.repeat = (p.repeat + 1) % 3
 }
 
+// SetRepeat sets repeat mode directly.
+func (p *Playlist) SetRepeat(mode RepeatMode) {
+	switch mode {
+	case RepeatAll, RepeatOne:
+		p.repeat = mode
+	default:
+		p.repeat = RepeatOff
+	}
+}
+
 // Shuffled returns whether shuffle is enabled.
 func (p *Playlist) Shuffled() bool { return p.shuffle }
 

ui/keys.go

@@ -17,12 +17,21 @@ import (
 
 // quit shuts down the player and signals the TUI to exit.
 func (m *Model) quit() tea.Cmd {
-	// Only save resume for seekable tracks:
-	// - local files (not stream)
-	// - HTTP streams with known duration (podcast MP3s, seek-by-reconnect)
-	// Exclude YTDL (position unreliable) and real-time live streams.
+	// Snapshot session state for startup restore.
+	tracks := m.playlist.Tracks()
+	m.exitSession.tracks = append([]playlist.Track(nil), tracks...)
+	m.exitSession.index = m.playlist.Index()
+	m.exitSession.shuffle = m.playlist.Shuffled()
+	m.exitSession.repeat = m.playlist.Repeat()
+
+	// Only save resume for tracks we can seek back into:
+	// - local files
+	// - seekable HTTP streams (known duration)
+	// - yt-dlp tracks (seek-by-restart)
+	// Exclude real-time live streams.
 	if track, _ := m.playlist.Current(); track.Path != "" &&
-		!playlist.IsYTDL(track.Path) && !track.IsLive() &&
+		!track.IsLive() &&
+		(m.player.Seekable() || m.player.IsYTDLSeek()) &&
 		m.player.IsPlaying() {
 		if secs := int(m.player.Position().Seconds()); secs > 0 {
 			m.exitResume.path = track.Path

ui/model.go

@@ -172,6 +172,12 @@ type Model struct {
 		path string
 		secs int
 	}
+	exitSession struct {
+		tracks  []playlist.Track
+		index   int
+		shuffle bool
+		repeat  playlist.RepeatMode
+	}
 
 	// preloading is true while a preloadStreamCmd goroutine is in-flight.
 	preloading bool
@@ -307,6 +313,19 @@ func (m Model) ResumeState() (path string, secs int) {
 	return m.exitResume.path, m.exitResume.secs
 }
 
+// SessionState returns the playlist/session state captured at exit.
+func (m Model) SessionState() (tracks []playlist.Track, index int, shuffle bool, repeat playlist.RepeatMode) {
+	return m.exitSession.tracks, m.exitSession.index, m.exitSession.shuffle, m.exitSession.repeat
+}
+
+// CurrentSessionState returns session state from the active playlist model.
+// This is used as a fallback when quit() wasn't the shutdown path.
+func (m Model) CurrentSessionState() (tracks []playlist.Track, index int, shuffle bool, repeat playlist.RepeatMode) {
+	src := m.playlist.Tracks()
+	tracks = append([]playlist.Track(nil), src...)
+	return tracks, m.playlist.Index(), m.playlist.Shuffled(), m.playlist.Repeat()
+}
+
 // ThemeName returns the current theme name.
 func (m Model) ThemeName() string {
 	if m.themeIdx < 0 || m.themeIdx >= len(m.themes) {
@@ -1217,9 +1236,10 @@ func (m *Model) applyResume() {
 	if track.Path != m.resume.path {
 		return
 	}
-	// Only seek if the player reports the stream is seekable; otherwise the
-	// seek is a no-op that returns nil, which we must not mistake for success.
-	if !m.player.Seekable() {
+	// Allow resume when:
+	// - the current source is seekable, or
+	// - yt-dlp seek-by-restart is available.
+	if !m.player.Seekable() && !m.player.IsYTDLSeek() {
 		return
 	}
 	target := time.Duration(m.resume.secs) * time.Second