@mevdragon/vidfarm-devcli 0.2.8 → 0.2.10

package/dist/src/services/template-sources.js

@@ -1,5 +1,5 @@
 import { createHash, createHmac } from "node:crypto";
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { execFile } from "node:child_process";
@@ -26,8 +26,8 @@ export class TemplateSourceAlreadyRegisteredError extends Error {
 }
 export class TemplateSourceService {
     certification = new TemplateCertificationService();
-    listSources(status) {
-        return database.listTemplateSources(status);
+    listSources(input) {
+        return database.listTemplateSources(input);
     }
     listReleases(input) {
         return database.listTemplateReleases(input);
@@ -368,6 +368,7 @@ export class TemplateSourceService {
             });
             throw new Error("Template release failed certification and cannot be activated.");
         }
+        await this.syncTemplateAboutAssets({ release, template });
         database.clearActiveTemplateReleases(release.templateId);
         database.updateTemplateReleaseStatus({
             id: release.id,
@@ -432,6 +433,47 @@ export class TemplateSourceService {
             }
         });
     }
+    async syncTemplateAboutAssets(input) {
+        const entries = Array.from(new Set(input.template.about.preview_media
+            .filter((entry) => !/^https?:\/\//i.test(entry))
+            .filter((entry) => !entry.replace(/^\/+/, "").startsWith("templates/"))));
+        for (const entry of entries) {
+            const asset = this.resolveTemplateAboutAsset(input.release, entry);
+            if (!asset) {
+                throw new Error(`Template about asset not found in release checkout: ${entry}`);
+            }
+            await storage.putBuffer(storage.templateAboutKey(input.template.id, asset.storageAssetPath), readFileSync(asset.sourcePath), inferContentType(asset.sourcePath));
+        }
+    }
+    resolveTemplateAboutAsset(release, entry) {
+        const normalizedEntry = entry.replace(/^\/+/, "");
+        const sourceRelativePath = normalizedEntry.startsWith("about/")
+            ? normalizedEntry
+            : path.posix.join("about", normalizedEntry);
+        const storageAssetPath = normalizedEntry.startsWith("about/")
+            ? normalizedEntry.slice("about/".length)
+            : normalizedEntry;
+        const checkoutRoot = path.resolve(release.checkoutPath);
+        let currentDir = path.dirname(release.modulePath);
+        while (true) {
+            const candidatePath = path.join(currentDir, sourceRelativePath);
+            if (existsSync(candidatePath)) {
+                return {
+                    sourcePath: candidatePath,
+                    storageAssetPath
+                };
+            }
+            if (path.resolve(currentDir) === checkoutRoot) {
+                break;
+            }
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                break;
+            }
+            currentDir = parentDir;
+        }
+        return null;
+    }
     async loadAndVerifyArtifactManifest(manifestKey, source) {
         const raw = await storage.readText(manifestKey);
         if (!raw) {
@@ -585,3 +627,26 @@ export class TemplateSourceService {
         throw new Error(`Template module path ${declaredModulePath} was not found in the imported release.`);
     }
 }
+function inferContentType(filePath) {
+    switch (path.extname(filePath).toLowerCase()) {
+        case ".png":
+            return "image/png";
+        case ".gif":
+            return "image/gif";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".webp":
+            return "image/webp";
+        case ".svg":
+            return "image/svg+xml";
+        case ".mp4":
+            return "video/mp4";
+        case ".webm":
+            return "video/webm";
+        case ".mov":
+            return "video/quicktime";
+        default:
+            return "application/octet-stream";
+    }
+}