cross-seed 7.0.0-21 → 7.0.0-23

package/dist/torrent.js

@@ -1,19 +1,20 @@
 import { distance } from "fastest-levenshtein";
-import bencode from "bencode";
 import { readdir, readFile, stat } from "fs/promises";
 import { extname, join, resolve } from "path";
 import { inspect } from "util";
+import { decode } from "./bencode.js";
 import { getClients, } from "./clients/TorrentClient.js";
 import { isChildPath } from "./utils.js";
 import { ALL_PARENTHESES_REGEX, ALL_SPACES_REGEX, ALL_SQUARE_BRACKETS_REGEX, LEVENSHTEIN_DIVISOR, MAX_PATH_BYTES, MediaType, MIN_VIDEO_QUERY_LENGTH, SAVED_TORRENTS_INFO_REGEX, USER_AGENT, } from "./constants.js";
 import { getDataByFuzzyName, indexDataDirs, shouldIgnorePathHeuristically, } from "./dataFiles.js";
 import { db } from "./db.js";
-import { Label, logger, logOnce } from "./logger.js";
-import { Metafile, updateMetafileMetadata } from "./parseTorrent.js";
+import { createClientLibrarySourceKey, createDataLibrarySourceKey, createTorrentLibraryItemInput, createTorrentLibrarySourceKey, beginLibraryScan, getLibraryScan, failLibraryScan, LibraryItemSource, LibraryScanStatus, markLibraryItemsMissingBySourceKeys, syncLibraryItems, } from "./libraryInventory.js";
+import { Label, logger } from "./logger.js";
+import { Metafile, updateMetafileMetadata, } from "./parseTorrent.js";
 import { isOk, resultOf, resultOfErr } from "./Result.js";
 import { getRuntimeConfig } from "./runtimeConfig.js";
 import { createSearcheeFromDB, createSearcheeFromPath, createSearcheeFromTorrentFile, getAnimeKeys, getEpisodeKeys, getLargestFile, getMovieKeys, getSeasonKeys, } from "./searchee.js";
-import { createKeyTitle, exists, filterAsync, filterAsyncYield, flatMapAsync, getLogString, inBatches, mapAsync, Mutex, notExists, stripExtension, wait, withMutex, } from "./utils.js";
+import { createKeyTitle, exists, filterAsync, filterAsyncYield, flatMapAsync, getLogString, inBatches, errorMessage, isTruthy, mapAsync, notExists, stripExtension, wait, } from "./utils.js";
 export var SnatchError;
 (function (SnatchError) {
     SnatchError["ABORTED"] = "ABORTED";
@@ -29,7 +30,7 @@ function isRecoverableTorrentDirError(error) {
     return ["ENOENT", "ENOTDIR", "EACCES", "EPERM"].includes(code ?? "");
 }
 function logRecoverableTorrentDirError(torrentDir, error) {
-    const message = error instanceof Error ? error.message : String(error ?? "");
+    const message = errorMessage(error);
     logger.warn({
         label: Label.INDEX,
         message: `Skipping torrentDir indexing for "${torrentDir}": ${message}`,
@@ -45,7 +46,7 @@ export async function parseTorrentWithMetadata(filePath, torrentInfos) {
     if (clients[0]?.clientType === Label.QBITTORRENT) {
         const fastResumePath = filePath.replace(extname(filePath), ".fastresume");
         if (await exists(fastResumePath)) {
-            updateMetafileMetadata(meta, bencode.decode(await readFile(fastResumePath)));
+            updateMetafileMetadata(meta, decode(await readFile(fastResumePath)));
             return meta;
         }
         else {
@@ -91,14 +92,15 @@ async function snatchOnce(candidate) {
         });
     }
     catch (e) {
-        if (e.name === "AbortError" || e.name === "TimeoutError") {
+        const errName = e instanceof Error ? e.name : "";
+        if (errName === "AbortError" || errName === "TimeoutError") {
             logger.debug(`${candidate.name}: ${url}`);
             return {
                 snatchError: SnatchError.ABORTED,
                 extra: `snatch timed out`,
             };
         }
-        else if (isMagnetRedirectError(e)) {
+        else if (e instanceof Error && isMagnetRedirectError(e)) {
             logger.debug(`${candidate.name}: ${url}`);
             return { snatchError: SnatchError.MAGNET_LINK };
         }
@@ -281,7 +283,10 @@ export async function cacheEnsembleTorrentEntry(searchee, torrentSavePaths) {
         savePath = torrentSavePaths.get(searchee.infoHash);
     }
     else {
-        const downloadDirResult = await getClients()[0].getDownloadDir(searchee, {
+        const client = getClients()[0];
+        if (!client)
+            return null;
+        const downloadDirResult = await client.getDownloadDir(searchee, {
             onlyCompleted: false,
         });
         if (downloadDirResult.isErr()) {
@@ -302,6 +307,29 @@ export async function cacheEnsembleTorrentEntry(searchee, torrentSavePaths) {
         element: ensemblePiece.element,
     }));
 }
+async function scanClientInventory(client, newSearcheesOnly) {
+    const scan = await beginLibraryScan({
+        source: LibraryItemSource.CLIENT,
+        sourceInstance: client.clientHost,
+    });
+    try {
+        const result = await client.getClientSearchees({
+            newSearcheesOnly,
+            includeFiles: true,
+            includeTrackers: true,
+            libraryScanId: scan.id,
+        });
+        if ((await getLibraryScan(scan.id))?.status !==
+            LibraryScanStatus.SUCCEEDED) {
+            throw new Error("Client did not complete its inventory refresh; preserving previous inventory");
+        }
+        return result;
+    }
+    catch (error) {
+        await failLibraryScan(scan.id, error);
+        throw error;
+    }
+}
 async function indexTorrents(options) {
     const { seasonFromEpisodes, torrentDir, useClientTorrents } = getRuntimeConfig();
     if (!useClientTorrents && !torrentDir)
@@ -316,7 +344,7 @@ async function indexTorrents(options) {
                 message: "Indexing torrentDir for reverse lookup...",
             });
             try {
-                searchees = await loadTorrentDirLight(torrentDir);
+                searchees = await loadTorrentDirIncremental(torrentDir);
             }
             catch (error) {
                 if (!isRecoverableTorrentDirError(error))
@@ -324,29 +352,35 @@ async function indexTorrents(options) {
                 logRecoverableTorrentDirError(torrentDir, error);
                 searchees = [];
             }
-            if (clients.length) {
-                infoHashPathMap = await clients[0].getAllDownloadDirs({
-                    metas: searchees,
-                    onlyCompleted: false,
-                    v1HashOnly: true,
-                });
+            if (clients.length && seasonFromEpisodes) {
+                try {
+                    infoHashPathMap = await clients[0].getAllDownloadDirs({
+                        metas: searchees,
+                        onlyCompleted: false,
+                        v1HashOnly: true,
+                    });
+                }
+                catch (error) {
+                    infoHashPathMap = new Map();
+                    logger.warn({
+                        label: Label.INDEX,
+                        message: `Skipping client-dependent episode grouping: ${errorMessage(error)}`,
+                    });
+                }
             }
         }
         else {
             logger.info("Indexing client torrents for reverse lookup...");
             searchees = await flatMapAsync(clients, async (client) => {
                 try {
-                    const { searchees } = await client.getClientSearchees({
-                        includeFiles: true,
-                        includeTrackers: true,
-                    });
+                    const { searchees } = await scanClientInventory(client, false);
                     return searchees;
                 }
                 catch (e) {
                     const message = e instanceof Error ? e.message : String(e ?? "");
                     logger.warn({
                         label: client.label,
-                        message: `Indexing client torrents failed; disabling client until next retry: ${message}`,
+                        message: `Indexing client torrents failed; keeping previous inventory until next retry: ${message}`,
                     });
                     logger.debug(e);
                     return [];
@@ -369,17 +403,14 @@ async function indexTorrents(options) {
         else {
             searchees = await flatMapAsync(clients, async (client) => {
                 try {
-                    return (await client.getClientSearchees({
-                        newSearcheesOnly: true,
-                        includeFiles: true,
-                        includeTrackers: true,
-                    })).newSearchees;
+                    return (await scanClientInventory(client, true))
+                        .newSearchees;
                 }
                 catch (e) {
                     const message = e instanceof Error ? e.message : String(e ?? "");
                     logger.warn({
                         label: client.label,
-                        message: `Indexing client torrents failed; disabling client until next retry: ${message}`,
+                        message: `Indexing client torrents failed; keeping previous inventory until next retry: ${message}`,
                     });
                     logger.debug(e);
                     return [];
@@ -398,65 +429,80 @@ async function indexTorrents(options) {
     });
 }
 async function indexTorrentDir(dir) {
-    const dirContents = new Set(await findAllTorrentFilesInDir(dir));
-    const newSearchees = [];
-    for (const filePath of dirContents) {
-        const doesAlreadyExist = await db("torrent")
-            .select("id")
-            .where({ file_path: filePath })
-            .first();
-        if (doesAlreadyExist)
-            continue;
-        let meta;
-        try {
-            meta = await parseTorrentFromPath(filePath);
-        }
-        catch (e) {
-            logOnce(`Failed to parse ${filePath}`, () => {
-                logger.error({
-                    label: Label.INDEX,
-                    message: `Failed to parse ${filePath}`,
-                });
-                logger.debug(e);
-            });
-            continue;
-        }
-        await db("torrent")
-            .insert({
-            file_path: filePath,
-            info_hash: meta.infoHash,
-            name: meta.name,
-        })
-            .onConflict("file_path")
-            .ignore();
-        const res = await createSearcheeFromTorrentFile(filePath, []);
-        if (res.isOk())
-            newSearchees.push(res.unwrap());
-    }
-    const rows = await db("torrent").select("file_path", "info_hash");
-    const toDelete = rows.filter((row) => !dirContents.has(row.file_path));
-    await inBatches(toDelete, async (batch) => {
-        await db("torrent")
-            .whereIn("file_path", batch.map((row) => row.file_path))
-            .del();
-        await db("ensemble")
-            .whereIn("info_hash", batch.map((row) => row.info_hash))
-            .del();
+    return loadTorrentDirIncremental(dir, { includeUnchanged: false });
+}
+let activeIndexing;
+let startupIndexingRequested = false;
+export function indexTorrentsAndDataDirs(options = { startup: false }) {
+    startupIndexingRequested ||= options.startup;
+    if (activeIndexing)
+        return activeIndexing;
+    activeIndexing = (async () => {
+        do {
+            const startup = startupIndexingRequested;
+            startupIndexingRequested = false;
+            try {
+                await runIndexing({ startup });
+            }
+            catch (error) {
+                // A settings update queued during a failed scan still gets a turn.
+                if (!startupIndexingRequested)
+                    throw error;
+            }
+        } while (startupIndexingRequested);
+    })().finally(() => {
+        activeIndexing = undefined;
     });
-    return newSearchees;
+    return activeIndexing;
 }
-export async function indexTorrentsAndDataDirs(options = { startup: false }) {
+async function runIndexing(options) {
     if (options.startup) {
         const { dataDirs, seasonFromEpisodes, torrentDir, useClientTorrents } = getRuntimeConfig();
+        const configuredSources = new Map([
+            [LibraryItemSource.DATA, new Set(dataDirs)],
+            [
+                LibraryItemSource.TORRENT,
+                new Set(torrentDir ? [torrentDir] : []),
+            ],
+            [
+                LibraryItemSource.CLIENT,
+                new Set(useClientTorrents
+                    ? getClients().map((client) => client.clientHost)
+                    : []),
+            ],
+        ]);
+        const activeItems = await db("library_item")
+            .whereNull("missing_since")
+            .select("source", "source_instance", "source_key", "info_hash");
+        const removedItems = activeItems.filter((item) => !configuredSources
+            .get(item.source)
+            ?.has(item.source_instance ?? ""));
+        const removedTorrentHashes = removedItems.filter((item) => item.source ===
+            LibraryItemSource.TORRENT);
+        await inBatches(removedTorrentHashes.map((item) => item.info_hash).filter(isTruthy), async (hashes) => {
+            await db("ensemble")
+                .whereNull("client_host")
+                .whereIn("info_hash", hashes)
+                .del();
+        });
+        await markLibraryItemsMissingBySourceKeys(removedItems.map((item) => item.source_key));
         if (!useClientTorrents) {
-            const hashes = (await db("client_searchee").select("info_hash")).map((r) => r.info_hash);
+            const clientRows = await db("client_searchee").select("client_host", "info_hash");
+            const hashes = clientRows.map((r) => r.info_hash);
             await inBatches(hashes, async (batch) => {
                 await db("ensemble").whereIn("info_hash", batch).del();
             });
+            await markLibraryItemsMissingBySourceKeys(clientRows.map((row) => createClientLibrarySourceKey({
+                clientHost: row.client_host,
+                infoHash: row.info_hash,
+            })));
             await db("client_searchee").del();
         }
         else {
             const clientHosts = getClients().map((client) => client.clientHost);
+            const clientRowsToDelete = await db("client_searchee")
+                .select("client_host", "info_hash")
+                .whereNotIn("client_host", clientHosts);
             await db("client_searchee")
                 .whereNotIn("client_host", clientHosts)
                 .del();
@@ -464,13 +510,18 @@ export async function indexTorrentsAndDataDirs(options = { startup: false }) {
                 .whereNotNull("client_host")
                 .whereNotIn("client_host", clientHosts)
                 .del();
+            await markLibraryItemsMissingBySourceKeys(clientRowsToDelete.map((row) => createClientLibrarySourceKey({
+                clientHost: row.client_host,
+                infoHash: row.info_hash,
+            })));
         }
         if (!torrentDir) {
-            const hashes = (await db("torrent").select("info_hash")).map((r) => r.info_hash);
+            const torrentRows = await getTorrentLibraryEntries();
+            const hashes = torrentRows.map((r) => r.info_hash).filter(isTruthy);
             await inBatches(hashes, async (batch) => {
                 await db("ensemble").whereIn("info_hash", batch).del();
             });
-            await db("torrent").del();
+            await markLibraryItemsMissingBySourceKeys(torrentRows.map((row) => createTorrentLibrarySourceKey(row.file_path)));
         }
         if (!dataDirs.length) {
             const paths = (await db("data").select("path")).map((r) => r.path);
@@ -479,6 +530,7 @@ export async function indexTorrentsAndDataDirs(options = { startup: false }) {
                     .whereIn("path", batch)
                     .whereNull("client_host")
                     .del();
+                await markLibraryItemsMissingBySourceKeys(batch.map(createDataLibrarySourceKey));
             });
             await db("data").del();
         }
@@ -491,41 +543,44 @@ export async function indexTorrentsAndDataDirs(options = { startup: false }) {
                     .whereIn("path", batch)
                     .whereNull("client_host")
                     .del();
+                await markLibraryItemsMissingBySourceKeys(batch.map(createDataLibrarySourceKey));
             });
         }
         if (!seasonFromEpisodes)
             await db("ensemble").del();
     }
-    return withMutex(Mutex.INDEX_TORRENTS_AND_DATA_DIRS, { useQueue: false }, async () => {
-        const maxRetries = 3;
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                await indexDataDirs(options); // Running together may increase failures
-                await indexTorrents(options); // Run second so this data is more fresh
-                break;
+    const maxRetries = 3;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            await indexDataDirs(options); // Running together may increase failures
+            await indexTorrents(options); // Run second so this data is more fresh
+            break;
+        }
+        catch (e) {
+            const log = {
+                label: Label.INDEX,
+                message: `Indexing failed (${maxRetries - attempt}): ${errorMessage(e)}`,
+            };
+            logger.debug(e);
+            if (attempt < maxRetries) {
+                logger.verbose(log);
             }
-            catch (e) {
-                const log = {
-                    label: Label.INDEX,
-                    message: `Indexing failed (${maxRetries - attempt}): ${e.message}`,
-                };
-                logger.debug(e);
-                if (attempt < maxRetries) {
-                    logger.verbose(log);
-                }
-                else {
-                    logger.error(log);
-                    if (options.startup)
-                        throw e;
-                }
+            else {
+                logger.error(log);
+                if (options.startup)
+                    throw e;
             }
         }
-    });
+    }
 }
 export async function getInfoHashesToExclude() {
     const { useClientTorrents } = getRuntimeConfig();
-    const database = useClientTorrents ? db("client_searchee") : db("torrent");
-    return new Set((await database.select("*")).map((e) => e.info_hash));
+    if (!useClientTorrents) {
+        return new Set((await getTorrentLibraryEntries())
+            .map((e) => e.info_hash)
+            .filter(isTruthy));
+    }
+    return new Set((await db("client_searchee").select("info_hash")).map((e) => e.info_hash));
 }
 export async function loadTorrentDirLight(torrentDir) {
     const torrentFilePaths = await findAllTorrentFilesInDir(torrentDir);
@@ -537,11 +592,135 @@ export async function loadTorrentDirLight(torrentDir) {
     for (const torrentFilePath of torrentFilePaths) {
         const searcheeResult = await createSearcheeFromTorrentFile(torrentFilePath, torrentInfos);
         if (searcheeResult.isOk()) {
-            searchees.push(searcheeResult.unwrap());
+            searchees.push({
+                ...searcheeResult.unwrap(),
+                path: torrentFilePath,
+            });
         }
     }
     return searchees;
 }
+function createTorrentFileFingerprint(filePath, stats) {
+    return JSON.stringify({
+        path: filePath,
+        size: stats.size,
+        mtimeMs: stats.mtimeMs,
+    });
+}
+function createSearcheeFromTorrentLibraryItem(row) {
+    if (!row.info_hash || !row.path)
+        return null;
+    return {
+        infoHash: row.info_hash,
+        path: row.path,
+        name: row.name,
+        title: row.title,
+        files: JSON.parse(row.files),
+        length: row.length,
+        category: row.category ?? undefined,
+        tags: row.tags ? JSON.parse(row.tags) : undefined,
+        trackers: row.trackers
+            ? JSON.parse(row.trackers)
+            : undefined,
+    };
+}
+async function getTorrentLibraryEntries() {
+    const rows = await db("library_item")
+        .where({
+        source: LibraryItemSource.TORRENT,
+        missing_since: null,
+    })
+        .whereNotNull("path")
+        .select("title", "name", "path", "info_hash");
+    return rows
+        .filter((row) => row.path !== null)
+        .map((row) => ({
+        title: row.title,
+        name: row.name,
+        file_path: row.path,
+        info_hash: row.info_hash,
+    }));
+}
+async function loadTorrentDirIncremental(torrentDir, options = { includeUnchanged: true }) {
+    const scan = await beginLibraryScan({
+        source: LibraryItemSource.TORRENT,
+        sourceInstance: torrentDir,
+    });
+    try {
+        const torrentFilePaths = await findAllTorrentFilesInDir(torrentDir);
+        const sourceKeys = torrentFilePaths.map(createTorrentLibrarySourceKey);
+        const existingRows = await db("library_item")
+            .where({
+            source: LibraryItemSource.TORRENT,
+            source_instance: torrentDir,
+        })
+            .whereIn("source_key", sourceKeys)
+            .select("source_key", "info_hash", "path", "name", "title", "files", "length", "category", "tags", "trackers", "content_fingerprint", "missing_since");
+        const existingBySourceKey = new Map(existingRows.map((row) => [row.source_key, row]));
+        const searchees = [];
+        const sourceKeysSeen = [];
+        const pathsToParse = [];
+        for (const filePath of torrentFilePaths) {
+            const fingerprint = createTorrentFileFingerprint(filePath, await stat(filePath));
+            const sourceKey = createTorrentLibrarySourceKey(filePath);
+            const existing = existingBySourceKey.get(sourceKey);
+            if (existing &&
+                existing.missing_since === null &&
+                existing.content_fingerprint === fingerprint) {
+                const searchee = createSearcheeFromTorrentLibraryItem(existing);
+                if (searchee) {
+                    if (options.includeUnchanged)
+                        searchees.push(searchee);
+                    sourceKeysSeen.push(sourceKey);
+                    continue;
+                }
+            }
+            pathsToParse.push({ filePath, fingerprint });
+        }
+        const client = getClients()[0];
+        let torrentInfos = [];
+        if (pathsToParse.length &&
+            client &&
+            client.clientType !== Label.QBITTORRENT) {
+            try {
+                torrentInfos = await client.getAllTorrents();
+            }
+            catch (error) {
+                logger.warn({
+                    label: Label.INDEX,
+                    message: `Client metadata unavailable; indexing torrent files without it: ${errorMessage(error)}`,
+                });
+            }
+        }
+        const itemsToUpsert = [];
+        for (const { filePath, fingerprint } of pathsToParse) {
+            const searcheeResult = await createSearcheeFromTorrentFile(filePath, torrentInfos);
+            if (searcheeResult.isOk()) {
+                const searchee = {
+                    ...searcheeResult.unwrap(),
+                    path: filePath,
+                };
+                searchees.push(searchee);
+                itemsToUpsert.push(createTorrentLibraryItemInput(searchee, filePath, torrentDir, {
+                    contentFingerprint: fingerprint,
+                }));
+            }
+        }
+        await syncLibraryItems({
+            scanId: scan.id,
+            source: LibraryItemSource.TORRENT,
+            sourceInstance: torrentDir,
+            itemsToUpsert,
+            sourceKeysSeen,
+            pruneMissing: true,
+        });
+        return searchees;
+    }
+    catch (error) {
+        await failLibraryScan(scan.id, error);
+        throw error;
+    }
+}
 function getKeysFromName(stem) {
     const episodeKeys = getEpisodeKeys(stem);
     if (episodeKeys) {
@@ -591,24 +770,24 @@ export async function getSimilarByName(name) {
     }
     const candidateMaxDistance = Math.floor(Math.min(...keyTitles.map((t) => t.length)) / LEVENSHTEIN_DIVISOR);
     const filterEntries = async (dbEntries) => {
-        return filterAsyncYield(dbEntries, async (dbEntry) => {
+        return filterAsyncYield(dbEntries, (dbEntry) => {
             const entry = getKeysFromName(dbEntry.title ?? dbEntry.name);
             if (entry.element !== element)
-                return false;
+                return Promise.resolve(false);
             if (!entry.keyTitles.length)
-                return false;
+                return Promise.resolve(false);
             const maxDistance = Math.min(candidateMaxDistance, Math.floor(Math.min(...entry.keyTitles.map((t) => t.length)) /
                 LEVENSHTEIN_DIVISOR));
-            return entry.keyTitles.some((dbKeyTitle) => {
+            return Promise.resolve(entry.keyTitles.some((dbKeyTitle) => {
                 return keyTitles.some((keyTitle) => distance(keyTitle, dbKeyTitle) <= maxDistance);
-            });
+            }));
         });
     };
     if (useClientTorrents) {
         clientSearchees.push(...(await filterEntries(await db("client_searchee"))).map(createSearcheeFromDB));
     }
     else if (torrentDir) {
-        const filteredTorrentEntries = (await filterEntries(await db("torrent").select("name", "file_path")));
+        const filteredTorrentEntries = (await filterEntries(await getTorrentLibraryEntries()));
         if (filteredTorrentEntries.length) {
             const client = getClients()[0];
             const torrentInfos = client && client.clientType !== Label.QBITTORRENT
@@ -646,23 +825,23 @@ async function getTorrentByFuzzyName(stem) {
     const { useClientTorrents } = getRuntimeConfig();
     const database = useClientTorrents
         ? await db("client_searchee")
-        : await db("torrent");
+        : await getTorrentLibraryEntries();
     const fullMatch = createKeyTitle(stem);
     // Attempt to filter torrents in DB to match incoming data before fuzzy check
     let filteredNames = [];
     if (fullMatch) {
-        filteredNames = await filterAsyncYield(database, async (dbEntry) => {
+        filteredNames = await filterAsyncYield(database, (dbEntry) => {
             const dbMatch = createKeyTitle(stripExtension(dbEntry.title ?? dbEntry.name));
-            return fullMatch === dbMatch;
+            return Promise.resolve(fullMatch === dbMatch);
         });
     }
     // If none match, proceed with fuzzy name check on all names.
     filteredNames = filteredNames.length > 0 ? filteredNames : database;
     const candidateMaxDistance = Math.floor(stem.length / LEVENSHTEIN_DIVISOR);
-    const potentialMatches = await filterAsyncYield(filteredNames, async (dbEntry) => {
+    const potentialMatches = await filterAsyncYield(filteredNames, (dbEntry) => {
         const dbTitle = stripExtension(dbEntry.title ?? dbEntry.name);
         const maxDistance = Math.min(candidateMaxDistance, Math.floor(dbTitle.length / LEVENSHTEIN_DIVISOR));
-        return distance(stem, dbTitle) <= maxDistance;
+        return Promise.resolve(distance(stem, dbTitle) <= maxDistance);
     });
     if (useClientTorrents)
         return potentialMatches.map(createSearcheeFromDB);
@@ -676,8 +855,11 @@ async function getTorrentByFuzzyName(stem) {
 }
 export async function getTorrentByCriteria(criteria) {
     const { useClientTorrents } = getRuntimeConfig();
-    const database = useClientTorrents ? db("client_searchee") : db("torrent");
-    const dbTorrents = await database.where((b) => b.where({ info_hash: criteria.infoHash }));
+    const dbTorrents = useClientTorrents
+        ? await db("client_searchee").where({
+            info_hash: criteria.infoHash,
+        })
+        : (await getTorrentLibraryEntries()).filter((entry) => entry.info_hash === criteria.infoHash);
     if (!dbTorrents.length) {
         const message = `Torrent client does not have any torrent with criteria ${inspect(criteria)}`;
         throw new Error(message);
@@ -688,8 +870,13 @@ export async function getTorrentByCriteria(criteria) {
     const torrentInfos = client && client.clientType !== Label.QBITTORRENT
         ? await client.getAllTorrents()
         : [];
+    const torrentRow = dbTorrents[0];
+    const searchee = (await createSearcheeFromTorrentFile(torrentRow.file_path, torrentInfos)).unwrapOrThrow(new Error(`Failed to create searchee from ${torrentRow.file_path}`));
     return [
-        (await createSearcheeFromTorrentFile(dbTorrents[0].file_path, torrentInfos)).unwrapOrThrow(new Error(`Failed to create searchee from ${dbTorrents[0].file_path}`)),
+        {
+            ...searchee,
+            path: torrentRow.file_path,
+        },
     ];
 }
 //# sourceMappingURL=torrent.js.map