seek: jump within the current track from the CLI and over MPRIS

`rsp seek 1:30`, `rsp seek +15`, `rsp seek -30` and `rsp seek` (print the
position) drive a new AudioCommand that seeks the format reader, resets the
decoder and drops the buffered samples, so the cpal stream keeps running and
playback continues from the new spot.

MPRIS gets a working Seek/SetPosition, reports CanSeek, and the state watcher
now emits Seeked when the playhead jumps (not just on track changes), which is
what clients need to move their progress bar after an external seek.

`rsp status` also reports the position (and duration when known) and says
Paused instead of Stopped when a track is loaded but not playing.

5 files changed, 245 insertions, 34 deletions

diff --git a/README.md b/README.md
index c171fce..c2cf39a 100644
--- a/README.md
+++ b/README.md
@@ -61,6 +61,7 @@ these are normal commands:
 - `stop`          Stop playback
 - `next`          Skip to next track
 - `previous`      Skip to previous track
+- `seek`          Seek within the current track (absolute, `+30`/`-30`, or `1:30`)
 - `volume`        Set volume (0-100)
 - `shuffle`       Shuffle mode
 - `queue`         Show the current queue
diff --git a/src/audio.rs b/src/audio.rs
index 8bac26f..5ce00ae 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -123,6 +123,7 @@ pub enum AudioCommand {
     Pause,
     Resume,
     Stop,
+    Seek(f64),
     SetVolume(f32),
 }
 
@@ -193,6 +194,11 @@ impl AudioEngine {
         let _ = self.command_tx.send(AudioCommand::Stop);
     }
 
+    /// Jump to `position` seconds into the current track.
+    pub fn seek(&self, position: f64) {
+        let _ = self.command_tx.send(AudioCommand::Seek(position));
+    }
+
     pub fn set_volume(&self, volume: f32) {
         let _ = self.command_tx.send(AudioCommand::SetVolume(volume));
     }
@@ -799,6 +805,22 @@ fn audio_thread(
                         *track = None;
                     }
                 }
+                AudioCommand::Seek(seconds) => {
+                    let target = seconds.max(0.0);
+                    if let Ok(mut d) = ctx.audio_data.lock()
+                        && let Some(data) = d.as_mut()
+                    {
+                        match seek_audio(data, target) {
+                            Ok(()) => {
+                                if let Ok(mut pos) = position.lock() {
+                                    *pos = target;
+                                }
+                                crate::debug_eprintln(format_args!("Seeked to {:.1}s", target));
+                            }
+                            Err(e) => eprintln!("Failed to seek: {}", e),
+                        }
+                    }
+                }
                 AudioCommand::SetVolume(vol) => {
                     if let Ok(mut volume_ref) = volume.lock() {
                         *volume_ref = vol;
@@ -865,6 +887,40 @@ fn audio_thread(
     }
 }
 
+/// Moves the decoder to `seconds` into the current track.
+///
+/// Symphonia's accurate seek lands on the packet *before* the requested
+/// position, so packets short of the required timestamp are dropped before
+/// playback resumes. The cpal stream itself keeps running: only the decoded
+/// buffers are flushed, so there is no gap beyond the dropped packet.
+fn seek_audio(data: &mut AudioData, seconds: f64) -> Result<(), String> {
+    use symphonia::core::formats::{SeekMode, SeekTo};
+    use symphonia::core::units::Time;
+
+    let time = Time::try_from_secs_f64(seconds).ok_or("invalid seek position")?;
+    let seeked = data
+        .format
+        .seek(
+            SeekMode::Accurate,
+            SeekTo::Time {
+                time,
+                track_id: None,
+            },
+        )
+        .map_err(|e| e.to_string())?;
+
+    data.decoder.reset();
+    data.sample_buffer.clear();
+    data.buffer_pos = 0;
+    while let Ok(Some(packet)) = data.format.next_packet() {
+        if packet.pts >= seeked.required_ts {
+            break;
+        }
+    }
+
+    Ok(())
+}
+
 fn open_audio_file(path: &PathBuf) -> Result<AudioData, Box<dyn std::error::Error>> {
     use symphonia::core::audio::layouts::CHANNEL_LAYOUT_STEREO;
     use symphonia::core::codecs::audio::AudioDecoderOptions;
diff --git a/src/cli.rs b/src/cli.rs
index 12bc3b0..79c31a8 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -68,6 +68,13 @@ pub enum Commands {
     Queue,
     /// Show player status
     Status,
+    /// Seek within the current track
+    Seek {
+        /// Position: `90`, `1:30`, `1:02:03`, or a relative offset `+15` / `-30`;
+        /// without one, the current position is printed
+        #[arg(value_name = "POSITION", allow_hyphen_values = true)]
+        position: Option<String>,
+    },
     /// Scan music paths to populate database
     Scan {
         #[arg(long)]
@@ -198,6 +205,10 @@ impl Cli {
             Commands::Status => {
                 crate::daemon::send_command("status".to_string())?;
             }
+            Commands::Seek { position } => match position {
+                Some(p) => crate::daemon::send_command(format!("seek {}", p))?,
+                None => crate::daemon::send_command("seek".to_string())?,
+            },
             Commands::Scan { force, paths } => {
                 let config = Config::load()?;
                 let db = Database::open(&config)?;
diff --git a/src/daemon.rs b/src/daemon.rs
index 8f470c1..4f95820 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -954,6 +954,49 @@ fn resume_queue_track(
     true
 }
 
+/// Parse a seek argument into an absolute position in seconds.
+///
+/// Accepts `90`, `1:30`, `1:02:03`, and relative offsets `+15` / `-30`.
+fn parse_seek(arg: &str, current: f64) -> Option<f64> {
+    let (sign, body) = match arg.as_bytes().first()? {
+        b'+' => (1.0, &arg[1..]),
+        b'-' => (-1.0, &arg[1..]),
+        _ => (0.0, arg),
+    };
+    let value = parse_time(body)?;
+    Some(if sign == 0.0 {
+        value
+    } else {
+        (current + sign * value).max(0.0)
+    })
+}
+
+/// Parse `SS`, `MM:SS`, or `HH:MM:SS` (fractions allowed) into seconds.
+fn parse_time(text: &str) -> Option<f64> {
+    let mut total = 0.0f64;
+    let mut parts = 0usize;
+    for part in text.split(':') {
+        let value: f64 = part.trim().parse().ok()?;
+        if value < 0.0 {
+            return None;
+        }
+        total = total * 60.0 + value;
+        parts += 1;
+    }
+    (1..=3).contains(&parts).then_some(total)
+}
+
+/// `83.4` -> `1:23`, `3723` -> `1:02:03`
+fn format_time(seconds: f64) -> String {
+    let secs = seconds.max(0.0) as u64;
+    let (hours, minutes, secs) = (secs / 3600, (secs % 3600) / 60, secs % 60);
+    if hours > 0 {
+        format!("{}:{:02}:{:02}", hours, minutes, secs)
+    } else {
+        format!("{}:{:02}", minutes, secs)
+    }
+}
+
 fn process_command(
     cmd: &str,
     audio: &AudioEngine,
@@ -964,20 +1007,38 @@ fn process_command(
 ) -> String {
     match cmd {
         "status" => {
-            if audio.is_playing() {
-                if let Some(track_path) = audio.current_track() {
-                    let track = Track::from_path(track_path);
-                    let fmt = Config::load().ok().and_then(|c| c.display_format.clone());
-                    let track_str = match fmt.as_deref() {
-                        Some(f) => track.format(f),
-                        None => track.display_string(0, 1),
-                    };
-                    format!("Playing\nTrack: {}\n", track_str)
-                } else {
-                    "Playing\n".to_string()
-                }
+            let current = audio.current_track().or_else(|| {
+                queue
+                    .lock()
+                    .ok()
+                    .and_then(|q| q.current().map(|t| t.path.clone()))
+            });
+            let Some(track_path) = current else {
+                return "Stopped\n".to_string();
+            };
+            let state = if audio.is_playing() {
+                "Playing"
             } else {
-                "Stopped\n".to_string()
+                "Paused"
+            };
+            let track = Track::from_path(track_path);
+            let fmt = Config::load().ok().and_then(|c| c.display_format.clone());
+            let track_str = match fmt.as_deref() {
+                Some(f) => track.format(f),
+                None => track.display_string(0, 1),
+            };
+            let position = format_time(audio.position());
+            match track.duration_secs {
+                Some(duration) if duration > 0.0 => {
+                    format!(
+                        "{}\nTrack: {}\nPosition: {} / {}\n",
+                        state,
+                        track_str,
+                        position,
+                        format_time(duration)
+                    )
+                }
+                _ => format!("{}\nTrack: {}\nPosition: {}\n", state, track_str, position),
             }
         }
         "pause" => {
@@ -1014,6 +1075,20 @@ fn process_command(
             notification::notify_change("Stopped");
             "Stopped\n".to_string()
         }
+        _ if cmd == "seek" || cmd.starts_with("seek ") => {
+            let current = audio.position();
+            let arg = cmd[4..].trim();
+            if arg.is_empty() {
+                return format!("Position: {}\n", format_time(current));
+            }
+            match parse_seek(arg, current) {
+                Some(target) => {
+                    audio.seek(target);
+                    format!("Seeking to {}\n", format_time(target))
+                }
+                None => "Usage: rsp seek <seconds|MM:SS|[+|-]seconds>\n".to_string(),
+            }
+        }
         "stop_daemon" => {
             shutdown_flag.store(true, Ordering::SeqCst);
             "Shutting down\n".to_string()
@@ -1834,3 +1909,42 @@ fn cleanup_daemon(socket_path: &std::path::Path, pid_path: &std::path::Path) {
     std::fs::remove_file(socket_path).ok();
     std::fs::remove_file(pid_path).ok();
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_absolute_seek_positions() {
+        assert_eq!(parse_seek("90", 10.0), Some(90.0));
+        assert_eq!(parse_seek("1:30", 10.0), Some(90.0));
+        assert_eq!(parse_seek("1:02:03", 0.0), Some(3723.0));
+        assert_eq!(parse_seek("83.5", 0.0), Some(83.5));
+    }
+
+    #[test]
+    fn parses_relative_seek_offsets() {
+        assert_eq!(parse_seek("+15", 60.0), Some(75.0));
+        assert_eq!(parse_seek("-15", 60.0), Some(45.0));
+        assert_eq!(
+            parse_seek("-60", 30.0),
+            Some(0.0),
+            "relative seeks never go below the start"
+        );
+    }
+
+    #[test]
+    fn rejects_bad_seek_positions() {
+        assert_eq!(parse_seek("abc", 0.0), None);
+        assert_eq!(parse_seek("", 0.0), None);
+        assert_eq!(parse_seek("-", 0.0), None);
+        assert_eq!(parse_seek("1:2:3:4", 0.0), None, "at most hours:min:sec");
+    }
+
+    #[test]
+    fn formats_positions_for_status() {
+        assert_eq!(format_time(0.0), "0:00");
+        assert_eq!(format_time(83.4), "1:23");
+        assert_eq!(format_time(3723.0), "1:02:03");
+    }
+}
diff --git a/src/mpris.rs b/src/mpris.rs
index 3fc706d..de19113 100644
--- a/src/mpris.rs
+++ b/src/mpris.rs
@@ -22,7 +22,7 @@ use std::path::PathBuf;
 use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 use zbus::blocking::Connection;
 use zbus::interface;
 use zbus::zvariant::{ObjectPath, Value};
@@ -101,14 +101,17 @@ pub struct MprisPlayer {
     loop_status: Arc<Mutex<String>>,
 }
 
+/// `mpris:trackid` advertised for whatever is playing. The spec only requires it to be a stable
+/// object path that changes per track; clients echo it back in `SetPosition`.
+const CURRENT_TRACK_ID: &str = "/org/mpris/MediaPlayer2/TrackList/CurrentTrack";
+
 /// Build the `Metadata` map (a{sv}) required by MPRIS, using only owned values
 /// so no borrowing from locals.
 fn build_metadata(track: &Track) -> HashMap<String, Value<'static>> {
     let mut map: HashMap<String, Value<'static>> = HashMap::new();
 
     // `mpris:trackid` is typed as an object path (`o`) in the spec, not as a string.
-    let trackid = ObjectPath::try_from("/org/mpris/MediaPlayer2/TrackList/CurrentTrack")
-        .expect("static object path");
+    let trackid = ObjectPath::try_from(CURRENT_TRACK_ID).expect("static object path");
     map.insert("mpris:trackid".into(), Value::new(trackid));
 
     let length_us = track
@@ -273,12 +276,23 @@ impl MprisPlayer {
         }
     }
 
-    fn seek(&self, _offset: i64) {
-        // Seeking not implemented yet.
+    fn seek(&self, offset: i64) {
+        let target = (self.audio.position() + offset as f64 / 1_000_000.0).max(0.0);
+        crate::debug_eprintln(format_args!("mpris: seek by {}us", offset));
+        self.audio.seek(target);
     }
 
-    fn set_position(&self, _track_id: zbus::zvariant::ObjectPath<'_>, _position: i64) {
-        // Seeking not implemented yet.
+    fn set_position(&self, track_id: zbus::zvariant::ObjectPath<'_>, position: i64) {
+        // The spec says to ignore the request when the id is not the track we are playing.
+        if track_id.as_str() != CURRENT_TRACK_ID {
+            crate::debug_eprintln(format_args!(
+                "mpris: ignoring SetPosition for foreign track {}",
+                track_id.as_str()
+            ));
+            return;
+        }
+        crate::debug_eprintln(format_args!("mpris: set position to {}us", position));
+        self.audio.seek((position as f64 / 1_000_000.0).max(0.0));
     }
 
     fn open_uri(&self, uri: String) {
@@ -446,7 +460,7 @@ impl MprisPlayer {
 
     #[zbus(property)]
     fn can_seek(&self) -> bool {
-        false
+        true
     }
 
     #[zbus(property)]
@@ -543,6 +557,7 @@ pub fn start_mpris_server(
             let mut last_volume: Option<f64> = None;
             let mut last_shuffle: Option<ShuffleMode> = None;
             let mut last_loop: Option<String> = None;
+            let mut last_position: Option<(Instant, i64)> = None;
 
             while !shutdown_flag.load(std::sync::atomic::Ordering::SeqCst) {
                 let status = playback_status(&poll_audio);
@@ -610,25 +625,39 @@ pub fn start_mpris_server(
                     }
                 }
 
-                // A different track (or none at all) means the playhead jumped, which is what
-                // `Seeked` exists for. Clients use it to reset their progress bar without
-                // having to notice that two consecutive tracks happen to share a length.
-                if track_changed {
-                    let position_us = if track.is_some() {
-                        (poll_audio.position() * 1_000_000.0) as i64
-                    } else {
-                        0
-                    };
-                    if let Err(e) = conn.emit_signal(
+                // A different track, or a position that is nowhere near where the playhead
+                // should be by now, means it jumped — which is what `Seeked` exists for. Clients
+                // use it to reset their progress bar without having to notice that two
+                // consecutive tracks happen to share a length. The steady tick is intentionally
+                // not signalled: the spec tells clients to interpolate while we report `Playing`.
+                let position_us = if track.is_some() {
+                    (poll_audio.position() * 1_000_000.0) as i64
+                } else {
+                    0
+                };
+                let jumped = match last_position {
+                    Some((at, seen)) if !track_changed => {
+                        let expected = if status == "Playing" {
+                            seen + at.elapsed().as_micros() as i64
+                        } else {
+                            seen
+                        };
+                        (position_us - expected).abs() > 1_500_000
+                    }
+                    _ => false,
+                };
+                if (track_changed || jumped)
+                    && let Err(e) = conn.emit_signal(
                         None::<&str>,
                         "/org/mpris/MediaPlayer2",
                         "org.mpris.MediaPlayer2.Player",
                         "Seeked",
                         &(position_us,),
-                    ) {
-                        crate::debug_eprintln(format_args!("mpris: failed to emit Seeked: {}", e));
-                    }
+                    )
+                {
+                    crate::debug_eprintln(format_args!("mpris: failed to emit Seeked: {}", e));
                 }
+                last_position = Some((Instant::now(), position_us));
 
                 last_status = Some(status);
                 last_track = track;