gitattributes

.gitattributes

@@ -0,0 +1,6 @@
+# FIX CRLF always when developer has not set
+# Linux/Mac: git config --global core.autocrlf input
+# Windows: git config --global core.autocrlf true
+# Auto detect text files and perform LF normalization
+* text=auto
+* eol=lf

src/plugin.ts

@@ -9,7 +9,8 @@
  * PLUGIN FILE ACCESS ARCHITECTURE
  * ============================================================================
  *
- * File access via WebDAV (WEBDAV_URL environment variable):
+ * File access via WebDAV, on the meta-core named by each /process request
+ * (its /urls -> webdavUrlInternal; WEBDAV_URL overrides):
  *   - Read media files:  GET  /webdav/watch/...  or /webdav/test/...
  *   - Write output:      PUT  /webdav/plugin/tmdb/...
  *   - Cache:             Local /cache mount (for JSON cache files)
@@ -18,6 +19,7 @@
  *   - No output mount needed on plugin containers
  *   - Consistent read/write architecture via HTTP
  *   - Works in any orchestration environment
+ *   - Posters land in the same core the CIDs are written to, always
  *
  * ============================================================================
  *
@@ -30,21 +32,12 @@
  */
 
 import axios from 'axios';
-import { statSync, openSync, readSync, closeSync } from 'fs';
 import { createHash } from 'crypto';
 import * as path from 'path';
 import type { PluginManifest, ProcessRequest, CallbackPayload } from './types.js';
 import { MetaCoreClient } from './meta-core-client.js';
 import { readJson, writeJson } from './cache.js';
-import { createWebDAVClient, WebDAVClient } from './webdav-client.js';
-
-// Initialize WebDAV client - required for plugin operation
-const webdavClient = createWebDAVClient();
-if (webdavClient) {
-    console.log('[tmdb] WebDAV client initialized for file access');
-} else {
-    console.warn('[tmdb] WARNING: WEBDAV_URL not set - plugin will not be able to write output files');
-}
+import { getWebDAVClient, WebDAVClient } from './webdav-client.js';
 
 const IMAGE_BASE_URL = 'https://image.tmdb.org/t/p/original';
 
@@ -52,54 +45,14 @@ const IMAGE_BASE_URL = 'https://image.tmdb.org/t/p/original';
  * ============================================================================
  * PLUGIN OUTPUT PATH - Written via WebDAV
  * ============================================================================
- * Output files (posters, backdrops) are written via WebDAV PUT requests.
- * Path: /files/plugin/tmdb/<filename> (accessible at WEBDAV_URL/plugin/tmdb/)
+ * Output files (posters, backdrops) are written via WebDAV PUT requests, to the
+ * WebDAV of the meta-core that issued the /process call.
+ * Path: /files/plugin/tmdb/<filename>
  * CACHE_PATH (/cache) - Local mount for plugin cache (handled by cache.ts)
  * ============================================================================
  */
 const PLUGIN_OUTPUT_WEBDAV_PATH = '/files/plugin/tmdb';
 
-/**
- * Compute midhash256 CID for a file (matches meta-hash algorithm)
- *
- * Algorithm:
- * - For files <= 1MB: Hashes entire file content + 8-byte size prefix
- * - For files > 1MB: Hashes middle 1MB + 8-byte size prefix
- * - Returns CIDv1 with custom codec 0x1000
- */
-function computeMidHash256Sync(filePath: string): string {
-    const SAMPLE_SIZE = 1024 * 1024; // 1MB
-    // varint encoding of 0x1000 (4096) for both codec and hash function code
-    const MIDHASH_VARINT = Buffer.from([0x80, 0x20]);
-
-    // Get file size
-    const stats = statSync(filePath);
-    const fileSize = stats.size;
-
-    // Create size buffer (64-bit big-endian)
-    const sizeBuffer = Buffer.allocUnsafe(8);
-    sizeBuffer.writeBigUInt64BE(BigInt(fileSize), 0);
-
-    // Extract sample data
-    let sampleData: Buffer;
-    if (fileSize <= SAMPLE_SIZE) {
-        // Small file: read entire content
-        const fd = openSync(filePath, 'r');
-        sampleData = Buffer.allocUnsafe(fileSize);
-        readSync(fd, sampleData, 0, fileSize, 0);
-        closeSync(fd);
-    } else {
-        // Large file: read middle 1MB
-        const middleOffset = Math.floor((fileSize - SAMPLE_SIZE) / 2);
-        const fd = openSync(filePath, 'r');
-        sampleData = Buffer.allocUnsafe(SAMPLE_SIZE);
-        readSync(fd, sampleData, 0, SAMPLE_SIZE, middleOffset);
-        closeSync(fd);
-    }
-
-    return computeMidHash256FromData(fileSize, sampleData);
-}
-
 /**
  * Compute midhash256 CID via WebDAV
  */
@@ -170,16 +123,6 @@ function computeMidHash256FromData(fileSize: number, sampleData: Buffer): string
     return cid;
 }
 
-/**
- * Compute midhash256 CID for a file (auto-selects WebDAV or filesystem)
- */
-async function computeMidHash256(filePath: string): Promise<string> {
-    if (webdavClient) {
-        return computeMidHash256WebDAV(webdavClient, filePath);
-    }
-    return computeMidHash256Sync(filePath);
-}
-
 export const manifest: PluginManifest = {
     id: 'tmdb',
     name: 'TMDB Metadata',
@@ -352,6 +295,7 @@ async function downloadImageToWebDAV(
  * no need to store any path in the parent file's metadata.
  */
 async function downloadAndHashImage(
+    webdavClient: WebDAVClient | null,
     imagePath: string,
     imageType: string,
     title: string,
@@ -409,6 +353,9 @@ export async function process(
 ): Promise<void> {
     const startTime = Date.now();
     const metaCore = new MetaCoreClient(request.metaCoreUrl);
+    // WebDAV of the very core we're enriching, so poster blobs and the poster
+    // CIDs we write can never point at different cores. Cached per core URL.
+    const webdavClient = await getWebDAVClient(request.metaCoreUrl);
 
     try {
         const { cid, existingMeta } = request;
@@ -451,15 +398,26 @@ export async function process(
             console.log(`[tmdb] Force recompute enabled for ${request.filePath ?? existingMeta?.fileName ?? cid}`);
         }
 
-        // Get midhash for caching
-        const midhash = existingMeta?.['cid_midhash256'];
+        const label = request.filePath ?? existingMeta?.fileName ?? cid;
 
-        // Check cache (skip if forceRecompute)
+        // Exact-file cache, keyed by the file's byte-hash. Only records carrying
+        // real file bytes have `cid_midhash256`; gateway/usenet records don't —
+        // which is exactly why the per-tmdbid cache below exists. Stores a full
+        // entry now, but tolerates the legacy raw-payload format from older builds.
+        const midhash = existingMeta?.['cid_midhash256'];
         if (midhash && !forceRecompute) {
-            const cachedData = await readJson<any>(`${midhash}_tmdb.json`);
-            if (cachedData) {
-                console.log(`[tmdb] Using cached TMDB data for ${request.filePath ?? existingMeta?.fileName ?? cid}`);
-                await applyTmdbData(metaCore, cid, cachedData);
+            const cached = await readJson<any>(`${midhash}_tmdb.json`);
+            if (cached) {
+                console.log(`[tmdb] Using byte-hash cached TMDB data for ${label}`);
+                const isEntry = cached.data !== undefined;
+                await applyTmdbData(
+                    metaCore,
+                    webdavClient,
+                    cid,
+                    isEntry ? cached.data : cached,
+                    // Legacy raw payloads carry no image CIDs → let applyTmdbData recompute.
+                    isEntry ? { posterCid: cached.posterCid, backdropCid: cached.backdropCid } : undefined
+                );
                 await sendCallback({
                     taskId: request.taskId,
                     status: 'completed',
@@ -469,33 +427,37 @@ export async function process(
             }
         }
 
-        let tmdbData = null;
-
-        // Resolve by a known TMDB id first (authoritative — e.g. a gateway
-        // anchor or jellyfin-nfo). Completes the full cycle (poster + plot +
-        // genres) from an id alone, with no fuzzy re-search.
+        // Resolve the show/movie entry, deduped per tmdbid. A record that already
+        // carries a tmdbid anchor (every gateway torrent/usenet hit does) takes
+        // the cached + single-flighted fast path, so N releases of one show share
+        // ONE TMDB fetch + poster seed instead of N.
+        let entry: TmdbCacheEntry | null = null;
         const knownTmdbId = existingMeta?.tmdbid;
         if (knownTmdbId) {
             const mediaType =
                 existingMeta?.videoType === 'tvshow' || existingMeta?.videoType === 'tv'
                     ? 'tv'
                     : 'movie';
-            tmdbData = await getByTmdbId(knownTmdbId, mediaType);
+            entry = await resolveEntryById(webdavClient, knownTmdbId, mediaType);
         }
 
-        // Try by IMDB ID
+        // Fallback: no usable id → resolve by IMDB id or fuzzy title, then cache
+        // the result by its resolved tmdbid so later releases of the same show
+        // take the fast path above.
+        if (!entry) {
+            let tmdbData: any = null;
+
             const imdbId = existingMeta?.imdbid;
-        if (!tmdbData && imdbId) {
+            if (imdbId) {
                 tmdbData = await findByImdbId(imdbId);
             }
 
-        // Try by title search
             if (!tmdbData) {
                 let title = existingMeta?.originalTitle || existingMeta?.fileName;
                 const year = existingMeta?.movieYear;
                 const videoType = existingMeta?.videoType;
 
-            // Strip trailing year from title if present (e.g., "Sintel 2010" -> "Sintel")
+                // Strip trailing year from title if present ("Sintel 2010" -> "Sintel").
                 if (title && year) {
                     const yearRegex = new RegExp(`\\s*[\\(\\[]?${year}[\\)\\]]?\\s*$`);
                     title = title.replace(yearRegex, '').trim();
@@ -507,16 +469,27 @@ export async function process(
             }
 
             if (tmdbData) {
-            await applyTmdbData(metaCore, cid, tmdbData);
-
-            // Cache TMDB data for future use
-            if (midhash) {
-                await writeJson(`${midhash}_tmdb.json`, tmdbData);
+                const images = await computeImageCids(webdavClient, tmdbData);
+                entry = { data: tmdbData, ...images };
+                if (tmdbData.id) {
+                    await writeJson(tmdbCacheKey(String(tmdbData.id), mediaTypeOf(tmdbData)), entry);
+                }
+            }
         }
 
-            console.log(`[tmdb] Fetched TMDB data for ${request.filePath ?? existingMeta?.fileName ?? cid}`);
+        if (entry) {
+            await applyTmdbData(metaCore, webdavClient, cid, entry.data, {
+                posterCid: entry.posterCid,
+                backdropCid: entry.backdropCid,
+            });
+            // Keep the exact-file cache warm too, so a future re-enrichment of
+            // this same file skips straight to the byte-hash hit.
+            if (midhash) {
+                await writeJson(`${midhash}_tmdb.json`, entry);
+            }
+            console.log(`[tmdb] Enriched ${label} (tmdbid=${entry.data.id})`);
         } else {
-            console.log(`[tmdb] No TMDB match found for ${request.filePath ?? existingMeta?.fileName ?? cid}`);
+            console.log(`[tmdb] No TMDB match found for ${label}`);
         }
 
         await sendCallback({
@@ -534,14 +507,109 @@ export async function process(
     }
 }
 
+/** Resolved TMDB payload plus the seeded poster/backdrop CIDs, cached per
+ *  tmdbid. Every torrent/usenet release of an episode carries the same
+ *  `tmdbid`, and TMDB only gives us show/movie-level fields (poster, plot,
+ *  genres — no per-episode data), so N releases can share ONE fetch + seed. */
+interface TmdbCacheEntry {
+    data: any;
+    posterCid: string | null;
+    backdropCid: string | null;
+}
+
+// In-process single-flight: collapses concurrent resolves of the same key onto
+// one promise, so a burst of same-tmdbid records that all miss the cold cache
+// triggers a single TMDB fetch (no thundering herd) — the rest await it.
+const tmdbEntryInflight = new Map<string, Promise<TmdbCacheEntry | null>>();
+
+// Persistent cache filename for a resolved show/movie. Includes mediaType +
+// language so a tv/movie id clash or a language switch can't return stale text.
+function tmdbCacheKey(tmdbId: string, mediaType: string): string {
+    return `tmdbid_${mediaType}_${tmdbId}_${metadataLanguage}_tmdb.json`;
+}
+
+// Media type from a raw TMDB payload's own shape (tv payloads carry
+// name/first_air_date). Mirrors the check in applyTmdbData.
+function mediaTypeOf(data: any): string {
+    return data?.first_air_date !== undefined ||
+        data?.name !== undefined ||
+        data?.original_name !== undefined
+        ? 'tv'
+        : 'movie';
+}
+
+// Download + hash the poster/backdrop for a resolved payload. Record-independent
+// (the image filename is keyed by tmdbId, so the blob dedups across records), so
+// the CIDs can be computed once per show and reused for every release.
+async function computeImageCids(
+    webdavClient: WebDAVClient | null,
+    data: any
+): Promise<{ posterCid: string | null; backdropCid: string | null }> {
+    const tmdbId = data?.id ? String(data.id) : '';
+    const displayTitle =
+        data?.title || data?.name || data?.original_title || data?.original_name || 'Unknown';
+    const releaseDate = data?.release_date || data?.first_air_date;
+    const year = releaseDate ? releaseDate.split('-')[0] : undefined;
+    const posterCid =
+        data?.poster_path && tmdbId
+            ? await downloadAndHashImage(webdavClient, data.poster_path, 'poster', displayTitle, year, tmdbId)
+            : null;
+    const backdropCid =
+        data?.backdrop_path && tmdbId
+            ? await downloadAndHashImage(webdavClient, data.backdrop_path, 'backdrop', displayTitle, year, tmdbId)
+            : null;
+    return { posterCid, backdropCid };
+}
+
+// Resolve the full entry (payload + image CIDs) for a KNOWN tmdbid, served from
+// the persistent per-tmdbid cache when possible and single-flighted otherwise.
+// This is the hot path for gateway records (torrent + usenet), which always
+// carry a `tmdbid` anchor — so N releases of one show share one TMDB fetch.
+async function resolveEntryById(
+    webdavClient: WebDAVClient | null,
+    tmdbId: string,
+    mediaType: string
+): Promise<TmdbCacheEntry | null> {
+    const key = tmdbCacheKey(tmdbId, mediaType);
+    if (!forceRecompute) {
+        const cached = await readJson<TmdbCacheEntry>(key);
+        if (cached?.data) {
+            return cached;
+        }
+    }
+    const inflight = tmdbEntryInflight.get(key);
+    if (inflight) {
+        return inflight;
+    }
+    const pending = (async (): Promise<TmdbCacheEntry | null> => {
+        console.log(`[tmdb] Resolving TMDB ${mediaType}/${tmdbId} (cache miss)`);
+        const data = await getByTmdbId(tmdbId, mediaType);
+        if (!data) {
+            return null;
+        }
+        const images = await computeImageCids(webdavClient, data);
+        const entry: TmdbCacheEntry = { data, ...images };
+        await writeJson(key, entry);
+        return entry;
+    })();
+    tmdbEntryInflight.set(key, pending);
+    try {
+        return await pending;
+    } finally {
+        tmdbEntryInflight.delete(key);
+    }
+}
+
 /**
  * Apply TMDB data to KV store using same keys as old TMDBProcessor
  */
 async function applyTmdbData(
     metaCore: MetaCoreClient,
+    webdavClient: WebDAVClient | null,
     cid: string,
-    data: any
-): Promise<void> {
+    data: any,
+    images?: { posterCid: string | null; backdropCid: string | null }
+): Promise<{ posterCid: string | null; backdropCid: string | null }> {
     const metadata: Record<string, string> = {};
 
     // Basic IDs
@@ -625,35 +693,29 @@ async function applyTmdbData(
     // Add tmdb-verified tag (same as old processor)
     await metaCore.addToSet(cid, 'tags', 'tmdb-verified');
 
-    // Download poster and backdrop images to plugin output folder. The
-    // watcher picks them up as first-class file entries, so all we need to
-    // store is the CID — `/api/file/{cid}` resolves through the standard
-    // reverse index, no path companion needed.
-    if (data.poster_path && tmdbId) {
-        const posterCid = await downloadAndHashImage(
-            data.poster_path,
-            'poster',
-            displayTitle,
-            year,
-            tmdbId
-        );
+    // Poster/backdrop CIDs. Reuse the precomputed values when the caller already
+    // seeded them (a per-tmdbid cache hit — so we don't re-download + re-hash the
+    // same image for every release of a show); otherwise download + hash now.
+    // The image filename is keyed by tmdbId, so the blob is deduped either way —
+    // this just also skips the WebDAV round-trips. The watcher picks the images
+    // up as first-class file entries, so storing the CID is all that's needed.
+    let posterCid = images ? images.posterCid : null;
+    if (!images && data.poster_path && tmdbId) {
+        posterCid = await downloadAndHashImage(webdavClient, data.poster_path, 'poster', displayTitle, year, tmdbId);
+    }
     if (posterCid) {
         await metaCore.setProperty(cid, 'poster', posterCid);
         console.log(`[tmdb] Set poster CID: ${posterCid}`);
     }
-    }
 
-    if (data.backdrop_path && tmdbId) {
-        const backdropCid = await downloadAndHashImage(
-            data.backdrop_path,
-            'backdrop',
-            displayTitle,
-            year,
-            tmdbId
-        );
+    let backdropCid = images ? images.backdropCid : null;
+    if (!images && data.backdrop_path && tmdbId) {
+        backdropCid = await downloadAndHashImage(webdavClient, data.backdrop_path, 'backdrop', displayTitle, year, tmdbId);
+    }
     if (backdropCid) {
         await metaCore.setProperty(cid, 'backdrop', backdropCid);
         console.log(`[tmdb] Set backdrop CID: ${backdropCid}`);
     }
-    }
+
+    return { posterCid, backdropCid };
 }

src/webdav-client.ts

@@ -136,15 +136,64 @@ export class WebDAVClient {
 }
 
 /**
- * Create a WebDAV client from environment variables
+ * WebDAV client for the meta-core that drove a /process call.
+ *
+ * The endpoint is read from that core's own /urls (`webdavUrlInternal`),
+ * so blobs always land in the /files of the core we write metadata to. A feeder
+ * whose plugins run beside it but enrich a remote hub core needs no per-stack
+ * wiring, and it is impossible to write posters into one core while pointing
+ * CIDs at another.
+ *
+ * WEBDAV_URL still wins when set — an explicit override for tests and for
+ * topologies where the core's advertised internal URL isn't reachable from here.
+ *
+ * Resolutions are cached per meta-core URL; failures are not, so a core that is
+ * still starting up is retried on the next task.
  */
-export function createWebDAVClient(): WebDAVClient | null {
-    const webdavUrl = process.env.WEBDAV_URL;
+const clientCache = new Map<string, Promise<WebDAVClient | null>>();
 
+async function resolveWebDAVUrl(metaCoreUrl: string): Promise<string | null> {
+    // /urls, not /api/urls — metaCoreUrl points at the meta-core backend, whose
+    // discovery routes are unprefixed (same base the /meta/* writes use).
+    const base = metaCoreUrl.replace(/\/$/, '');
+    const response = await fetch(`${base}/urls`, { signal: AbortSignal.timeout(5000) });
+
+    if (!response.ok) {
+        throw new Error(`GET ${base}/urls failed: ${response.status} ${response.statusText}`);
+    }
+
+    const urls = await response.json() as { webdavUrlInternal?: string; webdavUrl?: string };
+    return urls.webdavUrlInternal ?? urls.webdavUrl ?? null;
+}
+
+export async function getWebDAVClient(metaCoreUrl: string): Promise<WebDAVClient | null> {
+    const override = process.env.WEBDAV_URL;
+    if (override) {
+        return new WebDAVClient(override);
+    }
+
+    let pending = clientCache.get(metaCoreUrl);
+    if (!pending) {
+        pending = resolveWebDAVUrl(metaCoreUrl).then((webdavUrl) => {
             if (!webdavUrl) {
-        console.warn('[webdav-client] WEBDAV_URL not set, WebDAV client unavailable');
+                console.warn(`[webdav-client] meta-core ${metaCoreUrl} advertises no WebDAV URL`);
                 return null;
             }
-
+            console.log(`[webdav-client] Using WebDAV endpoint ${webdavUrl} (from ${metaCoreUrl})`);
             return new WebDAVClient(webdavUrl);
+        });
+        clientCache.set(metaCoreUrl, pending);
+    }
+
+    try {
+        const client = await pending;
+        if (!client) {
+            clientCache.delete(metaCoreUrl);
+        }
+        return client;
+    } catch (error) {
+        clientCache.delete(metaCoreUrl);
+        console.warn(`[webdav-client] Failed to resolve WebDAV URL from ${metaCoreUrl}: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
 }