@mevdragon/vidfarm-devcli 0.1.0

package/dist/src/services/storage.js

@@ -0,0 +1,93 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { config } from "../config.js";
+export class StorageService {
+    localRoot = path.join(config.VIDFARM_DATA_DIR, "storage");
+    s3 = config.STORAGE_DRIVER === "s3"
+        ? new S3Client({
+            region: config.AWS_REGION,
+            endpoint: config.AWS_S3_ENDPOINT || undefined
+        })
+        : null;
+    constructor() {
+        mkdirSync(this.localRoot, { recursive: true });
+    }
+    async putJson(key, value) {
+        const body = JSON.stringify(value, null, 2);
+        return this.putBuffer(key, Buffer.from(body, "utf8"), "application/json");
+    }
+    async putText(key, value, contentType = "text/plain; charset=utf-8") {
+        return this.putBuffer(key, Buffer.from(value, "utf8"), contentType);
+    }
+    async putBuffer(key, value, contentType = "application/octet-stream") {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            await this.s3.send(new PutObjectCommand({
+                Bucket: config.AWS_S3_BUCKET,
+                Key: key,
+                Body: value,
+                ContentType: contentType
+            }));
+            return { key, url: this.getPublicUrl(key) };
+        }
+        const filePath = path.join(this.localRoot, key);
+        mkdirSync(path.dirname(filePath), { recursive: true });
+        writeFileSync(filePath, value);
+        return { key, url: this.getPublicUrl(key) };
+    }
+    getPublicUrl(key) {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            const encodedKey = key.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+            if (config.AWS_S3_ENDPOINT) {
+                return `${config.AWS_S3_ENDPOINT.replace(/\/$/, "")}/${config.AWS_S3_BUCKET}/${encodedKey}`;
+            }
+            return `https://${config.AWS_S3_BUCKET}.s3.${config.AWS_REGION}.amazonaws.com/${encodedKey}`;
+        }
+        return `${config.PUBLIC_BASE_URL}/storage/${encodeURIComponent(key)}`;
+    }
+    readLocalJson(key) {
+        return JSON.parse(readFileSync(path.join(this.localRoot, key), "utf8"));
+    }
+    readLocalObject(key) {
+        const filePath = path.join(this.localRoot, key);
+        const body = readFileSync(filePath);
+        return {
+            body,
+            contentType: inferContentType(filePath)
+        };
+    }
+    async createPresignedWorkspaceUpload(customerId, relativePath, contentType) {
+        const key = `customers/${customerId}/workspace/${relativePath}`;
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            const command = new PutObjectCommand({
+                Bucket: config.AWS_S3_BUCKET,
+                Key: key,
+                ContentType: contentType
+            });
+            const url = await getSignedUrl(this.s3, command, { expiresIn: 900 });
+            return { key, url, method: "PUT" };
+        }
+        const url = `${config.PUBLIC_BASE_URL}/storage/${encodeURIComponent(key)}`;
+        return { key, url, method: "PUT" };
+    }
+}
+function inferContentType(filePath) {
+    switch (path.extname(filePath).toLowerCase()) {
+        case ".json":
+            return "application/json";
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".svg":
+            return "image/svg+xml";
+        case ".mp4":
+            return "video/mp4";
+        case ".txt":
+            return "text/plain; charset=utf-8";
+        default:
+            return "application/octet-stream";
+    }
+}

package/dist/src/services/webhooks.js

@@ -0,0 +1,61 @@
+import { createHmac } from "node:crypto";
+import { config } from "../config.js";
+import { database } from "../db.js";
+import { createId } from "../lib/ids.js";
+import { addSeconds, nowIso } from "../lib/time.js";
+export class WebhookService {
+    queueJobEvent(input) {
+        database.queueWebhookDelivery({
+            id: createId("whd"),
+            jobId: input.jobId,
+            customerId: input.customerId,
+            destinationUrl: input.destinationUrl,
+            eventType: input.eventType,
+            payload: input.payload
+        });
+    }
+    async flushPending(limit = 20) {
+        const deliveries = database.listPendingWebhookDeliveries(limit);
+        for (const delivery of deliveries) {
+            const payload = String(delivery.payload_json);
+            const signature = createHmac("sha256", config.WEBHOOK_SECRET).update(payload).digest("hex");
+            const attemptCount = Number(delivery.attempt_count) + 1;
+            try {
+                const response = await fetch(String(delivery.destination_url), {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-vidfarm-signature": signature,
+                        "x-vidfarm-event": String(delivery.event_type)
+                    },
+                    body: payload
+                });
+                if (!response.ok) {
+                    throw new Error(`Webhook returned ${response.status}`);
+                }
+                database.markWebhookDelivery({
+                    id: String(delivery.id),
+                    status: "delivered",
+                    attemptCount
+                });
+            }
+            catch (error) {
+                const retriesLeft = attemptCount < 6;
+                database.markWebhookDelivery({
+                    id: String(delivery.id),
+                    status: retriesLeft ? "retrying" : "failed",
+                    attemptCount,
+                    nextAttemptAt: retriesLeft ? addSeconds(new Date(), Math.min(300, attemptCount * 30)) : undefined,
+                    lastError: error instanceof Error ? error.message : "Unknown webhook error"
+                });
+            }
+        }
+    }
+    buildJobPayload(eventType, job) {
+        return {
+            type: eventType,
+            emitted_at: nowIso(),
+            job
+        };
+    }
+}

package/dist/src/template-sdk.js

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

package/dist/src/worker.js

@@ -0,0 +1,122 @@
+import { config } from "./config.js";
+import { createTemplateJobContext } from "./context.js";
+import { database } from "./db.js";
+import { templateRegistry } from "./registry.js";
+import { BillingService } from "./services/billing.js";
+import { JobsService } from "./services/jobs.js";
+import { ProviderAuthError, ProviderKeyUnavailableError, ProviderRateLimitError, ProviderService } from "./services/providers.js";
+import { RemotionService } from "./services/remotion.js";
+import { StorageService } from "./services/storage.js";
+import { WebhookService } from "./services/webhooks.js";
+export class Worker {
+    timer = null;
+    workerId = `worker-${process.pid}`;
+    jobs = new JobsService();
+    billing = new BillingService();
+    providers = new ProviderService();
+    storage = new StorageService();
+    remotion = new RemotionService();
+    webhooks = new WebhookService();
+    running = false;
+    start() {
+        this.timer = setInterval(() => void this.tick(), config.WORKER_POLL_MS);
+        void this.tick();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+        }
+    }
+    async tick() {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        try {
+            const runnable = database.listRunnableJobs(config.WORKER_BATCH_SIZE);
+            for (const job of runnable) {
+                await this.runJob(job.id);
+            }
+            await this.webhooks.flushPending();
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async runJob(jobId) {
+        const job = this.jobs.getJob(jobId);
+        if (!job || job.status !== "queued") {
+            return;
+        }
+        const customer = database.getCustomerById(job.customerId);
+        const template = templateRegistry.get(job.templateId);
+        if (!customer || !template) {
+            this.jobs.failJob(job.id, { message: "Missing customer or template." });
+            return;
+        }
+        const workflow = template.jobs[job.workflowName];
+        if (!workflow) {
+            this.jobs.failJob(job.id, { message: `Unknown workflow ${job.workflowName}` });
+            return;
+        }
+        this.jobs.markRunning(job.id);
+        await this.emitWebhookIfNeeded("job.running", job.id);
+        const ctx = createTemplateJobContext({
+            customer,
+            job,
+            template,
+            workerId: this.workerId,
+            storage: this.storage,
+            jobs: this.jobs,
+            billing: this.billing,
+            providers: this.providers,
+            remotion: this.remotion
+        });
+        try {
+            const result = await workflow(ctx, job.payload);
+            this.jobs.succeedJob(job.id, result.output ?? {}, result.progress ?? 1);
+            await this.emitWebhookIfNeeded("job.succeeded", job.id);
+        }
+        catch (error) {
+            if (error instanceof ProviderKeyUnavailableError) {
+                this.jobs.requeueJob(job, config.DEFAULT_JOB_DELAY_SECONDS, { message: error.message, type: "provider_key_unavailable" });
+                await this.emitWebhookIfNeeded("job.queued", job.id);
+                return;
+            }
+            if (error instanceof ProviderRateLimitError) {
+                this.jobs.requeueJob(job, error.retryAfterSeconds, { message: error.message, type: "provider_rate_limited" });
+                await this.emitWebhookIfNeeded("job.queued", job.id);
+                return;
+            }
+            if (error instanceof ProviderAuthError) {
+                this.jobs.requeueJob(job, 5, { message: error.message, type: "provider_auth_error" });
+                await this.emitWebhookIfNeeded("job.queued", job.id);
+                return;
+            }
+            this.jobs.failJob(job.id, { message: error instanceof Error ? error.message : "Unknown worker error" });
+            await this.emitWebhookIfNeeded("job.failed", job.id);
+        }
+    }
+    async emitWebhookIfNeeded(eventType, jobId) {
+        const job = this.jobs.getJob(jobId);
+        if (!job || !job.webhookUrl) {
+            return;
+        }
+        this.webhooks.queueJobEvent({
+            jobId: job.id,
+            customerId: job.customerId,
+            destinationUrl: job.webhookUrl,
+            eventType,
+            payload: this.webhooks.buildJobPayload(eventType, {
+                job_id: job.id,
+                tracer: job.tracer,
+                status: job.status,
+                template_id: job.templateId,
+                operation_name: job.operationName,
+                progress: job.progress,
+                result: job.result,
+                error: job.error
+            })
+        });
+    }
+}

package/dist/templates/template_0000/demo-template.js

@@ -0,0 +1,196 @@
+import { z } from "zod";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { normalizeToPortraitFrame } from "../../src/lib/images.js";
+import { defineTemplate } from "../../src/template-sdk.js";
+const slideInputSchema = z.tuple([z.string().min(3), z.string().min(1)]);
+const generateInputSchema = z.object({
+    slides: z.array(slideInputSchema).min(1).max(20),
+    secondsPerSlide: z.number().min(2).max(10).default(4)
+});
+const remotionEntryPoint = resolveRemotionEntryPoint();
+export const demoTemplate = defineTemplate({
+    id: "demo-template",
+    version: "1.0.0",
+    description: "Opinionated slideshow generator that makes tall images, picks text placement, and renders a TikTok-ready Remotion video.",
+    configSchema: z.object({
+        defaultProvider: z.enum(["openai", "gemini"]).default("gemini"),
+        textModel: z.string().default("gemini-3.1-flash-lite"),
+        imageModel: z.string().default("gemini-2.5-flash-image"),
+        renderCompositionId: z.string().default("demo-template")
+    }),
+    operations: {
+        generate: {
+            description: "Generate a slideshow from [[imagePrompt, exactOverlayText], ...] and return public artifact URLs.",
+            inputSchema: generateInputSchema,
+            workflow: "generateWorkflow",
+            webhookSupport: true
+        }
+    },
+    jobs: {
+        async generateWorkflow(ctx, input) {
+            const payload = generateInputSchema.parse(input);
+            ctx.logger.progress(0.04, "Starting demo slideshow pipeline");
+            const provider = String(ctx.templateConfig.defaultProvider ?? "gemini");
+            const textModel = String(ctx.templateConfig.textModel ?? "gemini-3.1-flash-lite");
+            const imageModel = String(ctx.templateConfig.imageModel ?? "gemini-2.5-flash-image");
+            const compositionId = String(ctx.templateConfig.renderCompositionId ?? "demo-template");
+            const slides = [];
+            for (const [index, [imagePrompt, overlayText]] of payload.slides.entries()) {
+                const prompt = buildImagePrompt(imagePrompt, overlayText);
+                ctx.logger.progress(0.08 + (index / payload.slides.length) * 0.42, `Generating slide ${index + 1} image`);
+                const image = await ctx.providers.generateImage({
+                    provider,
+                    model: imageModel,
+                    prompt,
+                    size: sourceImageSizeForProvider(provider)
+                });
+                await ctx.billing.record({
+                    type: "ai_generation",
+                    costUsd: 0.04,
+                    metadata: { stage: "image_generation", slideIndex: index, model: imageModel }
+                });
+                ctx.logger.progress(0.13 + (index / payload.slides.length) * 0.42, `Normalizing slide ${index + 1} to strict 9:16 portrait`);
+                const normalizedImage = await normalizeToPortraitFrame(image.bytes, { width: 1080, height: 1920 });
+                const imageArtifact = await ctx.storage.putBuffer(`slides/slide-${pad2(index + 1)}.png`, normalizedImage.bytes, {
+                    contentType: normalizedImage.contentType,
+                    kind: "image",
+                    metadata: {
+                        slideIndex: index,
+                        prompt,
+                        revisedPrompt: image.revisedPrompt,
+                        width: normalizedImage.width,
+                        height: normalizedImage.height,
+                        aspectRatio: "9:16"
+                    }
+                });
+                const layout = await safeAnalyzeLayout(ctx, {
+                    imageUrl: imageArtifact.url,
+                    overlayText,
+                    textModel
+                });
+                await ctx.billing.record({
+                    type: "ai_generation",
+                    costUsd: 0.005,
+                    metadata: { stage: "layout_analysis", slideIndex: index, model: textModel }
+                });
+                slides.push({
+                    index,
+                    imagePrompt,
+                    overlayText,
+                    imageUrl: imageArtifact.url,
+                    prompt,
+                    revisedPrompt: image.revisedPrompt,
+                    layout
+                });
+            }
+            ctx.logger.progress(0.58, "Saving slideshow manifest");
+            const manifest = {
+                templateId: "demo-template",
+                size: { width: 1080, height: 1920, aspectRatio: "9:16" },
+                secondsPerSlide: payload.secondsPerSlide,
+                font: "Times New Roman",
+                slides
+            };
+            const manifestArtifact = await ctx.storage.putJson("manifests/demo-template.json", manifest);
+            ctx.logger.progress(0.72, "Submitting Remotion render");
+            const render = await ctx.remotion.render({
+                compositionId,
+                entryPoint: remotionEntryPoint,
+                outputKey: "renders/final.mp4",
+                inputProps: {
+                    slides: slides.map((slide) => ({
+                        imageUrl: slide.imageUrl,
+                        text: slide.overlayText,
+                        layout: slide.layout
+                    })),
+                    fps: 30,
+                    secondsPerSlide: payload.secondsPerSlide
+                }
+            });
+            await ctx.billing.record({
+                type: "render",
+                costUsd: 0.35,
+                metadata: render.metadata
+            });
+            const files = slides.map((slide) => slide.imageUrl).filter((value) => Boolean(value));
+            if (manifestArtifact.url) {
+                files.push(manifestArtifact.url);
+            }
+            if (render.outputUrl) {
+                files.push(render.outputUrl);
+            }
+            ctx.logger.progress(1, "Demo slideshow complete", {
+                fileCount: files.length,
+                renderId: render.renderId
+            });
+            return {
+                progress: 1,
+                output: {
+                    files,
+                    render,
+                    manifest: manifestArtifact,
+                    slides
+                }
+            };
+        }
+    }
+});
+function buildImagePrompt(imagePrompt, overlayText) {
+    return [
+        "Create an exact 9:16 portrait slideshow image for a TikTok-style vertical video.",
+        "The composition must be designed for strict full-frame mobile portrait output at 1080x1920.",
+        "Do not produce square, landscape, or loose portrait framing.",
+        "Do not letterbox, pillarbox, add borders, or leave empty margins.",
+        "Keep the subject composition strong but leave one large clean zone with low visual detail for text overlay.",
+        "Do not place important faces, hands, or product details in the top or bottom caption-safe regions.",
+        "Do not render any words, letters, captions, subtitles, titles, logos, signage, labels, watermarks, or typography inside the image.",
+        "The final image must contain zero visible text.",
+        "Use cinematic lighting, crisp detail, and framing that already fits an exact 9:16 portrait frame.",
+        `User visual prompt: ${imagePrompt}`,
+        `Reserve room for a short editorial overlay approximately ${overlayText.length} characters long, but do not render the overlay text itself.`
+    ].join("\n");
+}
+async function safeAnalyzeLayout(ctx, input) {
+    if (!input.imageUrl) {
+        return defaultLayout();
+    }
+    try {
+        return await ctx.providers.analyzeImageLayout({
+            provider: String(ctx.templateConfig.defaultProvider ?? "gemini"),
+            model: input.textModel,
+            imageUrl: input.imageUrl,
+            overlayText: input.overlayText
+        });
+    }
+    catch (error) {
+        ctx.logger.warn("Layout analysis failed, using default placement", {
+            error: error instanceof Error ? error.message : "Unknown error"
+        });
+        return defaultLayout();
+    }
+}
+function defaultLayout() {
+    return {
+        zone: "bottom",
+        align: "center",
+        maxWidthPercent: 82,
+        justification: "Fallback placement keeps the overlay in a readable lower safe zone."
+    };
+}
+function sourceImageSizeForProvider(provider) {
+    if (provider === "openai") {
+        return "1024x1792";
+    }
+    return "1080x1920";
+}
+function pad2(value) {
+    return String(value).padStart(2, "0");
+}
+function resolveRemotionEntryPoint() {
+    const builtPath = fileURLToPath(new URL("./remotion/index.js", import.meta.url));
+    if (existsSync(builtPath)) {
+        return builtPath;
+    }
+    return fileURLToPath(new URL("./remotion/index.tsx", import.meta.url));
+}

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

@@ -0,0 +1,66 @@
+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: "demo-template", component: DemoTemplateVideo, width: 1080, height: 1920, fps: 30, durationInFrames: 120, defaultProps: { slides: [], secondsPerSlide: 4 }, calculateMetadata: ({ props }) => ({
+            width: 1080,
+            height: 1920,
+            durationInFrames: Math.max(1, props.slides.length) * Math.max(1, Math.round((props.secondsPerSlide ?? 4) * 30))
+        }) }));
+};
+const DemoTemplateVideo = ({ slides, secondsPerSlide = 4 }) => {
+    const { fps } = useVideoConfig();
+    const framesPerSlide = Math.max(1, Math.round(secondsPerSlide * fps));
+    return (_jsx(AbsoluteFill, { style: { backgroundColor: "#120f0b" }, children: slides.map((slide, index) => (_jsx(Sequence, { from: index * framesPerSlide, durationInFrames: framesPerSlide, children: _jsx(SlideFrame, { slide: slide }) }, `${slide.imageUrl}-${index}`))) }));
+};
+const SlideFrame = ({ slide }) => {
+    const frame = useCurrentFrame();
+    const { fps } = useVideoConfig();
+    const entrance = spring({ fps, frame, config: { damping: 200, stiffness: 140 } });
+    const scale = interpolate(entrance, [0, 1], [1.06, 1]);
+    const opacity = interpolate(entrance, [0, 1], [0.2, 1]);
+    return (_jsxs(AbsoluteFill, { children: [_jsx(AbsoluteFill, { style: { opacity, transform: `scale(${scale})` }, children: _jsx(Img, { src: slide.imageUrl, style: { width: "100%", height: "100%", objectFit: "cover" } }) }), _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%)" } }), _jsx(TextOverlay, { slide: slide })] }));
+};
+const TextOverlay = ({ slide }) => {
+    const zoneStyle = slide.layout.zone === "top"
+        ? { top: "8%", bottom: "auto" }
+        : slide.layout.zone === "center"
+            ? { top: "50%", bottom: "auto", transform: "translateY(-50%)" }
+            : { top: "auto", bottom: "9%" };
+    return (_jsx("div", { style: {
+            position: "absolute",
+            left: "9%",
+            right: "9%",
+            display: "flex",
+            justifyContent: alignmentToJustify(slide.layout.align),
+            pointerEvents: "none",
+            ...zoneStyle
+        }, children: _jsx("div", { style: {
+                maxWidth: `${slide.layout.maxWidthPercent}%`,
+                width: `${slide.layout.maxWidthPercent}%`,
+                boxSizing: "border-box",
+                padding: "28px 32px",
+                color: "#fffaf2",
+                fontFamily: '"Times New Roman", Times, serif',
+                fontSize: 72,
+                lineHeight: 1.08,
+                letterSpacing: "-0.03em",
+                textAlign: slide.layout.align,
+                overflowWrap: "anywhere",
+                wordBreak: "break-word",
+                whiteSpace: "pre-wrap",
+                background: "rgba(18, 14, 10, 0.28)",
+                boxShadow: "0 18px 44px rgba(0, 0, 0, 0.22)",
+                textShadow: "0 2px 6px rgba(0, 0, 0, 0.48)",
+                backdropFilter: "blur(8px)"
+            }, children: slide.text }) }));
+};
+function alignmentToJustify(align) {
+    switch (align) {
+        case "left":
+            return "flex-start";
+        case "right":
+            return "flex-end";
+        default:
+            return "center";
+    }
+}

package/dist/templates/template_0000/remotion/index.js

@@ -0,0 +1,3 @@
+import { registerRoot } from "remotion";
+import { RemotionRoot } from "./Root.js";
+registerRoot(RemotionRoot);

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@mevdragon/vidfarm-devcli",
+  "version": "0.1.0",
+  "description": "Developer CLI for running the Vidfarm local template platform.",
+  "type": "module",
+  "bin": {
+    "vidfarm": "dist/src/cli.js",
+    "vidfarm-devcli": "dist/src/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "PLATFORM_SPEC.md",
+    "AWS_REMOTION_HANDOFF.md",
+    ".env.example"
+  ],
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OfficeXApp/vidfarm-devcli.git"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "dev:cli": "tsx src/cli.ts dev",
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "start": "node dist/src/index.js",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.787.0",
+    "@aws-sdk/s3-request-presigner": "^3.787.0",
+    "@hono/node-server": "^1.14.4",
+    "@remotion/bundler": "4.0.355",
+    "@remotion/lambda": "4.0.355",
+    "@remotion/renderer": "4.0.355",
+    "better-sqlite3": "^12.1.1",
+    "dotenv": "^16.5.0",
+    "hono": "^4.8.3",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "remotion": "4.0.355",
+    "sharp": "^0.34.5",
+    "zod": "^3.25.28"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^24.0.1",
+    "@types/react": "^18.3.23",
+    "@types/react-dom": "^18.3.7",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
+  }
+}