Harden auth, add AI smart-search and post-download organization
Security & correctness hardening: - Gate /__api/token/auth behind auth and self-scope every handler to the caller (was fully unauthenticated — account-takeover hole). - Escape LDAP filter values (injection) and reject empty-password binds. - Enforce per-torrent ownership so private torrents aren't exposed via IDOR. - Assorted cleanup: fix 'use static' typos, drop dead Torrent.migrate + the getTorrentData noUpdate flag, Buffer.alloc, __dirname-relative reads, res.statusCode in the error handler, const-scope pubsub. Login-gated proxy + anti-indexing: - Block all proxying for logged-out users via an auth-token cookie the front end mirrors from its token; serve a local login page instead of hitting TPB. - robots.txt disallow-all + X-Robots-Tag noindex. Torrent category: - Store a normalized category (TV/Movie/Music/Adult/App/Game/Other) mapped from the TPB category id; captured at add time (migration). Smart Search (movies/TV): - New /__api/search: TMDB title confirm -> scrape piratebay.party HTML -> Ollama ranks releases against quality prefs (x265/1080p/~1.5GB/subs, prefer uncut) returning a recommended pick, optional warned 4K, and other editions. Front-end Smart Search box + dialog feeding the existing add flow. Post-download organization -> Emby (public Movie/TV only): - Completion watcher files finished torrents: Ollama parses the release name, TMDB canonicalizes title/year, files main video (+subs) into the library with edition/quality-aware names (movies + TV SxxExx), stops seeding, and triggers an Emby library scan. Low-confidence matches are flagged, not mis-filed; correctable via "Fix match". Adds organizedAt/metadata columns. Shared helpers: controller/tmdb.js, controller/ollama.js. Config blocks for tmdb/ollama/search/emby/library/organize (secrets stay in gitignored secrets.js). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,19 @@
|
||||
'use strict';
|
||||
|
||||
const conf = require('>/conf');
|
||||
|
||||
// Ask Emby to (re)scan its libraries so a newly filed item gets indexed.
|
||||
async function refresh(){
|
||||
let res = await fetch(`${conf.emby.url}/Library/Refresh?api_key=${conf.emby.apiKey}`, {
|
||||
method: 'POST',
|
||||
});
|
||||
if(!res.ok){
|
||||
let error = new Error('EmbyError');
|
||||
error.message = `Emby library refresh failed( ${res.status})`;
|
||||
error.status = 502;
|
||||
throw error;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
module.exports = { refresh };
|
||||
@@ -4,4 +4,5 @@ module.exports = {
|
||||
auth: require('./auth'),
|
||||
pubsub: require('./pubsub'),
|
||||
torrent: require('./torrent'),
|
||||
organizeWatcher: require('./organizeWatcher'),
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
'use strict';
|
||||
|
||||
const conf = require('>/conf');
|
||||
|
||||
// Pull the first JSON object out of a model response( tolerates ```json fences / prose).
|
||||
function extractJSON(content){
|
||||
let text = String(content).replace(/```json/gi, '').replace(/```/g, '').trim();
|
||||
let start = text.indexOf('{');
|
||||
let end = text.lastIndexOf('}');
|
||||
if(start === -1 || end === -1) throw new Error('No JSON in model response');
|
||||
return JSON.parse(text.slice(start, end + 1));
|
||||
}
|
||||
|
||||
// One-shot JSON chat against the Ollama cloud model.
|
||||
async function chatJSON(system, user){
|
||||
let res = await fetch(`${conf.ollama.url}/api/chat`, {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Content-Type': 'application/json',
|
||||
'Authorization': `Bearer ${conf.ollama.apiKey}`,
|
||||
},
|
||||
body: JSON.stringify({
|
||||
model: conf.ollama.model,
|
||||
stream: false,
|
||||
format: 'json',
|
||||
messages: [
|
||||
{ role: 'system', content: system },
|
||||
{ role: 'user', content: user },
|
||||
],
|
||||
}),
|
||||
});
|
||||
if(!res.ok){
|
||||
let error = new Error('OllamaError');
|
||||
error.message = `Ollama chat failed( ${res.status})`;
|
||||
error.status = 502;
|
||||
throw error;
|
||||
}
|
||||
let data = await res.json();
|
||||
return extractJSON(data.message && data.message.content);
|
||||
}
|
||||
|
||||
module.exports = { chatJSON, extractJSON };
|
||||
@@ -0,0 +1,286 @@
|
||||
'use strict';
|
||||
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
const conf = require('>/conf');
|
||||
const ollama = require('>/controller/ollama');
|
||||
const tmdb = require('>/controller/tmdb');
|
||||
const emby = require('>/controller/emby');
|
||||
const ps = require('>/controller/pubsub');
|
||||
|
||||
const VIDEO_EXT = new Set(['.mkv', '.mp4', '.avi', '.m4v', '.ts', '.wmv', '.mov']);
|
||||
const SUB_EXT = new Set(['.srt', '.ass', '.ssa', '.sub', '.vtt', '.idx']);
|
||||
|
||||
function ext(name){ return path.extname(name).toLowerCase(); }
|
||||
function isVideo(name){ return VIDEO_EXT.has(ext(name)) && !/sample/i.test(name); }
|
||||
function isSub(name){ return SUB_EXT.has(ext(name)); }
|
||||
|
||||
// Strip characters that are illegal / awkward in file paths.
|
||||
function sanitize(text){
|
||||
return String(text || '').replace(/[\/\\:*?"<>|]/g, '').replace(/\s+/g, ' ').trim();
|
||||
}
|
||||
|
||||
function pad2(n){ return String(n).padStart(2, '0'); }
|
||||
|
||||
// Normalize resolution to the library's convention( 2160p/uhd -> 4k).
|
||||
function normalizeRes(res){
|
||||
res = String(res || '').toLowerCase();
|
||||
if(/2160|4k|uhd/.test(res)) return '4k';
|
||||
let m = res.match(/(480|720|1080)p?/);
|
||||
return m ? `${m[1]}p` : '';
|
||||
}
|
||||
|
||||
// "Unrated 1080p" style suffix from edition + quality.
|
||||
function qualitySuffix(meta){
|
||||
let res = normalizeRes(meta.quality && meta.quality.resolution);
|
||||
return [sanitize(meta.edition), res].filter(Boolean).join(' ');
|
||||
}
|
||||
|
||||
// --- LLM metadata extraction ----------------------------------------------
|
||||
|
||||
function buildExtractPrompt(today){
|
||||
return [
|
||||
`You are a media library organizer. Today's date is ${today}.`,
|
||||
`Given a torrent's raw release name, its coarse type (Movie or TV), and its list of`,
|
||||
`video file names, extract clean metadata for filing. Return STRICT JSON only:`,
|
||||
`{"mediaType":"movie"|"tv","title":"clean title, no year/quality/tags",`,
|
||||
`"year":"YYYY" or "","edition":"Extended|Director's Cut|Unrated|Uncut|Remastered|`,
|
||||
`Theatrical|IMAX|Redux|" (notable edition if present, else empty),`,
|
||||
`"quality":{"resolution":"2160p|1080p|720p|480p|","codec":"x265|x264|"},`,
|
||||
`"episodes":[{"file":"<exact name from the list>","season":<int>,"episode":<int>}]}`,
|
||||
`Movies: "episodes" is []. TV: one entry per video file, mapping each file to its`,
|
||||
`season/episode inferred from the file name (SxxExx, 1x02, etc.).`,
|
||||
`Do not invent data; leave a field empty or [] when unknown.`,
|
||||
].join('\n');
|
||||
}
|
||||
|
||||
async function llmExtract({ name, category, files }){
|
||||
let today = new Date().toISOString().slice(0, 10);
|
||||
let user = JSON.stringify({ name, type: category, files });
|
||||
return await ollama.chatJSON(buildExtractPrompt(today), user);
|
||||
}
|
||||
|
||||
// Parse + canonicalize. Returns a metadata object, or one carrying `organizeError`
|
||||
// (so the caller flags the torrent instead of mis-filing it).
|
||||
async function resolveMeta({ name, category, files }){
|
||||
let llm;
|
||||
try{
|
||||
llm = await llmExtract({ name, category, files });
|
||||
}catch(error){
|
||||
return { organizeError: `parse failed: ${error.message}` };
|
||||
}
|
||||
|
||||
let mediaType = llm.mediaType === 'tv' || llm.mediaType === 'movie'
|
||||
? llm.mediaType
|
||||
: (category === 'TV' ? 'tv' : 'movie');
|
||||
|
||||
if(!llm.title) return { organizeError: `could not determine a title for "${name}"` };
|
||||
|
||||
let best = await tmdb.tmdbFindBest(llm.title, llm.year, mediaType);
|
||||
if(!best) return { organizeError: `no TMDB match for "${llm.title}" (${llm.year || '?'})` };
|
||||
|
||||
return {
|
||||
mediaType,
|
||||
title: best.title,
|
||||
year: best.year,
|
||||
edition: llm.edition || '',
|
||||
quality: llm.quality || {},
|
||||
episodes: Array.isArray(llm.episodes) ? llm.episodes : [],
|
||||
tmdbId: best.tmdbId,
|
||||
imdbId: best.imdbId,
|
||||
};
|
||||
}
|
||||
|
||||
// --- Target path building --------------------------------------------------
|
||||
|
||||
// Build the destination path for one video file. `episode` is the matching entry from
|
||||
// meta.episodes (TV only).
|
||||
function buildTarget(meta, fileName, episode){
|
||||
let title = sanitize(meta.title);
|
||||
let folder = `${title} (${meta.year})`;
|
||||
let suffix = qualitySuffix(meta);
|
||||
let e = ext(fileName);
|
||||
|
||||
if(meta.mediaType === 'tv' && episode){
|
||||
let dir = path.join(conf.library.root, conf.library.tv, folder, `Season ${pad2(episode.season)}`);
|
||||
let se = `S${pad2(episode.season)}E${pad2(episode.episode)}`;
|
||||
let base = `${folder} - ${se}${suffix ? ' - ' + suffix : ''}${e}`;
|
||||
return path.join(dir, base);
|
||||
}
|
||||
|
||||
let dir = path.join(conf.library.root, conf.library.movie, folder);
|
||||
let base = `${folder}${suffix ? ' - ' + suffix : ''}${e}`;
|
||||
return path.join(dir, base);
|
||||
}
|
||||
|
||||
// If the exact target exists, disambiguate with codec then a counter.
|
||||
function resolveCollision(target, meta){
|
||||
if(!fs.existsSync(target)) return target;
|
||||
let dir = path.dirname(target);
|
||||
let e = path.extname(target);
|
||||
let baseNoExt = path.basename(target, e);
|
||||
let codec = meta.quality && meta.quality.codec ? ' ' + sanitize(meta.quality.codec) : '';
|
||||
|
||||
let candidate = path.join(dir, `${baseNoExt}${codec}${e}`);
|
||||
let n = 2;
|
||||
while(fs.existsSync(candidate)){
|
||||
candidate = path.join(dir, `${baseNoExt}${codec} (${n})${e}`);
|
||||
n++;
|
||||
}
|
||||
return candidate;
|
||||
}
|
||||
|
||||
// --- Filesystem move -------------------------------------------------------
|
||||
|
||||
async function moveFile(src, dst){
|
||||
await fs.promises.mkdir(path.dirname(dst), { recursive: true });
|
||||
try{
|
||||
await fs.promises.rename(src, dst);
|
||||
}catch(error){
|
||||
if(error.code === 'EXDEV'){
|
||||
await fs.promises.copyFile(src, dst);
|
||||
await fs.promises.unlink(src);
|
||||
}else{
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Subs that belong to a given video( same basename, ignoring a language suffix).
|
||||
function subsFor(videoName, subFiles, isMovie){
|
||||
if(isMovie) return subFiles;
|
||||
let stem = path.basename(videoName, ext(videoName)).toLowerCase();
|
||||
return subFiles.filter(s => path.basename(s, ext(s)).toLowerCase().startsWith(stem.slice(0, 20)));
|
||||
}
|
||||
|
||||
// --- Orchestration ---------------------------------------------------------
|
||||
|
||||
// File a finished torrent into the library, then remove it from Transmission and refresh
|
||||
// Emby. Returns { organized:true, ... } or { organized:false, error }.
|
||||
async function fileTorrent(torrent){
|
||||
const { Torrent } = require('>/models');
|
||||
|
||||
let info = (await Torrent.trClient.get(torrent.hashString, ['downloadDir', 'files', 'name'])).torrents[0];
|
||||
if(!info) return await flag(torrent, 'torrent not found in Transmission');
|
||||
|
||||
let downloadDir = info.downloadDir;
|
||||
let videoFiles = info.files.filter(f => isVideo(f.name));
|
||||
let subFiles = info.files.filter(f => isSub(f.name)).map(f => f.name);
|
||||
if(!videoFiles.length) return await flag(torrent, 'no video files in torrent');
|
||||
|
||||
let meta = await resolveMeta({
|
||||
name: torrent.name,
|
||||
category: torrent.category,
|
||||
files: videoFiles.map(f => f.name),
|
||||
});
|
||||
if(meta.organizeError) return await flag(torrent, meta.organizeError, meta);
|
||||
|
||||
let isMovie = meta.mediaType !== 'tv';
|
||||
// Movie: file only the largest video. TV: file every episode video.
|
||||
let toFile = isMovie
|
||||
? [videoFiles.reduce((a, b) => (b.length > a.length ? b : a))]
|
||||
: videoFiles;
|
||||
|
||||
let filed = [];
|
||||
let libraryPath = null;
|
||||
for(let vf of toFile){
|
||||
let episode = isMovie ? null : (meta.episodes.find(e => e.file === vf.name) || null);
|
||||
if(!isMovie && !episode) continue; // can't place an episode we couldn't map
|
||||
|
||||
let dst = resolveCollision(buildTarget(meta, vf.name, episode), meta);
|
||||
await moveFile(path.join(downloadDir, vf.name), dst);
|
||||
filed.push({ path: dst, season: episode ? episode.season : null, episode: episode ? episode.episode : null });
|
||||
libraryPath = path.dirname(dst);
|
||||
|
||||
// carry matching sidecar subtitles, renamed to the video's base name
|
||||
let dstBase = path.basename(dst, ext(dst));
|
||||
for(let sub of subsFor(vf.name, subFiles, isMovie)){
|
||||
try{
|
||||
await moveFile(path.join(downloadDir, sub), path.join(path.dirname(dst), dstBase + ext(sub)));
|
||||
}catch(error){ /* subs are best-effort */ }
|
||||
}
|
||||
}
|
||||
|
||||
if(!filed.length) return await flag(torrent, 'could not map any video files to episodes', meta);
|
||||
|
||||
// Move + stop seeding: drop the torrent and delete whatever download data is left.
|
||||
try{ await Torrent.trClient.remove(torrent.hashString, true); }catch(error){ /* already gone */ }
|
||||
|
||||
torrent.organizedAt = new Date();
|
||||
torrent.metadata = { ...meta, libraryPath, files: filed };
|
||||
await torrent.save();
|
||||
|
||||
try{ await emby.refresh(); }catch(error){ console.error('emby refresh failed:', error.message); }
|
||||
ps.publish('torrent:organized', { hashString: torrent.hashString, libraryPath });
|
||||
|
||||
return { organized: true, libraryPath, files: filed };
|
||||
}
|
||||
|
||||
// Re-file an already-organized torrent under a user-chosen TMDB match. Moves the files
|
||||
// already in the library to their new canonical paths.
|
||||
async function refileWithMatch(torrent, tmdbId, mediaType){
|
||||
if(!torrent.metadata || !Array.isArray(torrent.metadata.files) || !torrent.metadata.files.length){
|
||||
let error = new Error('NothingToRefile');
|
||||
error.message = 'This torrent has no filed media to re-match';
|
||||
error.status = 409;
|
||||
throw error;
|
||||
}
|
||||
|
||||
let details = await tmdb.tmdbDetails(tmdbId, mediaType);
|
||||
let meta = {
|
||||
...torrent.metadata,
|
||||
mediaType,
|
||||
title: details.title,
|
||||
year: details.year,
|
||||
tmdbId,
|
||||
imdbId: details.imdbId,
|
||||
};
|
||||
delete meta.organizeError;
|
||||
|
||||
let filed = [];
|
||||
let libraryPath = null;
|
||||
for(let entry of torrent.metadata.files){
|
||||
let old = typeof entry === 'string' ? entry : entry.path;
|
||||
let episode = (entry && entry.season != null) ? { season: entry.season, episode: entry.episode } : null;
|
||||
let dst = resolveCollision(buildTarget(meta, old, episode), meta);
|
||||
if(dst !== old) await moveFile(old, dst);
|
||||
filed.push({ path: dst, season: episode ? episode.season : null, episode: episode ? episode.episode : null });
|
||||
libraryPath = path.dirname(dst);
|
||||
|
||||
let oldDir = path.dirname(old);
|
||||
try{ if(oldDir !== libraryPath) await fs.promises.rmdir(oldDir); }catch(error){ /* not empty / gone */ }
|
||||
}
|
||||
|
||||
meta.files = filed;
|
||||
meta.libraryPath = libraryPath;
|
||||
torrent.metadata = meta;
|
||||
torrent.organizedAt = new Date();
|
||||
await torrent.save();
|
||||
|
||||
try{ await emby.refresh(); }catch(error){ console.error('emby refresh failed:', error.message); }
|
||||
ps.publish('torrent:organized', { hashString: torrent.hashString, libraryPath });
|
||||
|
||||
return { organized: true, libraryPath, files: filed };
|
||||
}
|
||||
|
||||
// Record a problem in metadata without setting organizedAt( leaves it flagged for a
|
||||
// manual "fix match").
|
||||
async function flag(torrent, message, meta){
|
||||
console.error(`organize: ${torrent.hashString} skipped — ${message}`);
|
||||
torrent.metadata = { ...(meta || {}), organizeError: message };
|
||||
await torrent.save();
|
||||
return { organized: false, error: message };
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
fileTorrent,
|
||||
refileWithMatch,
|
||||
resolveMeta,
|
||||
llmExtract,
|
||||
buildTarget,
|
||||
qualitySuffix,
|
||||
normalizeRes,
|
||||
sanitize,
|
||||
moveFile,
|
||||
resolveCollision,
|
||||
};
|
||||
@@ -0,0 +1,42 @@
|
||||
'use strict';
|
||||
|
||||
const conf = require('>/conf');
|
||||
const organize = require('>/controller/organize');
|
||||
|
||||
let lock = false;
|
||||
|
||||
// Poll unorganized Movie/TV downloads; when Transmission reports one finished, file it.
|
||||
async function tick(){
|
||||
if(lock) return;
|
||||
lock = true;
|
||||
try{
|
||||
const { Torrent } = require('>/models');
|
||||
|
||||
let where = { organizedAt: null, category: ['Movie', 'TV'] };
|
||||
if(!conf.organize.includePrivate) where.isPrivate = false;
|
||||
|
||||
let pending = await Torrent.findAll({ where });
|
||||
if(!pending.length) return;
|
||||
|
||||
let byHash = {};
|
||||
for(let t of pending) byHash[t.hashString.toLowerCase()] = t;
|
||||
|
||||
let res = await Torrent.trClient.get(pending.map(t => t.hashString), ['hashString', 'percentDone', 'isFinished']);
|
||||
for(let tor of res.torrents){
|
||||
if(!(tor.isFinished || tor.percentDone === 1)) continue;
|
||||
let t = byHash[String(tor.hashString).toLowerCase()];
|
||||
if(!t) continue;
|
||||
if(t.metadata && t.metadata.organizeError) continue; // already tried; needs manual fix
|
||||
await organize.fileTorrent(t);
|
||||
}
|
||||
}catch(error){
|
||||
// Transmission down / transient — just try again next tick.
|
||||
}finally{
|
||||
lock = false;
|
||||
}
|
||||
}
|
||||
|
||||
setInterval(tick, conf.organize.interval || 10000);
|
||||
tick(); // reconcile once on boot
|
||||
|
||||
module.exports = { tick };
|
||||
@@ -1,6 +1,8 @@
|
||||
'use strict';
|
||||
|
||||
const {PubSub} = require('p2psub');
|
||||
|
||||
ps = new PubSub();
|
||||
const ps = new PubSub();
|
||||
|
||||
|
||||
module.exports = ps;
|
||||
|
||||
@@ -0,0 +1,277 @@
|
||||
'use strict';
|
||||
|
||||
const conf = require('>/conf');
|
||||
const { tmdbSearch, tmdbDetails } = require('>/controller/tmdb');
|
||||
|
||||
// TPB numeric categories that count as Movies / TV( used for the q.php search and to
|
||||
// keep the LLM from ever seeing non-video results).
|
||||
const MOVIE_CATS = [201, 202, 207, 209, 211];
|
||||
const TV_CATS = [205, 208, 212];
|
||||
|
||||
function humanSize(bytes){
|
||||
bytes = Number(bytes) || 0;
|
||||
let units = ['B', 'KB', 'MB', 'GB', 'TB'];
|
||||
let i = 0;
|
||||
while(bytes >= 1024 && i < units.length - 1){
|
||||
bytes /= 1024;
|
||||
i++;
|
||||
}
|
||||
return `${bytes.toFixed(bytes < 10 && i > 0 ? 1 : 0)} ${units[i]}`;
|
||||
}
|
||||
|
||||
async function fetchJSON(url, options){
|
||||
let res = await fetch(url, options);
|
||||
if(!res.ok){
|
||||
let error = new Error(`UpstreamError`);
|
||||
error.message = `Request to ${url.split('?')[0]} failed( ${res.status})`;
|
||||
error.status = 502;
|
||||
throw error;
|
||||
}
|
||||
return await res.json();
|
||||
}
|
||||
|
||||
// Turn a raw TPB category id into 'movie' | 'tv' | null.
|
||||
function videoKind(category){
|
||||
category = parseInt(category, 10);
|
||||
if(TV_CATS.includes(category)) return 'tv';
|
||||
if(MOVIE_CATS.includes(category) || (category >= 200 && category < 300)) return 'movie';
|
||||
return null;
|
||||
}
|
||||
|
||||
// --- TPB HTML search ------------------------------------------------------
|
||||
|
||||
const SIZE_UNITS = { B: 1, KIB: 1024, MIB: 1024 ** 2, GIB: 1024 ** 3, TIB: 1024 ** 4 };
|
||||
|
||||
function sizeToBytes(value, unit){
|
||||
return Math.round(parseFloat(value) * (SIZE_UNITS[String(unit).toUpperCase()] || 1));
|
||||
}
|
||||
|
||||
function decodeEntities(text){
|
||||
return String(text)
|
||||
.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>')
|
||||
.replace(/"/g, '"').replace(/�?39;/g, "'").replace(/'/g, "'");
|
||||
}
|
||||
|
||||
// Parse the classic TPB HTML result table( category cell, details link name, magnet,
|
||||
// then right-aligned size / seeders / leechers cells) into apibay-shaped objects.
|
||||
function parseTPBHtml(html){
|
||||
let out = [];
|
||||
for(let row of html.split(/<tr/i)){
|
||||
let hash = row.match(/magnet:\?xt=urn:btih:([A-Fa-f0-9]+)/i);
|
||||
if(!hash) continue;
|
||||
|
||||
let cat = row.match(/\/browse\/(\d+)/);
|
||||
let name = row.match(/title="Details for ([^"]+)"/i);
|
||||
let size = row.match(/<td align="right">\s*([\d.]+)(?: |\s)+(GiB|MiB|KiB|TiB)\s*<\/td>/i);
|
||||
let nums = [...row.matchAll(/<td align="right">\s*([\d,]+)\s*<\/td>/gi)].map(m => Number(m[1].replace(/,/g, '')));
|
||||
|
||||
if(!name) continue;
|
||||
// nums are [size, seeders, leechers]; size cell also matched the regex above so
|
||||
// seeders/leechers are the last two numeric right-aligned cells.
|
||||
let seeders = nums.length >= 2 ? nums[nums.length - 2] : 0;
|
||||
let leechers = nums.length >= 1 ? nums[nums.length - 1] : 0;
|
||||
|
||||
out.push({
|
||||
name: decodeEntities(name[1]),
|
||||
info_hash: hash[1].toLowerCase(),
|
||||
category: cat ? Number(cat[1]) : 0,
|
||||
size: size ? sizeToBytes(size[1], size[2]) : 0,
|
||||
seeders: seeders,
|
||||
leechers: leechers,
|
||||
imdb: null,
|
||||
});
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
async function tpbSearch(title){
|
||||
// Category 200 = all Video; we narrow to movie/tv subcats in prefilter().
|
||||
let url = `${conf.search.tpbBase}/search/${encodeURIComponent(title)}/1/99/200`;
|
||||
let res = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0' } });
|
||||
if(!res.ok){
|
||||
let error = new Error('UpstreamError');
|
||||
error.message = `TPB search failed( ${res.status})`;
|
||||
error.status = 502;
|
||||
throw error;
|
||||
}
|
||||
return parseTPBHtml(await res.text());
|
||||
}
|
||||
|
||||
// Deterministic pre-filter before the torrents ever reach the LLM.
|
||||
function prefilter(torrents, imdbId){
|
||||
let out = torrents.filter(t => videoKind(t.category) && Number(t.seeders) > 0);
|
||||
|
||||
// If we can positively identify the title by IMDB id, trust it and drop the rest.
|
||||
if(imdbId){
|
||||
let matches = out.filter(t => t.imdb && t.imdb === imdbId);
|
||||
if(matches.length) out = matches;
|
||||
}
|
||||
|
||||
return out
|
||||
.sort((a, b) => Number(b.seeders) - Number(a.seeders))
|
||||
.slice(0, 40);
|
||||
}
|
||||
|
||||
function buildMagnet(infoHash, name){
|
||||
let magnet = `magnet:?xt=urn:btih:${infoHash}&dn=${encodeURIComponent(name)}`;
|
||||
for(let tracker of conf.search.trackers){
|
||||
magnet += `&tr=${encodeURIComponent(tracker)}`;
|
||||
}
|
||||
return magnet;
|
||||
}
|
||||
|
||||
// --- LLM ranking ----------------------------------------------------------
|
||||
|
||||
function buildSystemPrompt(title, year, today){
|
||||
return [
|
||||
`You are a torrent-selection assistant. Today's date is ${today}.`,
|
||||
`Recent releases are legitimate: NEVER reject a torrent for being too new or assume`,
|
||||
`a current-year release is fake.`,
|
||||
``,
|
||||
`The user wants "${title}" (${year || 'unknown year'}). From the candidate list,`,
|
||||
`select the best releases.`,
|
||||
year ? `IMPORTANT: only pick releases whose name contains the year ${year}; reject other years or remakes of a same-named title.` : ``,
|
||||
`Preferences, in order:`,
|
||||
`- video codec HEVC/x265 (over x264/AVC)`,
|
||||
`- 1080p resolution`,
|
||||
`- total size around 1.5 GB (avoid needlessly huge files)`,
|
||||
`- English audio and English subtitles present`,
|
||||
`- prefer EXTENDED / UNRATED / UNCUT / DIRECTOR'S CUT editions`,
|
||||
`Reject: CAM, TS, TC, TELESYNC, HDCAM, SCREENER/SCR, and non-English-only copies.`,
|
||||
``,
|
||||
`Return STRICT JSON only, shape:`,
|
||||
`{"options":[{"role":"recommended|uhd|other","label":"...","info_hash":"...",`,
|
||||
`"name":"...","resolution":"...","codec":"...","hasSubs":true,"cut":"...",`,
|
||||
`"warning":"...","why":"..."}]}`,
|
||||
`Rules: exactly one "recommended" (the 1080p sweet spot). Include one "uhd" ONLY`,
|
||||
`if a 4K/2160p release exists, and set its "warning" to note it is a much larger,`,
|
||||
`slower download. Add "other" entries for genuinely distinct useful releases`,
|
||||
`(e.g. a different cut or a much smaller copy). "why" is one short sentence.`,
|
||||
`Copy info_hash verbatim from the chosen candidate.`,
|
||||
].join('\n');
|
||||
}
|
||||
|
||||
// Pull the first JSON object out of a model response( tolerates ```json fences / prose).
|
||||
function extractJSON(content){
|
||||
let text = String(content).replace(/```json/gi, '').replace(/```/g, '').trim();
|
||||
let start = text.indexOf('{');
|
||||
let end = text.lastIndexOf('}');
|
||||
if(start === -1 || end === -1) throw new Error('No JSON in model response');
|
||||
return JSON.parse(text.slice(start, end + 1));
|
||||
}
|
||||
|
||||
async function rankReleases(candidates, meta){
|
||||
let compact = candidates.map(t => ({
|
||||
name: t.name,
|
||||
sizeHuman: humanSize(t.size),
|
||||
seeders: Number(t.seeders),
|
||||
info_hash: t.info_hash,
|
||||
imdb: t.imdb || null,
|
||||
}));
|
||||
|
||||
let body = {
|
||||
model: conf.ollama.model,
|
||||
stream: false,
|
||||
format: 'json',
|
||||
messages: [
|
||||
{ role: 'system', content: buildSystemPrompt(meta.title, meta.year, meta.today) },
|
||||
{ role: 'user', content: JSON.stringify(compact) },
|
||||
],
|
||||
};
|
||||
|
||||
let data = await fetchJSON(`${conf.ollama.url}/api/chat`, {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Content-Type': 'application/json',
|
||||
'Authorization': `Bearer ${conf.ollama.apiKey}`,
|
||||
},
|
||||
body: JSON.stringify(body),
|
||||
});
|
||||
|
||||
let parsed = extractJSON(data.message && data.message.content);
|
||||
let options = Array.isArray(parsed.options) ? parsed.options : [];
|
||||
if(!options.length) throw new Error('Model returned no options');
|
||||
return options;
|
||||
}
|
||||
|
||||
// Deterministic fallback if the LLM is unavailable or returns junk: pick the most-seeded
|
||||
// candidate, preferring x265 + 1080p, so the feature degrades instead of failing.
|
||||
function fallbackReleases(candidates){
|
||||
let score = t => (/x265|hevc/i.test(t.name) ? 2 : 0) + (/1080p/i.test(t.name) ? 1 : 0);
|
||||
let best = [...candidates].sort((a, b) =>
|
||||
(score(b) - score(a)) || (Number(b.seeders) - Number(a.seeders))
|
||||
)[0];
|
||||
if(!best) return [];
|
||||
return [{
|
||||
role: 'recommended',
|
||||
label: 'Most seeded',
|
||||
info_hash: best.info_hash,
|
||||
name: best.name,
|
||||
sizeHuman: humanSize(best.size),
|
||||
seeders: Number(best.seeders),
|
||||
why: 'Automatically chosen (AI ranking unavailable): most seeders.',
|
||||
}];
|
||||
}
|
||||
|
||||
// Attach the fields the front end / add flow need to each option and drop any the model
|
||||
// hallucinated( info_hash must exist in the candidate set).
|
||||
function decorateOptions(options, candidates){
|
||||
let byHash = {};
|
||||
for(let t of candidates) byHash[String(t.info_hash).toLowerCase()] = t;
|
||||
|
||||
let out = [];
|
||||
for(let opt of options){
|
||||
let src = byHash[String(opt.info_hash).toLowerCase()];
|
||||
if(!src) continue;
|
||||
out.push({
|
||||
...opt,
|
||||
info_hash: src.info_hash,
|
||||
name: opt.name || src.name,
|
||||
category: Number(src.category),
|
||||
sizeHuman: opt.sizeHuman || humanSize(src.size),
|
||||
seeders: Number(src.seeders),
|
||||
magnetLink: buildMagnet(src.info_hash, src.name),
|
||||
});
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
async function findReleases(tmdbId, mediaType){
|
||||
let meta = await tmdbDetails(tmdbId, mediaType);
|
||||
let torrents = await tpbSearch(meta.title);
|
||||
let candidates = prefilter(torrents, meta.imdbId);
|
||||
|
||||
if(!candidates.length){
|
||||
return { title: meta.title, year: meta.year, options: [] };
|
||||
}
|
||||
|
||||
let today = new Date().toISOString().slice(0, 10);
|
||||
let options;
|
||||
try{
|
||||
options = await rankReleases(candidates, { title: meta.title, year: meta.year, today });
|
||||
}catch(error){
|
||||
console.error('rankReleases failed, using fallback:', error.message);
|
||||
options = fallbackReleases(candidates);
|
||||
}
|
||||
|
||||
options = decorateOptions(options, candidates);
|
||||
if(!options.length) options = decorateOptions(fallbackReleases(candidates), candidates);
|
||||
|
||||
return { title: meta.title, year: meta.year, options };
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
tmdbSearch,
|
||||
findReleases,
|
||||
// exported for unit tests
|
||||
prefilter,
|
||||
buildMagnet,
|
||||
humanSize,
|
||||
videoKind,
|
||||
extractJSON,
|
||||
decorateOptions,
|
||||
fallbackReleases,
|
||||
tpbSearch,
|
||||
parseTPBHtml,
|
||||
sizeToBytes,
|
||||
};
|
||||
@@ -0,0 +1,72 @@
|
||||
'use strict';
|
||||
|
||||
const conf = require('>/conf');
|
||||
|
||||
async function fetchJSON(url, options){
|
||||
let res = await fetch(url, options);
|
||||
if(!res.ok){
|
||||
let error = new Error('UpstreamError');
|
||||
error.message = `Request to ${url.split('?')[0]} failed( ${res.status})`;
|
||||
error.status = 502;
|
||||
throw error;
|
||||
}
|
||||
return await res.json();
|
||||
}
|
||||
|
||||
async function tmdbSearch(query){
|
||||
let url = `https://api.themoviedb.org/3/search/multi?include_adult=false`
|
||||
+ `&query=${encodeURIComponent(query)}&api_key=${conf.tmdb.apiKey}`;
|
||||
|
||||
let data = await fetchJSON(url);
|
||||
|
||||
return (data.results || [])
|
||||
.filter(item => item.media_type === 'movie' || item.media_type === 'tv')
|
||||
.slice(0, 4)
|
||||
.map(item => {
|
||||
let date = item.release_date || item.first_air_date || '';
|
||||
return {
|
||||
tmdbId: item.id,
|
||||
mediaType: item.media_type,
|
||||
title: item.title || item.name,
|
||||
year: date ? date.slice(0, 4) : '',
|
||||
posterUrl: item.poster_path ? `https://image.tmdb.org/t/p/w200${item.poster_path}` : null,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
async function tmdbDetails(tmdbId, mediaType){
|
||||
let url = `https://api.themoviedb.org/3/${mediaType}/${tmdbId}`
|
||||
+ `?append_to_response=external_ids&api_key=${conf.tmdb.apiKey}`;
|
||||
|
||||
let data = await fetchJSON(url);
|
||||
let date = data.release_date || data.first_air_date || '';
|
||||
|
||||
return {
|
||||
title: data.title || data.name,
|
||||
year: date ? date.slice(0, 4) : '',
|
||||
imdbId: data.imdb_id || (data.external_ids && data.external_ids.imdb_id) || null,
|
||||
};
|
||||
}
|
||||
|
||||
// Canonicalize a( possibly messy) title + year to the authoritative TMDB record.
|
||||
// Returns null when nothing matches so callers can flag instead of guessing.
|
||||
async function tmdbFindBest(title, year, mediaType){
|
||||
let results = await tmdbSearch(title);
|
||||
|
||||
let pool = results.filter(r => r.mediaType === mediaType);
|
||||
if(!pool.length) pool = results;
|
||||
if(!pool.length) return null;
|
||||
|
||||
let pick = (year && pool.find(r => r.year === String(year))) || pool[0];
|
||||
let details = await tmdbDetails(pick.tmdbId, pick.mediaType);
|
||||
|
||||
return {
|
||||
title: details.title,
|
||||
year: details.year,
|
||||
tmdbId: pick.tmdbId,
|
||||
mediaType: pick.mediaType,
|
||||
imdbId: details.imdbId,
|
||||
};
|
||||
}
|
||||
|
||||
module.exports = { fetchJSON, tmdbSearch, tmdbDetails, tmdbFindBest };
|
||||
Reference in New Issue
Block a user