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;