fix: reconnect stalled radio streams

Author: Alexsatter

internal/audio/player.go

@@ -19,15 +19,16 @@ import (
 // internal — mpv echoes them back on each property-change event so the
 // translator can route by id without parsing names.
 const (
-	propIDPause       = 1
-	propIDVolume      = 2
-	propIDMetadata    = 3
-	propIDMediaTitle  = 4
-	propIDIdleActive  = 5
-	propIDAudioBitr   = 6
-	propIDAudioCodec  = 7
-	propIDAudioParams = 8
-	propIDCacheState  = 9
+	propIDPause          = 1
+	propIDVolume         = 2
+	propIDMetadata       = 3
+	propIDMediaTitle     = 4
+	propIDIdleActive     = 5
+	propIDAudioBitr      = 6
+	propIDAudioCodec     = 7
+	propIDAudioParams    = 8
+	propIDCacheState     = 9
+	propIDPausedForCache = 10
 )
 
 // Event is the sealed interface implemented by every value emitted on
@@ -79,13 +80,21 @@ type CacheStateChanged struct {
 	Seconds float64
 }
 
+// BufferingChanged reports mpv's paused-for-cache state. It becomes true
+// when playback is no longer advancing because the demuxer is waiting for
+// network data (a common post-sleep failure mode for live radio streams).
+type BufferingChanged struct {
+	Stalled bool
+}
+
 func (MetadataChanged) isEvent()   {}
 func (PlaybackStarted) isEvent()   {}
 func (PlaybackPaused) isEvent()    {}
 func (PlaybackError) isEvent()     {}
 func (EOF) isEvent()               {}
 func (StreamInfoChanged) isEvent() {}
 func (CacheStateChanged) isEvent() {}
+func (BufferingChanged) isEvent()  {}
 
 // Options controls Player startup.
 type Options struct {
@@ -250,6 +259,7 @@ func NewPlayer(ctx context.Context, opts Options) (*Player, error) {
 		{propIDAudioCodec, "audio-codec-name"},
 		{propIDAudioParams, "audio-params"},
 		{propIDCacheState, "demuxer-cache-state"},
+		{propIDPausedForCache, "paused-for-cache"},
 	}
 	for _, prop := range properties {
 		if err := ipc.observe(ctx, prop.id, prop.name); err != nil {
@@ -470,6 +480,11 @@ func (p *Player) translatePropertyChange(raw ipcEvent) Event {
 		}
 		p.lastCacheSec = state.CacheDuration
 		return CacheStateChanged{Seconds: state.CacheDuration}
+	case "paused-for-cache":
+		var stalled bool
+		if err := json.Unmarshal(raw.Data, &stalled); err == nil {
+			return BufferingChanged{Stalled: stalled}
+		}
 	}
 	return nil
 }

internal/audio/player_test.go

@@ -155,6 +155,22 @@ func TestTranslateOne_PlaybackRestart(t *testing.T) {
 	}
 }
 
+func TestTranslateOne_PausedForCache(t *testing.T) {
+	p := &Player{}
+	e := p.translateOne(ipcEvent{
+		Event: "property-change",
+		Name:  "paused-for-cache",
+		Data:  json.RawMessage(`true`),
+	})
+	bc, ok := e.(BufferingChanged)
+	if !ok {
+		t.Fatalf("paused-for-cache: got %T, want BufferingChanged", e)
+	}
+	if !bc.Stalled {
+		t.Fatal("paused-for-cache true produced Stalled=false")
+	}
+}
+
 func TestTranslateOne_UnknownEventDropped(t *testing.T) {
 	p := &Player{}
 	if e := p.translateOne(ipcEvent{Event: "property-change", Name: "idle-active", Data: json.RawMessage("true")}); e != nil {

internal/tui/commands.go

@@ -89,6 +89,8 @@ func waitForEvent(p *audio.Player) tea.Cmd {
 			}
 		case audio.CacheStateChanged:
 			return CacheStateChangedMsg{Seconds: e.Seconds}
+		case audio.BufferingChanged:
+			return BufferingChangedMsg{Stalled: e.Stalled}
 		}
 		return nil
 	}
@@ -167,3 +169,13 @@ func clockTick() tea.Cmd {
 		return clockTickMsg{At: t}
 	})
 }
+
+// streamReconnectDelay is long enough to avoid flapping on brief network
+// hiccups, but short enough to recover quickly after laptop sleep.
+const streamReconnectDelay = 8 * time.Second
+
+func reconnectStreamAfter(seq int) tea.Cmd {
+	return tea.Tick(streamReconnectDelay, func(time.Time) tea.Msg {
+		return reconnectStreamMsg{seq: seq}
+	})
+}

internal/tui/messages.go

@@ -33,6 +33,16 @@ type CacheStateChangedMsg struct {
 	Seconds float64
 }
 
+// BufferingChangedMsg reports that mpv is internally paused waiting for
+// cache/network data. If it stays true, the UI can reload the live stream.
+type BufferingChangedMsg struct {
+	Stalled bool
+}
+
+// reconnectStreamMsg is fired by a delayed watchdog after a sustained
+// buffering stall. seq lets the model ignore stale timers.
+type reconnectStreamMsg struct{ seq int }
+
 // PlaybackStartedMsg fires when mpv unpauses.
 type PlaybackStartedMsg struct{}
 

internal/tui/model.go

@@ -156,6 +156,13 @@ type Model struct {
 	// cacheSeconds is how much audio mpv has buffered ahead. Drives
 	// the buffer-health indicator under the now-playing card.
 	cacheSeconds float64
+	// bufferingStalled mirrors mpv's paused-for-cache state. When it stays
+	// true after playback has already started, a watchdog reloads the live
+	// stream so laptop sleep/network drops recover without station hopping.
+	bufferingStalled bool
+	// reconnectSeq invalidates stale reconnect timers when the stall clears,
+	// playback is paused, or a different station is selected.
+	reconnectSeq int
 	// playStartedAt is when the current session started (i.e. last
 	// successful Play call). Drives the "listening 1h 23m" uptime
 	// label. Zero when nothing is playing.

internal/tui/model_test.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"strings"
 	"testing"
+	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
 
@@ -256,6 +257,29 @@ func TestPlaybackStartedWhileIdleDoesNotMarkPlaying(t *testing.T) {
 	}
 }
 
+func TestBufferingStallReconnectsActiveStream(t *testing.T) {
+	m := fixture()
+	m.playingIdx = 0
+	m.playing = true
+	m.loading = false
+
+	updated, cmd := m.Update(BufferingChangedMsg{Stalled: true})
+	m = updated.(Model)
+	if !m.bufferingStalled || m.reconnectSeq == 0 || cmd == nil {
+		t.Fatalf("stall did not arm reconnect: stalled=%v seq=%d cmdNil=%v", m.bufferingStalled, m.reconnectSeq, cmd == nil)
+	}
+
+	m.currentTrack = Track{Title: "old"}
+	m.streamInfo = audio.StreamInfoChanged{Bitrate: 128000}
+	m.cacheSeconds = 3
+	m.playStartedAt = time.Now()
+	updated, cmd = m.Update(reconnectStreamMsg{seq: m.reconnectSeq})
+	m = updated.(Model)
+	if !m.loading || m.currentTrack != (Track{}) || m.streamInfo != (audio.StreamInfoChanged{}) || m.cacheSeconds != 0 || !m.playStartedAt.IsZero() || cmd == nil {
+		t.Fatalf("reconnect did not reset playback state: loading=%v track=%+v info=%+v cache=%v started=%v cmdNil=%v", m.loading, m.currentTrack, m.streamInfo, m.cacheSeconds, m.playStartedAt, cmd == nil)
+	}
+}
+
 func TestView_ShowsPlayingMarker(t *testing.T) {
 	m := fixture()
 	m = send(t, m, "space") // dispatch play; model goes into loading state

internal/tui/update.go

@@ -47,6 +47,17 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case clockTickMsg:
 		m.nowTime = tick.At
 		return m, clockTick()
+	case reconnectStreamMsg:
+		if tick.seq != m.reconnectSeq || !m.bufferingStalled || !m.playing || m.playingIdx < 0 || m.playingIdx >= len(m.cfg.Stations) {
+			return m, nil
+		}
+		m.loading = true
+		m.currentTrack = Track{}
+		m.streamInfo = audio.StreamInfoChanged{}
+		m.cacheSeconds = 0
+		m.playStartedAt = time.Time{}
+		m.toast = &Toast{Message: "reconnecting stream…", Kind: ToastInfo}
+		return m, tea.Batch(playCmd(m.player, m.cfg.Stations[m.playingIdx].URL), clearToastAfter())
 	case clearToastMsg:
 		m.toast = nil
 		return m, nil
@@ -116,10 +127,14 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		if m.playingIdx < 0 || m.playingIdx >= len(m.cfg.Stations) {
 			m.playing = false
 			m.loading = false
+			m.bufferingStalled = false
+			m.reconnectSeq++
 			return m, waitForEvent(m.player)
 		}
 		m.playing = true
 		m.loading = false
+		m.bufferingStalled = false
+		m.reconnectSeq++
 		// First start after a fresh Play call: anchor the uptime
 		// counter. Resume after pause keeps the previous anchor so
 		// "listening 1h 23m" doesn't reset every time the user toggles.
@@ -131,6 +146,8 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case PlaybackPausedMsg:
 		m.playing = false
 		m.loading = false
+		m.bufferingStalled = false
+		m.reconnectSeq++
 		return m, waitForEvent(m.player)
 
 	case PlaybackErrorMsg:
@@ -141,6 +158,8 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.currentTrack = Track{}
 		m.streamInfo = audio.StreamInfoChanged{}
 		m.cacheSeconds = 0
+		m.bufferingStalled = false
+		m.reconnectSeq++
 		m.playStartedAt = time.Time{}
 		return m, tea.Batch(clearToastAfter(), waitForEvent(m.player))
 
@@ -151,6 +170,8 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.currentTrack = Track{}
 		m.streamInfo = audio.StreamInfoChanged{}
 		m.cacheSeconds = 0
+		m.bufferingStalled = false
+		m.reconnectSeq++
 		m.playStartedAt = time.Time{}
 		return m, waitForEvent(m.player)
 
@@ -167,6 +188,23 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.cacheSeconds = msg.Seconds
 		return m, waitForEvent(m.player)
 
+	case BufferingChangedMsg:
+		m.bufferingStalled = msg.Stalled
+		if !msg.Stalled {
+			m.reconnectSeq++
+			return m, waitForEvent(m.player)
+		}
+		// paused-for-cache also happens during initial buffering. Only arm
+		// the self-heal watchdog after a station was already playing; slow
+		// startup should keep buffering instead of reload-looping.
+		if m.playing && !m.loading && m.playingIdx >= 0 && m.playingIdx < len(m.cfg.Stations) {
+			m.reconnectSeq++
+			seq := m.reconnectSeq
+			m.toast = &Toast{Message: "stream stalled — reconnecting if it does not recover", Kind: ToastInfo}
+			return m, tea.Batch(waitForEvent(m.player), reconnectStreamAfter(seq), clearToastAfter())
+		}
+		return m, waitForEvent(m.player)
+
 	case CommandFailedMsg:
 		// Transient IPC failure (mpv was busy, request timed out) —
 		// not a stream death. Toast and move on; do NOT touch
@@ -551,6 +589,8 @@ func (m Model) commitDelete() (tea.Model, tea.Cmd) {
 		m.currentTrack = Track{}
 		m.streamInfo = audio.StreamInfoChanged{}
 		m.cacheSeconds = 0
+		m.bufferingStalled = false
+		m.reconnectSeq++
 		m.playStartedAt = time.Time{}
 		if m.player != nil {
 			cmd = pauseCmd(m.player)
@@ -592,12 +632,29 @@ func (m Model) togglePlayPause() (tea.Model, tea.Cmd) {
 		return m, clearToastAfter()
 	}
 	if m.cursor == m.playingIdx {
-		// Toggle pause/resume on the currently-playing station.
+		// Toggle pause/resume on the currently-playing station. Direct live
+		// streams are reloaded on resume instead of merely unpaused: after a
+		// laptop sleep mpv can be left with a dead HTTP connection, and
+		// set pause=false will not reconnect it. YouTube keeps true resume
+		// semantics because those URLs are finite media, not live radio.
 		if m.playing {
 			m.playing = false
+			m.loading = false
+			m.bufferingStalled = false
+			m.reconnectSeq++
 			return m, pauseCmd(m.player)
 		}
 		m.playing = true
+		m.bufferingStalled = false
+		m.reconnectSeq++
+		if !m.cfg.Stations[m.cursor].IsYouTube() {
+			m.loading = true
+			m.currentTrack = Track{}
+			m.streamInfo = audio.StreamInfoChanged{}
+			m.cacheSeconds = 0
+			m.playStartedAt = time.Time{}
+			return m, playCmd(m.player, m.cfg.Stations[m.cursor].URL)
+		}
 		return m, resumeCmd(m.player)
 	}
 	// Switching to a different station — replace playback. Mark the
@@ -609,6 +666,8 @@ func (m Model) togglePlayPause() (tea.Model, tea.Cmd) {
 	m.currentTrack = Track{}
 	m.streamInfo = audio.StreamInfoChanged{}
 	m.cacheSeconds = 0
+	m.bufferingStalled = false
+	m.reconnectSeq++
 	m.playStartedAt = time.Time{}
 	return m, playCmd(m.player, m.cfg.Stations[m.cursor].URL)
 }