cross-seed 6.11.1 → 6.12.0-0

package/dist/action.js

@@ -1,142 +1,54 @@
 import chalk from "chalk";
 import fs from "fs";
 import { dirname, join, resolve } from "path";
-import { getClient, shouldRecheck } from "./clients/TorrentClient.js";
+import { getClients, shouldRecheck, } from "./clients/TorrentClient.js";
 import { Action, ALL_EXTENSIONS, Decision, InjectionResult, LinkType, SaveResult, } from "./constants.js";
 import { CrossSeedError } from "./errors.js";
 import { Label, logger } from "./logger.js";
 import { resultOf, resultOfErr } from "./Result.js";
 import { getRuntimeConfig } from "./runtimeConfig.js";
-import { createSearcheeFromPath, getAbsoluteFilePath, getRootFolder, getSearcheeSource, getSourceRoot, } from "./searchee.js";
+import { createSearcheeFromPath, getRoot, getRootFolder, getSearcheeSource, } from "./searchee.js";
 import { saveTorrentFile } from "./torrent.js";
-import { findAFileWithExt, formatAsList, getLogString, getMediaType, } from "./utils.js";
+import { findAFileWithExt, formatAsList, getLogString, getMediaType, Mutex, withMutex, } from "./utils.js";
+const srcTestName = "test.cross-seed";
 const linkTestName = "cross-seed.test";
-function logActionResult(result, newMeta, searchee, tracker, decision) {
-    const metaLog = getLogString(newMeta, chalk.green.bold);
-    const searcheeLog = getLogString(searchee, chalk.magenta.bold);
-    const source = `${getSearcheeSource(searchee)} (${searcheeLog})`;
-    const foundBy = `Found ${metaLog} on ${chalk.bold(tracker)} by`;
-    let infoOrVerbose = logger.info;
-    let warnOrVerbose = logger.warn;
-    if (searchee.label === Label.INJECT) {
-        infoOrVerbose = logger.verbose;
-        warnOrVerbose = logger.verbose;
-    }
-    switch (result) {
-        case SaveResult.SAVED:
-            infoOrVerbose({
-                label: searchee.label,
-                message: `${foundBy} ${chalk.green.bold(decision)} from ${source} - saved`,
-            });
-            break;
-        case InjectionResult.SUCCESS:
-            infoOrVerbose({
-                label: searchee.label,
-                message: `${foundBy} ${chalk.green.bold(decision)} from ${source} - injected`,
-            });
-            break;
-        case InjectionResult.ALREADY_EXISTS:
-            infoOrVerbose({
-                label: searchee.label,
-                message: `${foundBy} ${chalk.yellow(decision)} from ${source} - exists`,
-            });
-            break;
-        case InjectionResult.TORRENT_NOT_COMPLETE:
-            warnOrVerbose({
-                label: searchee.label,
-                message: `${foundBy} ${chalk.yellow(decision)} from ${source} - incomplete torrent, saving...`,
-            });
-            break;
-        case InjectionResult.FAILURE:
-        default:
-            logger.error({
-                label: searchee.label,
-                message: `${foundBy} ${chalk.red(decision)} from ${source} - failed to inject, saving...`,
-            });
-            break;
-    }
-}
-/**
- * @return the root of linked files.
- */
-function linkExactTree(newMeta, destinationDir, sourceRoot, options) {
-    let alreadyExisted = false;
-    let linkedNewFiles = false;
-    for (const newFile of newMeta.files) {
-        const srcFilePath = getAbsoluteFilePath(sourceRoot, newFile.path);
-        const destFilePath = join(destinationDir, newFile.path);
-        if (fs.existsSync(destFilePath)) {
-            alreadyExisted = true;
-            continue;
-        }
-        if (options.ignoreMissing && !fs.existsSync(srcFilePath))
-            continue;
-        const destFileParentPath = dirname(destFilePath);
-        if (!fs.existsSync(destFileParentPath)) {
-            fs.mkdirSync(destFileParentPath, { recursive: true });
-        }
-        if (linkFile(srcFilePath, destFilePath)) {
-            linkedNewFiles = true;
-        }
-    }
-    const contentPath = join(destinationDir, newMeta.name);
-    return { contentPath, alreadyExisted, linkedNewFiles };
-}
-/**
- * @return the root of linked files.
- */
-function linkFuzzyTree(searchee, newMeta, destinationDir, sourceRoot, options) {
-    let alreadyExisted = false;
-    let linkedNewFiles = false;
+function linkAllFilesInMetafile(searchee, newMeta, decision, destinationDir, options) {
     const availableFiles = searchee.files.slice();
-    for (const newFile of newMeta.files) {
-        let matchedSearcheeFiles = availableFiles.filter((searcheeFile) => searcheeFile.length === newFile.length);
-        if (matchedSearcheeFiles.length > 1) {
-            matchedSearcheeFiles = matchedSearcheeFiles.filter((searcheeFile) => searcheeFile.name === newFile.name);
-        }
-        if (matchedSearcheeFiles.length) {
-            const srcFilePath = getAbsoluteFilePath(sourceRoot, matchedSearcheeFiles[0].path);
-            const destFilePath = join(destinationDir, newFile.path);
+    const paths = decision === Decision.MATCH && options.savePath
+        ? newMeta.files.map((file) => [
+            join(options.savePath, file.path),
+            join(destinationDir, file.path),
+        ])
+        : newMeta.files.reduce((acc, newFile) => {
+            let matchedSearcheeFiles = availableFiles.filter((searcheeFile) => searcheeFile.length === newFile.length);
+            if (matchedSearcheeFiles.length > 1) {
+                matchedSearcheeFiles = matchedSearcheeFiles.filter((searcheeFile) => searcheeFile.name === newFile.name);
+            }
+            if (!matchedSearcheeFiles.length)
+                return acc;
             const index = availableFiles.indexOf(matchedSearcheeFiles[0]);
             availableFiles.splice(index, 1);
-            if (fs.existsSync(destFilePath)) {
-                alreadyExisted = true;
-                continue;
-            }
-            if (options.ignoreMissing && !fs.existsSync(srcFilePath))
-                continue;
-            const destFileParentPath = dirname(destFilePath);
-            if (!fs.existsSync(destFileParentPath)) {
-                fs.mkdirSync(destFileParentPath, { recursive: true });
-            }
-            if (linkFile(srcFilePath, destFilePath)) {
-                linkedNewFiles = true;
-            }
-        }
-    }
-    const contentPath = join(destinationDir, newMeta.name);
-    return { contentPath, alreadyExisted, linkedNewFiles };
-}
-function linkVirtualSearchee(searchee, newMeta, destinationDir, options) {
+            const srcFilePath = options.savePath
+                ? join(options.savePath, matchedSearcheeFiles[0].path)
+                : matchedSearcheeFiles[0].path; // Absolute path
+            acc.push([srcFilePath, join(destinationDir, newFile.path)]);
+            return acc;
+        }, []);
     let alreadyExisted = false;
     let linkedNewFiles = false;
-    const availableFiles = searchee.files.slice();
-    for (const newFile of newMeta.files) {
-        let matchedSearcheeFiles = availableFiles.filter((searcheeFile) => searcheeFile.length === newFile.length);
-        if (matchedSearcheeFiles.length > 1) {
-            matchedSearcheeFiles = matchedSearcheeFiles.filter((searcheeFile) => searcheeFile.name === newFile.name);
-        }
-        if (matchedSearcheeFiles.length) {
-            const srcFilePath = matchedSearcheeFiles[0].path; // Absolute path
-            const destFilePath = join(destinationDir, newFile.path);
-            const index = availableFiles.indexOf(matchedSearcheeFiles[0]);
-            availableFiles.splice(index, 1);
+    try {
+        const validPaths = paths.filter(([srcFilePath, destFilePath]) => {
             if (fs.existsSync(destFilePath)) {
                 alreadyExisted = true;
-                continue;
+                return false;
             }
-            if (options.ignoreMissing && !fs.existsSync(srcFilePath))
-                continue;
+            if (fs.existsSync(srcFilePath))
+                return true;
+            if (options.ignoreMissing)
+                return false;
+            throw new Error(`Linking failed, ${srcFilePath} not found.`);
+        });
+        for (const [srcFilePath, destFilePath] of validPaths) {
             const destFileParentPath = dirname(destFilePath);
             if (!fs.existsSync(destFileParentPath)) {
                 fs.mkdirSync(destFileParentPath, { recursive: true });
@@ -146,66 +58,35 @@ function linkVirtualSearchee(searchee, newMeta, destinationDir, options) {
             }
         }
     }
-    const contentPath = join(destinationDir, newMeta.name);
-    return { contentPath, alreadyExisted, linkedNewFiles };
+    catch (e) {
+        return resultOfErr(e);
+    }
+    return resultOf({ alreadyExisted, linkedNewFiles });
 }
 function unlinkMetafile(meta, destinationDir) {
-    const fullPath = join(destinationDir, getRootFolder(meta.files[0]));
-    if (!fs.existsSync(fullPath))
-        return;
-    if (!fullPath.startsWith(destinationDir))
-        return; // assert: fullPath is within destinationDir
-    if (fs.statSync(fullPath).ino === fs.statSync(destinationDir).ino)
-        return; // assert: fullPath is not destinationDir
-    logger.verbose(`Unlinking ${fullPath}`);
-    fs.rmSync(fullPath, { recursive: true });
-}
-export async function linkAllFilesInMetafile(searchee, newMeta, tracker, decision, options) {
-    const { flatLinking } = getRuntimeConfig();
-    const client = getClient();
-    let sourceRoot;
-    if (searchee.infoHash) {
-        let savePath;
-        if (searchee.savePath) {
-            const refreshedSearchee = (await client.getClientSearchees({
-                newSearcheesOnly: true,
-                refresh: [searchee.infoHash],
-            })).newSearchees.find((s) => s.infoHash === searchee.infoHash);
-            if (!refreshedSearchee)
-                return resultOfErr("TORRENT_NOT_FOUND");
-            for (const [key, value] of Object.entries(refreshedSearchee)) {
-                searchee[key] = value;
-            }
-            if (!(await client.isTorrentComplete(searchee.infoHash)).orElse(false)) {
-                return resultOfErr("TORRENT_NOT_COMPLETE");
-            }
-            savePath = searchee.savePath;
-        }
-        else {
-            const downloadDirResult = await client.getDownloadDir(searchee, { onlyCompleted: options.onlyCompleted });
-            if (downloadDirResult.isErr()) {
-                return downloadDirResult.mapErr((e) => e === "NOT_FOUND" || e === "UNKNOWN_ERROR"
-                    ? "TORRENT_NOT_FOUND"
-                    : e);
-            }
-            savePath = downloadDirResult.unwrap();
-        }
-        sourceRoot = getSourceRoot(searchee, savePath);
-        if (!fs.existsSync(sourceRoot)) {
-            logger.error({
-                label: searchee.label,
-                message: `Linking failed, ${sourceRoot} not found. Make sure Docker volume mounts are set up properly.`,
-            });
-            return resultOfErr("MISSING_DATA");
-        }
+    const destinationDirIno = fs.statSync(destinationDir).ino;
+    const roots = meta.files.map((file) => join(destinationDir, getRoot(file)));
+    for (const root of roots) {
+        if (!fs.existsSync(root))
+            continue;
+        if (!root.startsWith(destinationDir))
+            continue; // assert: root is within destinationDir
+        if (resolve(root) === resolve(destinationDir))
+            continue; // assert: root is not destinationDir
+        if (fs.statSync(root).ino === destinationDirIno)
+            continue; // assert: root is not destinationDir
+        logger.verbose(`Unlinking ${root}`);
+        fs.rmSync(root, { recursive: true });
     }
-    else if (searchee.path) {
+}
+async function getSavePath(client, searchee, options) {
+    if (searchee.path) {
         if (!fs.existsSync(searchee.path)) {
             logger.error({
                 label: searchee.label,
-                message: `Linking failed, ${searchee.path} not found. Make sure Docker volume mounts are set up properly.`,
+                message: `Linking failed, ${searchee.path} not found.`,
             });
-            return resultOfErr("MISSING_DATA");
+            return resultOfErr("INVALID_DATA");
         }
         const result = await createSearcheeFromPath(searchee.path);
         if (result.isErr()) {
@@ -217,13 +98,13 @@ export async function linkAllFilesInMetafile(searchee, newMeta, tracker, decisio
                 searchee.length !== refreshedSearchee.length)) {
             return resultOfErr("TORRENT_NOT_COMPLETE");
         }
-        sourceRoot = searchee.path;
+        return resultOf(dirname(searchee.path));
     }
-    else {
+    else if (!searchee.infoHash) {
         for (const file of searchee.files) {
             if (!fs.existsSync(file.path)) {
-                logger.error(`Linking failed, ${file.path} not found. Make sure Docker volume mounts are set up properly.`);
-                return resultOfErr("MISSING_DATA");
+                logger.error(`Linking failed, ${file.path} not found.`);
+                return resultOfErr("INVALID_DATA");
             }
             if (options.onlyCompleted) {
                 const f = fs.statSync(file.path);
@@ -232,89 +113,296 @@ export async function linkAllFilesInMetafile(searchee, newMeta, tracker, decisio
                 }
             }
         }
+        return resultOf(undefined);
     }
+    let savePath;
+    if (searchee.savePath) {
+        const refreshedSearchee = (await client.getClientSearchees({
+            newSearcheesOnly: true,
+            refresh: [searchee.infoHash],
+        })).newSearchees.find((s) => s.infoHash === searchee.infoHash);
+        if (!refreshedSearchee)
+            return resultOfErr("TORRENT_NOT_FOUND");
+        for (const [key, value] of Object.entries(refreshedSearchee)) {
+            searchee[key] = value;
+        }
+        if (!(await client.isTorrentComplete(searchee.infoHash)).orElse(false)) {
+            return resultOfErr("TORRENT_NOT_COMPLETE");
+        }
+        savePath = searchee.savePath;
+    }
+    else {
+        const downloadDirResult = await client.getDownloadDir(searchee, { onlyCompleted: options.onlyCompleted });
+        if (downloadDirResult.isErr()) {
+            return downloadDirResult.mapErr((e) => e === "NOT_FOUND" || e === "UNKNOWN_ERROR"
+                ? "TORRENT_NOT_FOUND"
+                : e);
+        }
+        savePath = downloadDirResult.unwrap();
+    }
+    const rootFolder = getRootFolder(searchee.files[0]);
+    const sourceRootOrSavePath = searchee.files.length === 1
+        ? join(savePath, searchee.files[0].path)
+        : rootFolder
+            ? join(savePath, rootFolder)
+            : savePath;
+    if (!fs.existsSync(sourceRootOrSavePath)) {
+        logger.error({
+            label: searchee.label,
+            message: `Linking failed, ${sourceRootOrSavePath} not found.`,
+        });
+        return resultOfErr("INVALID_DATA");
+    }
+    return resultOf(savePath);
+}
+async function getClientAndDestinationDir(client, searchee, savePath, newMeta, tracker) {
+    const { flatLinking, linkType } = getRuntimeConfig();
+    if (!client) {
+        let srcPath;
+        let srcDev;
+        try {
+            srcPath = !savePath
+                ? searchee.files.find((f) => fs.existsSync(f.path)).path
+                : join(savePath, searchee.files.find((f) => fs.existsSync(join(savePath, f.path))).path);
+            srcDev = fs.statSync(srcPath).dev;
+        }
+        catch (e) {
+            logger.debug(e);
+            return null;
+        }
+        let error;
+        for (const testClient of getClients().filter((c) => !c.readonly)) {
+            const torrentSavePaths = new Set((await testClient.getAllDownloadDirs({
+                metas: [],
+                onlyCompleted: false,
+            })).values());
+            for (const torrentSavePath of torrentSavePaths) {
+                try {
+                    if (srcDev && fs.statSync(torrentSavePath).dev === srcDev) {
+                        client = testClient;
+                        break;
+                    }
+                    const testPath = join(torrentSavePath, linkTestName);
+                    linkFile(srcPath, testPath, linkType === LinkType.REFLINK
+                        ? linkType
+                        : LinkType.HARDLINK);
+                    fs.rmSync(testPath);
+                    client = testClient;
+                    break;
+                }
+                catch (e) {
+                    error = e;
+                }
+            }
+            if (client)
+                break;
+        }
+        if (!client) {
+            logger.debug(error);
+            return null;
+        }
+    }
+    let destinationDir;
     const clientSavePathRes = await client.getDownloadDir(newMeta, {
         onlyCompleted: false,
     });
-    let destinationDir = null;
     if (clientSavePathRes.isOk()) {
         destinationDir = clientSavePathRes.unwrap();
     }
     else {
-        const linkDir = sourceRoot
-            ? getLinkDir(sourceRoot)
+        if (clientSavePathRes.unwrapErr() === "INVALID_DATA") {
+            return null;
+        }
+        const linkDir = savePath
+            ? getLinkDir(savePath)
             : getLinkDirVirtual(searchee);
         if (!linkDir)
-            return resultOfErr("MISSING_DATA");
+            return null;
         destinationDir = flatLinking ? linkDir : join(linkDir, tracker);
     }
-    if (!sourceRoot) {
-        return resultOf(linkVirtualSearchee(searchee, newMeta, destinationDir, {
-            ignoreMissing: !options.onlyCompleted,
-        }));
-    }
-    else if (decision === Decision.MATCH) {
-        return resultOf(linkExactTree(newMeta, destinationDir, sourceRoot, {
-            ignoreMissing: !options.onlyCompleted,
-        }));
+    return { client, destinationDir };
+}
+function logActionResult(result, newMeta, searchee, tracker, decision) {
+    const metaLog = getLogString(newMeta, chalk.green.bold);
+    const searcheeLog = getLogString(searchee, chalk.magenta.bold);
+    const source = `${getSearcheeSource(searchee)} (${searcheeLog})`;
+    const foundBy = `Found ${metaLog} on ${chalk.bold(tracker)} by`;
+    let infoOrVerbose = logger.info;
+    let warnOrVerbose = logger.warn;
+    if (searchee.label === Label.INJECT) {
+        infoOrVerbose = logger.verbose;
+        warnOrVerbose = logger.verbose;
     }
-    else {
-        return resultOf(linkFuzzyTree(searchee, newMeta, destinationDir, sourceRoot, {
-            ignoreMissing: !options.onlyCompleted,
-        }));
+    switch (result) {
+        case SaveResult.SAVED:
+            infoOrVerbose({
+                label: searchee.label,
+                message: `${foundBy} ${chalk.green.bold(decision)} from ${source} - saved`,
+            });
+            break;
+        case InjectionResult.SUCCESS:
+            infoOrVerbose({
+                label: searchee.label,
+                message: `${foundBy} ${chalk.green.bold(decision)} from ${source} - injected`,
+            });
+            break;
+        case InjectionResult.ALREADY_EXISTS:
+            infoOrVerbose({
+                label: searchee.label,
+                message: `${foundBy} ${chalk.yellow(decision)} from ${source} - exists`,
+            });
+            break;
+        case InjectionResult.TORRENT_NOT_COMPLETE:
+            warnOrVerbose({
+                label: searchee.label,
+                message: `${foundBy} ${chalk.yellow(decision)} from ${source} - source is incomplete, saving...`,
+            });
+            break;
+        case InjectionResult.FAILURE:
+        default:
+            logger.error({
+                label: searchee.label,
+                message: `${foundBy} ${chalk.red(decision)} from ${source} - failed to inject, saving...`,
+            });
+            break;
     }
 }
 export async function performAction(newMeta, decision, searchee, tracker) {
+    return withMutex(Mutex.CLIENT_INJECTION, async () => {
+        return performActionWithoutMutex(newMeta, decision, searchee, tracker);
+    }, { useQueue: true });
+}
+export async function performActionWithoutMutex(newMeta, decision, searchee, tracker, injectClient, options = { onlyCompleted: true }) {
     const { action, linkDirs } = getRuntimeConfig();
     if (action === Action.SAVE) {
-        await saveTorrentFile(tracker, getMediaType(searchee), newMeta);
         logActionResult(SaveResult.SAVED, newMeta, searchee, tracker, decision);
-        return { actionResult: SaveResult.SAVED, linkedNewFiles: false };
+        await saveTorrentFile(tracker, getMediaType(newMeta), newMeta);
+        return { actionResult: SaveResult.SAVED };
     }
+    let savePath;
     let destinationDir;
     let unlinkOk = false;
     let linkedNewFiles = false;
+    const warnOrVerbose = searchee.label !== Label.INJECT ? logger.warn : logger.verbose;
+    const clients = getClients();
+    let client = clients.length === 1
+        ? clients[0]
+        : clients.find((c) => c.clientHost === searchee.clientHost && !c.readonly);
     if (linkDirs.length) {
-        const linkedFilesRootResult = await linkAllFilesInMetafile(searchee, newMeta, tracker, decision, { onlyCompleted: true });
-        if (linkedFilesRootResult.isOk()) {
-            const linkResult = linkedFilesRootResult.unwrap();
-            destinationDir = dirname(linkResult.contentPath);
-            unlinkOk = !linkResult.alreadyExisted;
-            linkedNewFiles = linkResult.linkedNewFiles;
+        const savePathRes = await getSavePath(client, searchee, options);
+        if (savePathRes.isErr()) {
+            const result = savePathRes.unwrapErr();
+            if (result === "TORRENT_NOT_COMPLETE") {
+                const actionResult = InjectionResult.TORRENT_NOT_COMPLETE;
+                logActionResult(actionResult, newMeta, searchee, tracker, decision);
+                await saveTorrentFile(tracker, getMediaType(newMeta), newMeta);
+                return { client, actionResult, linkedNewFiles };
+            }
+            const actionResult = InjectionResult.FAILURE;
+            logger.error({
+                label: searchee.label,
+                message: `Failed to link files for ${getLogString(newMeta)} from ${getLogString(searchee)}: ${result}`,
+            });
+            logActionResult(actionResult, newMeta, searchee, tracker, decision);
+            await saveTorrentFile(tracker, getMediaType(newMeta), newMeta);
+            return { actionResult, linkedNewFiles };
+        }
+        savePath = savePathRes.unwrap();
+        const res = await getClientAndDestinationDir(client, searchee, savePath, newMeta, tracker);
+        if (res) {
+            client = res.client;
+            destinationDir = res.destinationDir;
         }
         else {
-            const result = linkedFilesRootResult.unwrapErr();
-            const warnOrVerbose = searchee.label !== Label.INJECT ? logger.warn : logger.verbose;
-            warnOrVerbose({
+            client = undefined;
+        }
+    }
+    if (!client) {
+        logger.error({
+            label: searchee.label,
+            message: `Failed to find a torrent client for ${getLogString(searchee)}`,
+        });
+        const actionResult = InjectionResult.FAILURE;
+        logActionResult(actionResult, newMeta, searchee, tracker, decision);
+        await saveTorrentFile(tracker, getMediaType(newMeta), newMeta);
+        return { actionResult, linkedNewFiles };
+    }
+    for (const otherClient of clients) {
+        if (otherClient.clientHost === client.clientHost)
+            continue;
+        if ((await otherClient.isTorrentComplete(newMeta.infoHash)).isErr()) {
+            continue;
+        }
+        warnOrVerbose({
+            label: searchee.label,
+            message: `Skipping ${getLogString(newMeta)} injection into ${client.clientHost} - already exists in ${otherClient.clientHost}`,
+        });
+        const actionResult = InjectionResult.FAILURE;
+        logActionResult(actionResult, newMeta, searchee, tracker, decision);
+        return { actionResult, linkedNewFiles };
+    }
+    if (injectClient && injectClient.clientHost !== client.clientHost) {
+        warnOrVerbose({
+            label: searchee.label,
+            message: `Skipping ${getLogString(newMeta)} injection into ${client.clientHost} - existing match is using ${injectClient.clientHost}`,
+        });
+        const actionResult = InjectionResult.FAILURE;
+        logActionResult(actionResult, newMeta, searchee, tracker, decision);
+        return { actionResult, linkedNewFiles };
+    }
+    if (linkDirs.length) {
+        const res = linkAllFilesInMetafile(searchee, newMeta, decision, destinationDir, { savePath, ignoreMissing: !options.onlyCompleted });
+        if (res.isErr()) {
+            logger.error({
                 label: searchee.label,
-                message: `Failed to link files for ${getLogString(newMeta)}: ${result}`,
+                message: `Failed to link files for ${getLogString(newMeta)} from ${getLogString(searchee)}: ${res.unwrapErr().message}`,
             });
-            const injectionResult = result === "TORRENT_NOT_COMPLETE"
-                ? InjectionResult.TORRENT_NOT_COMPLETE
-                : InjectionResult.FAILURE;
-            logActionResult(injectionResult, newMeta, searchee, tracker, decision);
-            await saveTorrentFile(tracker, getMediaType(searchee), newMeta);
-            return { actionResult: injectionResult, linkedNewFiles };
+            const actionResult = InjectionResult.FAILURE;
+            logActionResult(actionResult, newMeta, searchee, tracker, decision);
+            await saveTorrentFile(tracker, getMediaType(newMeta), newMeta);
+            return { actionResult, linkedNewFiles };
         }
+        const linkResult = res.unwrap();
+        unlinkOk = !linkResult.alreadyExisted;
+        linkedNewFiles = linkResult.linkedNewFiles;
     }
     else if (searchee.path) {
         destinationDir = dirname(searchee.path);
     }
-    const result = await getClient().inject(newMeta, searchee, decision, destinationDir);
-    logActionResult(result, newMeta, searchee, tracker, decision);
-    if (result === InjectionResult.SUCCESS) {
+    const actionResult = await client.inject(newMeta, searchee, decision, {
+        onlyCompleted: options.onlyCompleted,
+        destinationDir,
+    });
+    logActionResult(actionResult, newMeta, searchee, tracker, decision);
+    if (actionResult === InjectionResult.SUCCESS) {
         // cross-seed may need to process these with the inject job
         if (shouldRecheck(searchee, decision) || !searchee.infoHash) {
-            await saveTorrentFile(tracker, getMediaType(searchee), newMeta);
+            await saveTorrentFile(tracker, getMediaType(newMeta), newMeta);
         }
     }
-    else if (result !== InjectionResult.ALREADY_EXISTS) {
-        await saveTorrentFile(tracker, getMediaType(searchee), newMeta);
+    else if (actionResult === InjectionResult.ALREADY_EXISTS) {
+        if (linkedNewFiles) {
+            logger.info({
+                label: client.label,
+                message: `Rechecking ${getLogString(newMeta)} as new files were linked from ${getLogString(searchee)}`,
+            });
+            await client.recheckTorrent(newMeta.infoHash);
+            client.resumeInjection(newMeta.infoHash, decision, {
+                checkOnce: false,
+            });
+        }
+    }
+    else {
+        await saveTorrentFile(tracker, getMediaType(newMeta), newMeta);
         if (unlinkOk && destinationDir) {
             unlinkMetafile(newMeta, destinationDir);
+            linkedNewFiles = false;
         }
     }
-    return { actionResult: result, linkedNewFiles };
+    if (actionResult === InjectionResult.FAILURE) {
+        return { actionResult, linkedNewFiles };
+    }
+    return { client, actionResult, linkedNewFiles };
 }
 export async function performActions(searchee, matches) {
     const results = [];
@@ -334,11 +422,24 @@ export function getLinkDir(pathStr) {
                 return linkDir;
         }
     }
-    const srcFile = pathStat.isFile()
+    let srcFile = pathStat.isFile()
         ? pathStr
         : pathStat.isDirectory()
             ? findAFileWithExt(pathStr, ALL_EXTENSIONS)
             : null;
+    let tempFile;
+    if (!srcFile) {
+        tempFile = pathStat.isDirectory()
+            ? join(pathStr, srcTestName)
+            : join(dirname(pathStr), srcTestName);
+        try {
+            fs.writeFileSync(tempFile, "");
+            srcFile = tempFile;
+        }
+        catch (e) {
+            logger.debug(e);
+        }
+    }
     if (srcFile) {
         for (const linkDir of linkDirs) {
             try {
@@ -347,6 +448,8 @@ export function getLinkDir(pathStr) {
                     ? linkType
                     : LinkType.HARDLINK);
                 fs.rmSync(testPath);
+                if (tempFile && fs.existsSync(tempFile))
+                    fs.rmSync(tempFile);
                 return linkDir;
             }
             catch {
@@ -354,6 +457,8 @@ export function getLinkDir(pathStr) {
             }
         }
     }
+    if (tempFile && fs.existsSync(tempFile))
+        fs.rmSync(tempFile);
     if (linkType !== LinkType.SYMLINK) {
         logger.error(`Cannot find any linkDir from linkDirs on the same drive to ${linkType} ${pathStr}`);
         return null;
@@ -423,10 +528,21 @@ function unwrapSymlinks(path) {
  */
 export function testLinking(srcDir) {
     const { linkDirs, linkType } = getRuntimeConfig();
+    let tempFile;
     try {
-        const srcFile = findAFileWithExt(srcDir, ALL_EXTENSIONS);
-        if (!srcFile)
-            return;
+        let srcFile = findAFileWithExt(srcDir, ALL_EXTENSIONS);
+        if (!srcFile) {
+            tempFile = join(srcDir, srcTestName);
+            try {
+                fs.writeFileSync(tempFile, "");
+                srcFile = tempFile;
+            }
+            catch (e) {
+                logger.error(e);
+                logger.error(`Failed to create test file in ${srcDir}, cross-seed is unable to verify linking for this path.`);
+                return;
+            }
+        }
         const linkDir = getLinkDir(srcDir);
         if (!linkDir)
             throw new Error(`No valid linkDir found for ${srcDir}`);
@@ -438,5 +554,9 @@ export function testLinking(srcDir) {
         logger.error(e);
         throw new CrossSeedError(`Failed to create a test ${linkType} from ${srcDir} in any linkDirs: [${formatAsList(linkDirs.map((d) => `"${d}"`), { sort: false, style: "short", type: "unit" })}]. Ensure that ${linkType} is supported between these paths (hardlink/reflink requires same drive, partition, and volume).`);
     }
+    finally {
+        if (tempFile && fs.existsSync(tempFile))
+            fs.rmSync(tempFile);
+    }
 }
 //# sourceMappingURL=action.js.map