@mevdragon/vidfarm-devcli 0.1.0 → 0.2.1

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

@@ -0,0 +1,37 @@
+import { pathToFileURL } from "node:url";
+export async function loadTemplateFromModule(modulePath) {
+    const loaded = await import(pathToFileURL(modulePath).href);
+    const candidates = Object.values(loaded);
+    for (const candidate of candidates) {
+        if (isTemplateDefinition(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`No template definition export found in ${modulePath}`);
+}
+function isTemplateDefinition(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    const about = typeof candidate.about === "object" && candidate.about !== null
+        ? candidate.about
+        : null;
+    const previewMedia = about && Array.isArray(about.preview_media)
+        ? about.preview_media
+        : null;
+    return (typeof candidate.id === "string" &&
+        typeof candidate.slugId === "string" &&
+        typeof candidate.version === "string" &&
+        about !== null &&
+        typeof about.title === "string" &&
+        typeof about.description === "string" &&
+        typeof about.viral_dna === "string" &&
+        typeof about.visual_dna === "string" &&
+        Array.isArray(previewMedia) &&
+        previewMedia.every((entry) => typeof entry === "string") &&
+        typeof about.link_to_original === "string" &&
+        typeof candidate.configSchema === "object" &&
+        typeof candidate.operations === "object" &&
+        typeof candidate.jobs === "object");
+}

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

@@ -0,0 +1,135 @@
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { config } from "../config.js";
+import { database } from "../db.js";
+import { createId } from "../lib/ids.js";
+import { nowIso } from "../lib/time.js";
+import { loadTemplateFromModule } from "./template-loader.js";
+import { TemplateCertificationService } from "./template-certification.js";
+const execFileAsync = promisify(execFile);
+export class TemplateSourceService {
+    certification = new TemplateCertificationService();
+    listSources() {
+        return database.listTemplateSources();
+    }
+    listReleases(templateId) {
+        return database.listTemplateReleases(templateId);
+    }
+    registerSource(input) {
+        const existingByTemplateId = database.getTemplateSourceByTemplateId(input.templateId);
+        if (existingByTemplateId) {
+            throw new Error("A template with this template_id already exists. Generate a new UUIDv4 and try again.");
+        }
+        const existingBySlugId = database.getTemplateSourceBySlugId(input.slugId);
+        if (existingBySlugId) {
+            throw new Error(`A template with slug_id ${input.slugId} already exists.`);
+        }
+        return database.createTemplateSource({
+            id: createId("tsrc"),
+            templateId: input.templateId,
+            slugId: input.slugId,
+            repoUrl: input.repoUrl,
+            branch: input.branch ?? "production",
+            templateModulePath: input.templateModulePath,
+            skillPath: input.skillPath ?? "SKILL.md",
+            installCommand: input.installCommand ?? "npm install",
+            buildCommand: input.buildCommand ?? "npm run build",
+            status: "active"
+        });
+    }
+    async importRelease(input) {
+        const source = database.getTemplateSource(input.sourceId);
+        if (!source) {
+            throw new Error("Template source not found.");
+        }
+        const commitSha = input.commitSha ?? await this.resolveBranchHead(source.repoUrl, source.branch);
+        const checkoutPath = path.join(config.TEMPLATE_SOURCE_ROOT, source.templateId, commitSha);
+        const skillPath = path.join(checkoutPath, source.skillPath);
+        const modulePath = path.join(checkoutPath, source.templateModulePath);
+        if (!existsSync(checkoutPath)) {
+            mkdirSync(path.dirname(checkoutPath), { recursive: true });
+            await this.runShell(["git", "clone", "--branch", source.branch, source.repoUrl, checkoutPath], process.cwd());
+            await this.runShell(["git", "checkout", commitSha], checkoutPath);
+            if (source.installCommand.trim()) {
+                await this.runCommandString(source.installCommand, checkoutPath);
+            }
+            if (source.buildCommand.trim()) {
+                await this.runCommandString(source.buildCommand, checkoutPath);
+            }
+        }
+        const template = await loadTemplateFromModule(modulePath);
+        if (template.id !== source.templateId) {
+            throw new Error(`Imported template id ${template.id} does not match source template id ${source.templateId}.`);
+        }
+        if (template.slugId !== source.slugId) {
+            throw new Error(`Imported template slug_id ${template.slugId} does not match source slug_id ${source.slugId}.`);
+        }
+        const certificationReport = await this.certification.certify({ template, skillPath });
+        const status = certificationReport.passed ? "certified" : "failed";
+        return database.createTemplateRelease({
+            id: createId("trel"),
+            sourceId: source.id,
+            templateId: source.templateId,
+            branch: source.branch,
+            commitSha,
+            checkoutPath,
+            skillPath,
+            modulePath,
+            status,
+            certificationReport,
+            activatedAt: null
+        });
+    }
+    async activateRelease(input) {
+        const release = database.getTemplateRelease(input.releaseId);
+        if (!release) {
+            throw new Error("Template release not found.");
+        }
+        if (release.status !== "certified" && release.status !== "active") {
+            throw new Error("Only certified releases can be activated.");
+        }
+        const template = await loadTemplateFromModule(release.modulePath);
+        const certificationReport = release.certificationReport ?? await this.certification.certify({
+            template,
+            skillPath: release.skillPath
+        });
+        if (!certificationReport.passed) {
+            database.updateTemplateReleaseStatus({
+                id: release.id,
+                status: "failed",
+                certificationReport
+            });
+            throw new Error("Template release failed certification and cannot be activated.");
+        }
+        database.clearActiveTemplateReleases(release.templateId);
+        database.updateTemplateReleaseStatus({
+            id: release.id,
+            status: "active",
+            certificationReport,
+            activatedAt: nowIso()
+        });
+        return {
+            release: database.getTemplateRelease(release.id),
+            template: {
+                ...template,
+                skillPath: release.skillPath
+            }
+        };
+    }
+    async resolveBranchHead(repoUrl, branch) {
+        const { stdout } = await execFileAsync("git", ["ls-remote", repoUrl, branch], { cwd: process.cwd() });
+        const line = stdout.trim().split("\n").find(Boolean);
+        if (!line) {
+            throw new Error(`Unable to resolve branch ${branch} for ${repoUrl}`);
+        }
+        return line.split(/\s+/)[0];
+    }
+    async runShell(args, cwd) {
+        await execFileAsync(args[0], args.slice(1), { cwd });
+    }
+    async runCommandString(command, cwd) {
+        await execFileAsync("/bin/sh", ["-lc", command], { cwd });
+    }
+}

package/dist/src/worker.js

@@ -17,7 +17,8 @@ export class Worker {
     storage = new StorageService();
     remotion = new RemotionService();
     webhooks = new WebhookService();
-    running = false;
+    tickInFlight = false;
+    activeJobs = 0;
     start() {
         this.timer = setInterval(() => void this.tick(), config.WORKER_POLL_MS);
         void this.tick();
@@ -28,22 +29,33 @@ export class Worker {
         }
     }
     async tick() {
-        if (this.running) {
+        if (this.tickInFlight) {
             return;
         }
-        this.running = true;
+        this.tickInFlight = true;
         try {
-            const runnable = database.listRunnableJobs(config.WORKER_BATCH_SIZE);
-            for (const job of runnable) {
-                await this.runJob(job.id);
+            const availableSlots = Math.max(0, config.WORKER_MAX_CONCURRENT_JOBS - this.activeJobs);
+            if (availableSlots > 0) {
+                const runnable = database.listRunnableJobs(Math.min(config.WORKER_BATCH_SIZE, availableSlots));
+                const executions = runnable.map(async (job) => {
+                    this.activeJobs += 1;
+                    try {
+                        await this.runJob(job.id);
+                    }
+                    finally {
+                        this.activeJobs -= 1;
+                    }
+                });
+                await Promise.all(executions);
             }
             await this.webhooks.flushPending();
         }
         finally {
-            this.running = false;
+            this.tickInFlight = false;
         }
     }
     async runJob(jobId) {
+        await templateRegistry.ensureInitialized();
         const job = this.jobs.getJob(jobId);
         if (!job || job.status !== "queued") {
             return;

package/dist/templates/template_0000/src/lib/images.js

@@ -0,0 +1,242 @@
+import sharp from "sharp";
+export async function normalizeToPortraitFrame(input, target = { width: 1080, height: 1920 }) {
+    const buffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+    const oriented = sharp(buffer, { density: 144 }).rotate();
+    const trimmed = await trimFlatBorders(oriented);
+    const targetAspect = target.width / target.height;
+    // If the model already returned a near-native vertical frame, avoid the
+    // activity crop pass because it can misread low-detail edges as padding.
+    const shouldPreserveFraming = await isCloseToAspect(trimmed, targetAspect, 0.025);
+    const cropped = shouldPreserveFraming ? trimmed : await cropToActiveImageRegion(trimmed);
+    const portraitCrop = await cropToPortraitAspect(cropped, targetAspect);
+    const output = await portraitCrop
+        .resize(target.width, target.height, {
+        fit: "cover",
+        position: sharp.strategy.attention
+    })
+        .png()
+        .toBuffer();
+    const exact = await ensureExactPixelSize(output, target);
+    return {
+        bytes: exact,
+        contentType: "image/png",
+        width: target.width,
+        height: target.height
+    };
+}
+async function isCloseToAspect(image, targetAspect, tolerance) {
+    const metadata = await image.metadata();
+    const width = metadata.width ?? 0;
+    const height = metadata.height ?? 0;
+    if (!width || !height) {
+        return false;
+    }
+    return Math.abs(width / height - targetAspect) <= tolerance;
+}
+async function trimFlatBorders(image) {
+    const metadata = await image.metadata();
+    const sourceWidth = metadata.width ?? 0;
+    const sourceHeight = metadata.height ?? 0;
+    if (!sourceWidth || !sourceHeight || sourceWidth < 3 || sourceHeight < 3) {
+        return image;
+    }
+    const { data, info } = await image
+        .clone()
+        .trim({ threshold: 16 })
+        .png()
+        .toBuffer({ resolveWithObject: true });
+    const widthRatio = info.width / sourceWidth;
+    const heightRatio = info.height / sourceHeight;
+    if (widthRatio > 0.985 && heightRatio > 0.985) {
+        return image;
+    }
+    return sharp(data).rotate();
+}
+async function cropToActiveImageRegion(image) {
+    const metadata = await image.metadata();
+    const sourceWidth = metadata.width ?? 0;
+    const sourceHeight = metadata.height ?? 0;
+    if (!sourceWidth || !sourceHeight) {
+        return image;
+    }
+    const sampleWidth = 96;
+    const sampleHeight = 170;
+    const sample = await image
+        .clone()
+        .resize(sampleWidth, sampleHeight, { fit: "fill" })
+        .grayscale()
+        .raw()
+        .toBuffer();
+    const bounds = detectActiveBounds(sample, sampleWidth, sampleHeight);
+    if (!bounds) {
+        return image;
+    }
+    const left = Math.max(0, Math.floor((bounds.left / sampleWidth) * sourceWidth));
+    const top = Math.max(0, Math.floor((bounds.top / sampleHeight) * sourceHeight));
+    const width = Math.min(sourceWidth - left, Math.max(1, Math.ceil((bounds.width / sampleWidth) * sourceWidth)));
+    const height = Math.min(sourceHeight - top, Math.max(1, Math.ceil((bounds.height / sampleHeight) * sourceHeight)));
+    return image.extract({ left, top, width, height });
+}
+async function cropToPortraitAspect(image, targetAspect) {
+    const metadata = await image.metadata();
+    const sourceWidth = metadata.width ?? 0;
+    const sourceHeight = metadata.height ?? 0;
+    if (!sourceWidth || !sourceHeight) {
+        return image;
+    }
+    const sourceAspect = sourceWidth / sourceHeight;
+    if (Math.abs(sourceAspect - targetAspect) < 0.015) {
+        return image;
+    }
+    const focus = await detectFocusPoint(image, sourceWidth, sourceHeight);
+    if (sourceAspect > targetAspect) {
+        const cropWidth = Math.max(1, Math.min(sourceWidth, Math.round(sourceHeight * targetAspect)));
+        const left = clamp(Math.round(focus.x - cropWidth / 2), 0, sourceWidth - cropWidth);
+        return image.extract({ left, top: 0, width: cropWidth, height: sourceHeight });
+    }
+    const cropHeight = Math.max(1, Math.min(sourceHeight, Math.round(sourceWidth / targetAspect)));
+    const top = clamp(Math.round(focus.y - cropHeight / 2), 0, sourceHeight - cropHeight);
+    return image.extract({ left: 0, top, width: sourceWidth, height: cropHeight });
+}
+function detectActiveBounds(sample, width, height) {
+    const rowActivity = new Array(height).fill(0);
+    const colActivity = new Array(width).fill(0);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const index = y * width + x;
+            const current = sample[index] ?? 0;
+            const left = x > 0 ? sample[index - 1] ?? current : current;
+            const up = y > 0 ? sample[index - width] ?? current : current;
+            const right = x < width - 1 ? sample[index + 1] ?? current : current;
+            const down = y < height - 1 ? sample[index + width] ?? current : current;
+            const energy = Math.abs(current - left) +
+                Math.abs(current - right) +
+                Math.abs(current - up) +
+                Math.abs(current - down);
+            rowActivity[y] += energy;
+            colActivity[x] += energy;
+        }
+    }
+    const smoothedRows = smoothSeries(rowActivity.map((value) => value / width), 9);
+    const smoothedCols = smoothSeries(colActivity.map((value) => value / height), 7);
+    const rowBounds = findActiveRange(smoothedRows, Math.round(height * 0.18));
+    const colBounds = findActiveRange(smoothedCols, Math.round(width * 0.16));
+    if (!rowBounds || !colBounds) {
+        return null;
+    }
+    const topMargin = rowBounds.start / height;
+    const bottomMargin = (height - rowBounds.end - 1) / height;
+    const leftMargin = colBounds.start / width;
+    const rightMargin = (width - colBounds.end - 1) / width;
+    const croppedWidth = colBounds.end - colBounds.start + 1;
+    const croppedHeight = rowBounds.end - rowBounds.start + 1;
+    const croppedAreaRatio = (croppedWidth * croppedHeight) / (width * height);
+    const significantMargins = topMargin > 0.11 || bottomMargin > 0.11 || leftMargin > 0.08 || rightMargin > 0.08;
+    if (!significantMargins && croppedAreaRatio > 0.9) {
+        return null;
+    }
+    return {
+        left: colBounds.start,
+        top: rowBounds.start,
+        width: croppedWidth,
+        height: croppedHeight
+    };
+}
+async function detectFocusPoint(image, sourceWidth, sourceHeight) {
+    const sampleWidth = 120;
+    const sampleHeight = Math.max(1, Math.round((sourceHeight / Math.max(sourceWidth, 1)) * sampleWidth));
+    const sample = await image
+        .clone()
+        .resize(sampleWidth, sampleHeight, { fit: "fill" })
+        .grayscale()
+        .raw()
+        .toBuffer();
+    let weightedX = 0;
+    let weightedY = 0;
+    let totalWeight = 0;
+    for (let y = 0; y < sampleHeight; y += 1) {
+        for (let x = 0; x < sampleWidth; x += 1) {
+            const index = y * sampleWidth + x;
+            const current = sample[index] ?? 0;
+            const left = x > 0 ? sample[index - 1] ?? current : current;
+            const up = y > 0 ? sample[index - sampleWidth] ?? current : current;
+            const right = x < sampleWidth - 1 ? sample[index + 1] ?? current : current;
+            const down = y < sampleHeight - 1 ? sample[index + sampleWidth] ?? current : current;
+            const energy = Math.abs(current - left) +
+                Math.abs(current - right) +
+                Math.abs(current - up) +
+                Math.abs(current - down);
+            const centerBiasX = 1 - Math.abs((x + 0.5) / sampleWidth - 0.5) * 0.45;
+            const centerBiasY = 1 - Math.abs((y + 0.5) / sampleHeight - 0.5) * 0.35;
+            const weight = Math.max(energy, 1) * centerBiasX * centerBiasY;
+            weightedX += (x + 0.5) * weight;
+            weightedY += (y + 0.5) * weight;
+            totalWeight += weight;
+        }
+    }
+    if (totalWeight <= 0) {
+        return { x: sourceWidth / 2, y: sourceHeight / 2 };
+    }
+    return {
+        x: (weightedX / totalWeight / sampleWidth) * sourceWidth,
+        y: (weightedY / totalWeight / sampleHeight) * sourceHeight
+    };
+}
+function findActiveRange(values, minSpan) {
+    const mean = values.reduce((sum, value) => sum + value, 0) / Math.max(values.length, 1);
+    const max = values.reduce((best, value) => Math.max(best, value), 0);
+    if (max <= 0) {
+        return null;
+    }
+    const threshold = mean + (max - mean) * 0.18;
+    let start = 0;
+    while (start < values.length && values[start] < threshold) {
+        start += 1;
+    }
+    let end = values.length - 1;
+    while (end >= 0 && values[end] < threshold) {
+        end -= 1;
+    }
+    if (start >= end) {
+        return null;
+    }
+    const desiredSpan = Math.max(minSpan, end - start + 1);
+    const extra = desiredSpan - (end - start + 1);
+    const expandStart = Math.floor(extra / 2);
+    const expandEnd = extra - expandStart;
+    start = Math.max(0, start - expandStart - 4);
+    end = Math.min(values.length - 1, end + expandEnd + 4);
+    return { start, end };
+}
+function smoothSeries(values, radius) {
+    return values.map((_, index) => {
+        let total = 0;
+        let count = 0;
+        for (let offset = -radius; offset <= radius; offset += 1) {
+            const value = values[index + offset];
+            if (value === undefined) {
+                continue;
+            }
+            total += value;
+            count += 1;
+        }
+        return total / Math.max(count, 1);
+    });
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+async function ensureExactPixelSize(input, target) {
+    const metadata = await sharp(input).metadata();
+    if (metadata.width === target.width && metadata.height === target.height) {
+        return input;
+    }
+    const exactCrop = await cropToPortraitAspect(sharp(input), target.width / target.height);
+    return exactCrop
+        .resize(target.width, target.height, {
+        fit: "cover",
+        position: sharp.strategy.attention
+    })
+        .png()
+        .toBuffer();
+}

package/dist/templates/template_0000/src/remotion/Root.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AbsoluteFill, Composition, Img, Sequence, interpolate, spring, useCurrentFrame, useVideoConfig } from "remotion";
+export const RemotionRoot = () => {
+    return (_jsx(Composition, { id: "template-0000", component: TemplateVideo, width: 1080, height: 1920, fps: 30, durationInFrames: 120, defaultProps: { slides: [] }, calculateMetadata: ({ props }) => ({
+            width: 1080,
+            height: 1920,
+            durationInFrames: Math.max(1, sumSlideFrames(props.slides, 30))
+        }) }));
+};
+const TemplateVideo = ({ slides }) => {
+    const { fps } = useVideoConfig();
+    let currentFrame = 0;
+    return (_jsx(AbsoluteFill, { style: { backgroundColor: "#120f0b" }, children: slides.map((slide, index) => {
+            const durationInFrames = msToFrames(slide.durationMs, fps);
+            const sequence = (_jsx(Sequence, { from: currentFrame, durationInFrames: durationInFrames, children: _jsx(SlideFrame, { slide: slide }) }, `${slide.imageUrl}-${index}`));
+            currentFrame += durationInFrames;
+            return sequence;
+        }) }));
+};
+const SlideFrame = ({ slide }) => {
+    const frame = useCurrentFrame();
+    const { fps } = useVideoConfig();
+    const entrance = spring({ fps, frame, config: { damping: 200, stiffness: 140 } });
+    const opacity = interpolate(entrance, [0, 1], [0.35, 1]);
+    const lift = interpolate(entrance, [0, 1], [22, 0]);
+    return (_jsxs(AbsoluteFill, { children: [_jsx(AbsoluteFill, { style: { opacity, transform: `translateY(${lift}px)` }, children: _jsx(Img, { src: slide.imageUrl, style: { width: "100%", height: "100%", objectFit: "fill" } }) }), _jsx(AbsoluteFill, { style: { background: "linear-gradient(180deg, rgba(0,0,0,0.18) 0%, rgba(0,0,0,0.06) 36%, rgba(0,0,0,0.34) 100%)" } })] }));
+};
+function msToFrames(durationMs, fps) {
+    return Math.max(1, Math.round((durationMs / 1000) * fps));
+}
+function sumSlideFrames(slides, fps) {
+    return slides.reduce((total, slide) => total + msToFrames(slide.durationMs, fps), 0);
+}

package/dist/templates/template_0000/src/sdk.js

@@ -0,0 +1,3 @@
+export function defineTemplate(definition) {
+    return definition;
+}

package/dist/templates/template_0000/src/style-options.js

@@ -0,0 +1,51 @@
+export const TEMPLATE_FONT_OPTIONS = [
+    {
+        id: "source_code_pro",
+        label: "Source Code Pro",
+        family: "Source Code Pro",
+        assetFile: "SourceCodePro[wght].ttf"
+    },
+    {
+        id: "montserrat",
+        label: "Montserrat",
+        family: "Montserrat",
+        assetFile: "Montserrat[wght].ttf"
+    },
+    {
+        id: "yesteryear",
+        label: "Yesteryear",
+        family: "Yesteryear",
+        assetFile: "Yesteryear-Regular.ttf"
+    },
+    {
+        id: "dm_serif_display",
+        label: "DM Serif Display",
+        family: "DM Serif Display",
+        assetFile: "DMSerifDisplay-Regular.ttf"
+    },
+    {
+        id: "abel",
+        label: "Abel",
+        family: "Abel",
+        assetFile: "Abel-Regular.ttf"
+    }
+];
+export const TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS = [
+    { id: "black", label: "Black", hex: "#000000" },
+    { id: "red", label: "Red", hex: "#EA403F" },
+    { id: "orange", label: "Orange", hex: "#FF933D" },
+    { id: "yellow", label: "Yellow", hex: "#F2CD46" },
+    { id: "lime_green", label: "Lime Green", hex: "#78C25E" },
+    { id: "teal", label: "Teal", hex: "#77C8A6" },
+    { id: "light_blue", label: "Light Blue", hex: "#3496F0" },
+    { id: "dark_blue", label: "Dark Blue", hex: "#3496F0" },
+    { id: "violet", label: "Violet", hex: "#5756D4" },
+    { id: "pink", label: "Pink", hex: "#F7D7E9" },
+    { id: "brown", label: "Brown", hex: "#A3895B" },
+    { id: "dark_green", label: "Dark Green", hex: "#32523B" },
+    { id: "blue_gray", label: "Blue Gray", hex: "#2F688C" },
+    { id: "light_gray", label: "Light Gray", hex: "#92979E" },
+    { id: "dark_gray", label: "Dark Gray", hex: "#333333" }
+];
+export const TEMPLATE_FONT_IDS = TEMPLATE_FONT_OPTIONS.map((option) => option.id);
+export const TEMPLATE_TEXT_BACKGROUND_COLOR_IDS = TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS.map((option) => option.id);

package/dist/templates/template_0000/src/template-dna.js

@@ -0,0 +1,9 @@
+// Generated by `vidfarm analyze-viral-dna` and `vidfarm analyze-visual-dna`.
+// Keep source notes in `research/source_notes.md` and reference media in `research/preview/`.
+export const templateLinkToOriginal = "";
+export const templateSourceNotesPath = "research/source_notes.md";
+export const templatePreviewMediaRelativePaths = [];
+export const templateViralDna = "Run `vidfarm analyze-viral-dna --template-dir .` after adding source notes and preview media.";
+export const templateVisualDna = "Run `vidfarm analyze-visual-dna --template-dir .` after adding source notes and preview media.";
+export const templateViralDnaAnalysis = null;
+export const templateVisualDnaAnalysis = null;