align plugin with new architecture

src/webdav-client.ts

@@ -64,7 +64,7 @@ export class WebDAVClient {
     }
 
     /**
-     * Read first N bytes of a file (for language detection)
+     * Read first N bytes of a file (for magic byte detection)
      * Uses HTTP Range request
      */
     async readBytes(filePath: string, start: number, end: number): Promise<Buffer> {
@@ -86,7 +86,7 @@ export class WebDAVClient {
     }
 
     /**
-     * Read entire file as buffer (for small files)
+     * Read entire file as buffer (for small files only)
      */
     async readFile(filePath: string): Promise<Buffer> {
         const url = this.toWebDAVUrl(filePath);
@@ -101,6 +101,25 @@ export class WebDAVClient {
         return Buffer.from(arrayBuffer);
     }
 
+    /**
+     * Write file via HTTP PUT
+     */
+    async writeFile(filePath: string, data: Buffer | string): Promise<void> {
+        const url = this.toWebDAVUrl(filePath);
+
+        const response = await fetch(url, {
+            method: 'PUT',
+            body: data,
+            headers: {
+                'Content-Type': 'application/octet-stream',
+            },
+        });
+
+        if (!response.ok) {
+            throw new Error(`WebDAV PUT failed for ${filePath}: ${response.status} ${response.statusText}`);
+        }
+    }
+
     /**
      * Check if file exists via HTTP HEAD
      */
@@ -116,38 +135,96 @@ export class WebDAVClient {
     }
 
     /**
-     * List directory contents via HTTP GET (returns JSON from nginx autoindex)
+     * List a directory: GET <dir>/ with Accept: application/json, which both
+     * meta-core's WebDAV and meta-sort's nginx autoindex answer with
+     * [{name, type: "file"|"directory", size, mtime}].
+     *
+     * (Addition to the tmdb/still-extractor copy of this file: the subtitle
+     * plugin has no /files mount, so sibling discovery must go over WebDAV.)
      */
-    async readdir(dirPath: string): Promise<string[]> {
+    async list(dirPath: string): Promise<DirectoryEntry[]> {
         const url = this.toWebDAVUrl(dirPath);
         const finalUrl = url.endsWith('/') ? url : url + '/';
 
-        const response = await fetch(finalUrl, {
-            method: 'GET',
-            headers: {
-                'Accept': 'application/json',
-            },
-        });
-
+        const response = await fetch(finalUrl, { method: 'GET', headers: { 'Accept': 'application/json' } });
         if (!response.ok) {
             throw new Error(`WebDAV GET (dir) failed for ${dirPath}: ${response.status} ${response.statusText}`);
         }
 
-        const entries = await response.json() as Array<{ name: string; type: string }>;
-        return entries.map(e => e.name);
+        const entries = await response.json() as Array<{ name: string; type: string; size?: number }>;
+        return entries.map((e) => ({
+            name: e.name,
+            type: e.type === 'directory' ? 'directory' : 'file',
+            size: typeof e.size === 'number' ? e.size : undefined,
+        }));
     }
 }
 
+export interface DirectoryEntry {
+    name: string;
+    type: 'file' | 'directory';
+    size?: number;
+}
+
 /**
- * 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>>();
 
-    if (!webdavUrl) {
-        console.warn('[webdav-client] WEBDAV_URL not set, WebDAV client unavailable');
-        return 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}`);
     }
 
-    return new WebDAVClient(webdavUrl);
+    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] 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;
+    }
 }