CORE: fixed media links

Cargo.lock

@@ -1418,7 +1418,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "furumusic"
-version = "0.1.22"
+version = "0.2.1"
 dependencies = [
  "anyhow",
  "async-trait",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "furumusic"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
 

src/agent/cover_art.rs

@@ -323,27 +323,50 @@ pub async fn save_cover_to_storage(
     let hash = hash_image(&cover.data);
 
     // Check if we already have this exact image in the DB
-    let existing: Option<(i64,)> = sqlx::query_as(
+    let existing: Option<(i64, String)> = sqlx::query_as(
-        "SELECT id FROM furumusic__media_file WHERE sha256_hash = $1 AND file_type = 'cover_art' LIMIT 1",
+        "SELECT id, file_path FROM furumusic__media_file WHERE sha256_hash = $1 AND file_type = 'cover_art' LIMIT 1",
     )
     .bind(&hash)
     .fetch_optional(pool)
     .await?;
 
-    if let Some((id,)) = existing {
+    if let Some((id, file_path)) = existing {
-        if let Some((file_path,)) = sqlx::query_as::<_, (String,)>(
+        let path = crate::media_paths::resolve_media_file_path(storage_dir, &file_path);
-            "SELECT file_path FROM furumusic__media_file WHERE id = $1",
+        let is_inside_storage = crate::media_paths::path_for_root(storage_dir, &path).is_some();
-        )
+        if !is_inside_storage {
-        .bind(id)
+            tracing::warn!(
-        .fetch_optional(pool)
+                media_file_id = id,
-        .await?
+                path = %path.display(),
-        {
+                "Ignoring duplicate cover hash whose stored file is outside agent_storage_dir"
-            let path = crate::media_paths::resolve_media_file_path(storage_dir, &file_path);
+            );
+        } else if !path.exists() {
+            if let Some(parent) = path.parent() {
+                tokio::fs::create_dir_all(parent).await?;
+            }
+            match tokio::fs::write(&path, &cover.data).await {
+                Ok(()) => {
+                    tracing::info!(
+                        media_file_id = id,
+                        path = %path.display(),
+                        "Restored missing cover file for existing MediaFile"
+                    );
+                }
+                Err(err) => {
+                    tracing::warn!(
+                        media_file_id = id,
+                        path = %path.display(),
+                        error = %err,
+                        "Failed to restore missing cover file for existing MediaFile; creating a new cover file"
+                    );
+                }
+            }
+        }
+        if is_inside_storage && path.exists() {
             if let Err(err) = crate::agent::cover_variants::ensure_cover_variants(&path).await {
                 tracing::warn!(media_file_id = id, error = %err, "Failed to generate cover variants");
             }
+            return Ok(id);
         }
-        return Ok(id);
     }
 
     let ext = extension_for_mime(&cover.mime_type);
@@ -352,7 +375,9 @@ pub async fn save_cover_to_storage(
     let artist_dir = sanitize_dir_name(artist_name);
     let album_dir = sanitize_dir_name(release_title);
 
-    let dest_dir = Path::new(storage_dir).join(&artist_dir).join(&album_dir);
+    let dest_dir = crate::media_paths::resolve_config_path_buf(storage_dir)
+        .join(&artist_dir)
+        .join(&album_dir);
     tokio::fs::create_dir_all(&dest_dir).await?;
 
     let dest_path = dest_dir.join(&filename);

src/config.rs

@@ -416,6 +416,13 @@ impl AppConfig {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::sync::{Mutex, MutexGuard};
+
+    static ENV_LOCK: Mutex<()> = Mutex::new(());
+
+    fn lock_env() -> MutexGuard<'static, ()> {
+        ENV_LOCK.lock().unwrap_or_else(|err| err.into_inner())
+    }
 
     #[test]
     fn defaults_are_sane() {
@@ -439,20 +446,14 @@ mod tests {
     }
 
     #[test]
-    fn maps_foreign_windows_media_paths_to_working_dir() {
+    fn keeps_absolute_windows_media_paths() {
-        let expected = std::env::current_dir()
-            .unwrap()
-            .join("media")
-            .join("uploads")
-            .to_string_lossy()
-            .to_string();
         assert_eq!(
             crate::media_paths::resolve_config_path(r"C:\Users\ab\repos\furumusic\media\uploads"),
-            expected
+            "C:/Users/ab/repos/furumusic/media/uploads"
         );
     }
 
-    // SAFETY: tests run with --test-threads=1 so no concurrent env access.
+    // SAFETY: environment-mutating tests take ENV_LOCK before changing vars.
     unsafe fn set(k: &str, v: &str) {
         unsafe { std::env::set_var(k, v) };
     }
@@ -462,6 +463,7 @@ mod tests {
 
     #[test]
     fn env_override_string_field() {
+        let _guard = lock_env();
         unsafe {
             set("FURU_OIDC_ISSUER", "https://example.com");
         }
@@ -474,6 +476,7 @@ mod tests {
 
     #[test]
     fn env_override_bool_field() {
+        let _guard = lock_env();
         unsafe {
             set("FURU_AUTH_SSO_ENABLED", "true");
         }
@@ -486,6 +489,7 @@ mod tests {
 
     #[test]
     fn source_tracking_env() {
+        let _guard = lock_env();
         unsafe {
             set("FURU_OIDC_ISSUER", "https://tracked.example.com");
         }

src/jobs/artwork_backfill.rs

@@ -1,7 +1,10 @@
 use std::path::PathBuf;
 
 use reqwest::Client;
-use serde::Deserialize;
+use serde::{
+    Deserialize,
+    de::{self, DeserializeOwned},
+};
 
 use crate::agent::cover_art::{self, CoverImage, CoverSource};
 use crate::agent::cover_variants;
@@ -26,6 +29,13 @@ struct ArtistCandidate {
     name: String,
 }
 
+#[derive(Debug, sqlx::FromRow)]
+struct ArtworkRefCandidate {
+    entity_id: i64,
+    media_file_id: i64,
+    file_path: Option<String>,
+}
+
 #[derive(Debug, Deserialize)]
 struct LastfmAlbumResponse {
     album: Option<LastfmImageContainer>,
@@ -40,6 +50,24 @@ struct LastfmArtistResponse {
     message: Option<String>,
 }
 
+#[derive(Debug, Deserialize)]
+struct LastfmTopAlbumsResponse {
+    topalbums: Option<LastfmTopAlbumsContainer>,
+    error: Option<i32>,
+    message: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct LastfmTopAlbumsContainer {
+    #[serde(default, deserialize_with = "deserialize_one_or_many")]
+    album: Vec<LastfmTopAlbum>,
+}
+
+#[derive(Debug, Deserialize)]
+struct LastfmTopAlbum {
+    image: Option<Vec<LastfmImage>>,
+}
+
 #[derive(Debug, Deserialize)]
 struct LastfmImageContainer {
     image: Option<Vec<LastfmImage>>,
@@ -54,6 +82,9 @@ struct LastfmImage {
 
 #[derive(Default)]
 struct ArtworkStats {
+    broken_release_refs_cleared: u64,
+    broken_track_refs_cleared: u64,
+    broken_artist_refs_cleared: u64,
     release_local_assigned: u64,
     release_lastfm_assigned: u64,
     release_lastfm_not_found: u64,
@@ -108,6 +139,7 @@ impl Job for ArtworkBackfillJob {
             log.info("Media path normalization pass: all media file paths are already relative");
         }
 
+        repair_missing_artwork_refs(ctx, log, storage_dir, &mut stats).await?;
         backfill_release_local(ctx, log, storage_dir, &mut stats).await?;
 
         let api_key = ctx.config.lastfm_api_key.trim();
@@ -118,10 +150,14 @@ impl Job for ArtworkBackfillJob {
             backfill_artist_lastfm(ctx, log, storage_dir, api_key, &client, &mut stats).await?;
         }
 
+        backfill_artist_album_fallbacks(ctx, log, &mut stats).await?;
         repair_cover_variants(ctx, log, storage_dir, &mut stats).await?;
 
         log.info(&format!(
-            "Artwork backfill complete: release_local_assigned={}, release_lastfm_assigned={}, release_lastfm_not_found={}, release_skipped_no_audio={}, artist_lastfm_assigned={}, artist_lastfm_not_found={}, artist_album_fallback_assigned={}, variants_created={}, variants_unchanged={}, variants_missing_original={}, failed={}",
+            "Artwork backfill complete: broken_release_refs_cleared={}, broken_track_refs_cleared={}, broken_artist_refs_cleared={}, release_local_assigned={}, release_lastfm_assigned={}, release_lastfm_not_found={}, release_skipped_no_audio={}, artist_lastfm_assigned={}, artist_lastfm_not_found={}, artist_album_fallback_assigned={}, variants_created={}, variants_unchanged={}, variants_missing_original={}, failed={}",
+            stats.broken_release_refs_cleared,
+            stats.broken_track_refs_cleared,
+            stats.broken_artist_refs_cleared,
             stats.release_local_assigned,
             stats.release_lastfm_assigned,
             stats.release_lastfm_not_found,
@@ -138,6 +174,188 @@ impl Job for ArtworkBackfillJob {
     }
 }
 
+async fn repair_missing_artwork_refs(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    storage_dir: &str,
+    stats: &mut ArtworkStats,
+) -> anyhow::Result<()> {
+    repair_missing_release_cover_refs(ctx, log, storage_dir, stats).await?;
+    repair_missing_track_cover_refs(ctx, log, storage_dir, stats).await?;
+    repair_missing_artist_image_refs(ctx, log, storage_dir, stats).await?;
+    Ok(())
+}
+
+async fn repair_missing_release_cover_refs(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    storage_dir: &str,
+    stats: &mut ArtworkStats,
+) -> anyhow::Result<()> {
+    let rows = sqlx::query_as::<_, ArtworkRefCandidate>(
+        r#"SELECT r.id AS entity_id,
+                  r.cover_file_id AS media_file_id,
+                  mf.file_path::text AS file_path
+             FROM furumusic__release r
+             LEFT JOIN furumusic__media_file mf ON mf.id = r.cover_file_id
+            WHERE r.cover_file_id IS NOT NULL
+              AND r.is_hidden = false
+            ORDER BY r.id"#,
+    )
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    for row in rows {
+        if artwork_ref_exists(storage_dir, row.file_path.as_deref()) {
+            continue;
+        }
+
+        let result = sqlx::query(
+            r#"UPDATE furumusic__release
+                  SET cover_file_id = NULL,
+                      updated_at = $3
+                WHERE id = $1
+                  AND cover_file_id = $2"#,
+        )
+        .bind(row.entity_id)
+        .bind(row.media_file_id)
+        .bind(now_iso())
+        .execute(&ctx.pool)
+        .await?;
+
+        if result.rows_affected() > 0 {
+            reset_lookup_state(&ctx.pool, "release", row.entity_id).await?;
+            stats.broken_release_refs_cleared += 1;
+            log.warn(&format!(
+                "Release {}: cleared missing cover reference media_file_id={}{}",
+                row.entity_id,
+                row.media_file_id,
+                artwork_ref_location(storage_dir, row.file_path.as_deref())
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+async fn repair_missing_track_cover_refs(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    storage_dir: &str,
+    stats: &mut ArtworkStats,
+) -> anyhow::Result<()> {
+    let rows = sqlx::query_as::<_, ArtworkRefCandidate>(
+        r#"SELECT t.id AS entity_id,
+                  t.cover_file_id AS media_file_id,
+                  mf.file_path::text AS file_path
+             FROM furumusic__track t
+             LEFT JOIN furumusic__media_file mf ON mf.id = t.cover_file_id
+            WHERE t.cover_file_id IS NOT NULL
+              AND t.is_hidden = false
+            ORDER BY t.id"#,
+    )
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    for row in rows {
+        if artwork_ref_exists(storage_dir, row.file_path.as_deref()) {
+            continue;
+        }
+
+        let result = sqlx::query(
+            r#"UPDATE furumusic__track
+                  SET cover_file_id = NULL,
+                      updated_at = $3
+                WHERE id = $1
+                  AND cover_file_id = $2"#,
+        )
+        .bind(row.entity_id)
+        .bind(row.media_file_id)
+        .bind(now_iso())
+        .execute(&ctx.pool)
+        .await?;
+
+        if result.rows_affected() > 0 {
+            stats.broken_track_refs_cleared += 1;
+            log.warn(&format!(
+                "Track {}: cleared missing cover reference media_file_id={}{}",
+                row.entity_id,
+                row.media_file_id,
+                artwork_ref_location(storage_dir, row.file_path.as_deref())
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+async fn repair_missing_artist_image_refs(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    storage_dir: &str,
+    stats: &mut ArtworkStats,
+) -> anyhow::Result<()> {
+    let rows = sqlx::query_as::<_, ArtworkRefCandidate>(
+        r#"SELECT a.id AS entity_id,
+                  a.image_file_id AS media_file_id,
+                  mf.file_path::text AS file_path
+             FROM furumusic__artist a
+             LEFT JOIN furumusic__media_file mf ON mf.id = a.image_file_id
+            WHERE a.image_file_id IS NOT NULL
+              AND a.is_hidden = false
+            ORDER BY a.id"#,
+    )
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    for row in rows {
+        if artwork_ref_exists(storage_dir, row.file_path.as_deref()) {
+            continue;
+        }
+
+        let result = sqlx::query(
+            r#"UPDATE furumusic__artist
+                  SET image_file_id = NULL,
+                      updated_at = $3
+                WHERE id = $1
+                  AND image_file_id = $2"#,
+        )
+        .bind(row.entity_id)
+        .bind(row.media_file_id)
+        .bind(now_iso())
+        .execute(&ctx.pool)
+        .await?;
+
+        if result.rows_affected() > 0 {
+            reset_lookup_state(&ctx.pool, "artist", row.entity_id).await?;
+            stats.broken_artist_refs_cleared += 1;
+            log.warn(&format!(
+                "Artist {}: cleared missing image reference media_file_id={}{}",
+                row.entity_id,
+                row.media_file_id,
+                artwork_ref_location(storage_dir, row.file_path.as_deref())
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+fn artwork_ref_exists(storage_dir: &str, file_path: Option<&str>) -> bool {
+    file_path
+        .map(|value| crate::media_paths::resolve_media_file_path(storage_dir, value).exists())
+        .unwrap_or(false)
+}
+
+fn artwork_ref_location(storage_dir: &str, file_path: Option<&str>) -> String {
+    file_path
+        .map(|value| {
+            let path = crate::media_paths::resolve_media_file_path(storage_dir, value);
+            format!(" at {}", path.display())
+        })
+        .unwrap_or_else(|| " with missing media_file row".to_string())
+}
+
 async fn backfill_release_local(
     ctx: &JobContext,
     log: &mut JobLog,
@@ -475,11 +693,15 @@ async fn backfill_artist_lastfm(
     let artists = sqlx::query_as::<_, ArtistCandidate>(
         r#"SELECT a.id, a.name::text AS name
              FROM furumusic__artist a
+             LEFT JOIN furumusic__media_file mf ON mf.id = a.image_file_id
              LEFT JOIN furumusic__artwork_lookup_state s
                ON s.entity_kind = 'artist'
               AND s.entity_id = a.id
               AND s.source = 'lastfm'
-            WHERE a.image_file_id IS NULL
+            WHERE (
+                    a.image_file_id IS NULL
+                 OR mf.file_path NOT LIKE '%/__artist_image__/%'
+                  )
               AND a.is_hidden = false
               AND (
                     s.entity_id IS NULL
@@ -532,7 +754,15 @@ async fn backfill_artist_lastfm(
                                       SET image_file_id = $1,
                                           updated_at = $3
                                     WHERE id = $2
-                                      AND image_file_id IS NULL"#,
+                                      AND (
+                                            image_file_id IS NULL
+                                         OR EXISTS (
+                                                SELECT 1
+                                                  FROM furumusic__media_file mf
+                                                 WHERE mf.id = furumusic__artist.image_file_id
+                                                   AND mf.file_path NOT LIKE '%/__artist_image__/%'
+                                            )
+                                          )"#,
                         )
                         .bind(image_file_id)
                         .bind(artist.id)
@@ -659,6 +889,70 @@ async fn backfill_artist_lastfm(
     Ok(())
 }
 
+async fn backfill_artist_album_fallbacks(
+    ctx: &JobContext,
+    log: &mut JobLog,
+    stats: &mut ArtworkStats,
+) -> anyhow::Result<()> {
+    let artists = sqlx::query_as::<_, ArtistCandidate>(
+        r#"SELECT a.id, a.name::text AS name
+             FROM furumusic__artist a
+            WHERE a.image_file_id IS NULL
+              AND a.is_hidden = false
+              AND EXISTS (
+                    SELECT 1
+                      FROM furumusic__release_artist ra
+                      JOIN furumusic__release r ON r.id = ra.release_id
+                     WHERE ra.artist_id = a.id
+                       AND r.cover_file_id IS NOT NULL
+                       AND r.is_hidden = false
+                    UNION
+                    SELECT 1
+                      FROM furumusic__track_artist ta
+                      JOIN furumusic__track t ON t.id = ta.track_id
+                      JOIN furumusic__release r ON r.id = t.release_id
+                     WHERE ta.artist_id = a.id
+                       AND r.cover_file_id IS NOT NULL
+                       AND r.is_hidden = false
+                  )
+            ORDER BY a.id"#,
+    )
+    .fetch_all(&ctx.pool)
+    .await?;
+
+    if artists.is_empty() {
+        log.info("Artist album fallback pass: no artists need local album fallback");
+        return Ok(());
+    }
+
+    log.info(&format!(
+        "Artist album fallback pass: checking {} artist(s) without images",
+        artists.len()
+    ));
+
+    for artist in artists {
+        match assign_artist_album_fallback(ctx, artist.id).await {
+            Ok(Some(media_file_id)) => {
+                stats.artist_album_fallback_assigned += 1;
+                log.info(&format!(
+                    "Artist {} \"{}\": assigned local album cover fallback (media_file_id={media_file_id})",
+                    artist.id, artist.name
+                ));
+            }
+            Ok(None) => {}
+            Err(err) => {
+                stats.failed += 1;
+                log.warn(&format!(
+                    "Artist {} \"{}\": failed to assign album fallback artwork: {err}",
+                    artist.id, artist.name
+                ));
+            }
+        }
+    }
+
+    Ok(())
+}
+
 async fn repair_cover_variants(
     ctx: &JobContext,
     log: &mut JobLog,
@@ -666,17 +960,25 @@ async fn repair_cover_variants(
     stats: &mut ArtworkStats,
 ) -> anyhow::Result<()> {
     let rows: Vec<(i64, String)> = sqlx::query_as(
-        "SELECT id, file_path FROM furumusic__media_file WHERE file_type = 'cover_art' ORDER BY id",
+        r#"SELECT DISTINCT mf.id, mf.file_path::text
+             FROM furumusic__media_file mf
+            WHERE mf.file_type = 'cover_art'
+              AND (
+                    EXISTS (SELECT 1 FROM furumusic__release r WHERE r.cover_file_id = mf.id)
+                 OR EXISTS (SELECT 1 FROM furumusic__track t WHERE t.cover_file_id = mf.id)
+                 OR EXISTS (SELECT 1 FROM furumusic__artist a WHERE a.image_file_id = mf.id)
+                  )
+            ORDER BY mf.id"#,
     )
     .fetch_all(&ctx.pool)
     .await?;
 
     if rows.is_empty() {
-        log.info("Cover variant pass: no cover art media files found");
+        log.info("Cover variant pass: no referenced cover art media files found");
         return Ok(());
     }
     log.info(&format!(
-        "Cover variant pass: checking {} cover art media file(s)",
+        "Cover variant pass: checking {} referenced cover art media file(s)",
         rows.len()
     ));
 
@@ -805,6 +1107,18 @@ async fn fetch_lastfm_artist_image(
     client: &Client,
     api_key: &str,
     artist: &str,
+) -> anyhow::Result<Option<String>> {
+    if let Some(image_url) = fetch_lastfm_artist_info_image(client, api_key, artist).await? {
+        return Ok(Some(image_url));
+    }
+
+    fetch_lastfm_artist_top_album_image(client, api_key, artist).await
+}
+
+async fn fetch_lastfm_artist_info_image(
+    client: &Client,
+    api_key: &str,
+    artist: &str,
 ) -> anyhow::Result<Option<String>> {
     let response = client
         .get("https://ws.audioscrobbler.com/2.0/")
@@ -836,6 +1150,70 @@ async fn fetch_lastfm_artist_image(
         .and_then(|artist| choose_best_image(artist.image)))
 }
 
+async fn fetch_lastfm_artist_top_album_image(
+    client: &Client,
+    api_key: &str,
+    artist: &str,
+) -> anyhow::Result<Option<String>> {
+    let response = client
+        .get("https://ws.audioscrobbler.com/2.0/")
+        .query(&[
+            ("method", "artist.getTopAlbums"),
+            ("api_key", api_key),
+            ("artist", artist),
+            ("autocorrect", "1"),
+            ("limit", "10"),
+            ("format", "json"),
+        ])
+        .send()
+        .await?;
+    let body = response.text().await?;
+    let parsed: LastfmTopAlbumsResponse = serde_json::from_str(&body)?;
+    if let Some(code) = parsed.error {
+        if code == 6 || code == 7 {
+            return Ok(None);
+        }
+        if code == 29 {
+            anyhow::bail!("Last.fm rate limit exceeded");
+        }
+        anyhow::bail!(
+            "Last.fm API error {code}: {}",
+            parsed.message.unwrap_or_default()
+        );
+    }
+
+    let albums = parsed
+        .topalbums
+        .map(|topalbums| topalbums.album)
+        .unwrap_or_default();
+    Ok(albums
+        .into_iter()
+        .filter_map(|album| choose_best_image(album.image))
+        .next())
+}
+
+fn deserialize_one_or_many<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
+where
+    D: de::Deserializer<'de>,
+    T: DeserializeOwned,
+{
+    let value = Option::<serde_json::Value>::deserialize(deserializer)?;
+    let Some(value) = value else {
+        return Ok(Vec::new());
+    };
+
+    match value {
+        serde_json::Value::Array(values) => values
+            .into_iter()
+            .map(|value| serde_json::from_value(value).map_err(de::Error::custom))
+            .collect(),
+        serde_json::Value::Object(_) => serde_json::from_value(value)
+            .map(|item| vec![item])
+            .map_err(de::Error::custom),
+        _ => Ok(Vec::new()),
+    }
+}
+
 fn choose_best_image(images: Option<Vec<LastfmImage>>) -> Option<String> {
     let mut images = images.unwrap_or_default();
     images.sort_by_key(|image| image_size_rank(&image.size));
@@ -946,6 +1324,24 @@ async fn record_lookup_state(
     Ok(())
 }
 
+async fn reset_lookup_state(
+    pool: &sqlx::PgPool,
+    entity_kind: &str,
+    entity_id: i64,
+) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"DELETE FROM furumusic__artwork_lookup_state
+            WHERE entity_kind = $1
+              AND entity_id = $2
+              AND source = 'lastfm'"#,
+    )
+    .bind(entity_kind)
+    .bind(entity_id)
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
 fn cover_source_description(source: &CoverSource) -> String {
     match source {
         CoverSource::FolderFile(path) => format!("folder: {}", path.display()),

src/jobs/inbox_discover.rs

@@ -75,7 +75,9 @@ impl Job for InboxDiscoverJob {
 
         for (_folder, files) in &groups {
             for file_path in files {
-                let input_path_str = file_path.to_string_lossy().to_string();
+                let input_path_str =
+                    crate::media_paths::path_for_root(&config.agent_inbox_dir, file_path)
+                        .unwrap_or_else(|| file_path.to_string_lossy().to_string());
 
                 // Skip if a PendingReview already exists for this path
                 match PendingReview::exists_for_path(&ctx.db, &input_path_str).await {

src/jobs/inbox_process.rs

@@ -225,14 +225,13 @@ fn group_reviews_by_folder(
     reviews: &[PendingReview],
     inbox_dir: &str,
 ) -> Vec<(String, Vec<PendingReview>)> {
-    let inbox = Path::new(inbox_dir);
     let mut map: HashMap<String, Vec<PendingReview>> = HashMap::new();
 
     for r in reviews {
-        let path = Path::new(r.input_path_str());
+        let path = crate::media_paths::resolve_path_from_root(inbox_dir, r.input_path_str());
-        let folder = path.parent().unwrap_or(path);
+        let folder = path.parent().unwrap_or(path.as_path());
-        let rel = folder.strip_prefix(inbox).unwrap_or(folder);
+        let key = crate::media_paths::path_for_root(inbox_dir, folder)
-        let key = rel.to_string_lossy().to_string();
+            .unwrap_or_else(|| folder.to_string_lossy().to_string());
         map.entry(key).or_default().push(r.clone());
     }
 
@@ -287,8 +286,9 @@ async fn process_folder_batch(
     let mut failed_reviews: Vec<PendingReview> = Vec::new();
 
     for mut review in reviews {
-        let input_path_str = review.input_path_str().to_owned();
+        let stored_input_path = review.input_path_str().to_owned();
-        let file_path = Path::new(&input_path_str);
+        let file_path =
+            crate::media_paths::resolve_path_from_root(&config.agent_inbox_dir, &stored_input_path);
         let filename = file_path
             .file_name()
             .and_then(|n| n.to_str())
@@ -336,7 +336,7 @@ async fn process_folder_batch(
             };
 
         // Parse path hints
-        let relative = file_path.strip_prefix(inbox_path).unwrap_or(file_path);
+        let relative = file_path.strip_prefix(inbox_path).unwrap_or(&file_path);
         let uploader = crate::jobs::uploader_from_relative_path(pool, relative).await;
         let hinted_relative = crate::jobs::strip_user_upload_prefix(relative);
         let hints = crate::agent::path_hints::parse(&hinted_relative);
@@ -471,8 +471,11 @@ async fn process_folder_batch(
 
     // Build folder context from the first file's folder
     let folder_ctx = {
-        let first_path = Path::new(prepared[0].review.input_path_str());
+        let first_path = crate::media_paths::resolve_path_from_root(
-        let folder = first_path.parent().unwrap_or(first_path);
+            &config.agent_inbox_dir,
+            prepared[0].review.input_path_str(),
+        );
+        let folder = first_path.parent().unwrap_or(first_path.as_path());
         let mut folder_files: Vec<String> = std::fs::read_dir(folder)
             .ok()
             .map(|rd| {
@@ -631,7 +634,11 @@ async fn process_folder_batch(
         p.review.result_json = Some(result_json);
         let _ = p.review.save(db).await;
 
-        let input_path_str = p.review.input_path_str().to_owned();
+        let input_path = crate::media_paths::resolve_path_from_root(
+            &config.agent_inbox_dir,
+            p.review.input_path_str(),
+        );
+        let input_path_str = input_path.to_string_lossy().to_string();
 
         if confidence >= config.agent_confidence_threshold {
             match finalize_approved(
@@ -787,10 +794,10 @@ pub async fn finalize_approved(
         format!("{}.{}", sanitize_filename(track_title), ext)
     };
 
-    let storage_dir = Path::new(storage_dir_str);
+    let storage_dir = crate::media_paths::resolve_config_path_buf(storage_dir_str);
     let storage_path = if source_path.exists() {
         match mover::move_to_storage(
-            storage_dir,
+            &storage_dir,
             artist_name,
             release_title,
             &dest_filename,

src/media_paths.rs

@@ -1,7 +1,5 @@
 use std::path::{Component, Path, PathBuf};
 
-const KNOWN_MEDIA_ROOTS: &[&str] = &["media/library", "media/uploads"];
-
 pub fn resolve_config_path(value: &str) -> String {
     let path = resolve_config_path_buf(value);
     if path.as_os_str().is_empty() {
@@ -18,97 +16,75 @@ pub fn resolve_config_path_buf(value: &str) -> PathBuf {
     }
 
     let normalized = normalize_slashes(trimmed);
-    if is_host_absolute(&normalized) {
+    if is_absolute_path(&normalized) {
-        return PathBuf::from(normalized);
+        PathBuf::from(normalized)
+    } else {
+        app_root().join(slash_path(&normalized))
     }
-
-    if looks_like_windows_absolute(&normalized) {
-        if let Some(relative) = extract_known_media_root(&normalized) {
-            return app_root().join(slash_path(&relative));
-        }
-        return PathBuf::from(normalized);
-    }
-
-    app_root().join(slash_path(&normalized))
 }
 
 pub fn resolve_media_file_path(storage_dir: &str, file_path: &str) -> PathBuf {
-    let storage_root = resolve_config_path_buf(storage_dir);
+    resolve_path_from_root(storage_dir, file_path)
-    if let Some(relative) = normalize_stored_media_file_path(storage_dir, file_path) {
-        return storage_root.join(slash_path(&relative));
-    }
-
-    let normalized = normalize_slashes(file_path.trim());
-    let path = PathBuf::from(&normalized);
-    if path.is_absolute() {
-        path
-    } else {
-        storage_root.join(path)
-    }
 }
 
 pub fn media_file_path_for_storage(storage_dir: &str, path: &Path) -> Option<String> {
-    let storage_root = resolve_config_path_buf(storage_dir);
+    path_for_root(storage_dir, path)
-    if let Ok(relative) = path.strip_prefix(&storage_root) {
-        return relative_path_string(relative);
-    }
-
-    let normalized = normalize_slashes(&path.to_string_lossy());
-    relative_after_storage_marker(&storage_root, &normalized).or_else(|| {
-        if !is_host_absolute(&normalized) && !looks_like_windows_absolute(&normalized) {
-            normalize_relative_path(&normalized)
-        } else {
-            None
-        }
-    })
 }
 
-pub fn normalize_stored_media_file_path(storage_dir: &str, file_path: &str) -> Option<String> {
+pub fn resolve_path_from_root(root_dir: &str, stored_path: &str) -> PathBuf {
-    let trimmed = file_path.trim();
+    let normalized = normalize_slashes(stored_path.trim());
-    if trimmed.is_empty() {
+    if is_absolute_path(&normalized) {
-        return None;
+        PathBuf::from(normalized)
+    } else {
+        resolve_config_path_buf(root_dir).join(slash_path(&normalized))
+    }
+}
+
+pub fn path_for_root(root_dir: &str, path: &Path) -> Option<String> {
+    let root = resolve_config_path_buf(root_dir);
+    let normalized = normalize_slashes(&path.to_string_lossy());
+    if is_absolute_path(&normalized) {
+        return strip_root_prefix(&root, &normalized);
     }
 
-    let storage_root = resolve_config_path_buf(storage_dir);
+    relative_path_string(path)
-    let normalized = normalize_slashes(trimmed);
-    let path = PathBuf::from(&normalized);
-    if path.is_absolute() {
-        if let Ok(relative) = path.strip_prefix(&storage_root) {
-            return relative_path_string(relative);
-        }
-        return relative_after_storage_marker(&storage_root, &normalized);
-    }
-
-    if looks_like_windows_absolute(&normalized) {
-        return relative_after_storage_marker(&storage_root, &normalized);
-    }
-
-    if let Some(relative) = relative_after_storage_marker_prefix(&storage_root, &normalized) {
-        return Some(relative);
-    }
-
-    normalize_relative_path(&normalized)
 }
 
 pub async fn normalize_media_file_paths(
     pool: &sqlx::PgPool,
     storage_dir: &str,
 ) -> anyhow::Result<u64> {
-    let rows: Vec<(i64, String)> =
+    normalize_table_paths(pool, "furumusic__media_file", "file_path", storage_dir).await
-        sqlx::query_as("SELECT id, file_path FROM furumusic__media_file ORDER BY id")
+}
-            .fetch_all(pool)
+
-            .await?;
+pub async fn normalize_pending_review_paths(
+    pool: &sqlx::PgPool,
+    inbox_dir: &str,
+) -> anyhow::Result<u64> {
+    normalize_table_paths(pool, "furumusic__pending_review", "input_path", inbox_dir).await
+}
+
+async fn normalize_table_paths(
+    pool: &sqlx::PgPool,
+    table: &str,
+    column: &str,
+    root_dir: &str,
+) -> anyhow::Result<u64> {
+    let sql = format!("SELECT id, {column} FROM {table} WHERE {column} IS NOT NULL ORDER BY id");
+    let rows: Vec<(i64, String)> = sqlx::query_as(&sql).fetch_all(pool).await?;
 
     let mut updated = 0;
-    for (id, file_path) in rows {
+    for (id, stored_path) in rows {
-        let Some(relative) = normalize_stored_media_file_path(storage_dir, &file_path) else {
+        let Some(normalized) = normalize_stored_path(root_dir, &stored_path) else {
             continue;
         };
-        if relative == file_path {
+        if normalized == stored_path {
             continue;
         }
-        sqlx::query("UPDATE furumusic__media_file SET file_path = $1 WHERE id = $2")
+
-            .bind(&relative)
+        let sql = format!("UPDATE {table} SET {column} = $1 WHERE id = $2");
+        sqlx::query(&sql)
+            .bind(&normalized)
             .bind(id)
             .execute(pool)
             .await?;
@@ -118,6 +94,19 @@ pub async fn normalize_media_file_paths(
     Ok(updated)
 }
 
+fn normalize_stored_path(root_dir: &str, stored_path: &str) -> Option<String> {
+    let normalized = normalize_slashes(stored_path);
+    if normalized.is_empty() {
+        return None;
+    }
+
+    if is_absolute_path(&normalized) {
+        strip_root_prefix(&resolve_config_path_buf(root_dir), &normalized)
+    } else {
+        normalize_relative_path(&normalized)
+    }
+}
+
 fn app_root() -> PathBuf {
     std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
 }
@@ -126,8 +115,8 @@ fn normalize_slashes(value: &str) -> String {
     value.trim().replace('\\', "/")
 }
 
-fn is_host_absolute(value: &str) -> bool {
+fn is_absolute_path(value: &str) -> bool {
-    Path::new(value).is_absolute()
+    value.starts_with('/') || Path::new(value).is_absolute() || looks_like_windows_absolute(value)
 }
 
 fn looks_like_windows_absolute(value: &str) -> bool {
@@ -156,6 +145,35 @@ fn normalize_relative_path(value: &str) -> Option<String> {
     Some(parts.join("/"))
 }
 
+fn strip_root_prefix(root: &Path, normalized_path: &str) -> Option<String> {
+    let root_string = normalize_slashes(&root.to_string_lossy());
+    let root_trimmed = root_string.trim_end_matches('/');
+    let path_trimmed = normalized_path.trim();
+
+    let root_cmp = comparable_path(root_trimmed);
+    let path_cmp = comparable_path(path_trimmed);
+    if path_cmp == root_cmp {
+        return None;
+    }
+
+    let prefix = format!("{root_cmp}/");
+    if path_cmp.starts_with(&prefix) {
+        let tail = &path_trimmed[root_trimmed.len() + 1..];
+        return normalize_relative_path(tail);
+    }
+
+    None
+}
+
+fn comparable_path(value: &str) -> String {
+    let normalized = normalize_slashes(value).trim_end_matches('/').to_owned();
+    if cfg!(windows) || looks_like_windows_absolute(&normalized) {
+        normalized.to_ascii_lowercase()
+    } else {
+        normalized
+    }
+}
+
 fn relative_path_string(path: &Path) -> Option<String> {
     let mut parts = Vec::new();
     for component in path.components() {
@@ -172,75 +190,6 @@ fn relative_path_string(path: &Path) -> Option<String> {
     }
 }
 
-fn extract_known_media_root(value: &str) -> Option<String> {
-    KNOWN_MEDIA_ROOTS
-        .iter()
-        .filter_map(|marker| relative_from_marker(value, marker, true))
-        .next()
-}
-
-fn relative_after_storage_marker(storage_root: &Path, value: &str) -> Option<String> {
-    let marker = storage_marker(storage_root)?;
-    relative_from_marker(value, &marker, false)
-}
-
-fn relative_after_storage_marker_prefix(storage_root: &Path, value: &str) -> Option<String> {
-    let marker = storage_marker(storage_root)?;
-    let normalized = normalize_slashes(value);
-    let normalized_lower = normalized.to_ascii_lowercase();
-    let marker_lower = marker.to_ascii_lowercase();
-    if normalized_lower == marker_lower {
-        return None;
-    }
-    normalized_lower
-        .strip_prefix(&(marker_lower + "/"))
-        .and_then(|_| normalize_relative_path(&normalized[marker.len() + 1..]))
-}
-
-fn storage_marker(storage_root: &Path) -> Option<String> {
-    let parts: Vec<String> = storage_root
-        .components()
-        .filter_map(|component| match component {
-            Component::Normal(value) => Some(value.to_string_lossy().to_string()),
-            _ => None,
-        })
-        .collect();
-
-    if parts.len() >= 2 {
-        Some(format!(
-            "{}/{}",
-            parts[parts.len() - 2],
-            parts[parts.len() - 1]
-        ))
-    } else {
-        parts.last().cloned()
-    }
-}
-
-fn relative_from_marker(value: &str, marker: &str, include_marker: bool) -> Option<String> {
-    let normalized = normalize_slashes(value);
-    let haystack = format!("/{}", normalized.trim_matches('/'));
-    let marker = marker.trim_matches('/');
-    let needle = format!("/{marker}");
-    let haystack_lower = haystack.to_ascii_lowercase();
-    let needle_lower = needle.to_ascii_lowercase();
-    let index = haystack_lower.rfind(&needle_lower)?;
-    let after_marker = index + needle.len();
-    if after_marker < haystack.len() && haystack.as_bytes().get(after_marker) != Some(&b'/') {
-        return None;
-    }
-    let tail = haystack[after_marker..].trim_matches('/');
-    if include_marker {
-        if tail.is_empty() {
-            Some(marker.to_string())
-        } else {
-            Some(format!("{marker}/{tail}"))
-        }
-    } else {
-        normalize_relative_path(tail)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -252,11 +201,26 @@ mod tests {
     }
 
     #[test]
-    fn maps_foreign_windows_config_media_root_to_app_root() {
+    fn keeps_absolute_config_path() {
-        let expected = app_root().join("media").join("uploads");
+        assert_eq!(resolve_config_path_buf("/media"), PathBuf::from("/media"));
+    }
+
+    #[test]
+    fn resolves_relative_media_file_under_storage_root() {
         assert_eq!(
-            resolve_config_path_buf(r"C:\Users\ab\repos\furumusic\media\uploads"),
+            resolve_media_file_path("/media", "Buckethead/Pike/cover.jpg"),
-            expected
+            PathBuf::from("/media")
+                .join("Buckethead")
+                .join("Pike")
+                .join("cover.jpg")
+        );
+    }
+
+    #[test]
+    fn keeps_absolute_media_file_path() {
+        assert_eq!(
+            resolve_media_file_path("/media", "/media/Buckethead/Pike/cover.jpg"),
+            PathBuf::from("/media/Buckethead/Pike/cover.jpg")
         );
     }
 
@@ -271,40 +235,22 @@ mod tests {
     }
 
     #[test]
-    fn normalizes_legacy_windows_media_file_path() {
+    fn stores_windows_path_relative_to_windows_storage_root() {
-        let storage = app_root().join("media").join("library");
         assert_eq!(
-            normalize_stored_media_file_path(
+            path_for_root(
-                &storage.to_string_lossy(),
+                r"C:\Users\ab\repos\furumusic\library",
-                r"C:\Users\ab\repos\furumusic\media\library\Buckethead\Pike\cover.jpg",
+                Path::new(r"C:\Users\ab\repos\furumusic\library\Artist\Album\track.mp3"),
             )
             .as_deref(),
-            Some("Buckethead/Pike/cover.jpg")
+            Some("Artist/Album/track.mp3")
         );
     }
 
     #[test]
-    fn strips_accidental_relative_storage_root_prefix() {
+    fn normalizes_relative_backslashes() {
-        let storage = app_root().join("media").join("library");
         assert_eq!(
-            normalize_stored_media_file_path(
+            normalize_stored_path("/media", r"Artist\Album\track.mp3").as_deref(),
-                &storage.to_string_lossy(),
+            Some("Artist/Album/track.mp3")
-                "media/library/Buckethead/Pike/cover.jpg",
-            )
-            .as_deref(),
-            Some("Buckethead/Pike/cover.jpg")
-        );
-    }
-
-    #[test]
-    fn resolves_legacy_windows_media_file_path_to_current_storage() {
-        let storage = app_root().join("media").join("library");
-        assert_eq!(
-            resolve_media_file_path(
-                &storage.to_string_lossy(),
-                r"C:\Users\ab\repos\furumusic\media\library\Buckethead\Pike\cover.jpg",
-            ),
-            storage.join("Buckethead").join("Pike").join("cover.jpg")
         );
     }
 }

src/player/mod.rs

@@ -3907,7 +3907,6 @@ impl App for PlayerApp {
                 {
                     let pool = Arc::clone(&pool);
                     let pool_config = Arc::clone(&pool_config);
-                    let config = Arc::clone(&self.config);
                     get(
                         move |session: Session,
                               db: Database,
@@ -3915,7 +3914,6 @@ impl App for PlayerApp {
                               request: cot::request::Request| {
                             let pool = Arc::clone(&pool);
                             let pool_config = Arc::clone(&pool_config);
-                            let config = Arc::clone(&config);
                             async move {
                                 let pg_pool = pool
                                     .get_or_init(|| async {
@@ -3926,7 +3924,9 @@ impl App for PlayerApp {
                                             .expect("player pool")
                                     })
                                     .await;
-                                stream_handler(session, db, pg_pool, &config, &request, path).await
+                                let (live_config, _) = AppConfig::load_with_db(&db).await;
+                                stream_handler(session, db, pg_pool, &live_config, &request, path)
+                                    .await
                             }
                         },
                     )
@@ -3939,12 +3939,10 @@ impl App for PlayerApp {
                 {
                     let pool = Arc::clone(&pool);
                     let pool_config = Arc::clone(&pool_config);
-                    let config = Arc::clone(&self.config);
                     get(
                         move |session: Session, db: Database, path: Path<PathMediaFileVariant>| {
                             let pool = Arc::clone(&pool);
                             let pool_config = Arc::clone(&pool_config);
-                            let config = Arc::clone(&config);
                             async move {
                                 let pg_pool = pool
                                     .get_or_init(|| async {
@@ -3955,7 +3953,9 @@ impl App for PlayerApp {
                                             .expect("player pool")
                                     })
                                     .await;
-                                cover_variant_handler(session, db, pg_pool, &config, path).await
+                                let (live_config, _) = AppConfig::load_with_db(&db).await;
+                                cover_variant_handler(session, db, pg_pool, &live_config, path)
+                                    .await
                             }
                         },
                     )
@@ -3967,12 +3967,10 @@ impl App for PlayerApp {
                 {
                     let pool = Arc::clone(&pool);
                     let pool_config = Arc::clone(&pool_config);
-                    let config = Arc::clone(&self.config);
                     get(
                         move |session: Session, db: Database, path: Path<PathMediaFileId>| {
                             let pool = Arc::clone(&pool);
                             let pool_config = Arc::clone(&pool_config);
-                            let config = Arc::clone(&config);
                             async move {
                                 let pg_pool = pool
                                     .get_or_init(|| async {
@@ -3983,7 +3981,8 @@ impl App for PlayerApp {
                                             .expect("player pool")
                                     })
                                     .await;
-                                cover_handler(session, db, pg_pool, &config, path).await
+                                let (live_config, _) = AppConfig::load_with_db(&db).await;
+                                cover_handler(session, db, pg_pool, &live_config, path).await
                             }
                         },
                     )

src/scheduler/mod.rs

@@ -1481,6 +1481,20 @@ pub async fn start_scheduler(
             Err(e) => tracing::warn!("Failed to normalize media file paths: {e:#}"),
         }
     }
+    if !live_config.agent_inbox_dir.trim().is_empty() {
+        match crate::media_paths::normalize_pending_review_paths(
+            &pool,
+            &live_config.agent_inbox_dir,
+        )
+        .await
+        {
+            Ok(0) => {}
+            Ok(n) => {
+                tracing::info!("Normalized {n} pending review path(s) to relative inbox paths")
+            }
+            Err(e) => tracing::warn!("Failed to normalize pending review paths: {e:#}"),
+        }
+    }
 
     // Upsert ScheduledJob rows
     for job in registry.all_jobs() {