Files
playlistd/src/main.rs
T
Claude a8b1123777 Add discover UI with new song suggestions
Each mix rebuild now also finds songs that aren't in the library: the
user's Listenbrainz recommendations they've never played, plus an LB
Radio prompt per mix when a Listenbrainz token is configured. Each
candidate goes to the mix whose genre profile it fits best and is
skipped if it's already in the library or was played recently.

discover/ is a new React app to listen to the mixes: library songs
stream from Subsonic and suggested songs are found on YouTube with
yt-dlp, both proxied through playlistd with Range support for seeking.
Suggestions can be liked (kept in a "Liked new songs" list) or hidden.

- discover: candidate gathering, genre fit scoring, library filtering
- web: /api/discover routes, Subsonic/YouTube streaming proxy
- youtube: yt-dlp search (skipping hour-long results) and audio URLs
- mix tags now hold library genre names, for display in the UI
- config: listenbrainz.token, discover.ui, discover.ytdlp, discover.format

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018opPJMJjLWr4RqdG6vuK6p
2026-11-13 16:39:46 +00:00

231 lines
6.4 KiB
Rust

mod cluster;
mod daemon;
mod discover;
mod listenbrainz;
mod mix;
mod models;
mod playlist;
mod subsonic;
mod track;
mod web;
mod youtube;
use crate::daemon::{cluster_mixes_daemon, create_playlists_daemon, update_playlists_daemon};
use crate::models::{
ClusterMixRule, CreateTrackedPlaylist, PartialClusterMixRule, PartialCreateTrackedPlaylist,
PartialTrackedPlaylist, TrackedPlaylist,
};
use crate::subsonic::{Subsonic, SubsonicBuilder};
use config::Config;
use rocket::serde::json::{json, Json};
use rocket::{get, post, routes, serde::json::Value as JsonValue, State};
use serde::{Deserialize, Serialize};
use sqlx::postgres::PgPool;
use std::sync::{Arc, OnceLock};
pub static CONFIG: OnceLock<Config> = OnceLock::new();
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
CONFIG
.set(
Config::builder()
.add_source(config::File::with_name("playlistd").required(false))
.add_source(config::Environment::default().separator("_"))
.build()
.unwrap(),
)
.unwrap();
let database = PgPool::connect(
CONFIG
.get()
.unwrap()
.get::<String>("database.url")?
.as_str(),
)
.await?;
sqlx::migrate!().run(&database).await?;
let media_client = Arc::new(
SubsonicBuilder::new()
.base(CONFIG.get().unwrap().get::<String>("subsonic.base")?)
.username(CONFIG.get().unwrap().get::<String>("subsonic.username")?)
.password(CONFIG.get().unwrap().get::<String>("subsonic.password")?)
.build()?,
);
{
let _media_client = media_client.clone();
tokio::spawn(async move {
update_playlists_daemon(_media_client).await.unwrap();
});
}
{
let _media_client = media_client.clone();
tokio::spawn(async move {
create_playlists_daemon(_media_client).await.unwrap();
});
}
{
let _media_client = media_client.clone();
tokio::spawn(async move {
cluster_mixes_daemon(_media_client).await.unwrap();
});
}
let youtube = youtube::YouTube::new(
CONFIG
.get()
.unwrap()
.get::<String>("discover.ytdlp")
.unwrap_or_else(|_| "yt-dlp".to_string()),
);
let mut server = rocket::build()
.manage(media_client)
.manage(database)
.manage(youtube)
.mount("/api/discover", web::routes())
.mount(
"/api/playlist",
routes![
create_tracking_playlist,
add_tracking_playlist,
all_playlists,
create_tracking_playlist_rule,
create_cluster_mix_rule,
all_cluster_mix_rules,
],
);
// the discover UI's built files (discover/dist)
if let Ok(ui) = CONFIG.get().unwrap().get::<String>("discover.ui") {
server = server.mount("/", rocket::fs::FileServer::from(ui));
}
server.launch().await?;
Ok(())
}
#[derive(Serialize)]
struct JsonError {
error: String,
}
impl From<sqlx::Error> for JsonError {
fn from(value: sqlx::Error) -> Self {
Self {
error: value.to_string(),
}
}
}
impl From<uuid::Error> for JsonError {
fn from(value: uuid::Error) -> Self {
Self {
error: value.to_string(),
}
}
}
#[derive(Serialize)]
enum Response<T> {
Success(T),
Error(JsonError),
}
#[derive(Deserialize)]
pub struct CreatePlaylist {
pub playlist_name: String,
pub playlist_size: i32,
pub tracking_user: Option<String>,
pub tracking_type: Option<String>,
}
/// Create a new playlist and attach a tracker
#[post("/rule", data = "<create_playlist_rule>")]
async fn create_tracking_playlist_rule(
pool: &State<PgPool>,
create_playlist_rule: Json<PartialCreateTrackedPlaylist>,
) -> Json<Response<CreateTrackedPlaylist>> {
match create_playlist_rule.record(pool.inner()).await {
Ok(playlist) => Json(Response::Success(playlist)),
Err(e) => Json(Response::Error(e.into())),
}
}
/// Create a new playlist and attach a tracker
#[post("/create", data = "<create_playlist>")]
async fn create_tracking_playlist(
media_client: &State<Arc<Subsonic>>,
pool: &State<PgPool>,
create_playlist: Json<CreatePlaylist>,
) -> Json<Response<TrackedPlaylist>> {
match media_client
.create_playlist(create_playlist.playlist_name.clone())
.await
{
Ok(created_playlist) => {
let partial = PartialTrackedPlaylist {
playlist_id: created_playlist.id,
playlist_size: create_playlist.playlist_size,
tracking_user: create_playlist.tracking_user.clone(),
tracking_type: create_playlist.tracking_type.clone(),
};
match partial.record(pool.inner()).await {
Ok(playlist) => Json(Response::Success(playlist)),
Err(e) => Json(Response::Error(e.into())),
}
}
Err(_) => Json(Response::Error(JsonError {
error: "Couldn't create Subsonic playlist".to_string(),
})),
}
}
/// Add tracking to an existing playlist
#[post("/track", data = "<playlist>")]
async fn add_tracking_playlist(
pool: &State<PgPool>,
playlist: Json<PartialTrackedPlaylist>,
) -> Json<Response<TrackedPlaylist>> {
match playlist.record(pool.inner()).await {
Ok(playlist) => Json(Response::Success(playlist)),
Err(e) => Json(Response::Error(e.into())),
}
}
/// Get all tracked playlists
#[get("/")]
async fn all_playlists(pool: &State<PgPool>) -> JsonValue {
match TrackedPlaylist::all(pool.inner()).await {
Ok(playlists) => json!(playlists),
Err(_) => json!([]),
}
}
/// Create a rule that maintains genre mixes built from clustering a user's recent listens
#[post("/mix", data = "<rule>")]
async fn create_cluster_mix_rule(
pool: &State<PgPool>,
rule: Json<PartialClusterMixRule>,
) -> Json<Response<ClusterMixRule>> {
match rule.record(pool.inner()).await {
Ok(rule) => Json(Response::Success(rule)),
Err(e) => Json(Response::Error(e.into())),
}
}
/// Get all cluster mix rules
#[get("/mix")]
async fn all_cluster_mix_rules(pool: &State<PgPool>) -> JsonValue {
match ClusterMixRule::all(pool.inner()).await {
Ok(rules) => json!(rules),
Err(_) => json!([]),
}
}