Merge pull request #370 from lklynet/feature/lidarr-existing-monitoring

Add Lidarr existing-albums monitoring support

Author: lklynet

.tests/auth/lidarr-preferences.integration.test.js

@@ -309,7 +309,7 @@ test("requestAlbumFromSearch rejects when artist must be created without addArti
   }
 });
 
-test("addAlbum preserves artist monitoring state while monitoring only the requested album", async () => {
+test("addAlbum checks artist monitoring while monitoring only the requested album", async () => {
   const originalIsConfigured = lidarrClient.isConfigured;
   const originalGetArtist = lidarrClient.getArtist;
   const originalGetAlbumByMbid = lidarrClient.getAlbumByMbid;
@@ -338,14 +338,26 @@ test("addAlbum preserves artist monitoring state while monitoring only the reque
       sizeOnDisk: 0,
     },
   });
-  lidarrClient.updateArtistMonitoring = async () => {
+  lidarrClient.updateArtistMonitoring = async (_artistId, monitorOption) => {
     updateArtistMonitoringCalls += 1;
+    assert.equal(monitorOption, "none");
+    return {
+      id: 7,
+      artistName: "Boards of Canada",
+      foreignArtistId: "artist-mbid",
+      monitored: true,
+      monitor: "none",
+      monitorNewItems: "none",
+      addOptions: {
+        monitor: "none",
+      },
+    };
   };
 
   try {
     const album = await libraryManager.addAlbum(7, "album-mbid", "Geogaddi");
     assert.equal(album.id, "42");
-    assert.equal(updateArtistMonitoringCalls, 0);
+    assert.equal(updateArtistMonitoringCalls, 1);
   } finally {
     lidarrClient.isConfigured = originalIsConfigured;
     lidarrClient.getArtist = originalGetArtist;
@@ -363,11 +375,13 @@ test("addAlbum monitors and searches the requested album after Lidarr conflict l
   const originalGetAlbum = lidarrClient.getAlbum;
   const originalMonitorAlbum = lidarrClient.monitorAlbum;
   const originalTriggerAlbumSearch = lidarrClient.triggerAlbumSearch;
+  const originalUpdateArtistMonitoring = lidarrClient.updateArtistMonitoring;
   const originalWaitForAlbumByMbidForArtist =
     libraryManager.waitForAlbumByMbidForArtist;
 
   let monitorCalls = 0;
   let searchCalls = 0;
+  let updateArtistMonitoringCalls = 0;
 
   lidarrClient.isConfigured = () => true;
   lidarrClient.getArtist = async () => ({
@@ -378,6 +392,17 @@ test("addAlbum monitors and searches the requested album after Lidarr conflict l
     monitor: "none",
   });
   lidarrClient.getAlbumByMbid = async () => null;
+  lidarrClient.updateArtistMonitoring = async (_artistId, monitorOption) => {
+    updateArtistMonitoringCalls += 1;
+    assert.equal(monitorOption, "none");
+    return {
+      id: 7,
+      artistName: "Boards of Canada",
+      foreignArtistId: "artist-mbid",
+      monitored: true,
+      monitor: "none",
+    };
+  };
   lidarrClient.addAlbum = async () => {
     throw new Error("AlbumExistsValidator: This album has already been added");
   };
@@ -420,6 +445,7 @@ test("addAlbum monitors and searches the requested album after Lidarr conflict l
 
     assert.equal(album.id, "42");
     assert.equal(album.monitored, true);
+    assert.equal(updateArtistMonitoringCalls, 1);
     assert.equal(monitorCalls, 1);
     assert.equal(searchCalls, 1);
   } finally {
@@ -430,6 +456,7 @@ test("addAlbum monitors and searches the requested album after Lidarr conflict l
     lidarrClient.getAlbum = originalGetAlbum;
     lidarrClient.monitorAlbum = originalMonitorAlbum;
     lidarrClient.triggerAlbumSearch = originalTriggerAlbumSearch;
+    lidarrClient.updateArtistMonitoring = originalUpdateArtistMonitoring;
     libraryManager.waitForAlbumByMbidForArtist =
       originalWaitForAlbumByMbidForArtist;
   }

.tests/search/search-service.test.js

@@ -524,18 +524,7 @@ export default function registerDownloads(router) {
         }
 
         try {
-          if (!artist.monitored || artist.monitorOption === "none") {
-            const artistMbidToUpdate = artist.mbid || artist.foreignArtistId;
-            if (artistMbidToUpdate) {
-              try {
-                await libraryManager.updateArtist(artistMbidToUpdate, {
-                  monitored: true,
-                  monitorOption: "missing",
-                });
-                artist = await libraryManager.getArtist(artistMbidToUpdate);
-              } catch {}
-            }
-          }
+          artist = await libraryManager.ensureArtistMonitored(artist);
           if (!album.monitored) {
             await libraryManager.updateAlbum(albumId, { monitored: true });
           }
@@ -549,6 +538,14 @@ export default function registerDownloads(router) {
               name: "AlbumSearch",
               albumIds: [parseInt(albumId, 10)],
             });
+            await libraryManager.ensureRequestedAlbumMonitoring(
+              artist.id,
+              albumId,
+            );
+            libraryManager.scheduleRequestedAlbumMonitoringRepair(
+              artist.id,
+              albumId,
+            );
           }
           invalidateAllDownloadStatusesCache();
 
@@ -601,6 +598,13 @@ export default function registerDownloads(router) {
           return res.status(404).json({ error: "Album not found" });
         }
 
+        const artist = album.artistId
+          ? await libraryManager.getArtistById(album.artistId)
+          : null;
+        if (artist) {
+          await libraryManager.ensureArtistMonitored(artist);
+        }
+
         if (!album.monitored) {
           await libraryManager.updateAlbum(albumId, { monitored: true });
         }
@@ -609,6 +613,16 @@ export default function registerDownloads(router) {
           name: "AlbumSearch",
           albumIds: [parseInt(albumId, 10)],
         });
+        if (album.artistId) {
+          await libraryManager.ensureRequestedAlbumMonitoring(
+            album.artistId,
+            albumId,
+          );
+          libraryManager.scheduleRequestedAlbumMonitoringRepair(
+            album.artistId,
+            albumId,
+          );
+        }
         invalidateAllDownloadStatusesCache();
 
         res.json({

backend/routes/library/handlers/downloads.js

@@ -46,6 +46,19 @@ function upsertCachedArtist(mappedArtist) {
   _cachedArtists.unshift(mappedArtist);
 }
 
+function removeCachedArtistByMbid(mbid) {
+  if (!mbid || !Array.isArray(_cachedArtists) || _cachedArtists.length === 0) {
+    return;
+  }
+  _cachedArtists = _cachedArtists.filter(
+    (artist) => artist?.mbid !== mbid && artist?.foreignArtistId !== mbid,
+  );
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 async function getLidarrClient() {
   if (!lidarrClient) {
     try {
@@ -292,8 +305,8 @@ export class LibraryManager {
     });
 
     switch (artist.monitorOption) {
-      case "all":
       case "existing":
+      case "all":
         albumsToMonitor.push(...eligibleAlbums.filter((album) => !album.monitored));
         break;
       case "latest":
@@ -552,6 +565,69 @@ export class LibraryManager {
     }
   }
 
+  async ensureArtistMonitored(artist, monitorOption = null) {
+    if (!artist || artist.monitored !== false) {
+      return artist;
+    }
+
+    const mbid = artist.mbid || artist.foreignArtistId;
+    if (!mbid) {
+      return artist;
+    }
+
+    const nextMonitorOption =
+      monitorOption ||
+      artist.monitorOption ||
+      artist.addOptions?.monitor ||
+      "none";
+    const updated = await this.updateArtist(mbid, {
+      monitored: true,
+      monitorOption: nextMonitorOption,
+    });
+    return updated?.error ? artist : updated;
+  }
+
+  async ensureRequestedAlbumMonitoring(artistId, albumId, options = {}) {
+    const normalizedArtistId = String(artistId || "").trim();
+    const normalizedAlbumId = String(albumId || "").trim();
+    if (!normalizedArtistId || !normalizedAlbumId) {
+      return { artist: null, album: null };
+    }
+
+    let artist = await this.getArtistById(normalizedArtistId);
+    if (artist?.monitored === false) {
+      artist = await this.ensureArtistMonitored(artist, options.monitorOption);
+    }
+
+    let album = await this.getAlbumById(normalizedAlbumId);
+    if (album?.monitored === false) {
+      album = await this.updateAlbum(normalizedAlbumId, { monitored: true });
+    }
+
+    return { artist, album };
+  }
+
+  scheduleRequestedAlbumMonitoringRepair(artistId, albumId, options = {}) {
+    const normalizedArtistId = String(artistId || "").trim();
+    const normalizedAlbumId = String(albumId || "").trim();
+    if (!normalizedArtistId || !normalizedAlbumId) return;
+
+    for (const delayMs of [1000, 3000, 8000, 15000]) {
+      const timeout = setTimeout(() => {
+        this.ensureRequestedAlbumMonitoring(
+          normalizedArtistId,
+          normalizedAlbumId,
+          options,
+        ).catch((error) => {
+          console.error(
+            `[LibraryManager] Failed to stabilize requested album monitoring: ${error.message}`,
+          );
+        });
+      }, delayMs);
+      timeout.unref?.();
+    }
+  }
+
   async getAllArtists() {
     try {
       const lidarr = await getLidarrClient();
@@ -686,8 +762,7 @@ export class LibraryManager {
     const artistPath = lidarrArtist.path ?? null;
     const monitorOption =
       lidarrArtist.monitor || lidarrArtist.addOptions?.monitor || "none";
-    const normalizedMonitorOption =
-      monitorOption === "existing" ? "all" : monitorOption;
+    const normalizedMonitorOption = monitorOption || "none";
     return {
       id: lidarrArtist.id?.toString() || lidarrArtist.foreignArtistId,
       mbid: lidarrArtist.foreignArtistId,
@@ -725,8 +800,7 @@ export class LibraryManager {
       ) {
         const monitorOption =
           updates.monitorOption || lidarrArtist.monitor || "none";
-        const normalizedMonitorOption =
-          monitorOption === "existing" ? "all" : monitorOption;
+        const normalizedMonitorOption = monitorOption || "none";
         await lidarr.updateArtistMonitoring(lidarrArtist.id, monitorOption);
         console.log(
           `[LibraryManager] Updated Lidarr monitoring for "${lidarrArtist.artistName}" to "${monitorOption}"`,
@@ -771,6 +845,7 @@ export class LibraryManager {
       if (!lidarrArtist)
         return { success: false, error: "Artist not found in Lidarr" };
       await lidarr.deleteArtist(lidarrArtist.id, deleteFiles);
+      removeCachedArtistByMbid(mbid);
       console.log(
         `[LibraryManager] Deleted artist "${lidarrArtist.artistName}" from Lidarr`,
       );
@@ -805,7 +880,6 @@ export class LibraryManager {
           msg.includes("foreignalbumid")
         );
       };
-      const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
       const settings = getSettings();
       const searchOnAdd = settings.integrations?.lidarr?.searchOnAdd ?? false;
       const shouldTriggerSearch =
@@ -818,6 +892,11 @@ export class LibraryManager {
         }
         if (shouldTriggerSearch) {
           await lidarr.triggerAlbumSearch(existingAlbum.id);
+          await this.ensureRequestedAlbumMonitoring(artistId, existingAlbum.id);
+          this.scheduleRequestedAlbumMonitoringRepair(
+            artistId,
+            existingAlbum.id,
+          );
         }
         const refreshedExisting = await lidarr
           .getAlbum(existingAlbum.id)
@@ -847,6 +926,12 @@ export class LibraryManager {
         }
       }
       if (!lidarrArtist) return { error: "Artist not found in Lidarr" };
+      if (lidarrArtist.monitored === false) {
+        lidarrArtist = await lidarr.updateArtistMonitoring(
+          artistId,
+          lidarrArtist.monitor || lidarrArtist.addOptions?.monitor || "none",
+        );
+      }
       const existing = await lidarr.getAlbumByMbid(releaseGroupMbid);
       const artistNumericId = parseInt(artistId, 10);
       const sameArtistExisting =
@@ -912,6 +997,13 @@ export class LibraryManager {
       if (!lidarrAlbum) {
         return { error: "Failed to add album to Lidarr" };
       }
+      if (shouldTriggerSearch) {
+        await this.ensureRequestedAlbumMonitoring(artistId, lidarrAlbum.id);
+        this.scheduleRequestedAlbumMonitoringRepair(artistId, lidarrAlbum.id);
+        lidarrAlbum = await lidarr
+          .getAlbum(lidarrAlbum.id)
+          .catch(() => lidarrAlbum);
+      }
       const updatedArtist = await lidarr.getArtist(artistId);
       return this.mapLidarrAlbum(lidarrAlbum, updatedArtist);
     } catch (error) {
@@ -993,6 +1085,8 @@ export class LibraryManager {
       throw error;
     }
 
+    artist = await this.ensureArtistMonitored(artist);
+
     let existingAlbum = await lidarr.getAlbumByMbid(normalizedAlbumMbid);
     if (
       existingAlbum &&