CORE: Added Last.FM scrobbling

Cargo.lock

@@ -1418,7 +1418,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "furumusic"
-version = "0.1.18"
+version = "0.1.21"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -1430,6 +1430,7 @@ dependencies = [
  "id3",
  "image",
  "librqbit",
+ "md-5",
  "openidconnect",
  "reqwest",
  "schemars 0.9.0",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "furumusic"
-version = "0.1.19"
+version = "0.1.21"
 edition = "2024"
 description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
 
@@ -20,6 +20,7 @@ symphonia = { version = "0.5", default-features = false, features = ["mp3","aac"
 id3 = "1"
 encoding_rs = "0.8"
 sha2 = "0.10"
+md-5 = "0.10"
 image = { version = "0.25", default-features = false, features = ["jpeg", "png", "webp", "gif", "bmp"] }
 sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres"] }
 anyhow = "1.0"

src/admin/mod.rs

@@ -428,6 +428,88 @@ impl App for AdminApp {
                 },
                 "admin_v2_library_item",
             ),
+            Route::with_handler_and_name(
+                "/v2/api/library/item/detail",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    get(move |session: Session,
+                              db: Database,
+                              query: UrlQuery<v2::LibraryItemDetailQuery>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("admin pool")
+                                })
+                                .await;
+                            v2::library_item_detail(session, db, pg_pool, query.0).await
+                        }
+                    })
+                },
+                "admin_v2_library_item_detail",
+            ),
+            Route::with_handler_and_name(
+                "/v2/api/library/item/image",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    cot::router::method::post(
+                        move |session: Session,
+                              db: Database,
+                              json: Json<v2::SetLibraryImageRequest>| {
+                            let pool = Arc::clone(&pool);
+                            let pool_config = Arc::clone(&pool_config);
+                            async move {
+                                let pg_pool = pool
+                                    .get_or_init(|| async {
+                                        sqlx::postgres::PgPoolOptions::new()
+                                            .max_connections(5)
+                                            .connect(&pool_config.database_url)
+                                            .await
+                                            .expect("admin pool")
+                                    })
+                                    .await;
+                                v2::set_library_item_image(session, db, pg_pool, json).await
+                            }
+                        },
+                    )
+                },
+                "admin_v2_library_item_image",
+            ),
+            Route::with_handler_and_name(
+                "/v2/api/library/item/upload-image",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    cot::router::method::post(
+                        move |session: Session,
+                              db: Database,
+                              json: Json<v2::UploadLibraryImageRequest>| {
+                            let pool = Arc::clone(&pool);
+                            let pool_config = Arc::clone(&pool_config);
+                            async move {
+                                let pg_pool = pool
+                                    .get_or_init(|| async {
+                                        sqlx::postgres::PgPoolOptions::new()
+                                            .max_connections(5)
+                                            .connect(&pool_config.database_url)
+                                            .await
+                                            .expect("admin pool")
+                                    })
+                                    .await;
+                                v2::upload_library_item_image(session, db, pg_pool, json).await
+                            }
+                        },
+                    )
+                },
+                "admin_v2_library_item_upload_image",
+            ),
             Route::with_handler_and_name(
                 "/v2/api/library/bulk",
                 {

src/admin/v2.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use cot::db::{Database, Model};
 use cot::html::Html;
@@ -67,6 +67,31 @@ pub(super) struct UpdateLibraryItemRequest {
     id: i64,
     title: String,
     hidden: bool,
+    release_type: Option<String>,
+    year: Option<String>,
+    artist_ids: Option<Vec<i64>>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct LibraryItemDetailQuery {
+    kind: String,
+    id: i64,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct SetLibraryImageRequest {
+    kind: String,
+    id: i64,
+    media_file_id: Option<i64>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct UploadLibraryImageRequest {
+    kind: String,
+    id: i64,
+    data: String,
+    filename: String,
+    mime_type: String,
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
@@ -235,6 +260,8 @@ struct AdminSettingsDto {
     values: AdminSettingsValues,
     sources: AdminSettingsSources,
     lastfm_api_key_configured: bool,
+    lastfm_shared_secret_configured: bool,
+    lastfm_scrobbling_configured: bool,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
@@ -249,6 +276,7 @@ struct AdminSettingsValues {
     oidc_user_groups: String,
     swagger_enabled: bool,
     lastfm_api_key: String,
+    lastfm_shared_secret: String,
     agent_enabled: bool,
     agent_inbox_dir: String,
     agent_storage_dir: String,
@@ -272,6 +300,7 @@ struct AdminSettingsSources {
     oidc_user_groups: &'static str,
     swagger_enabled: &'static str,
     lastfm_api_key: &'static str,
+    lastfm_shared_secret: &'static str,
     agent_enabled: &'static str,
     agent_inbox_dir: &'static str,
     agent_storage_dir: &'static str,
@@ -295,6 +324,7 @@ pub(super) struct UpdateSettingsRequest {
     oidc_user_groups: String,
     swagger_enabled: bool,
     lastfm_api_key: String,
+    lastfm_shared_secret: String,
     agent_enabled: bool,
     agent_inbox_dir: String,
     agent_storage_dir: String,
@@ -348,6 +378,32 @@ struct LibraryItemDto {
     updated_at: Option<String>,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+struct LibraryItemDetailDto {
+    item: LibraryItemDto,
+    title: String,
+    hidden: bool,
+    release_type: Option<String>,
+    year: Option<i32>,
+    current_image_url: Option<String>,
+    selected_artist_ids: Vec<i64>,
+    artists: Vec<ArtistOptionDto>,
+    available_covers: Vec<AvailableCoverDto>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct ArtistOptionDto {
+    id: i64,
+    name: String,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+struct AvailableCoverDto {
+    media_file_id: i64,
+    release_title: String,
+    cover_url: String,
+}
+
 #[derive(Debug, sqlx::FromRow)]
 struct IdRow {
     id: i64,
@@ -658,6 +714,10 @@ pub async fn update_settings(
         ("oidc_user_groups", body.oidc_user_groups.trim().to_string()),
         ("swagger_enabled", body.swagger_enabled.to_string()),
         ("lastfm_api_key", body.lastfm_api_key.trim().to_string()),
+        (
+            "lastfm_shared_secret",
+            body.lastfm_shared_secret.trim().to_string(),
+        ),
         ("agent_enabled", body.agent_enabled.to_string()),
         ("agent_inbox_dir", body.agent_inbox_dir.trim().to_string()),
         (
@@ -734,6 +794,9 @@ pub async fn settings_probe(
 fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
     AdminSettingsDto {
         lastfm_api_key_configured: !config.lastfm_api_key.trim().is_empty(),
+        lastfm_shared_secret_configured: !config.lastfm_shared_secret.trim().is_empty(),
+        lastfm_scrobbling_configured: !config.lastfm_api_key.trim().is_empty()
+            && !config.lastfm_shared_secret.trim().is_empty(),
         values: AdminSettingsValues {
             auth_password_enabled: config.auth_password_enabled,
             auth_sso_enabled: config.auth_sso_enabled,
@@ -745,6 +808,7 @@ fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
             oidc_user_groups: config.oidc_user_groups,
             swagger_enabled: config.swagger_enabled,
             lastfm_api_key: config.lastfm_api_key,
+            lastfm_shared_secret: config.lastfm_shared_secret,
             agent_enabled: config.agent_enabled,
             agent_inbox_dir: config.agent_inbox_dir,
             agent_storage_dir: config.agent_storage_dir,
@@ -766,6 +830,7 @@ fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
             oidc_user_groups: sources.oidc_user_groups.code(),
             swagger_enabled: sources.swagger_enabled.code(),
             lastfm_api_key: sources.lastfm_api_key.code(),
+            lastfm_shared_secret: sources.lastfm_shared_secret.code(),
             agent_enabled: sources.agent_enabled.code(),
             agent_inbox_dir: sources.agent_inbox_dir.code(),
             agent_storage_dir: sources.agent_storage_dir.code(),
@@ -903,6 +968,28 @@ pub async fn library(
     Json(page).into_response()
 }
 
+pub async fn library_item_detail(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    query: LibraryItemDetailQuery,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+    let kind = normalize_library_kind(Some(query.kind.as_str()));
+    let Some(item) = fetch_library_item(pool, &kind, query.id)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?
+    else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
+    };
+    let detail = load_library_item_detail(pool, &kind, item)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    Json(detail).into_response()
+}
+
 pub async fn update_library_item(
     session: Session,
     db: Database,
@@ -936,13 +1023,27 @@ pub async fn update_library_item(
             .await
         }
         "releases" => {
+            let release_type = body
+                .release_type
+                .as_deref()
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .unwrap_or("album");
+            let year = body
+                .year
+                .as_deref()
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .and_then(|value| value.parse::<i32>().ok());
             sqlx::query(
                 "UPDATE furumusic__release \
-                 SET title = $1, title_sort = $2, is_hidden = $3, updated_at = $4 \
-                 WHERE id = $5",
+                 SET title = $1, title_sort = $2, release_type = $3, year = $4, is_hidden = $5, updated_at = $6 \
+                 WHERE id = $7",
             )
             .bind(title)
             .bind(normalize_name(title))
+            .bind(release_type)
+            .bind(year)
             .bind(body.hidden)
             .bind(&now)
             .bind(body.id)
@@ -970,6 +1071,28 @@ pub async fn update_library_item(
     if affected == 0 {
         return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
     }
+    if kind == "releases" {
+        if let Some(mut artist_ids) = body.artist_ids {
+            let mut seen_artist_ids = HashSet::new();
+            artist_ids.retain(|id| *id > 0 && seen_artist_ids.insert(*id));
+            sqlx::query("DELETE FROM furumusic__release_artist WHERE release_id = $1")
+                .bind(body.id)
+                .execute(pool)
+                .await
+                .map_err(|e| cot::Error::internal(e.to_string()))?;
+            for (position, artist_id) in artist_ids.iter().enumerate() {
+                sqlx::query(
+                    "INSERT INTO furumusic__release_artist (release_id, artist_id, position) VALUES ($1, $2, $3)",
+                )
+                .bind(body.id)
+                .bind(*artist_id)
+                .bind(position as i32)
+                .execute(pool)
+                .await
+                .map_err(|e| cot::Error::internal(e.to_string()))?;
+            }
+        }
+    }
 
     let Some(item) = fetch_library_item(pool, &kind, body.id)
         .await
@@ -981,6 +1104,128 @@ pub async fn update_library_item(
     Json(item).into_response()
 }
 
+pub async fn set_library_item_image(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    Json(body): Json<SetLibraryImageRequest>,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+    let kind = normalize_library_kind(Some(body.kind.as_str()));
+    if kind != "artists" && kind != "releases" {
+        return Ok(json_error(StatusCode::BAD_REQUEST, "unsupported kind"));
+    }
+    if let Some(fid) = body.media_file_id {
+        let exists: Option<i64> = sqlx::query_scalar(
+            "SELECT id FROM furumusic__media_file WHERE id = $1 AND file_type = 'cover_art'",
+        )
+        .bind(fid)
+        .fetch_optional(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+        if exists.is_none() {
+            return Ok(json_error(StatusCode::NOT_FOUND, "image not found"));
+        }
+    }
+    let now = now_string();
+    let result = if kind == "releases" {
+        sqlx::query(
+            "UPDATE furumusic__release SET cover_file_id = $1, updated_at = $2 WHERE id = $3",
+        )
+        .bind(body.media_file_id)
+        .bind(&now)
+        .bind(body.id)
+        .execute(pool)
+        .await
+    } else {
+        sqlx::query(
+            "UPDATE furumusic__artist SET image_file_id = $1, updated_at = $2 WHERE id = $3",
+        )
+        .bind(body.media_file_id)
+        .bind(&now)
+        .bind(body.id)
+        .execute(pool)
+        .await
+    }
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+    if result.rows_affected() == 0 {
+        return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
+    }
+    Json(serde_json::json!({ "ok": true })).into_response()
+}
+
+pub async fn upload_library_item_image(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    Json(body): Json<UploadLibraryImageRequest>,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+    let kind = normalize_library_kind(Some(body.kind.as_str()));
+    if kind != "artists" && kind != "releases" {
+        return Ok(json_error(StatusCode::BAD_REQUEST, "unsupported kind"));
+    }
+    let storage_dir = AppConfig::load_with_db(&db).await.0.agent_storage_dir;
+    if storage_dir.trim().is_empty() {
+        return Err(cot::Error::internal("agent_storage_dir is not configured"));
+    }
+    use base64::Engine;
+    let image_data = base64::engine::general_purpose::STANDARD
+        .decode(body.data.trim())
+        .map_err(|e| cot::Error::internal(format!("invalid base64: {e}")))?;
+    if image_data.is_empty() {
+        return Ok(json_error(StatusCode::BAD_REQUEST, "image is empty"));
+    }
+    let title: Option<String> = if kind == "releases" {
+        sqlx::query_scalar("SELECT title::text FROM furumusic__release WHERE id = $1")
+    } else {
+        sqlx::query_scalar("SELECT name::text FROM furumusic__artist WHERE id = $1")
+    }
+    .bind(body.id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+    let Some(title) = title else {
+        return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
+    };
+    let cover = crate::agent::cover_art::CoverImage {
+        data: image_data,
+        mime_type: body.mime_type,
+        source: crate::agent::cover_art::CoverSource::FolderFile(std::path::PathBuf::from(
+            body.filename,
+        )),
+    };
+    let media_file_id = crate::agent::cover_art::save_cover_to_storage(
+        &db,
+        pool,
+        &storage_dir,
+        &title,
+        if kind == "artists" {
+            "__artist_image__"
+        } else {
+            "__release_cover__"
+        },
+        &cover,
+    )
+    .await
+    .map_err(|e| cot::Error::internal(format!("failed to save image: {e}")))?;
+    set_library_item_image(
+        session,
+        db,
+        pool,
+        Json(SetLibraryImageRequest {
+            kind,
+            id: body.id,
+            media_file_id: Some(media_file_id),
+        }),
+    )
+    .await
+}
+
 pub async fn bulk_library(
     session: Session,
     db: Database,
@@ -1619,6 +1864,103 @@ async fn fetch_library_item(
     Ok(row.map(|row| library_item_dto(kind, row)))
 }
 
+async fn load_library_item_detail(
+    pool: &PgPool,
+    kind: &str,
+    item: LibraryItemDto,
+) -> anyhow::Result<LibraryItemDetailDto> {
+    let mut detail = LibraryItemDetailDto {
+        title: item.title.clone(),
+        hidden: item.is_hidden.unwrap_or(false),
+        release_type: None,
+        year: None,
+        current_image_url: None,
+        selected_artist_ids: Vec::new(),
+        artists: Vec::new(),
+        available_covers: Vec::new(),
+        item,
+    };
+
+    match kind {
+        "artists" => {
+            let image_file_id: Option<i64> =
+                sqlx::query_scalar("SELECT image_file_id FROM furumusic__artist WHERE id = $1")
+                    .bind(detail.item.id)
+                    .fetch_optional(pool)
+                    .await?
+                    .flatten();
+            detail.current_image_url =
+                image_file_id.map(|id| format!("/api/player/cover/{id}/large"));
+            detail.available_covers = artist_available_covers(pool, detail.item.id).await?;
+        }
+        "releases" => {
+            let row: Option<(Option<String>, Option<i32>, Option<i64>)> = sqlx::query_as(
+                "SELECT release_type::text, year, cover_file_id FROM furumusic__release WHERE id = $1",
+            )
+            .bind(detail.item.id)
+            .fetch_optional(pool)
+            .await?;
+            if let Some((release_type, year, cover_file_id)) = row {
+                detail.release_type = release_type;
+                detail.year = year;
+                detail.current_image_url =
+                    cover_file_id.map(|id| format!("/api/player/cover/{id}/large"));
+            }
+            detail.selected_artist_ids = sqlx::query_as::<_, IdRow>(
+                "SELECT artist_id AS id FROM furumusic__release_artist WHERE release_id = $1 ORDER BY position, artist_id",
+            )
+            .bind(detail.item.id)
+            .fetch_all(pool)
+            .await?
+            .into_iter()
+            .map(|row| row.id)
+            .collect();
+            detail.artists = load_artist_options(pool).await?;
+        }
+        _ => {}
+    }
+
+    Ok(detail)
+}
+
+async fn load_artist_options(pool: &PgPool) -> anyhow::Result<Vec<ArtistOptionDto>> {
+    let rows = sqlx::query_as::<_, (i64, String)>(
+        "SELECT id, name::text FROM furumusic__artist ORDER BY name ASC",
+    )
+    .fetch_all(pool)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|(id, name)| ArtistOptionDto { id, name })
+        .collect())
+}
+
+async fn artist_available_covers(
+    pool: &PgPool,
+    artist_id: i64,
+) -> anyhow::Result<Vec<AvailableCoverDto>> {
+    let rows = sqlx::query_as::<_, (i64, String)>(
+        "SELECT DISTINCT r.cover_file_id AS media_file_id, r.title::text AS release_title \
+         FROM furumusic__release r \
+         LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
+         LEFT JOIN furumusic__track t ON t.release_id = r.id \
+         LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
+         WHERE r.cover_file_id IS NOT NULL AND (ra.artist_id = $1 OR ta.artist_id = $1) \
+         ORDER BY r.title::text ASC",
+    )
+    .bind(artist_id)
+    .fetch_all(pool)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|(media_file_id, release_title)| AvailableCoverDto {
+            media_file_id,
+            release_title,
+            cover_url: format!("/api/player/cover/{media_file_id}/medium"),
+        })
+        .collect())
+}
+
 async fn library_ids_by_filter(
     pool: &PgPool,
     kind: &str,

src/admin/views.rs

@@ -184,6 +184,16 @@ fn config_display_entries(config: &AppConfig, sources: &ConfigSources) -> Vec<Co
             config.agent_concurrency.to_string(),
             defaults.agent_concurrency.to_string()
         ),
+        entry!(
+            lastfm_api_key,
+            config.lastfm_api_key.clone(),
+            defaults.lastfm_api_key.clone()
+        ),
+        entry!(
+            lastfm_shared_secret,
+            config.lastfm_shared_secret.clone(),
+            defaults.lastfm_shared_secret.clone()
+        ),
     ]
 }
 
@@ -258,6 +268,10 @@ struct SettingsTemplate {
     agent_context_limit_source: &'static str,
     agent_concurrency: String,
     agent_concurrency_source: &'static str,
+    lastfm_api_key: String,
+    lastfm_api_key_source: &'static str,
+    lastfm_shared_secret: String,
+    lastfm_shared_secret_source: &'static str,
 }
 
 pub async fn settings_handler(
@@ -310,6 +324,10 @@ pub async fn settings_handler(
         agent_context_limit_source: sources.agent_context_limit.code(),
         agent_concurrency: config.agent_concurrency.to_string(),
         agent_concurrency_source: sources.agent_concurrency.code(),
+        lastfm_api_key: config.lastfm_api_key.clone(),
+        lastfm_api_key_source: sources.lastfm_api_key.code(),
+        lastfm_shared_secret: config.lastfm_shared_secret.clone(),
+        lastfm_shared_secret_source: sources.lastfm_shared_secret.code(),
     };
     Ok(Html::new(template.render()?))
 }
@@ -334,6 +352,8 @@ pub struct OidcSettingsForm {
     agent_confidence_threshold: Option<String>,
     agent_context_limit: Option<String>,
     agent_concurrency: Option<String>,
+    lastfm_api_key: Option<String>,
+    lastfm_shared_secret: Option<String>,
 }
 
 pub async fn settings_submit(
@@ -380,7 +400,9 @@ pub async fn settings_submit(
             let agent_confidence_threshold = data.agent_confidence_threshold.unwrap_or_default();
             let agent_context_limit = data.agent_context_limit.unwrap_or_default();
             let agent_concurrency = data.agent_concurrency.unwrap_or_default();
-            let fields: [(&str, &str); 18] = [
+            let lastfm_api_key = data.lastfm_api_key.unwrap_or_default();
+            let lastfm_shared_secret = data.lastfm_shared_secret.unwrap_or_default();
+            let fields: [(&str, &str); 20] = [
                 ("auth_password_enabled", pw_enabled),
                 ("auth_sso_enabled", sso_enabled),
                 ("oidc_button_text", &oidc_button_text),
@@ -399,6 +421,8 @@ pub async fn settings_submit(
                 ("agent_confidence_threshold", &agent_confidence_threshold),
                 ("agent_context_limit", &agent_context_limit),
                 ("agent_concurrency", &agent_concurrency),
+                ("lastfm_api_key", &lastfm_api_key),
+                ("lastfm_shared_secret", &lastfm_shared_secret),
             ];
             for (key, value) in fields {
                 let mut entry = ConfigEntry::new(key.to_owned(), value.to_owned());

src/config.rs

@@ -134,6 +134,7 @@ pub struct ConfigSources {
     pub agent_context_limit: ConfigSource,
     pub agent_concurrency: ConfigSource,
     pub lastfm_api_key: ConfigSource,
+    pub lastfm_shared_secret: ConfigSource,
 }
 
 impl Default for ConfigSources {
@@ -160,6 +161,7 @@ impl Default for ConfigSources {
             agent_context_limit: ConfigSource::Default,
             agent_concurrency: ConfigSource::Default,
             lastfm_api_key: ConfigSource::Default,
+            lastfm_shared_secret: ConfigSource::Default,
         }
     }
 }
@@ -266,6 +268,8 @@ pub struct AppConfig {
     pub agent_concurrency: u64,
     /// Last.fm API key for weekly popularity enrichment.
     pub lastfm_api_key: String,
+    /// Last.fm shared secret for authenticated scrobbling calls.
+    pub lastfm_shared_secret: String,
 }
 
 impl Default for AppConfig {
@@ -292,6 +296,7 @@ impl Default for AppConfig {
             agent_context_limit: 8192,
             agent_concurrency: 2,
             lastfm_api_key: String::new(),
+            lastfm_shared_secret: String::new(),
         }
     }
 }
@@ -319,6 +324,7 @@ impl_env_overrides!(
     agent_context_limit,
     agent_concurrency,
     lastfm_api_key,
+    lastfm_shared_secret,
 );
 
 impl AppConfig {
@@ -403,6 +409,7 @@ impl AppConfig {
         apply_db_field!(agent_context_limit);
         apply_db_field!(agent_concurrency);
         apply_db_field!(lastfm_api_key);
+        apply_db_field!(lastfm_shared_secret);
     }
 }
 

src/i18n/phrases.rs

@@ -95,6 +95,10 @@ translations! {
     settings_api:             "API"                           , "API";
     settings_swagger:         "Swagger UI"                    , "Swagger UI";
     settings_swagger_help:    "Serves interactive API docs at /swagger/ (requires restart)" , "Интерактивная документация API на /swagger/ (требуется перезапуск)";
+    settings_lastfm_api_key:  "Last.fm API key"               , "API ключ Last.fm";
+    settings_lastfm_api_key_help: "Used for Last.fm popularity and account connection" , "Используется для популярности Last.fm и подключения аккаунта";
+    settings_lastfm_shared_secret: "Last.fm shared secret"    , "Shared secret Last.fm";
+    settings_lastfm_shared_secret_help: "Required for signed Last.fm scrobbling requests" , "Нужен для подписанных запросов скробблинга Last.fm";
 
     // OIDC login errors
     login_oidc_error:         "SSO login failed. Please try again." , "Ошибка входа через SSO. Попробуйте ещё раз.";
@@ -268,6 +272,7 @@ translations! {
     // Player UI
     player_library:          "Library"                         , "Библиотека";
     player_artists:          "Artists"                         , "Артисты";
+    player_release:          "Release"                         , "Релиз";
     player_releases:         "Releases"                        , "Релизы";
     player_tracks:           "Tracks"                          , "Треки";
     player_title:            "Title"                           , "Название";
@@ -326,6 +331,14 @@ translations! {
     player_lastfm_playcount: "Last.fm plays"                   , "Прослушивания Last.fm";
     player_lastfm_updated:   "Last.fm updated"                 , "Last.fm обновлён";
     player_lastfm_not_loaded: "not loaded yet"                 , "ещё не загружено";
+    player_lastfm_profile:   "Last.fm"                         , "Last.fm";
+    player_lastfm_connect:   "Connect Last.fm"                 , "Подключить Last.fm";
+    player_lastfm_connected: "Connected as {user}"             , "Подключён: {user}";
+    player_lastfm_reconnect: "Reconnect Last.fm"               , "Переподключить Last.fm";
+    player_lastfm_not_configured: "Last.fm is not configured"  , "Last.fm не настроен";
+    player_lastfm_disconnect_confirm: "Disconnect Last.fm account {user}?" , "Отвязать аккаунт Last.fm {user}?";
+    player_lastfm_connect_failed: "Could not open Last.fm connection" , "Не удалось открыть подключение Last.fm";
+    player_lastfm_disconnect_failed: "Could not disconnect Last.fm" , "Не удалось отвязать Last.fm";
     player_play:             "Play"                            , "Играть";
     player_like:             "Like"                            , "Лайк";
     player_add_to_queue:     "Add to queue"                    , "Добавить в очередь";

src/jobs/lastfm_scrobble.rs

@@ -0,0 +1,34 @@
+use crate::lastfm;
+use crate::scheduler::{Job, JobContext, JobLog};
+
+pub struct LastfmScrobbleJob;
+
+#[async_trait::async_trait]
+impl Job for LastfmScrobbleJob {
+    fn name(&self) -> &'static str {
+        "lastfm_scrobble"
+    }
+
+    fn description(&self) -> &'static str {
+        "Send queued Last.fm scrobbles for connected users"
+    }
+
+    fn default_cron(&self) -> &'static str {
+        // Every minute.
+        "0 * * * * *"
+    }
+
+    async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> anyhow::Result<()> {
+        if !lastfm::is_configured(&ctx.config) {
+            log.warn("Last.fm API key/shared secret are not configured; skipping scrobble outbox");
+            return Ok(());
+        }
+
+        let summary = lastfm::process_pending_scrobbles(&ctx.pool, &ctx.config, None, 50).await?;
+        log.info(&format!(
+            "Last.fm scrobble outbox processed: considered={}, sent={}, failed={}, blocked={}, skipped={}",
+            summary.considered, summary.sent, summary.failed, summary.blocked, summary.skipped
+        ));
+        Ok(())
+    }
+}

src/jobs/mod.rs

@@ -5,6 +5,7 @@ pub mod cover_variant_backfill;
 pub mod inbox_discover;
 pub mod inbox_process;
 pub mod lastfm_popularity;
+pub mod lastfm_scrobble;
 pub mod metadata_backfill;
 
 use std::path::{Component, Path, PathBuf};

src/lastfm.rs

@@ -0,0 +1,619 @@
+use std::collections::BTreeMap;
+use std::time::Duration;
+
+use anyhow::Context;
+use md5::{Digest, Md5};
+use reqwest::Client;
+use serde::Deserialize;
+use sqlx::PgPool;
+
+use crate::config::AppConfig;
+
+const LASTFM_API_URL: &str = "https://ws.audioscrobbler.com/2.0/";
+const MAX_BATCH_SIZE: i64 = 50;
+const MAX_ATTEMPTS: i32 = 8;
+
+#[derive(Debug, Clone)]
+pub struct LastfmCredentials {
+    api_key: String,
+    shared_secret: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct LastfmSession {
+    pub username: String,
+    pub session_key: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct LastfmTrackPayload {
+    pub artist: String,
+    pub track: String,
+    pub album: Option<String>,
+    pub album_artist: Option<String>,
+    pub track_number: Option<i32>,
+    pub duration_seconds: Option<i32>,
+}
+
+#[derive(Debug, Clone)]
+pub struct LastfmScrobblePayload {
+    pub track: LastfmTrackPayload,
+    pub timestamp: i64,
+}
+
+#[derive(Debug)]
+pub struct LastfmApiError {
+    pub code: Option<i32>,
+    pub message: String,
+}
+
+impl std::fmt::Display for LastfmApiError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.code {
+            Some(code) => write!(f, "Last.fm API error {code}: {}", self.message),
+            None => write!(f, "Last.fm API error: {}", self.message),
+        }
+    }
+}
+
+impl std::error::Error for LastfmApiError {}
+
+impl LastfmApiError {
+    fn new(code: Option<i32>, message: impl Into<String>) -> Self {
+        Self {
+            code,
+            message: message.into(),
+        }
+    }
+
+    pub fn is_invalid_session(&self) -> bool {
+        self.code == Some(9)
+    }
+
+    pub fn is_retryable(&self) -> bool {
+        matches!(self.code, Some(11 | 16 | 29) | None)
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct ScrobbleProcessSummary {
+    pub considered: u64,
+    pub sent: u64,
+    pub failed: u64,
+    pub blocked: u64,
+    pub skipped: u64,
+}
+
+pub fn is_configured(config: &AppConfig) -> bool {
+    !config.lastfm_api_key.trim().is_empty() && !config.lastfm_shared_secret.trim().is_empty()
+}
+
+impl LastfmCredentials {
+    pub fn from_config(config: &AppConfig) -> Option<Self> {
+        let api_key = config.lastfm_api_key.trim();
+        let shared_secret = config.lastfm_shared_secret.trim();
+        if api_key.is_empty() || shared_secret.is_empty() {
+            return None;
+        }
+        Some(Self {
+            api_key: api_key.to_owned(),
+            shared_secret: shared_secret.to_owned(),
+        })
+    }
+
+    pub fn api_key(&self) -> &str {
+        &self.api_key
+    }
+}
+
+pub struct LastfmClient {
+    client: Client,
+    credentials: LastfmCredentials,
+}
+
+impl LastfmClient {
+    pub fn new(credentials: LastfmCredentials) -> anyhow::Result<Self> {
+        let client = Client::builder()
+            .user_agent(format!(
+                "furumusic-lastfm-scrobbler/{}",
+                env!("CARGO_PKG_VERSION")
+            ))
+            .timeout(Duration::from_secs(15))
+            .build()
+            .context("failed to build Last.fm HTTP client")?;
+        Ok(Self {
+            client,
+            credentials,
+        })
+    }
+
+    pub async fn get_session(&self, token: &str) -> Result<LastfmSession, LastfmApiError> {
+        let params = self.signed_params(
+            "auth.getSession",
+            None,
+            vec![("token".to_string(), token.to_string())],
+        );
+        let body = self.post(params).await?;
+        let response: AuthSessionResponse = serde_json::from_str(&body)
+            .map_err(|err| LastfmApiError::new(None, err.to_string()))?;
+        if let Some(code) = response.error {
+            return Err(LastfmApiError::new(
+                Some(code),
+                response
+                    .message
+                    .unwrap_or_else(|| "authentication failed".to_string()),
+            ));
+        }
+        let Some(session) = response.session else {
+            return Err(LastfmApiError::new(
+                None,
+                "Last.fm auth response did not include a session",
+            ));
+        };
+        Ok(LastfmSession {
+            username: session.name,
+            session_key: session.key,
+        })
+    }
+
+    pub async fn update_now_playing(
+        &self,
+        session_key: &str,
+        track: &LastfmTrackPayload,
+    ) -> Result<(), LastfmApiError> {
+        let mut extra = vec![
+            ("artist".to_string(), track.artist.clone()),
+            ("track".to_string(), track.track.clone()),
+        ];
+        push_optional(&mut extra, "album", track.album.as_deref());
+        push_optional(&mut extra, "albumArtist", track.album_artist.as_deref());
+        push_optional_i32(&mut extra, "trackNumber", track.track_number);
+        push_optional_i32(&mut extra, "duration", track.duration_seconds);
+
+        let params = self.signed_params("track.updateNowPlaying", Some(session_key), extra);
+        let body = self.post(params).await?;
+        check_lastfm_error(&body)
+    }
+
+    pub async fn scrobble_batch(
+        &self,
+        session_key: &str,
+        scrobbles: &[LastfmScrobblePayload],
+    ) -> Result<(), LastfmApiError> {
+        let mut extra = Vec::new();
+        for (index, scrobble) in scrobbles.iter().take(MAX_BATCH_SIZE as usize).enumerate() {
+            let suffix = format!("[{index}]");
+            extra.push((format!("artist{suffix}"), scrobble.track.artist.clone()));
+            extra.push((format!("track{suffix}"), scrobble.track.track.clone()));
+            extra.push((format!("timestamp{suffix}"), scrobble.timestamp.to_string()));
+            push_optional(
+                &mut extra,
+                &format!("album{suffix}"),
+                scrobble.track.album.as_deref(),
+            );
+            push_optional(
+                &mut extra,
+                &format!("albumArtist{suffix}"),
+                scrobble.track.album_artist.as_deref(),
+            );
+            push_optional_i32(
+                &mut extra,
+                &format!("trackNumber{suffix}"),
+                scrobble.track.track_number,
+            );
+            push_optional_i32(
+                &mut extra,
+                &format!("duration{suffix}"),
+                scrobble.track.duration_seconds,
+            );
+        }
+
+        let params = self.signed_params("track.scrobble", Some(session_key), extra);
+        let body = self.post(params).await?;
+        check_lastfm_error(&body)
+    }
+
+    fn signed_params(
+        &self,
+        method: &str,
+        session_key: Option<&str>,
+        extra: Vec<(String, String)>,
+    ) -> Vec<(String, String)> {
+        let mut params = BTreeMap::new();
+        params.insert("api_key".to_string(), self.credentials.api_key.clone());
+        params.insert("method".to_string(), method.to_string());
+        if let Some(session_key) = session_key {
+            params.insert("sk".to_string(), session_key.to_string());
+        }
+        for (key, value) in extra {
+            params.insert(key, value);
+        }
+
+        let mut signature_input = String::new();
+        for (key, value) in &params {
+            signature_input.push_str(key);
+            signature_input.push_str(value);
+        }
+        signature_input.push_str(&self.credentials.shared_secret);
+        let digest = Md5::digest(signature_input.as_bytes());
+        let api_sig = format!("{digest:x}");
+
+        let mut out = params.into_iter().collect::<Vec<_>>();
+        out.push(("api_sig".to_string(), api_sig));
+        out.push(("format".to_string(), "json".to_string()));
+        out
+    }
+
+    async fn post(&self, params: Vec<(String, String)>) -> Result<String, LastfmApiError> {
+        let response = self
+            .client
+            .post(LASTFM_API_URL)
+            .form(&params)
+            .send()
+            .await
+            .map_err(|err| LastfmApiError::new(None, err.to_string()))?;
+        let status = response.status();
+        let body = response
+            .text()
+            .await
+            .map_err(|err| LastfmApiError::new(None, err.to_string()))?;
+        if !status.is_success() {
+            if let Some(err) = parse_error(&body) {
+                return Err(err);
+            }
+            return Err(LastfmApiError::new(None, format!("HTTP {status}: {body}")));
+        }
+        Ok(body)
+    }
+}
+
+pub async fn process_pending_scrobbles(
+    pool: &PgPool,
+    config: &AppConfig,
+    user_id: Option<i64>,
+    limit_per_user: i64,
+) -> anyhow::Result<ScrobbleProcessSummary> {
+    let Some(credentials) = LastfmCredentials::from_config(config) else {
+        return Ok(ScrobbleProcessSummary::default());
+    };
+    let client = LastfmClient::new(credentials)?;
+    let user_ids = pending_user_ids(pool, user_id).await?;
+    let mut summary = ScrobbleProcessSummary::default();
+
+    for uid in user_ids {
+        let rows = fetch_pending_scrobbles(pool, uid, limit_per_user.min(MAX_BATCH_SIZE)).await?;
+        if rows.is_empty() {
+            continue;
+        }
+        summary.considered += rows.len() as u64;
+
+        let mut ids = Vec::new();
+        let mut attempt_rows = Vec::new();
+        let mut payloads = Vec::new();
+        for row in &rows {
+            match row.payload() {
+                Some(payload) => {
+                    ids.push(row.id);
+                    attempt_rows.push((row.id, row.attempt_count));
+                    payloads.push(payload);
+                }
+                None => {
+                    mark_row_failed(pool, row.id, "track has no primary Last.fm artist").await?;
+                    summary.skipped += 1;
+                }
+            }
+        }
+        if ids.is_empty() {
+            continue;
+        }
+
+        match client.scrobble_batch(&rows[0].session_key, &payloads).await {
+            Ok(()) => {
+                mark_rows_sent(pool, &ids).await?;
+                clear_account_error(pool, uid).await?;
+                summary.sent += ids.len() as u64;
+            }
+            Err(err) if err.is_invalid_session() => {
+                mark_account_reauth_required(pool, uid, &err.to_string()).await?;
+                mark_rows_blocked(pool, &ids, &err.to_string()).await?;
+                summary.blocked += ids.len() as u64;
+            }
+            Err(err) => {
+                mark_rows_retry_or_failed(pool, &attempt_rows, &err).await?;
+                summary.failed += ids.len() as u64;
+                if err.code == Some(29) {
+                    break;
+                }
+            }
+        }
+    }
+
+    Ok(summary)
+}
+
+#[derive(Debug, Deserialize)]
+struct AuthSessionResponse {
+    session: Option<AuthSession>,
+    error: Option<i32>,
+    message: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct AuthSession {
+    name: String,
+    key: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct ErrorEnvelope {
+    error: Option<i32>,
+    message: Option<String>,
+}
+
+#[derive(Debug, sqlx::FromRow)]
+struct PendingScrobbleRow {
+    id: i64,
+    started_at: i64,
+    duration_seconds: i32,
+    attempt_count: i32,
+    session_key: String,
+    title: String,
+    artist_name: Option<String>,
+    album_title: Option<String>,
+    album_artist_name: Option<String>,
+    track_number: Option<i32>,
+}
+
+impl PendingScrobbleRow {
+    fn payload(&self) -> Option<LastfmScrobblePayload> {
+        let artist = self
+            .artist_name
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())?
+            .to_string();
+        Some(LastfmScrobblePayload {
+            track: LastfmTrackPayload {
+                artist,
+                track: self.title.clone(),
+                album: non_empty(self.album_title.as_deref()),
+                album_artist: non_empty(self.album_artist_name.as_deref()),
+                track_number: self.track_number,
+                duration_seconds: Some(self.duration_seconds),
+            },
+            timestamp: self.started_at,
+        })
+    }
+}
+
+fn non_empty(value: Option<&str>) -> Option<String> {
+    value
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+}
+
+fn push_optional(params: &mut Vec<(String, String)>, key: &str, value: Option<&str>) {
+    if let Some(value) = value.map(str::trim).filter(|value| !value.is_empty()) {
+        params.push((key.to_string(), value.to_string()));
+    }
+}
+
+fn push_optional_i32(params: &mut Vec<(String, String)>, key: &str, value: Option<i32>) {
+    if let Some(value) = value {
+        params.push((key.to_string(), value.to_string()));
+    }
+}
+
+fn check_lastfm_error(body: &str) -> Result<(), LastfmApiError> {
+    if let Some(err) = parse_error(body) {
+        return Err(err);
+    }
+    Ok(())
+}
+
+fn parse_error(body: &str) -> Option<LastfmApiError> {
+    let envelope: ErrorEnvelope = serde_json::from_str(body).ok()?;
+    envelope
+        .error
+        .map(|code| LastfmApiError::new(Some(code), envelope.message.unwrap_or_default()))
+}
+
+async fn pending_user_ids(pool: &PgPool, user_id: Option<i64>) -> anyhow::Result<Vec<i64>> {
+    if let Some(user_id) = user_id {
+        return Ok(vec![user_id]);
+    }
+    let rows = sqlx::query_scalar::<_, i64>(
+        r#"SELECT DISTINCT o.user_id
+             FROM furumusic__lastfm_scrobble_outbox o
+             JOIN furumusic__lastfm_account a ON a.user_id = o.user_id
+            WHERE o.status IN ('pending', 'retry')
+              AND a.reauth_required = false
+            ORDER BY o.user_id"#,
+    )
+    .fetch_all(pool)
+    .await?;
+    Ok(rows)
+}
+
+async fn fetch_pending_scrobbles(
+    pool: &PgPool,
+    user_id: i64,
+    limit: i64,
+) -> anyhow::Result<Vec<PendingScrobbleRow>> {
+    let rows = sqlx::query_as::<_, PendingScrobbleRow>(
+        r#"SELECT o.id,
+                  o.started_at,
+                  o.duration_seconds,
+                  o.attempt_count,
+                  a.session_key::text AS session_key,
+                  t.title::text AS title,
+                  r.title::text AS album_title,
+                  t.track_number,
+                  (
+                    SELECT ar.name::text
+                      FROM furumusic__track_artist ta
+                      JOIN furumusic__artist ar ON ar.id = ta.artist_id
+                     WHERE ta.track_id = t.id AND ta.role <> 'featuring'
+                     ORDER BY ta.position
+                     LIMIT 1
+                  ) AS artist_name,
+                  (
+                    SELECT ar.name::text
+                      FROM furumusic__release_artist ra
+                      JOIN furumusic__artist ar ON ar.id = ra.artist_id
+                     WHERE ra.release_id = r.id
+                     ORDER BY ra.position
+                     LIMIT 1
+                  ) AS album_artist_name
+             FROM furumusic__lastfm_scrobble_outbox o
+             JOIN furumusic__lastfm_account a ON a.user_id = o.user_id
+             JOIN furumusic__track t ON t.id = o.track_id
+             LEFT JOIN furumusic__release r ON r.id = t.release_id
+            WHERE o.user_id = $1
+              AND o.status IN ('pending', 'retry')
+              AND a.reauth_required = false
+            ORDER BY o.created_at, o.id
+            LIMIT $2"#,
+    )
+    .bind(user_id)
+    .bind(limit)
+    .fetch_all(pool)
+    .await?;
+    Ok(rows)
+}
+
+async fn clear_account_error(pool: &PgPool, user_id: i64) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_account
+              SET last_error = NULL,
+                  reauth_required = false,
+                  updated_at = $2
+            WHERE user_id = $1"#,
+    )
+    .bind(user_id)
+    .bind(now_iso())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn mark_account_reauth_required(
+    pool: &PgPool,
+    user_id: i64,
+    error: &str,
+) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_account
+              SET reauth_required = true,
+                  last_error = $2,
+                  updated_at = $3
+            WHERE user_id = $1"#,
+    )
+    .bind(user_id)
+    .bind(error)
+    .bind(now_iso())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn mark_rows_sent(pool: &PgPool, ids: &[i64]) -> anyhow::Result<()> {
+    if ids.is_empty() {
+        return Ok(());
+    }
+    let now = now_iso();
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_scrobble_outbox
+              SET status = 'sent',
+                  updated_at = $2,
+                  scrobbled_at = $2,
+                  last_error = NULL
+            WHERE id = ANY($1)"#,
+    )
+    .bind(ids)
+    .bind(now)
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn mark_row_failed(pool: &PgPool, id: i64, error: &str) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_scrobble_outbox
+              SET status = 'failed',
+                  attempt_count = attempt_count + 1,
+                  last_error = $2,
+                  updated_at = $3
+            WHERE id = $1"#,
+    )
+    .bind(id)
+    .bind(error)
+    .bind(now_iso())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn mark_rows_blocked(pool: &PgPool, ids: &[i64], error: &str) -> anyhow::Result<()> {
+    if ids.is_empty() {
+        return Ok(());
+    }
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_scrobble_outbox
+              SET status = 'blocked',
+                  attempt_count = attempt_count + 1,
+                  last_error = $2,
+                  updated_at = $3
+            WHERE id = ANY($1)"#,
+    )
+    .bind(ids)
+    .bind(error)
+    .bind(now_iso())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+async fn mark_rows_retry_or_failed(
+    pool: &PgPool,
+    rows: &[(i64, i32)],
+    error: &LastfmApiError,
+) -> anyhow::Result<()> {
+    if rows.is_empty() {
+        return Ok(());
+    }
+    let ids: Vec<i64> = rows.iter().map(|(id, _)| *id).collect();
+    let next_status = if error.is_retryable()
+        && rows
+            .iter()
+            .any(|(_, attempt_count)| attempt_count + 1 < MAX_ATTEMPTS)
+    {
+        "retry"
+    } else {
+        "failed"
+    };
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_scrobble_outbox
+              SET status = CASE
+                    WHEN attempt_count + 1 >= $2 THEN 'failed'
+                    ELSE $3
+                  END,
+                  attempt_count = attempt_count + 1,
+                  last_error = $4,
+                  updated_at = $5
+            WHERE id = ANY($1)"#,
+    )
+    .bind(&ids)
+    .bind(MAX_ATTEMPTS)
+    .bind(next_status)
+    .bind(error.to_string())
+    .bind(now_iso())
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+fn now_iso() -> String {
+    chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string()
+}

src/main.rs

@@ -5,6 +5,7 @@ mod auth;
 mod config;
 mod i18n;
 mod jobs;
+mod lastfm;
 mod music;
 mod oidc;
 mod player;
@@ -55,6 +56,7 @@ fn build_registry() -> Arc<JobRegistry> {
     registry.register(jobs::cover_variant_backfill::CoverVariantBackfillJob);
     registry.register(jobs::metadata_backfill::MetadataBackfillJob);
     registry.register(jobs::lastfm_popularity::LastfmPopularityJob);
+    registry.register(jobs::lastfm_scrobble::LastfmScrobbleJob);
     Arc::new(registry)
 }
 

src/music/mod.rs

@@ -1692,6 +1692,83 @@ pub mod db_migrations {
             &[Operation::custom(create_lastfm_track_popularity).build()];
     }
 
+    // -- M0033: Last.fm scrobbling -----------------------------------------
+
+    #[cot::db::migrations::migration_op]
+    async fn create_lastfm_scrobbling(
+        ctx: migrations::MigrationContext<'_>,
+    ) -> cot::db::Result<()> {
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__lastfm_account (
+                    user_id BIGINT PRIMARY KEY,
+                    lastfm_username VARCHAR(255) NOT NULL,
+                    session_key TEXT NOT NULL,
+                    connected_at VARCHAR(32) NOT NULL,
+                    updated_at VARCHAR(32) NOT NULL,
+                    last_error TEXT,
+                    reauth_required BOOLEAN NOT NULL DEFAULT FALSE
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__lastfm_auth_state (
+                    state VARCHAR(64) PRIMARY KEY,
+                    user_id BIGINT NOT NULL,
+                    created_at VARCHAR(32) NOT NULL
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__lastfm_scrobble_outbox (
+                    id BIGSERIAL PRIMARY KEY,
+                    user_id BIGINT NOT NULL,
+                    track_id BIGINT NOT NULL,
+                    started_at BIGINT NOT NULL,
+                    listened_seconds INTEGER NOT NULL,
+                    duration_seconds INTEGER NOT NULL,
+                    status VARCHAR(32) NOT NULL,
+                    attempt_count INTEGER NOT NULL DEFAULT 0,
+                    last_error TEXT,
+                    created_at VARCHAR(32) NOT NULL,
+                    updated_at VARCHAR(32) NOT NULL,
+                    scrobbled_at VARCHAR(32),
+                    dedupe_key VARCHAR(128) NOT NULL UNIQUE
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_lastfm_scrobble_outbox_status
+                   ON furumusic__lastfm_scrobble_outbox (status, created_at, id)",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_lastfm_scrobble_outbox_user
+                   ON furumusic__lastfm_scrobble_outbox (user_id, status, created_at)",
+            )
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0033CreateLastfmScrobbling;
+
+    impl migrations::Migration for M0033CreateLastfmScrobbling {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0033_create_lastfm_scrobbling";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] =
+            &[migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0032_create_lastfm_track_popularity",
+            )];
+        const OPERATIONS: &'static [Operation] =
+            &[Operation::custom(create_lastfm_scrobbling).build()];
+    }
+
     pub const MIGRATIONS: &[&SyncDynMigration] = &[
         &M0006CreateMediaFile,
         &M0007CreateArtist,
@@ -1715,5 +1792,6 @@ pub mod db_migrations {
         &M0030AddMediaFileUploader,
         &M0031CreateTorrentSession,
         &M0032CreateLastfmTrackPopularity,
+        &M0033CreateLastfmScrobbling,
     ];
 }

src/player/dto.rs

@@ -55,6 +55,8 @@ pub(super) struct TrackItem {
     pub(super) duration_seconds: f64,
     pub(super) artists: Vec<ArtistRef>,
     pub(super) featured_artists: Vec<ArtistRef>,
+    pub(super) release_id: i64,
+    pub(super) release_title: String,
     pub(super) release_year: Option<i32>,
     pub(super) cover_url: Option<String>,
     pub(super) stream_url: String,
@@ -170,6 +172,35 @@ pub(super) struct UserProfile {
     pub(super) stats: UserStats,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct LastfmStatus {
+    pub(super) configured: bool,
+    pub(super) connected: bool,
+    pub(super) username: Option<String>,
+    pub(super) reauth_required: bool,
+    pub(super) last_error: Option<String>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct LastfmActionResponse {
+    pub(super) ok: bool,
+    pub(super) queued: bool,
+    pub(super) sent: bool,
+    pub(super) message: Option<String>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct LastfmNowPlayingRequest {
+    pub(super) track_id: i64,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct LastfmScrobbleRequest {
+    pub(super) track_id: i64,
+    pub(super) started_at: Option<i64>,
+    pub(super) listened_seconds: i32,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 pub(super) struct AgentQueueStatus {
     pub(super) queued_count: i64,

src/player/mod.rs

@@ -16,6 +16,7 @@ use cot::{App, Body, Template};
 use crate::auth;
 use crate::config::AppConfig;
 use crate::i18n::Translations;
+use crate::lastfm::{LastfmClient, LastfmCredentials, LastfmTrackPayload};
 use crate::scheduler::SchedulerHandle;
 use crate::torrents::{TorrentPreviewRequest, TorrentService, TorrentStartRequest};
 
@@ -49,6 +50,36 @@ struct LocalUploadResponse {
     size: u64,
 }
 
+#[derive(Debug, sqlx::FromRow)]
+struct LastfmAccountApiRow {
+    session_key: String,
+    reauth_required: bool,
+    last_error: Option<String>,
+}
+
+#[derive(Debug, sqlx::FromRow)]
+struct LastfmStatusRow {
+    username: String,
+    reauth_required: bool,
+    last_error: Option<String>,
+}
+
+#[derive(Debug, sqlx::FromRow)]
+struct LastfmTrackMetaRow {
+    title: String,
+    duration_seconds: f64,
+    track_number: Option<i32>,
+    album_title: Option<String>,
+    artist_name: Option<String>,
+    album_artist_name: Option<String>,
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct LastfmCallbackQuery {
+    token: Option<String>,
+    state: Option<String>,
+}
+
 // ---------------------------------------------------------------------------
 // SPA shell
 // ---------------------------------------------------------------------------
@@ -114,6 +145,493 @@ async fn me_handler(
     .into_response()
 }
 
+// ---------------------------------------------------------------------------
+// Last.fm account + scrobbling
+// ---------------------------------------------------------------------------
+
+fn redirect_response(location: &str) -> cot::response::Response {
+    cot::http::Response::builder()
+        .status(StatusCode::SEE_OTHER)
+        .header(cot::http::header::LOCATION, location)
+        .body(Body::fixed(""))
+        .expect("valid response")
+}
+
+fn request_origin(request: &cot::request::Request) -> Option<String> {
+    let headers = request.headers();
+    let host = headers
+        .get("x-forwarded-host")
+        .or_else(|| headers.get("host"))?
+        .to_str()
+        .ok()?;
+    let proto = headers
+        .get("x-forwarded-proto")
+        .and_then(|value| value.to_str().ok())
+        .unwrap_or("http");
+    Some(format!("{proto}://{host}"))
+}
+
+async fn lastfm_status_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+) -> cot::Result<cot::response::Response> {
+    let Some(user) = auth::get_session_user(&session, &db).await else {
+        return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
+    };
+    let (config, _) = AppConfig::load_with_db(&db).await;
+    let configured = crate::lastfm::is_configured(&config);
+    let account = sqlx::query_as::<_, LastfmStatusRow>(
+        r#"SELECT lastfm_username::text AS username,
+                  reauth_required,
+                  last_error::text AS last_error
+             FROM furumusic__lastfm_account
+            WHERE user_id = $1"#,
+    )
+    .bind(user.id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    Json(LastfmStatus {
+        configured,
+        connected: account.is_some(),
+        username: account.as_ref().map(|row| row.username.clone()),
+        reauth_required: account
+            .as_ref()
+            .map(|row| row.reauth_required)
+            .unwrap_or(false),
+        last_error: account.and_then(|row| row.last_error),
+    })
+    .into_response()
+}
+
+async fn lastfm_connect_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    request: cot::request::Request,
+) -> cot::Result<cot::response::Response> {
+    let Some(user) = auth::get_session_user(&session, &db).await else {
+        return Ok(redirect_response("/login"));
+    };
+    let (config, _) = AppConfig::load_with_db(&db).await;
+    let Some(credentials) = LastfmCredentials::from_config(&config) else {
+        return Ok(redirect_response("/?lastfm=not_configured"));
+    };
+    let Some(origin) = request_origin(&request) else {
+        return Ok(redirect_response("/?lastfm=bad_origin"));
+    };
+
+    let state = uuid::Uuid::new_v4().simple().to_string();
+    let now = chrono::Utc::now();
+    let stale = (now - chrono::Duration::hours(1))
+        .format("%Y-%m-%dT%H:%M:%SZ")
+        .to_string();
+    sqlx::query("DELETE FROM furumusic__lastfm_auth_state WHERE created_at < $1")
+        .bind(stale)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query(
+        r#"INSERT INTO furumusic__lastfm_auth_state (state, user_id, created_at)
+           VALUES ($1, $2, $3)
+           ON CONFLICT (state) DO NOTHING"#,
+    )
+    .bind(&state)
+    .bind(user.id)
+    .bind(now.format("%Y-%m-%dT%H:%M:%SZ").to_string())
+    .execute(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let callback = format!("{origin}/api/player/lastfm/callback?state={state}");
+    let mut url = reqwest::Url::parse("https://www.last.fm/api/auth/")
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    url.query_pairs_mut()
+        .append_pair("api_key", credentials.api_key())
+        .append_pair("cb", &callback);
+    Ok(redirect_response(url.as_str()))
+}
+
+async fn lastfm_callback_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    query: cot::request::extractors::UrlQuery<LastfmCallbackQuery>,
+) -> cot::Result<cot::response::Response> {
+    let Some(user) = auth::get_session_user(&session, &db).await else {
+        return Ok(redirect_response("/login"));
+    };
+    let Some(token) = query
+        .0
+        .token
+        .as_deref()
+        .map(str::trim)
+        .filter(|v| !v.is_empty())
+    else {
+        return Ok(redirect_response("/?lastfm=missing_token"));
+    };
+    let Some(state) = query
+        .0
+        .state
+        .as_deref()
+        .map(str::trim)
+        .filter(|v| !v.is_empty())
+    else {
+        return Ok(redirect_response("/?lastfm=missing_state"));
+    };
+
+    let state_user_id = sqlx::query_scalar::<_, i64>(
+        "SELECT user_id FROM furumusic__lastfm_auth_state WHERE state = $1",
+    )
+    .bind(state)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+    if state_user_id != Some(user.id) {
+        return Ok(redirect_response("/?lastfm=bad_state"));
+    }
+    sqlx::query("DELETE FROM furumusic__lastfm_auth_state WHERE state = $1")
+        .bind(state)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let (config, _) = AppConfig::load_with_db(&db).await;
+    let Some(credentials) = LastfmCredentials::from_config(&config) else {
+        return Ok(redirect_response("/?lastfm=not_configured"));
+    };
+    let client = LastfmClient::new(credentials).map_err(|e| cot::Error::internal(e.to_string()))?;
+    match client.get_session(token).await {
+        Ok(lastfm_session) => {
+            let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+            sqlx::query(
+                r#"INSERT INTO furumusic__lastfm_account
+                      (user_id, lastfm_username, session_key, connected_at, updated_at, last_error, reauth_required)
+                   VALUES ($1, $2, $3, $4, $4, NULL, false)
+                   ON CONFLICT (user_id) DO UPDATE SET
+                      lastfm_username = EXCLUDED.lastfm_username,
+                      session_key = EXCLUDED.session_key,
+                      updated_at = EXCLUDED.updated_at,
+                      last_error = NULL,
+                      reauth_required = false"#,
+            )
+            .bind(user.id)
+            .bind(&lastfm_session.username)
+            .bind(&lastfm_session.session_key)
+            .bind(&now)
+            .execute(pool)
+            .await
+            .map_err(|e| cot::Error::internal(e.to_string()))?;
+            Ok(redirect_response("/?lastfm=connected"))
+        }
+        Err(err) => {
+            tracing::warn!("Last.fm auth failed for user {}: {err}", user.id);
+            Ok(redirect_response("/?lastfm=auth_failed"))
+        }
+    }
+}
+
+async fn lastfm_disconnect_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+) -> cot::Result<cot::response::Response> {
+    let Some(user) = auth::get_session_user(&session, &db).await else {
+        return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
+    };
+    let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+    sqlx::query("DELETE FROM furumusic__lastfm_account WHERE user_id = $1")
+        .bind(user.id)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_scrobble_outbox
+              SET status = 'blocked',
+                  last_error = 'Last.fm account disconnected',
+                  updated_at = $2
+            WHERE user_id = $1 AND status IN ('pending', 'retry')"#,
+    )
+    .bind(user.id)
+    .bind(now)
+    .execute(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+    Json(serde_json::json!({"ok": true})).into_response()
+}
+
+async fn load_lastfm_account(
+    pool: &sqlx::PgPool,
+    user_id: i64,
+) -> cot::Result<Option<LastfmAccountApiRow>> {
+    sqlx::query_as::<_, LastfmAccountApiRow>(
+        r#"SELECT session_key::text AS session_key,
+                  reauth_required,
+                  last_error::text AS last_error
+             FROM furumusic__lastfm_account
+            WHERE user_id = $1"#,
+    )
+    .bind(user_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))
+}
+
+async fn load_lastfm_track_payload(
+    pool: &sqlx::PgPool,
+    track_id: i64,
+) -> cot::Result<Option<LastfmTrackPayload>> {
+    let row = sqlx::query_as::<_, LastfmTrackMetaRow>(
+        r#"SELECT t.title::text AS title,
+                  t.duration_seconds,
+                  t.track_number,
+                  r.title::text AS album_title,
+                  (
+                    SELECT a.name::text
+                      FROM furumusic__track_artist ta
+                      JOIN furumusic__artist a ON a.id = ta.artist_id
+                     WHERE ta.track_id = t.id AND ta.role <> 'featuring'
+                     ORDER BY ta.position
+                     LIMIT 1
+                  ) AS artist_name,
+                  (
+                    SELECT a.name::text
+                      FROM furumusic__release_artist ra
+                      JOIN furumusic__artist a ON a.id = ra.artist_id
+                     WHERE ra.release_id = r.id
+                     ORDER BY ra.position
+                     LIMIT 1
+                  ) AS album_artist_name
+             FROM furumusic__track t
+             LEFT JOIN furumusic__release r ON r.id = t.release_id
+            WHERE t.id = $1 AND t.is_hidden = false"#,
+    )
+    .bind(track_id)
+    .fetch_optional(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    Ok(row.and_then(|row| {
+        let artist = row
+            .artist_name
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())?
+            .to_string();
+        Some(LastfmTrackPayload {
+            artist,
+            track: row.title,
+            album: row
+                .album_title
+                .map(|value| value.trim().to_string())
+                .filter(|value| !value.is_empty()),
+            album_artist: row
+                .album_artist_name
+                .map(|value| value.trim().to_string())
+                .filter(|value| !value.is_empty()),
+            track_number: row.track_number,
+            duration_seconds: Some(row.duration_seconds.round() as i32),
+        })
+    }))
+}
+
+async fn update_lastfm_account_error(
+    pool: &sqlx::PgPool,
+    user_id: i64,
+    error: &str,
+    reauth_required: bool,
+) -> cot::Result<()> {
+    sqlx::query(
+        r#"UPDATE furumusic__lastfm_account
+              SET last_error = $2,
+                  reauth_required = $3,
+                  updated_at = $4
+            WHERE user_id = $1"#,
+    )
+    .bind(user_id)
+    .bind(error)
+    .bind(reauth_required)
+    .bind(chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string())
+    .execute(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+    Ok(())
+}
+
+async fn lastfm_now_playing_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    Json(entry): Json<LastfmNowPlayingRequest>,
+) -> cot::Result<cot::response::Response> {
+    let Some(user) = auth::get_session_user(&session, &db).await else {
+        return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
+    };
+    let (config, _) = AppConfig::load_with_db(&db).await;
+    let Some(credentials) = LastfmCredentials::from_config(&config) else {
+        return Json(LastfmActionResponse {
+            ok: false,
+            queued: false,
+            sent: false,
+            message: Some("Last.fm is not configured".to_string()),
+        })
+        .into_response();
+    };
+    let Some(account) = load_lastfm_account(pool, user.id).await? else {
+        return Json(LastfmActionResponse {
+            ok: false,
+            queued: false,
+            sent: false,
+            message: Some("Last.fm account is not connected".to_string()),
+        })
+        .into_response();
+    };
+    if account.reauth_required {
+        return Json(LastfmActionResponse {
+            ok: false,
+            queued: false,
+            sent: false,
+            message: account.last_error,
+        })
+        .into_response();
+    }
+    let Some(track) = load_lastfm_track_payload(pool, entry.track_id).await? else {
+        return Json(LastfmActionResponse {
+            ok: false,
+            queued: false,
+            sent: false,
+            message: Some("Track has no primary artist for Last.fm".to_string()),
+        })
+        .into_response();
+    };
+    let client = LastfmClient::new(credentials).map_err(|e| cot::Error::internal(e.to_string()))?;
+    match client
+        .update_now_playing(&account.session_key, &track)
+        .await
+    {
+        Ok(()) => Json(LastfmActionResponse {
+            ok: true,
+            queued: false,
+            sent: true,
+            message: None,
+        })
+        .into_response(),
+        Err(err) => {
+            let reauth_required = err.is_invalid_session();
+            update_lastfm_account_error(pool, user.id, &err.to_string(), reauth_required).await?;
+            Json(LastfmActionResponse {
+                ok: false,
+                queued: false,
+                sent: false,
+                message: Some(err.to_string()),
+            })
+            .into_response()
+        }
+    }
+}
+
+async fn lastfm_scrobble_handler(
+    session: Session,
+    db: Database,
+    pool: &sqlx::PgPool,
+    Json(entry): Json<LastfmScrobbleRequest>,
+) -> cot::Result<cot::response::Response> {
+    let Some(user) = auth::get_session_user(&session, &db).await else {
+        return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
+    };
+    let (config, _) = AppConfig::load_with_db(&db).await;
+    if !crate::lastfm::is_configured(&config) {
+        return Json(LastfmActionResponse {
+            ok: false,
+            queued: false,
+            sent: false,
+            message: Some("Last.fm is not configured".to_string()),
+        })
+        .into_response();
+    }
+    if load_lastfm_account(pool, user.id).await?.is_none() {
+        return Json(LastfmActionResponse {
+            ok: false,
+            queued: false,
+            sent: false,
+            message: Some("Last.fm account is not connected".to_string()),
+        })
+        .into_response();
+    }
+    let Some(track) = load_lastfm_track_payload(pool, entry.track_id).await? else {
+        return Json(LastfmActionResponse {
+            ok: false,
+            queued: false,
+            sent: false,
+            message: Some("Track has no primary artist for Last.fm".to_string()),
+        })
+        .into_response();
+    };
+    let duration_seconds = track.duration_seconds.unwrap_or(0).max(0);
+    if duration_seconds <= 30 {
+        return Json(LastfmActionResponse {
+            ok: false,
+            queued: false,
+            sent: false,
+            message: Some("Track is too short to scrobble".to_string()),
+        })
+        .into_response();
+    }
+    let threshold = ((duration_seconds as f64 / 2.0).min(240.0)).ceil() as i32;
+    let listened_seconds = entry.listened_seconds.max(0);
+    if listened_seconds < threshold {
+        return Json(LastfmActionResponse {
+            ok: false,
+            queued: false,
+            sent: false,
+            message: Some("Scrobble threshold has not been reached".to_string()),
+        })
+        .into_response();
+    }
+
+    let now_ts = chrono::Utc::now().timestamp();
+    let started_at = entry
+        .started_at
+        .unwrap_or(now_ts - listened_seconds as i64)
+        .min(now_ts);
+    let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+    let dedupe_key = format!("{}:{}:{}", user.id, entry.track_id, started_at);
+    sqlx::query(
+        r#"INSERT INTO furumusic__lastfm_scrobble_outbox
+              (user_id, track_id, started_at, listened_seconds, duration_seconds, status, created_at, updated_at, dedupe_key)
+           VALUES ($1, $2, $3, $4, $5, 'pending', $6, $6, $7)
+           ON CONFLICT (dedupe_key) DO NOTHING"#,
+    )
+    .bind(user.id)
+    .bind(entry.track_id)
+    .bind(started_at)
+    .bind(listened_seconds)
+    .bind(duration_seconds)
+    .bind(&now)
+    .bind(&dedupe_key)
+    .execute(pool)
+    .await
+    .map_err(|e| cot::Error::internal(e.to_string()))?;
+
+    let sent =
+        match crate::lastfm::process_pending_scrobbles(pool, &config, Some(user.id), 10).await {
+            Ok(summary) => summary.sent > 0,
+            Err(err) => {
+                tracing::warn!("Last.fm immediate scrobble send failed: {err:#}");
+                false
+            }
+        };
+    Json(LastfmActionResponse {
+        ok: true,
+        queued: true,
+        sent,
+        message: None,
+    })
+    .into_response()
+}
+
 // ---------------------------------------------------------------------------
 // GET /api/player/agent-queue
 // ---------------------------------------------------------------------------
@@ -465,6 +983,8 @@ async fn release_detail_handler(
         r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
                   t.duration_seconds, t.cover_file_id,
                   r.cover_file_id as release_cover_file_id,
+                  r.id as release_id,
+                  r.title::text as release_title,
                   r.year as release_year,
                   COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
                   mf.audio_format,
@@ -542,6 +1062,8 @@ async fn release_detail_handler(
                 duration_seconds: t.duration_seconds,
                 artists: track_main_artists.remove(&tid).unwrap_or_default(),
                 featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
+                release_id: t.release_id,
+                release_title: t.release_title,
                 release_year: t.release_year,
                 cover_url: track_cover_variant_url(
                     t.cover_file_id,
@@ -707,6 +1229,8 @@ async fn playlist_detail_handler(
         r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
                   t.duration_seconds, t.cover_file_id,
                   r.cover_file_id as release_cover_file_id,
+                  r.id as release_id,
+                  r.title::text as release_title,
                   r.year as release_year,
                   COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
                   mf.audio_format,
@@ -804,6 +1328,8 @@ async fn build_track_items(
                 duration_seconds: t.duration_seconds,
                 artists: track_main_artists.remove(&tid).unwrap_or_default(),
                 featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
+                release_id: t.release_id,
+                release_title: t.release_title,
                 release_year: t.release_year,
                 cover_url: track_cover_variant_url(
                     t.cover_file_id,
@@ -835,13 +1361,19 @@ async fn likes_playlist_handler(
         r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
                   t.duration_seconds, t.cover_file_id,
                   r.cover_file_id as release_cover_file_id,
+                  r.id as release_id,
+                  r.title::text as release_title,
                   r.year as release_year,
                   COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
                   mf.audio_format,
                   mf.audio_bitrate,
                   mf.audio_sample_rate,
                   mf.audio_bit_depth,
-                  mf.file_size_bytes
+                  mf.file_size_bytes,
+                  t.lastfm_listeners,
+                  t.lastfm_playcount,
+                  t.lastfm_rating,
+                  t.lastfm_updated_at
            FROM furumusic__user_liked_track ult
            JOIN furumusic__track t ON t.id = ult.track_id
            JOIN furumusic__release r ON r.id = t.release_id
@@ -1476,6 +2008,8 @@ async fn search_handler(
             r#"SELECT t.id, t.title::text AS title, t.track_number, t.disc_number,
                       t.duration_seconds, t.cover_file_id,
                       rel.cover_file_id AS release_cover_file_id,
+                      rel.id AS release_id,
+                      rel.title::text AS release_title,
                       rel.year AS release_year,
                       COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
                       mf.audio_format,
@@ -1550,11 +2084,13 @@ async fn search_handler(
 
         let t = sqlx::query_as::<_, SearchTrackRow>(
             r#"SELECT id, title, track_number, disc_number, duration_seconds, cover_file_id,
-                      release_cover_file_id, release_year, uploader_name, audio_format, audio_bitrate,
+                      release_cover_file_id, release_id, release_title, release_year, uploader_name, audio_format, audio_bitrate,
                       audio_sample_rate, audio_bit_depth, file_size_bytes, lastfm_listeners, lastfm_playcount, lastfm_rating, lastfm_updated_at FROM (
                 SELECT t.id, t.title::text AS title, t.track_number, t.disc_number,
                        t.duration_seconds, t.cover_file_id,
                        rel.cover_file_id AS release_cover_file_id,
+                       rel.id AS release_id,
+                       rel.title::text AS release_title,
                        rel.year AS release_year,
                        COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
                        mf.audio_format,
@@ -1580,7 +2116,7 @@ async fn search_handler(
                 ) t
                 JOIN furumusic__release rel ON rel.id = t.release_id
                 LEFT JOIN furumusic__media_file mf ON mf.id = t.audio_file_id
-                GROUP BY t.id, t.title, t.track_number, t.disc_number, t.duration_seconds, t.cover_file_id, rel.cover_file_id, rel.year,
+                GROUP BY t.id, t.title, t.track_number, t.disc_number, t.duration_seconds, t.cover_file_id, rel.cover_file_id, rel.id, rel.title, rel.year,
                          mf.uploader_name, mf.audio_format, mf.audio_bitrate, mf.audio_sample_rate, mf.audio_bit_depth, mf.file_size_bytes,
                          t.lastfm_listeners, t.lastfm_playcount, t.lastfm_rating, t.lastfm_updated_at
                 ORDER BY similarity DESC
@@ -1677,6 +2213,8 @@ async fn search_handler(
                 duration_seconds: t.duration_seconds,
                 artists: track_main_artists.remove(&tid).unwrap_or_default(),
                 featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
+                release_id: t.release_id,
+                release_title: t.release_title,
                 release_year: t.release_year,
                 cover_url: track_cover_variant_url(
                     t.cover_file_id,
@@ -2252,6 +2790,8 @@ async fn tracks_by_ids_handler(
         r#"SELECT t.id, t.title::text as title, t.track_number, t.disc_number,
                   t.duration_seconds, t.cover_file_id,
                   r.cover_file_id as release_cover_file_id,
+                  r.id as release_id,
+                  r.title::text as release_title,
                   r.year as release_year,
                   COALESCE(mf.uploader_name, 'UFO')::text AS uploader_name,
                   mf.audio_format,
@@ -2328,6 +2868,8 @@ async fn tracks_by_ids_handler(
                 duration_seconds: t.duration_seconds,
                 artists: track_main_artists.remove(&tid).unwrap_or_default(),
                 featured_artists: track_feat_artists.remove(&tid).unwrap_or_default(),
+                release_id: t.release_id,
+                release_title: t.release_title,
                 release_year: t.release_year,
                 cover_url: track_cover_variant_url(
                     t.cover_file_id,
@@ -2413,6 +2955,152 @@ impl App for PlayerApp {
                 },
                 "player_me",
             ),
+            Route::with_handler_and_name(
+                "/lastfm/status",
+                get({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("player pool")
+                                })
+                                .await;
+                            lastfm_status_handler(session, db, pg_pool).await
+                        }
+                    }
+                }),
+                "player_lastfm_status",
+            ),
+            Route::with_handler_and_name(
+                "/lastfm/connect",
+                get({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, request: cot::request::Request| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("player pool")
+                                })
+                                .await;
+                            lastfm_connect_handler(session, db, pg_pool, request).await
+                        }
+                    }
+                }),
+                "player_lastfm_connect",
+            ),
+            Route::with_handler_and_name(
+                "/lastfm/callback",
+                get({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session,
+                          db: Database,
+                          query: cot::request::extractors::UrlQuery<LastfmCallbackQuery>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("player pool")
+                                })
+                                .await;
+                            lastfm_callback_handler(session, db, pg_pool, query).await
+                        }
+                    }
+                }),
+                "player_lastfm_callback",
+            ),
+            Route::with_handler_and_name(
+                "/lastfm/disconnect",
+                post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("player pool")
+                                })
+                                .await;
+                            lastfm_disconnect_handler(session, db, pg_pool).await
+                        }
+                    }
+                }),
+                "player_lastfm_disconnect",
+            ),
+            Route::with_handler_and_name(
+                "/lastfm/now-playing",
+                post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, json: Json<LastfmNowPlayingRequest>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("player pool")
+                                })
+                                .await;
+                            lastfm_now_playing_handler(session, db, pg_pool, json).await
+                        }
+                    }
+                }),
+                "player_lastfm_now_playing",
+            ),
+            Route::with_handler_and_name(
+                "/lastfm/scrobble",
+                post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session, db: Database, json: Json<LastfmScrobbleRequest>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("player pool")
+                                })
+                                .await;
+                            lastfm_scrobble_handler(session, db, pg_pool, json).await
+                        }
+                    }
+                }),
+                "player_lastfm_scrobble",
+            ),
             Route::with_handler_and_name(
                 "/agent-queue",
                 {

src/player/rows.rs

@@ -37,6 +37,8 @@ pub(super) struct TrackRow {
     pub(super) duration_seconds: f64,
     pub(super) cover_file_id: Option<i64>,
     pub(super) release_cover_file_id: Option<i64>,
+    pub(super) release_id: i64,
+    pub(super) release_title: String,
     pub(super) release_year: Option<i32>,
     pub(super) uploader_name: String,
     pub(super) audio_format: Option<String>,
@@ -107,6 +109,8 @@ pub(super) struct PlaylistTrackRow {
     pub(super) duration_seconds: f64,
     pub(super) cover_file_id: Option<i64>,
     pub(super) release_cover_file_id: Option<i64>,
+    pub(super) release_id: i64,
+    pub(super) release_title: String,
     pub(super) release_year: Option<i32>,
     pub(super) uploader_name: String,
     pub(super) audio_format: Option<String>,
@@ -170,6 +174,8 @@ pub(super) struct SearchTrackRow {
     pub(super) duration_seconds: f64,
     pub(super) cover_file_id: Option<i64>,
     pub(super) release_cover_file_id: Option<i64>,
+    pub(super) release_id: i64,
+    pub(super) release_title: String,
     pub(super) release_year: Option<i32>,
     pub(super) uploader_name: String,
     pub(super) audio_format: Option<String>,

src/scheduler/mod.rs

@@ -1357,7 +1357,10 @@ async fn run_scheduled_job(
 
     // Check agent_enabled (re-read from DB every run)
     let (live_config, _) = AppConfig::load_with_db(db).await;
-    if !live_config.agent_enabled && job_name != "lastfm_popularity" {
+    if !live_config.agent_enabled
+        && job_name != "lastfm_popularity"
+        && job_name != "lastfm_scrobble"
+    {
         tracing::warn!(job = job_name, "Skipping: agent_enabled=false");
         return;
     }

templates/admin/settings.html

@@ -85,6 +85,16 @@
     <td><input type="checkbox" name="swagger_enabled" id="swagger_enabled" value="on"{% if swagger_enabled %} checked{% endif %}></td>
     <td><span class="badge badge-{{ swagger_enabled_source }}">{{ swagger_enabled_source }}</span></td>
   </tr>
+  <tr>
+    <td><label for="lastfm_api_key">{{ t.settings_lastfm_api_key }}</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_lastfm_api_key_help }}</span></td>
+    <td><input type="password" name="lastfm_api_key" id="lastfm_api_key" value="{{ lastfm_api_key }}"></td>
+    <td><span class="badge badge-{{ lastfm_api_key_source }}">{{ lastfm_api_key_source }}</span></td>
+  </tr>
+  <tr>
+    <td><label for="lastfm_shared_secret">{{ t.settings_lastfm_shared_secret }}</label><br><span style="font-size:.75rem;color:#999;">{{ t.settings_lastfm_shared_secret_help }}</span></td>
+    <td><input type="password" name="lastfm_shared_secret" id="lastfm_shared_secret" value="{{ lastfm_shared_secret }}"></td>
+    <td><span class="badge badge-{{ lastfm_shared_secret_source }}">{{ lastfm_shared_secret_source }}</span></td>
+  </tr>
 </table>
 
 <h2>{{ t.settings_agent }}</h2>

templates/admin/v2.html

@@ -870,6 +870,165 @@ tbody tr:hover {
     font-size: 11px;
 }
 
+.image-editor {
+    display: grid;
+    grid-template-columns: 150px minmax(0, 1fr);
+    gap: 14px;
+    margin-bottom: 12px;
+}
+
+.image-preview {
+    width: 150px;
+    aspect-ratio: 1;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-primary);
+    display: grid;
+    place-items: center;
+    overflow: hidden;
+    color: var(--text-subdued);
+    font-size: 12px;
+}
+
+.image-preview img {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+}
+
+.cover-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(86px, 1fr));
+    gap: 8px;
+}
+
+.cover-option {
+    min-width: 0;
+    padding: 6px;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-primary);
+    color: var(--text-secondary);
+    cursor: pointer;
+}
+
+.cover-option:hover {
+    border-color: rgba(29, 185, 84, 0.55);
+    color: var(--text-primary);
+}
+
+.cover-option img {
+    width: 100%;
+    aspect-ratio: 1;
+    object-fit: cover;
+    border-radius: 5px;
+    display: block;
+}
+
+.cover-option span {
+    display: block;
+    margin-top: 5px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-size: 10px;
+}
+
+.artist-tags {
+    display: flex;
+    gap: 6px;
+    flex-wrap: wrap;
+    margin-bottom: 8px;
+}
+
+.artist-picker {
+    position: relative;
+}
+
+.artist-picker input {
+    width: 100%;
+}
+
+.artist-results {
+    position: absolute;
+    left: 0;
+    right: 0;
+    top: calc(100% + 5px);
+    z-index: 5;
+    max-height: 242px;
+    overflow: auto;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-elevated);
+    box-shadow: 0 14px 34px rgba(0, 0, 0, 0.38);
+}
+
+.artist-result {
+    width: 100%;
+    min-height: 34px;
+    padding: 8px 10px;
+    border: 0;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.06);
+    background: transparent;
+    color: var(--text-secondary);
+    text-align: left;
+    cursor: pointer;
+}
+
+.artist-result:hover,
+.artist-result:focus {
+    background: var(--bg-hover);
+    color: var(--text-primary);
+}
+
+.artist-result:last-child {
+    border-bottom: 0;
+}
+
+.tag button {
+    width: 16px;
+    height: 16px;
+    margin-left: 5px;
+    border: 0;
+    border-radius: 999px;
+    background: rgba(255, 255, 255, 0.14);
+    color: inherit;
+    cursor: pointer;
+    line-height: 1;
+}
+
+.tag button:hover {
+    background: rgba(255, 255, 255, 0.24);
+}
+
+.editor-grid {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 12px;
+}
+
+.image-actions {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    flex-wrap: wrap;
+    margin-bottom: 10px;
+}
+
+.file-name {
+    max-width: 280px;
+    color: var(--text-subdued);
+    font-size: 11px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.cover-option.active {
+    border-color: rgba(29, 185, 84, 0.8);
+    box-shadow: 0 0 0 1px rgba(29, 185, 84, 0.32);
+}
+
 .muted {
     color: var(--text-subdued);
 }
@@ -977,7 +1136,7 @@ tbody tr:hover {
             <button class="nav-btn" :class="{active: activeView === 'settings'}" @click="openSettings()">
                 <i data-lucide="settings"></i>
                 <span>Settings</span>
-                <span class="nav-count" x-text="settings.lastfm_api_key_configured ? 'ok' : ''"></span>
+                <span class="nav-count" x-text="settings.lastfm_scrobbling_configured ? 'ok' : ''"></span>
             </button>
         </div>
 
@@ -1575,7 +1734,7 @@ tbody tr:hover {
                                     <strong>API</strong>
                                     <span>Developer and enrichment integrations</span>
                                 </div>
-                                <span class="badge" :class="settings.lastfm_api_key_configured ? 'ok' : 'disabled'" x-text="settings.lastfm_api_key_configured ? 'Last.fm configured' : 'Last.fm missing'"></span>
+                                <span class="badge" :class="settings.lastfm_scrobbling_configured ? 'ok' : 'disabled'" x-text="settings.lastfm_scrobbling_configured ? 'Last.fm configured' : 'Last.fm missing'"></span>
                             </div>
                             <div class="settings-grid">
                                 <div class="setting-toggle">
@@ -1591,11 +1750,19 @@ tbody tr:hover {
                                 </div>
                                 <div class="setting-field">
                                     <label>
-                                        <span>Last.fm API key</span>
+                                        <span>{{ t.settings_lastfm_api_key }}</span>
                                         <span class="source-pill" :class="sourceClass('lastfm_api_key')" x-text="settingSource('lastfm_api_key')"></span>
                                     </label>
                                     <input type="password" x-model="settingsDraft.lastfm_api_key" autocomplete="off" />
-                                    <div class="setting-help">Used by the weekly Last.fm popularity task.</div>
+                                    <div class="setting-help">{{ t.settings_lastfm_api_key_help }}</div>
+                                </div>
+                                <div class="setting-field">
+                                    <label>
+                                        <span>{{ t.settings_lastfm_shared_secret }}</span>
+                                        <span class="source-pill" :class="sourceClass('lastfm_shared_secret')" x-text="settingSource('lastfm_shared_secret')"></span>
+                                    </label>
+                                    <input type="password" x-model="settingsDraft.lastfm_shared_secret" autocomplete="off" />
+                                    <div class="setting-help">{{ t.settings_lastfm_shared_secret_help }}</div>
                                 </div>
                             </div>
                         </section>
@@ -1753,14 +1920,55 @@ tbody tr:hover {
                 </button>
             </div>
             <div class="modal-body" x-show="activeLibraryItem">
+                <div class="empty" x-show="editorLoading">Loading editor...</div>
+                <div x-show="!editorLoading">
                     <div class="field">
-                    <label>Title</label>
+                        <label x-text="isArtistEditor() ? 'Artist name' : 'Title'"></label>
                         <input x-model="editorDraft.title" />
                     </div>
+
+                    <div class="editor-grid" x-show="isReleaseEditor()">
                         <div class="field">
-                    <label>Primary Relation Search</label>
-                    <input placeholder="Start typing to attach artist, release, or playlist" />
+                            <label>Release type</label>
+                            <select x-model="editorDraft.release_type">
+                                <option value="album">Album</option>
+                                <option value="single">Single</option>
+                                <option value="ep">EP</option>
+                                <option value="compilation">Compilation</option>
+                                <option value="soundtrack">Soundtrack</option>
+                                <option value="live">Live</option>
+                                <option value="remix">Remix</option>
+                                <option value="unknown">Unknown</option>
+                            </select>
                         </div>
+                        <div class="field">
+                            <label>Year</label>
+                            <input type="number" min="0" max="3000" x-model="editorDraft.year" />
+                        </div>
+                    </div>
+
+                    <div class="field" x-show="isReleaseEditor()">
+                        <label>Release artists</label>
+                        <div class="artist-tags">
+                            <template x-for="artist in selectedEditorArtists()" :key="artist.id">
+                                <span class="tag relation">
+                                    <span x-text="artist.name"></span>
+                                    <button type="button" @click="removeEditorArtist(artist.id)">x</button>
+                                </span>
+                            </template>
+                            <span class="muted" x-show="selectedEditorArtists().length === 0">No artists attached</span>
+                        </div>
+                        <div class="artist-picker">
+                            <input class="search" placeholder="Search artist" x-model="editorArtistToAdd" @keydown.enter.prevent="addEditorArtist()" @keydown.escape="editorArtistToAdd = ''" />
+                            <div class="artist-results" x-show="editorArtistSearchOpen()" x-transition>
+                                <template x-for="artist in filteredEditorArtists()" :key="artist.id">
+                                    <button class="artist-result" type="button" @click="addEditorArtist(artist)" x-text="artist.name"></button>
+                                </template>
+                                <div class="artist-result muted" x-show="filteredEditorArtists().length === 0">No matching artists</div>
+                            </div>
+                        </div>
+                    </div>
+
                     <div class="field">
                         <label>Visibility</label>
                         <select class="search" style="width:100%" x-model="editorDraft.hidden">
@@ -1768,17 +1976,66 @@ tbody tr:hover {
                             <option value="true">Hidden from player</option>
                         </select>
                     </div>
-                <div class="toolbar">
-                    <button class="btn primary" @click="saveLibraryItem()">
-                        <i data-lucide="save"></i>
-                        Save
+
+                    <div x-show="canEditLibraryImage()">
+                        <label class="muted" style="display:block; margin: 2px 0 8px; font-size: 11px; font-weight: 800; text-transform: uppercase;">Image</label>
+                        <div class="image-editor">
+                            <div class="image-preview">
+                                <template x-if="editorDetail && editorDetail.current_image_url">
+                                    <img :src="editorDetail.current_image_url" alt="" />
+                                </template>
+                                <span x-show="!editorDetail || !editorDetail.current_image_url">No image</span>
+                            </div>
+                            <div>
+                                <div class="image-actions">
+                                    <input type="file" accept="image/*" x-ref="libraryImageInput" style="display:none" @change="setEditorImageFile($event)" />
+                                    <button class="btn" type="button" @click="$refs.libraryImageInput.click()">
+                                        <i data-lucide="image-plus"></i>
+                                        Choose image
                                     </button>
-                    <button class="btn danger" @click="deleteLibraryItem(activeLibraryItem)">
+                                    <button class="btn primary" type="button" @click="uploadLibraryImage()" :disabled="!editorImageFile || editorImageUploading">
+                                        <i :data-lucide="editorImageUploading ? 'loader-circle' : 'upload'"></i>
+                                        <span x-text="editorImageUploading ? 'Uploading...' : 'Upload'"></span>
+                                    </button>
+                                    <button class="btn danger" type="button" @click="removeLibraryImage()" :disabled="!editorDetail || !editorDetail.current_image_url || editorImageUploading">
+                                        <i data-lucide="trash-2"></i>
+                                        Remove
+                                    </button>
+                                    <span class="file-name" x-show="editorImageFile" x-text="editorImageFile ? editorImageFile.name : ''"></span>
+                                </div>
+                                <p class="muted" x-show="isReleaseEditor()">Release covers are uploaded manually here.</p>
+                                <p class="muted" x-show="isArtistEditor()">Pick an image from releases where this artist appears, or upload one manually.</p>
+                            </div>
+                        </div>
+
+                        <div x-show="isArtistEditor()">
+                            <div class="field" style="margin-bottom:8px">
+                                <label>Available release images</label>
+                            </div>
+                            <div class="cover-grid" x-show="editorDetail && editorDetail.available_covers && editorDetail.available_covers.length">
+                                <template x-for="cover in editorDetail.available_covers" :key="cover.media_file_id">
+                                    <button class="cover-option" type="button" :class="{active: editorDetail.current_image_url && editorDetail.current_image_url.includes('/cover/' + cover.media_file_id + '/')}" @click="setLibraryImage(cover.media_file_id)">
+                                        <img :src="cover.cover_url" alt="" />
+                                        <span x-text="cover.release_title"></span>
+                                    </button>
+                                </template>
+                            </div>
+                            <div class="empty" x-show="editorDetail && (!editorDetail.available_covers || editorDetail.available_covers.length === 0)">No release images found for this artist</div>
+                        </div>
+                    </div>
+
+                    <div class="toolbar">
+                        <button class="btn primary" @click="saveLibraryItem()" :disabled="!editorCanSave()">
+                            <i :data-lucide="editorSaving ? 'loader-circle' : 'save'"></i>
+                            <span x-text="editorSaving ? 'Saving...' : 'Save'"></span>
+                        </button>
+                        <button class="btn danger" @click="deleteLibraryItem(activeLibraryItem)" :disabled="editorSaving || editorImageUploading">
                             <i data-lucide="trash-2"></i>
                             Delete
                         </button>
                     </div>
                 </div>
+            </div>
         </section>
     </div>
 
@@ -1837,8 +2094,14 @@ function adminV2() {
         librarySelectionScope: 'ids',
         activeLibraryItem: null,
         editorOpen: false,
-        editorDraft: { title: '', hidden: 'false' },
-        settings: { values: {}, sources: {}, lastfm_api_key_configured: false },
+        editorLoading: false,
+        editorSaving: false,
+        editorImageUploading: false,
+        editorImageFile: null,
+        editorArtistToAdd: '',
+        editorDetail: null,
+        editorDraft: { title: '', hidden: 'false', release_type: 'album', year: '', artist_ids: [] },
+        settings: { values: {}, sources: {}, lastfm_api_key_configured: false, lastfm_shared_secret_configured: false, lastfm_scrobbling_configured: false },
         settingsDraft: {
             auth_password_enabled: false,
             auth_sso_enabled: false,
@@ -1850,6 +2113,7 @@ function adminV2() {
             oidc_user_groups: '',
             swagger_enabled: false,
             lastfm_api_key: '',
+            lastfm_shared_secret: '',
             agent_enabled: false,
             agent_inbox_dir: '',
             agent_storage_dir: '',
@@ -1924,14 +2188,18 @@ function adminV2() {
             const parts = raw.split('/').filter(Boolean);
             const view = parts[0] || 'reviews';
             if (view === 'reviews') {
+                const nextStatus = parts[1] || null;
+                if (this.reviewFilter.status !== nextStatus) this.clearReviewSelection();
                 this.activeView = 'reviews';
-                this.reviewFilter.status = parts[1] || null;
+                this.reviewFilter.status = nextStatus;
             } else if (view === 'jobs') {
                 this.activeView = 'jobs';
                 if (parts[1]) this.activeJobName = decodeURIComponent(parts[1]);
             } else if (view === 'library') {
+                const nextKind = ['artists', 'releases', 'playlists'].includes(parts[1]) ? parts[1] : 'artists';
+                if (this.libraryKind !== nextKind) this.clearLibrarySelection();
                 this.activeView = 'library';
-                this.libraryKind = ['artists', 'releases', 'playlists'].includes(parts[1]) ? parts[1] : 'artists';
+                this.libraryKind = nextKind;
             } else if (view === 'settings') {
                 this.activeView = 'settings';
             } else if (view === 'tools') {
@@ -1971,6 +2239,7 @@ function adminV2() {
         },
 
         openReviews(status = null) {
+            if (this.reviewFilter.status !== status) this.clearReviewSelection();
             this.activeView = 'reviews';
             this.reviewFilter.status = status;
             this.setRoute(status ? `#reviews/${status}` : '#reviews');
@@ -1987,7 +2256,9 @@ function adminV2() {
 
         openLibrary(kind = this.libraryKind) {
             this.activeView = 'library';
-            this.libraryKind = ['artists', 'releases', 'playlists'].includes(kind) ? kind : 'artists';
+            const nextKind = ['artists', 'releases', 'playlists'].includes(kind) ? kind : 'artists';
+            if (this.libraryKind !== nextKind) this.clearLibrarySelection();
+            this.libraryKind = nextKind;
             this.setRoute(`#library/${this.libraryKind}`);
             this.loadLibrary();
         },
@@ -2006,7 +2277,7 @@ function adminV2() {
             params.set('offset', this.reviews.offset || 0);
             try {
                 this.reviews = await this.request(`${this.apiBase}/reviews?${params.toString()}`);
-                this.clearReviewSelection();
+                if (resetOffset) this.clearReviewSelection();
             } catch (error) {
                 this.showToast(error.message);
             } finally {
@@ -2037,7 +2308,7 @@ function adminV2() {
             if (this.librarySearch) params.set('search', this.librarySearch);
             try {
                 this.library = await this.request(`${this.apiBase}/library?${params.toString()}`);
-                this.clearLibrarySelection();
+                if (resetOffset) this.clearLibrarySelection();
             } catch (error) {
                 this.showToast(error.message);
             } finally {
@@ -2228,6 +2499,7 @@ function adminV2() {
                     body: JSON.stringify(payload)
                 });
                 this.showToast(`${result.affected} review row(s) updated`);
+                this.clearReviewSelection();
                 await this.loadReviews(false);
             } catch (error) {
                 this.showToast(error.message);
@@ -2343,9 +2615,184 @@ function adminV2() {
             this.activeLibraryItem = item;
             this.editorDraft = {
                 title: item.title || '',
-                hidden: item.is_hidden ? 'true' : 'false'
+                hidden: item.is_hidden ? 'true' : 'false',
+                release_type: 'album',
+                year: '',
+                artist_ids: []
             };
+            this.editorDetail = null;
+            this.editorImageFile = null;
+            this.editorArtistToAdd = '';
             this.editorOpen = true;
+            this.loadEditorDetail(item);
+        },
+
+        async loadEditorDetail(item) {
+            const key = `${item.kind}:${item.id}`;
+            this.editorLoading = true;
+            try {
+                const params = new URLSearchParams({ kind: item.kind, id: item.id });
+                const detail = await this.request(`${this.apiBase}/library/item/detail?${params.toString()}`);
+                if (!this.activeLibraryItem || `${this.activeLibraryItem.kind}:${this.activeLibraryItem.id}` !== key) return;
+                this.editorDetail = detail;
+                this.editorDraft = {
+                    title: detail.title || '',
+                    hidden: detail.hidden ? 'true' : 'false',
+                    release_type: detail.release_type || 'album',
+                    year: detail.year || '',
+                    artist_ids: Array.isArray(detail.selected_artist_ids) ? detail.selected_artist_ids.slice() : []
+                };
+                this.editorImageFile = null;
+                this.editorArtistToAdd = '';
+            } catch (error) {
+                this.showToast(error.message);
+            } finally {
+                if (this.activeLibraryItem && `${this.activeLibraryItem.kind}:${this.activeLibraryItem.id}` === key) {
+                    this.editorLoading = false;
+                }
+                this.icons();
+            }
+        },
+
+        isArtistEditor() {
+            return this.activeLibraryItem && this.activeLibraryItem.kind === 'artists';
+        },
+
+        isReleaseEditor() {
+            return this.activeLibraryItem && this.activeLibraryItem.kind === 'releases';
+        },
+
+        canEditLibraryImage() {
+            return this.isArtistEditor() || this.isReleaseEditor();
+        },
+
+        editorCanSave() {
+            return Boolean(this.activeLibraryItem && this.editorDetail && !this.editorLoading && !this.editorSaving);
+        },
+
+        selectedEditorArtists() {
+            const selected = this.editorDraft.artist_ids || [];
+            const artists = (this.editorDetail && this.editorDetail.artists) || [];
+            return selected.map(id => {
+                const artist = artists.find(row => Number(row.id) === Number(id));
+                return artist || { id, name: `Artist #${id}` };
+            });
+        },
+
+        editorAvailableArtists() {
+            const selected = new Set((this.editorDraft.artist_ids || []).map(id => Number(id)));
+            const artists = (this.editorDetail && this.editorDetail.artists) || [];
+            return artists.filter(artist => !selected.has(Number(artist.id)));
+        },
+
+        normalizedArtistSearch(value) {
+            return String(value || '').trim().toLowerCase();
+        },
+
+        filteredEditorArtists() {
+            const raw = String(this.editorArtistToAdd || '').trim();
+            const query = this.normalizedArtistSearch(raw);
+            const candidates = this.editorAvailableArtists();
+            if (!query) return candidates.slice(0, 12);
+            return candidates
+                .map(artist => {
+                    const name = this.normalizedArtistSearch(artist.name);
+                    let score = 3;
+                    if (name === query) score = 0;
+                    else if (name.startsWith(query)) score = 1;
+                    else if (name.includes(query)) score = 2;
+                    return { artist, score };
+                })
+                .filter(row => row.score < 3)
+                .sort((a, b) => a.score - b.score || a.artist.name.localeCompare(b.artist.name))
+                .slice(0, 12)
+                .map(row => row.artist);
+        },
+
+        editorArtistSearchOpen() {
+            return this.isReleaseEditor() && String(this.editorArtistToAdd || '').trim().length > 0;
+        },
+
+        addEditorArtist(artist = null) {
+            const raw = String(this.editorArtistToAdd || '').trim();
+            const candidates = this.filteredEditorArtists();
+            artist = artist
+                || candidates.find(row => this.normalizedArtistSearch(row.name) === this.normalizedArtistSearch(raw))
+                || candidates[0];
+            if (artist && !(this.editorDraft.artist_ids || []).map(Number).includes(Number(artist.id))) {
+                this.editorDraft.artist_ids = (this.editorDraft.artist_ids || []).concat([Number(artist.id)]);
+            }
+            this.editorArtistToAdd = '';
+        },
+
+        removeEditorArtist(id) {
+            this.editorDraft.artist_ids = (this.editorDraft.artist_ids || []).filter(value => Number(value) !== Number(id));
+        },
+
+        setEditorImageFile(event) {
+            this.editorImageFile = event.target.files && event.target.files.length ? event.target.files[0] : null;
+        },
+
+        readFileAsDataUrl(file) {
+            return new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onload = () => resolve(reader.result);
+                reader.onerror = () => reject(reader.error || new Error('failed to read file'));
+                reader.readAsDataURL(file);
+            });
+        },
+
+        async uploadLibraryImage() {
+            if (!this.activeLibraryItem || !this.editorImageFile || this.editorImageUploading) return;
+            this.editorImageUploading = true;
+            try {
+                const dataUrl = await this.readFileAsDataUrl(this.editorImageFile);
+                const data = String(dataUrl).split(',')[1] || '';
+                await this.request(`${this.apiBase}/library/item/upload-image`, {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        kind: this.activeLibraryItem.kind,
+                        id: this.activeLibraryItem.id,
+                        filename: this.editorImageFile.name,
+                        mime_type: this.editorImageFile.type || 'application/octet-stream',
+                        data
+                    })
+                });
+                await this.loadEditorDetail(this.activeLibraryItem);
+                this.showToast('Image uploaded');
+            } catch (error) {
+                this.showToast(error.message);
+            } finally {
+                this.editorImageUploading = false;
+                if (this.$refs.libraryImageInput) this.$refs.libraryImageInput.value = '';
+                this.icons();
+            }
+        },
+
+        async setLibraryImage(mediaFileId) {
+            if (!this.activeLibraryItem || this.editorImageUploading) return;
+            this.editorImageUploading = true;
+            try {
+                await this.request(`${this.apiBase}/library/item/image`, {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        kind: this.activeLibraryItem.kind,
+                        id: this.activeLibraryItem.id,
+                        media_file_id: mediaFileId
+                    })
+                });
+                await this.loadEditorDetail(this.activeLibraryItem);
+                this.showToast(mediaFileId ? 'Image selected' : 'Image removed');
+            } catch (error) {
+                this.showToast(error.message);
+            } finally {
+                this.editorImageUploading = false;
+                this.icons();
+            }
+        },
+
+        removeLibraryImage() {
+            this.setLibraryImage(null);
         },
 
         toggleLibrary(item) {
@@ -2362,14 +2809,18 @@ function adminV2() {
 
         selectedLibraryCount() {
             if (this.librarySelectionScope === 'filter') return this.library.total || 0;
-            return Object.keys(this.selectedLibraryIds).length;
+            return this.currentLibrarySelectionKeys().length;
+        },
+
+        currentLibrarySelectionKeys() {
+            return Object.keys(this.selectedLibraryIds).filter(key => key.startsWith(`${this.libraryKind}:`));
         },
 
         async bulkLibrary(action) {
             const count = this.selectedLibraryCount();
             if (!count) return;
             if (action === 'delete' && !confirm(`Delete ${count} ${this.libraryKind}?`)) return;
-            const ids = Object.keys(this.selectedLibraryIds)
+            const ids = this.currentLibrarySelectionKeys()
                 .map(key => Number(key.split(':')[1]))
                 .filter(Boolean);
             try {
@@ -2384,6 +2835,7 @@ function adminV2() {
                     })
                 });
                 this.showToast(`${result.affected} ${this.libraryKind} updated`);
+                this.clearLibrarySelection();
                 await this.loadLibrary(false);
                 await this.refreshCountsOnly();
             } catch (error) {
@@ -2392,7 +2844,8 @@ function adminV2() {
         },
 
         async saveLibraryItem() {
-            if (!this.activeLibraryItem) return;
+            if (!this.editorCanSave()) return;
+            this.editorSaving = true;
             try {
                 const updated = await this.request(`${this.apiBase}/library/item`, {
                     method: 'POST',
@@ -2400,16 +2853,22 @@ function adminV2() {
                         kind: this.activeLibraryItem.kind,
                         id: this.activeLibraryItem.id,
                         title: this.editorDraft.title,
-                        hidden: this.editorDraft.hidden === 'true'
+                        hidden: this.editorDraft.hidden === 'true',
+                        release_type: this.editorDraft.release_type || null,
+                        year: this.editorDraft.year || '',
+                        artist_ids: this.editorDraft.artist_ids || []
                     })
                 });
                 this.replaceLibraryItem(updated);
                 this.activeLibraryItem = updated;
-                this.editorOpen = false;
+                if (this.editorDetail) this.editorDetail.item = updated;
                 this.showToast('Saved');
                 await this.refreshCountsOnly();
             } catch (error) {
                 this.showToast(error.message);
+            } finally {
+                this.editorSaving = false;
+                this.icons();
             }
         },
 

templates/player/modals.html

@@ -11,7 +11,32 @@
                         </svg>
                     </button>
                 </div>
-                <pre class="info-modal-body" x-text="$store.info.modal.body"></pre>
+                <div class="info-modal-body">
+                    <template x-if="$store.info.modal.rows && $store.info.modal.rows.length">
+                        <table class="info-table">
+                            <tbody>
+                                <template x-for="(row, idx) in $store.info.modal.rows" :key="row.label + '-' + idx">
+                                    <tr>
+                                        <th x-text="row.label"></th>
+                                        <td>
+                                            <template x-if="row.links && row.links.length">
+                                                <div class="info-link-list">
+                                                    <template x-for="link in row.links" :key="link.type + '-' + link.id + '-' + link.label">
+                                                        <button class="info-link" type="button" @click="$store.info.navigate(link)" x-text="link.label"></button>
+                                                    </template>
+                                                </div>
+                                            </template>
+                                            <template x-if="!row.links || !row.links.length">
+                                                <span x-text="row.value"></span>
+                                            </template>
+                                        </td>
+                                    </tr>
+                                </template>
+                            </tbody>
+                        </table>
+                    </template>
+                    <pre class="info-modal-plain" x-show="!$store.info.modal.rows || !$store.info.modal.rows.length" x-text="$store.info.modal.body"></pre>
+                </div>
             </div>
         </div>
     </template>

templates/player/scripts.html

@@ -4,11 +4,14 @@ const T = {
     info: "{{ t.player_info }}",
     noDetails: "{{ t.player_no_details }}",
     trackInfoTitle: "{{ t.player_track_info }}",
+    releaseInfoTitle: "{{ t.player_release_info }}",
     loadingHistory: "{{ t.player_loading_history }}",
     failedLoadHistory: "{{ t.player_failed_load_history }}",
     totalPlays: "{{ t.player_total_plays }}",
     unknown: "{{ t.player_unknown }}",
     unknownSize: "{{ t.player_unknown_size }}",
+    title: "{{ t.player_title }}",
+    release: "{{ t.player_release }}",
     unknownRelease: "{{ t.player_unknown_release }}",
     unknownTrack: "{{ t.player_unknown_track }}",
     unknownAudio: "{{ t.player_unknown_audio }}",
@@ -27,6 +30,14 @@ const T = {
     lastfmPlaycount: "{{ t.player_lastfm_playcount }}",
     lastfmUpdated: "{{ t.player_lastfm_updated }}",
     lastfmNotLoaded: "{{ t.player_lastfm_not_loaded }}",
+    lastfmProfile: "{{ t.player_lastfm_profile }}",
+    lastfmConnect: "{{ t.player_lastfm_connect }}",
+    lastfmConnected: "{{ t.player_lastfm_connected }}",
+    lastfmReconnect: "{{ t.player_lastfm_reconnect }}",
+    lastfmNotConfigured: "{{ t.player_lastfm_not_configured }}",
+    lastfmDisconnectConfirm: "{{ t.player_lastfm_disconnect_confirm }}",
+    lastfmConnectFailed: "{{ t.player_lastfm_connect_failed }}",
+    lastfmDisconnectFailed: "{{ t.player_lastfm_disconnect_failed }}",
     trackWord: "{{ t.player_tracks_count }}",
     clientIdle: "{{ t.player_client_idle }}",
     active: "{{ t.player_active }}",
@@ -124,14 +135,33 @@ document.addEventListener('alpine:init', () => {
     Alpine.store('info', {
         modal: null,
         open(title, body) {
+            if (Array.isArray(body)) {
+                this.openRows(title, body);
+                return;
+            }
             this.modal = {
                 title: title || T.info,
                 body: body || T.noDetails,
+                rows: null,
+            };
+        },
+        openRows(title, rows) {
+            this.modal = {
+                title: title || T.info,
+                body: '',
+                rows: (rows || []).filter(row => row && ((row.value !== undefined && row.value !== null && row.value !== '') || (row.links && row.links.length))),
             };
         },
         close() {
             this.modal = null;
         },
+        navigate(link) {
+            if (!link || !link.id) return;
+            this.close();
+            const library = Alpine.store('library');
+            if (link.type === 'release') library.openRelease(link.id);
+            if (link.type === 'artist') library.openArtist(link.id);
+        },
     });
 
     // -----------------------------------------------------------------------
@@ -140,9 +170,12 @@ document.addEventListener('alpine:init', () => {
     Alpine.store('user', {
         profile: null,
         menuOpen: false,
+        lastfm: { configured: false, connected: false, username: null, reauth_required: false, last_error: null },
+        lastfmBusy: false,
 
         init() {
             this.load();
+            this.loadLastfm();
         },
 
         async load() {
@@ -155,6 +188,56 @@ document.addEventListener('alpine:init', () => {
             }
         },
 
+        async loadLastfm() {
+            try {
+                const res = await fetch('/api/player/lastfm/status');
+                if (!res.ok) throw new Error('failed');
+                this.lastfm = await res.json();
+                const player = Alpine.store('player');
+                if (player?.isPlaying) player._sendNowPlaying();
+            } catch {
+                this.lastfm = { configured: false, connected: false, username: null, reauth_required: false, last_error: null };
+            }
+        },
+
+        lastfmLabel() {
+            if (!this.lastfm?.configured) return T.lastfmNotConfigured;
+            if (this.lastfm?.connected && this.lastfm?.reauth_required) return T.lastfmReconnect;
+            if (this.lastfm?.connected) {
+                const user = this.lastfm.username || T.unknown;
+                return T.lastfmConnected.replace('{user}', user);
+            }
+            return T.lastfmConnect;
+        },
+
+        lastfmClass() {
+            if (!this.lastfm?.configured) return 'not-configured';
+            if (this.lastfm?.connected && this.lastfm?.reauth_required) return 'needs-auth';
+            if (this.lastfm?.connected) return 'connected';
+            return 'available';
+        },
+
+        async handleLastfm() {
+            if (this.lastfmBusy) return;
+            if (!this.lastfm?.configured) return;
+            if (!this.lastfm?.connected || this.lastfm?.reauth_required) {
+                window.location.href = '/api/player/lastfm/connect';
+                return;
+            }
+            const user = this.lastfm.username || T.unknown;
+            if (!window.confirm(T.lastfmDisconnectConfirm.replace('{user}', user))) return;
+            this.lastfmBusy = true;
+            try {
+                const res = await fetch('/api/player/lastfm/disconnect', { method: 'POST' });
+                if (!res.ok) throw new Error(T.lastfmDisconnectFailed);
+                await this.loadLastfm();
+            } catch {
+                alert(T.lastfmDisconnectFailed);
+            } finally {
+                this.lastfmBusy = false;
+            }
+        },
+
         initials() {
             const name = this.profile?.name || '';
             return name.trim().charAt(0) || '?';
@@ -272,6 +355,11 @@ document.addEventListener('alpine:init', () => {
         progress: 0,
         _saveTimer: null,
         _historyRecorded: false,
+        _nowPlayingSent: false,
+        _scrobbleSent: false,
+        _playbackStartedAt: null,
+        _listenedSeconds: 0,
+        _lastAudioTime: 0,
 
         init() {
             audio.volume = this.volume;
@@ -280,15 +368,27 @@ document.addEventListener('alpine:init', () => {
                 this.currentTime = audio.currentTime;
                 this.duration = audio.duration || 0;
                 this.progress = this.duration > 0 ? (this.currentTime / this.duration) * 100 : 0;
+                this._trackListenedDelta();
+                this._maybeScrobble();
             });
 
             audio.addEventListener('ended', () => {
+                this._trackListenedDelta();
+                this._maybeScrobble(true);
                 this._recordHistory(true);
                 this.next();
             });
 
-            audio.addEventListener('play', () => { this.isPlaying = true; });
-            audio.addEventListener('pause', () => { this.isPlaying = false; });
+            audio.addEventListener('play', () => {
+                this.isPlaying = true;
+                if (!this._playbackStartedAt) this._playbackStartedAt = Math.floor(Date.now() / 1000);
+                this._lastAudioTime = audio.currentTime || 0;
+                this._sendNowPlaying();
+            });
+            audio.addEventListener('pause', () => {
+                this.isPlaying = false;
+                this._lastAudioTime = audio.currentTime || 0;
+            });
 
             audio.addEventListener('loadedmetadata', () => {
                 this.duration = audio.duration || 0;
@@ -311,6 +411,7 @@ document.addEventListener('alpine:init', () => {
         play(track) {
             this.currentTrack = track;
             this._historyRecorded = false;
+            this._resetPlaybackTracking();
             audio.src = track.stream_url;
             audio.play().catch(() => {});
             this._updateMediaSession();
@@ -327,11 +428,13 @@ document.addEventListener('alpine:init', () => {
 
         seek(time) {
             audio.currentTime = time;
+            this._lastAudioTime = audio.currentTime || 0;
         },
 
         seekRelative(delta) {
             if (!this.currentTrack) return;
             audio.currentTime = Math.max(0, Math.min(audio.duration || 0, audio.currentTime + delta));
+            this._lastAudioTime = audio.currentTime || 0;
         },
 
         seekFromClick(event) {
@@ -519,6 +622,7 @@ document.addEventListener('alpine:init', () => {
                                 if (currentTrack) {
                                     this.currentTrack = currentTrack;
                                     this._historyRecorded = false;
+                                    this._resetPlaybackTracking();
                                     audio.src = currentTrack.stream_url;
                                     // Seek to saved position once metadata is loaded
                                     const seekMs = state.position_ms || 0;
@@ -551,6 +655,87 @@ document.addEventListener('alpine:init', () => {
                 }),
             }).catch(() => {});
         },
+
+        _resetPlaybackTracking() {
+            this._nowPlayingSent = false;
+            this._scrobbleSent = false;
+            this._playbackStartedAt = null;
+            this._listenedSeconds = 0;
+            this._lastAudioTime = 0;
+        },
+
+        _trackListenedDelta() {
+            if (!this.currentTrack) return;
+            const current = audio.currentTime || 0;
+            if (!this.isPlaying) {
+                this._lastAudioTime = current;
+                return;
+            }
+            const previous = Number.isFinite(this._lastAudioTime) ? this._lastAudioTime : current;
+            const delta = current - previous;
+            if (delta > 0 && delta < 5) {
+                this._listenedSeconds += delta;
+            }
+            this._lastAudioTime = current;
+        },
+
+        _trackDuration() {
+            const candidates = [
+                this.currentTrack?.duration_seconds,
+                this.duration,
+                audio.duration,
+            ];
+            for (const value of candidates) {
+                const duration = Number(value || 0);
+                if (Number.isFinite(duration) && duration > 0) return duration;
+            }
+            return 0;
+        },
+
+        _scrobbleThreshold(duration) {
+            return Math.min(duration / 2, 240);
+        },
+
+        _sendNowPlaying() {
+            if (this._nowPlayingSent || !this.currentTrack) return;
+            const lastfm = Alpine.store('user')?.lastfm;
+            if (!lastfm?.configured || !lastfm?.connected || lastfm?.reauth_required) return;
+            this._nowPlayingSent = true;
+            fetch('/api/player/lastfm/now-playing', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ track_id: this.currentTrack.id }),
+            }).catch(() => {});
+        },
+
+        _maybeScrobble(force = false) {
+            if (this._scrobbleSent || !this.currentTrack) return;
+            const lastfm = Alpine.store('user')?.lastfm;
+            if (!lastfm?.configured || !lastfm?.connected || lastfm?.reauth_required) return;
+            const duration = this._trackDuration();
+            if (!duration || duration <= 30) return;
+            const threshold = this._scrobbleThreshold(duration);
+            const listened = force ? this._listenedSeconds + 1 : this._listenedSeconds;
+            if (listened < threshold) return;
+            this._listenedSeconds = Math.max(this._listenedSeconds, listened);
+            this._sendScrobble();
+        },
+
+        _sendScrobble() {
+            if (this._scrobbleSent || !this.currentTrack) return;
+            this._scrobbleSent = true;
+            fetch('/api/player/lastfm/scrobble', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    track_id: this.currentTrack.id,
+                    started_at: this._playbackStartedAt || Math.floor(Date.now() / 1000),
+                    listened_seconds: Math.floor(this._listenedSeconds),
+                }),
+            }).catch(() => {
+                this._scrobbleSent = false;
+            });
+        },
     });
 
     // -----------------------------------------------------------------------
@@ -892,7 +1077,7 @@ document.addEventListener('alpine:init', () => {
         },
 
         openTrackInfo(track) {
-            Alpine.store('info').open(T.trackInfoTitle, this.trackInfo(track));
+            Alpine.store('info').openRows(T.trackInfoTitle, this.trackInfoRows(track));
         },
 
         uploadersInfo(uploaders) {
@@ -915,6 +1100,31 @@ document.addEventListener('alpine:init', () => {
             return lines.join('\n');
         },
 
+        openReleaseInfo(release) {
+            Alpine.store('info').openRows(T.releaseInfoTitle, this.releaseInfoRows(release));
+        },
+
+        infoLinks(items, type) {
+            const seen = new Set();
+            return (items || [])
+                .filter(item => item && item.id && !seen.has(Number(item.id)) && seen.add(Number(item.id)))
+                .map(item => ({ type, id: item.id, label: item.label || item.name || item.title || String(item.id) }));
+        },
+
+        releaseInfoRows(release) {
+            if (!release) return [];
+            const rows = [
+                { label: T.release, value: release.title || T.unknownRelease },
+                { label: T.type, value: release.release_type || T.unknown },
+                { label: T.year, value: release.year || T.unknown },
+                { label: T.tracks, value: release.track_count || release.tracks?.length || 0 },
+                { label: T.uploaders, value: this.uploadersInfo(release.uploaders || []) },
+            ];
+            const artistLinks = this.infoLinks(release.artists || [], 'artist');
+            if (artistLinks.length) rows.splice(1, 0, { label: T.artists, links: artistLinks });
+            return rows;
+        },
+
         trackInfo(track) {
             if (!track) return '';
             const artists = this.trackArtistLinks(track).map(artist => artist.label).join(', ') || T.unknown;
@@ -945,6 +1155,40 @@ document.addEventListener('alpine:init', () => {
             return lines.join('\n');
         },
 
+        trackInfoRows(track) {
+            if (!track) return [];
+            const artistLinks = this.infoLinks(this.trackArtistLinks(track), 'artist');
+            const releaseLinks = track.release_id
+                ? [{ type: 'release', id: track.release_id, label: track.release_title || T.unknownRelease }]
+                : [];
+            const audio = [
+                track.audio_format || null,
+                track.audio_bitrate ? `${track.audio_bitrate} kbps` : null,
+                track.audio_sample_rate ? `${track.audio_sample_rate} Hz` : null,
+                track.audio_bit_depth ? `${track.audio_bit_depth}-bit` : null,
+            ].filter(Boolean).join(' · ') || T.unknownAudio;
+            const rows = [
+                { label: T.title, value: track.title || T.unknownTrack },
+                { label: T.release, links: releaseLinks },
+                { label: T.artists, links: artistLinks },
+                { label: T.releaseYear, value: track.release_year || T.unknown },
+                { label: T.duration, value: formatTime(track.duration_seconds) },
+                { label: T.audio, value: audio },
+                { label: T.size, value: this.bytes(track.file_size_bytes) },
+                { label: T.uploader, value: track.uploader_name || 'UFO' },
+            ];
+            if (track.lastfm_rating != null || track.lastfm_listeners != null || track.lastfm_playcount != null) {
+                const rating = Number(track.lastfm_rating || 0);
+                rows.push({ label: T.lastfmRating, value: Number.isFinite(rating) ? Math.round(rating) : T.unknown });
+                rows.push({ label: T.lastfmListeners, value: new Intl.NumberFormat().format(track.lastfm_listeners || 0) });
+                rows.push({ label: T.lastfmPlaycount, value: new Intl.NumberFormat().format(track.lastfm_playcount || 0) });
+                if (track.lastfm_updated_at) rows.push({ label: T.lastfmUpdated, value: track.lastfm_updated_at });
+            } else {
+                rows.push({ label: T.lastfmRating, value: T.lastfmNotLoaded });
+            }
+            return rows;
+        },
+
         async openRelease(id, options = {}) {
             this._beginNavigation('#release/' + id, options);
             this.searchQuery = '';

templates/player/shell.html

@@ -38,6 +38,13 @@
                         <span class="user-stat-label">{{ t.player_listened }}</span>
                     </div>
                 </div>
+                <button class="lastfm-profile-action"
+                        :class="$store.user.lastfmClass()"
+                        :disabled="$store.user.lastfmBusy || !$store.user.lastfm?.configured"
+                        @click="$store.user.handleLastfm()">
+                    <span class="lastfm-dot"></span>
+                    <span class="lastfm-profile-text" x-text="$store.user.lastfmLabel()"></span>
+                </button>
             </div>
             <div class="sidebar-header">
                 <h2>{{ t.player_library }}</h2>
@@ -324,6 +331,13 @@
                             <span class="user-stat-label">{{ t.player_listened }}</span>
                         </div>
                     </div>
+                    <button class="lastfm-profile-action"
+                            :class="$store.user.lastfmClass()"
+                            :disabled="$store.user.lastfmBusy || !$store.user.lastfm?.configured"
+                            @click="$store.user.handleLastfm()">
+                        <span class="lastfm-dot"></span>
+                        <span class="lastfm-profile-text" x-text="$store.user.lastfmLabel()"></span>
+                    </button>
                     <button class="modal-btn modal-btn-primary mobile-account-logout"
                             @click="$store.user.logout()">
                         {{ t.player_log_out }}
@@ -391,7 +405,7 @@
                                                     <template x-if="!release.cover_url">
                                                         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="12" cy="12" r="4"/></svg>
                                                     </template>
-                                                    <button class="card-info-btn" @click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo(release))" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
+                                                    <button class="card-info-btn" @click.stop="$store.library.openReleaseInfo(release)" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
                                                         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
                                                     </button>
                                                 </div>
@@ -562,7 +576,7 @@
                                             <template x-if="!release.cover_url">
                                                 <span class="placeholder-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="12" cy="12" r="4"/></svg></span>
                                             </template>
-                                            <button class="card-info-btn" @click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo(release))" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
+                                            <button class="card-info-btn" @click.stop="$store.library.openReleaseInfo(release)" :title="$store.library.releaseInfo(release)" aria-label="{{ t.player_release_info }}">
                                                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
                                             </button>
                                             <button class="card-enqueue-btn" @click.stop="$store.library.enqueueRelease(release.id)" title="{{ t.player_add_to_queue }}">
@@ -690,7 +704,7 @@
                             <div class="release-year" x-text="$store.library.currentRelease.year || ''"></div>
                             <div class="release-actions">
                                 <button class="release-action-btn secondary"
-                                        @click.stop="$store.info.open('{{ t.player_release_info }}', $store.library.releaseInfo($store.library.currentRelease))"
+                                        @click.stop="$store.library.openReleaseInfo($store.library.currentRelease)"
                                         :title="$store.library.releaseInfo($store.library.currentRelease)"
                                         aria-label="{{ t.player_release_info }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
@@ -928,7 +942,16 @@
                         </template>
                     </div>
                     <div class="player-track-info">
+                        <div class="player-track-title-row">
                             <div class="player-track-title" x-text="$store.player.currentTrack.title"></div>
+                            <button class="like-btn player-current-like"
+                                    :class="{ liked: $store.likes.has($store.player.currentTrack.id) }"
+                                    @click.stop="$store.likes.toggle($store.player.currentTrack.id)"
+                                    title="{{ t.player_like }}"
+                                    aria-label="{{ t.player_like }}">
+                                <svg viewBox="0 0 24 24" :fill="$store.likes.has($store.player.currentTrack.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
+                            </button>
+                        </div>
                         <div class="player-track-artist">
                             <template x-for="(artist, artistIdx) in $store.library.trackArtistLinks($store.player.currentTrack)" :key="artist.label + '-' + artist.id + '-' + artistIdx">
                                 <span>

templates/player/styles.html

@@ -165,6 +165,68 @@ button.user-stat:hover {
     color: var(--text-subdued);
 }
 
+.lastfm-profile-action {
+    width: 100%;
+    min-height: 34px;
+    margin-top: 8px;
+    padding: 7px 9px;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    background: var(--bg-primary);
+    color: var(--text-secondary);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    text-align: left;
+    transition: background 0.15s, border-color 0.15s, color 0.15s;
+}
+
+.lastfm-profile-action:not(:disabled):hover {
+    background: var(--bg-hover);
+    color: var(--text-primary);
+}
+
+.lastfm-profile-action:disabled {
+    cursor: default;
+    opacity: 0.72;
+}
+
+.lastfm-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--text-subdued);
+    flex-shrink: 0;
+}
+
+.lastfm-profile-action.connected {
+    border-color: rgba(29, 185, 84, 0.32);
+    color: var(--text-primary);
+}
+
+.lastfm-profile-action.connected .lastfm-dot {
+    background: #1db954;
+}
+
+.lastfm-profile-action.available .lastfm-dot,
+.lastfm-profile-action.needs-auth .lastfm-dot {
+    background: var(--accent);
+}
+
+.lastfm-profile-action.needs-auth {
+    border-color: rgba(255, 184, 77, 0.4);
+}
+
+.lastfm-profile-text {
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-size: 11px;
+    font-weight: 650;
+}
+
 .sidebar-header {
     padding: 16px;
     display: flex;
@@ -1079,12 +1141,28 @@ button.user-stat:hover {
     overflow: hidden;
     min-width: 0;
 }
+
+.player-track-title-row {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    min-width: 0;
+}
+
 .player-track-title {
     font-size: 13px;
     font-weight: 500;
     white-space: nowrap;
     overflow: hidden;
     text-overflow: ellipsis;
+    min-width: 0;
+}
+
+.player-current-like {
+    width: 24px;
+    height: 24px;
+    padding: 4px;
+    flex: 0 0 auto;
 }
 
 .player-track-artist {
@@ -1763,7 +1841,7 @@ button.user-stat:hover {
 .modal-playlist-item svg { width: 16px; height: 16px; flex-shrink: 0; }
 
 .info-modal {
-    max-width: min(520px, calc(100vw - 24px));
+    max-width: min(620px, calc(100vw - 24px));
 }
 
 .info-modal-head {
@@ -1785,14 +1863,72 @@ button.user-stat:hover {
     border-radius: 8px;
     background: var(--bg-primary);
     color: var(--text-secondary);
-    font-family: ui-monospace, SFMono-Regular, Consolas, monospace;
     font-size: 13px;
     line-height: 1.55;
-    white-space: pre-wrap;
     overflow: auto;
     max-height: min(58dvh, 520px);
 }
 
+.info-modal-plain {
+    margin: 0;
+    font-family: ui-monospace, SFMono-Regular, Consolas, monospace;
+    white-space: pre-wrap;
+}
+
+.info-table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+.info-table th,
+.info-table td {
+    padding: 9px 0;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.07);
+    vertical-align: top;
+}
+
+.info-table tr:last-child th,
+.info-table tr:last-child td {
+    border-bottom: 0;
+}
+
+.info-table th {
+    width: 34%;
+    padding-right: 18px;
+    color: var(--text-subdued);
+    font-size: 11px;
+    font-weight: 700;
+    text-align: left;
+    text-transform: uppercase;
+}
+
+.info-table td {
+    color: var(--text-primary);
+}
+
+.info-link-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 6px;
+}
+
+.info-link {
+    border: 1px solid rgba(29, 185, 84, 0.36);
+    border-radius: 999px;
+    background: rgba(29, 185, 84, 0.1);
+    color: var(--text-primary);
+    cursor: pointer;
+    padding: 3px 8px;
+    font: inherit;
+    line-height: 1.3;
+}
+
+.info-link:hover {
+    border-color: rgba(29, 185, 84, 0.7);
+    background: rgba(29, 185, 84, 0.18);
+    color: var(--accent);
+}
+
 .modal-btn {
     padding: 8px 16px;
     border-radius: 20px;
@@ -2921,6 +3057,22 @@ button.user-stat:hover {
         max-width: 400px;
     }
 
+    .info-table th,
+    .info-table td {
+        display: block;
+        width: 100%;
+        padding-right: 0;
+    }
+
+    .info-table th {
+        padding-bottom: 2px;
+        border-bottom: 0;
+    }
+
+    .info-table td {
+        padding-top: 0;
+    }
+
     .torrent-modal {
         width: 100vw;
         max-width: none;