feat(spotify): play single Spotify tracks via librespot

Add a Spotify playback path for Premium accounts. Spotify exposes no
downloadable audio, so unlike the yt-dlp-backed services this uses
librespot to authenticate as a Connect device and decode the DRM
Ogg/Vorbis stream in-process.

- `looper spotify login` runs the OAuth browser flow once and caches
  reusable credentials.
- A new `PlaybackInput::Spotify` variant carries a `spotify:track:` URI.
  `plugin::resolve_url` intercepts Spotify links before the yt-dlp check
  so it works without yt-dlp installed.
- The Sink->Source bridge (src/spotify/sink.rs) connects librespot's
  push model to rodio's pull model via a bounded channel: the sink
  blocks under backpressure (throttling the decoder to real time) and
  the source yields silence on underrun rather than ending, since
  track-end is driven by PlayerEvent::EndOfTrack.
- AudioPlayer gains a Spotify branch that keeps the librespot Player
  alive and self-loops the track on end-of-track. play_loop is
  unchanged; the existing wall-clock loop counter handles it.

Pin vergen to 9.0.6: librespot-core's build script pulls vergen-gitcl
1.0.8 (needs vergen ^9.0.6), but vergen 9.1.0 bumps its internal
vergen-lib to 9.x and collides with vergen-gitcl's vergen-lib 0.1.6.

Single tracks only for now; playlists/albums return a clear error.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: program247365

Cargo.lock

@@ -29,6 +29,10 @@ rodio = { version = "0.22", default-features = false, features = ["playback", "m
 souvlaki = { version = "0.8", default-features = false, features = ["use_zbus"] }
 structopt = "0.3.21"
 tokio = { version = "1", features = ["rt-multi-thread"] }
+librespot-core = "0.8"
+librespot-metadata = "0.8"
+librespot-oauth = "0.8"
+librespot-playback = { version = "0.8", default-features = false }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 cocoa = "0.24"

Cargo.toml

@@ -91,6 +91,9 @@ pub struct AudioPlayer {
     pub channels: u16,
     input: PlaybackInput,
     refillable: bool,
+    // Keeps librespot playback alive for Spotify sources; dropping it stops the
+    // track and its end-of-track loop listener. `None` for all other inputs.
+    _spotify: Option<crate::spotify::SpotifyPlayback>,
 }
 
 trait MediaReader: Read + Seek + Send + Sync {}
@@ -107,6 +110,31 @@ impl AudioPlayer {
         device.log_on_drop(false);
         let sink = Player::connect_new(device.mixer());
 
+        // Spotify can't be read as a file or byte stream: librespot decodes it
+        // in-process and pushes PCM through a bridge `Source`. Wire that up and
+        // return early — the file/stream decode path below doesn't apply.
+        if let PlaybackInput::Spotify { track_uri } = &input {
+            let (source, playback, sample_rate, channels, duration) =
+                crate::spotify::open_playback(track_uri, repeat)?;
+            let buf = Arc::new(Mutex::new(VecDeque::with_capacity(BUF_CAP)));
+            sink.append(SampleTap {
+                inner: source,
+                buf: buf.clone(),
+            });
+            return Ok(Self {
+                _device: device,
+                _download_runtime: None,
+                sink,
+                duration,
+                sample_buf: buf,
+                sample_rate,
+                channels,
+                input,
+                refillable: false,
+                _spotify: Some(playback),
+            });
+        }
+
         let (reader, duration, runtime, byte_len) = open_input(&input)?;
         let source = decode_input(reader, byte_len)?;
 
@@ -144,6 +172,7 @@ impl AudioPlayer {
             channels,
             input,
             refillable,
+            _spotify: None,
         })
     }
 
@@ -275,6 +304,11 @@ fn open_input(
                 .wrap_err("failed to open process audio stream")?;
             Ok((Box::new(reader), None, Some(runtime), None))
         }
+        // Spotify is wired up earlier in `AudioPlayer::new` and never reaches
+        // the file/stream reader path.
+        PlaybackInput::Spotify { .. } => {
+            unreachable!("Spotify inputs are handled before open_input")
+        }
     }
 }
 

src/audio.rs

@@ -11,6 +11,7 @@ mod play_loop;
 mod playback_input;
 mod plugin;
 mod schema;
+mod spotify;
 mod startup_logo;
 mod storage;
 mod tui;
@@ -112,6 +113,20 @@ EXAMPLES:
         #[structopt(subcommand)]
         cmd: ConfigCmd,
     },
+    /// Manage Spotify access (Premium account required)
+    Spotify {
+        #[structopt(subcommand)]
+        cmd: SpotifyCmd,
+    },
+}
+
+#[derive(StructOpt, Debug)]
+enum SpotifyCmd {
+    /// Authorize looper with your Spotify account via your browser.
+    ///
+    /// Run this once. Credentials are cached so future playback needs no
+    /// re-login. Requires a Spotify Premium subscription.
+    Login,
 }
 
 #[derive(StructOpt, Debug)]
@@ -167,6 +182,7 @@ fn run_app(opt: Opt) -> Result<()> {
         let result = match opt.cmd {
             Some(Command::Play { url }) => play_file(&url, ctx),
             Some(Command::Config { cmd }) => cmd_config(cmd),
+            Some(Command::Spotify { cmd }) => cmd_spotify(cmd),
             None => browse_history(ctx),
         };
         match result {
@@ -205,10 +221,17 @@ fn run_app(opt: Opt) -> Result<()> {
     match opt.cmd {
         Some(Command::Play { url }) => play_file(&url, ctx),
         Some(Command::Config { cmd }) => cmd_config(cmd),
+        Some(Command::Spotify { cmd }) => cmd_spotify(cmd),
         None => browse_history(ctx),
     }
 }
 
+fn cmd_spotify(cmd: SpotifyCmd) -> Result<()> {
+    match cmd {
+        SpotifyCmd::Login => spotify::login(),
+    }
+}
+
 fn cmd_config(cmd: ConfigCmd) -> Result<()> {
     match cmd {
         ConfigCmd::Set { key: ConfigKey::SyncFolder { path } } => {

src/main.rs

@@ -13,6 +13,14 @@ pub enum PlaybackInput {
         args: Vec<String>,
         format_hint: ProcessFormat,
     },
+    /// A Spotify track, decoded in-process by librespot. The string is a
+    /// canonical Spotify track URI (`spotify:track:<base62>`). Unlike the
+    /// other variants there is no file or byte stream — `AudioPlayer` hands
+    /// this to the librespot bridge, which pushes decoded PCM into a rodio
+    /// `Source`.
+    Spotify {
+        track_uri: String,
+    },
 }
 
 #[derive(Clone, Debug)]
@@ -41,4 +49,10 @@ impl PlaybackInput {
             format_hint,
         }
     }
+
+    pub fn spotify(track_uri: impl Into<String>) -> Self {
+        Self::Spotify {
+            track_uri: track_uri.into(),
+        }
+    }
 }

src/playback_input.rs

@@ -33,6 +33,12 @@ pub trait ServicePlugin {
 }
 
 pub fn resolve_url(url: &str) -> Result<Option<Vec<TrackInfo>>> {
+    // Spotify is handled by librespot, not yt-dlp, and uses `spotify:` URIs that
+    // aren't http(s). Intercept before the remote-URL and yt-dlp checks below.
+    if crate::spotify::is_spotify_url(url) {
+        return crate::spotify::resolve(url).map(Some);
+    }
+
     if !is_remote_url(url) {
         return Ok(None);
     }