CORE: Added Last.FM scrobbling

src/admin/v2.rs

@@ -260,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)]
@@ -274,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,
@@ -297,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,
@@ -320,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,
@@ -709,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()),
         (
@@ -785,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,
@@ -796,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,
@@ -817,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(),

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. Попробуйте ещё раз.";
@@ -327,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/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/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

@@ -172,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
 // ---------------------------------------------------------------------------
@@ -2437,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/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;
     }