@mevdragon/vidfarm-devcli 0.1.0

package/dist/src/services/providers.js

@@ -0,0 +1,529 @@
+import { config } from "../config.js";
+import { database } from "../db.js";
+import { parseJson } from "../lib/json.js";
+import { decryptString } from "../lib/crypto.js";
+import { createId } from "../lib/ids.js";
+import { addSeconds } from "../lib/time.js";
+export class ProviderKeyUnavailableError extends Error {
+}
+export class ProviderAuthError extends Error {
+}
+export class ProviderRateLimitError extends Error {
+    retryAfterSeconds;
+    constructor(message, retryAfterSeconds = 60) {
+        super(message);
+        this.retryAfterSeconds = retryAfterSeconds;
+    }
+}
+export class ProviderService {
+    async leaseCustomerKey(input) {
+        const leaseToken = createId("lease");
+        const row = database.acquireProviderKeyLease({
+            customerId: input.customerId,
+            provider: input.provider,
+            workerId: input.workerId,
+            jobId: input.jobId,
+            leaseToken,
+            expiresAt: addSeconds(new Date(), 90)
+        });
+        if (!row) {
+            throw new ProviderKeyUnavailableError(`No eligible ${input.provider} key available.`);
+        }
+        return {
+            keyId: row.keyId,
+            leaseToken,
+            provider: input.provider,
+            secret: decryptString(row.encryptedSecret, config.ENCRYPTION_SECRET)
+        };
+    }
+    async releaseLease(lease) {
+        database.releaseProviderKeyLease({ keyId: lease.keyId, leaseToken: lease.leaseToken });
+    }
+    async generateText(input) {
+        const lease = await this.leaseCustomerKey({
+            customerId: input.customerId,
+            provider: input.provider,
+            jobId: input.jobId,
+            workerId: input.workerId
+        });
+        try {
+            if (config.mockProviders) {
+                const text = [
+                    `Hook: ${input.prompt.slice(0, 80)}`,
+                    "Beat 1: Identify the pain point.",
+                    "Beat 2: Show the turning point.",
+                    "Beat 3: Close with a clear CTA."
+                ].join("\n");
+                database.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 180,
+                    outputTokens: 120,
+                    costUsd: 0.02,
+                    metadata: { mock: true }
+                });
+                database.touchProviderKey(lease.keyId);
+                return {
+                    text,
+                    usage: {
+                        inputTokens: 180,
+                        outputTokens: 120,
+                        costUsd: 0.02
+                    }
+                };
+            }
+            const result = await this.callProvider({ ...input, apiKey: lease.secret });
+            database.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "success",
+                inputTokens: result.usage.inputTokens,
+                outputTokens: result.usage.outputTokens,
+                costUsd: result.usage.costUsd
+            });
+            database.touchProviderKey(lease.keyId);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof ProviderRateLimitError) {
+                database.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "rate_limit",
+                    metadata: { retryAfterSeconds: error.retryAfterSeconds }
+                });
+                database.setProviderKeyCooldown(lease.keyId, addSeconds(new Date(), error.retryAfterSeconds));
+            }
+            else if (error instanceof ProviderAuthError) {
+                database.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "auth_error"
+                });
+                database.setProviderKeyCooldown(lease.keyId, null, "invalid", "auth_error");
+            }
+            throw error;
+        }
+        finally {
+            await this.releaseLease(lease);
+        }
+    }
+    async generateImage(input) {
+        const lease = await this.leaseCustomerKey({
+            customerId: input.customerId,
+            provider: input.provider,
+            jobId: input.jobId,
+            workerId: input.workerId
+        });
+        try {
+            if (config.mockProviders) {
+                const svg = buildMockSlideSvg(input.prompt);
+                database.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    costUsd: 0.04,
+                    metadata: { mock: true, type: "image_generation" }
+                });
+                database.touchProviderKey(lease.keyId);
+                return {
+                    bytes: Buffer.from(svg, "utf8"),
+                    contentType: "image/svg+xml",
+                    revisedPrompt: input.prompt
+                };
+            }
+            const result = input.provider === "gemini"
+                ? await this.callGeminiImageGeneration({
+                    model: input.model,
+                    prompt: input.prompt,
+                    apiKey: lease.secret
+                })
+                : await this.callOpenAIImageGeneration({
+                    model: input.model,
+                    prompt: input.prompt,
+                    size: input.size,
+                    apiKey: lease.secret
+                });
+            database.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "success",
+                inputTokens: 0,
+                outputTokens: 0,
+                costUsd: 0.04,
+                metadata: { type: "image_generation" }
+            });
+            database.touchProviderKey(lease.keyId);
+            return result;
+        }
+        finally {
+            await this.releaseLease(lease);
+        }
+    }
+    async analyzeImageLayout(input) {
+        const lease = await this.leaseCustomerKey({
+            customerId: input.customerId,
+            provider: input.provider,
+            jobId: input.jobId,
+            workerId: input.workerId
+        });
+        try {
+            if (config.mockProviders) {
+                database.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    costUsd: 0.005,
+                    metadata: { mock: true, type: "layout_analysis" }
+                });
+                database.touchProviderKey(lease.keyId);
+                return {
+                    zone: "bottom",
+                    align: "center",
+                    maxWidthPercent: 82,
+                    justification: "Mock mode defaults to bottom-center for readable slideshow captions."
+                };
+            }
+            const raw = input.provider === "gemini"
+                ? await this.callGeminiLayoutAnalysis({
+                    model: input.model,
+                    imageUrl: input.imageUrl,
+                    overlayText: input.overlayText,
+                    apiKey: lease.secret
+                })
+                : await this.callOpenAILayoutAnalysis({
+                    model: input.model,
+                    imageUrl: input.imageUrl,
+                    overlayText: input.overlayText,
+                    apiKey: lease.secret
+                });
+            const parsed = parseJson(raw, null);
+            if (!parsed?.zone || !parsed?.align) {
+                throw new Error(`${input.provider} layout analysis returned invalid JSON`);
+            }
+            database.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "success",
+                inputTokens: 0,
+                outputTokens: 0,
+                costUsd: 0.005,
+                metadata: { type: "layout_analysis" }
+            });
+            database.touchProviderKey(lease.keyId);
+            return {
+                zone: parsed.zone,
+                align: parsed.align,
+                maxWidthPercent: clamp(Number(parsed.maxWidthPercent ?? 76), 52, 88),
+                justification: parsed.justification ?? "Selected to preserve legibility and subject framing."
+            };
+        }
+        finally {
+            await this.releaseLease(lease);
+        }
+    }
+    async callOpenAIImageGeneration(input) {
+        const response = await fetch("https://api.openai.com/v1/images/generations", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: JSON.stringify({
+                model: input.model,
+                prompt: input.prompt,
+                size: input.size ?? "1024x1536",
+                response_format: "b64_json"
+            })
+        });
+        if (response.status === 401) {
+            throw new ProviderAuthError("openai authentication failed");
+        }
+        if (response.status === 429) {
+            throw new ProviderRateLimitError("openai rate limited");
+        }
+        if (!response.ok) {
+            throw new Error(`openai image generation returned ${response.status}`);
+        }
+        const data = await response.json();
+        const encoded = data.data?.[0]?.b64_json;
+        if (!encoded) {
+            throw new Error("openai image generation returned no image payload");
+        }
+        return {
+            bytes: Buffer.from(encoded, "base64"),
+            contentType: "image/png",
+            revisedPrompt: data.data?.[0]?.revised_prompt ?? null
+        };
+    }
+    async callGeminiImageGeneration(input) {
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${input.model}:generateContent?key=${input.apiKey}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                contents: [{ parts: [{ text: input.prompt }] }],
+                generationConfig: {
+                    responseModalities: ["TEXT", "IMAGE"]
+                }
+            })
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("gemini authentication failed");
+        }
+        if (response.status === 429) {
+            throw new ProviderRateLimitError("gemini rate limited");
+        }
+        if (!response.ok) {
+            throw new Error(`gemini image generation returned ${response.status}`);
+        }
+        const data = await response.json();
+        const part = data.candidates?.[0]?.content?.parts?.find((item) => item.inlineData?.data);
+        const encoded = part?.inlineData?.data;
+        if (!encoded) {
+            throw new Error("gemini image generation returned no image payload");
+        }
+        return {
+            bytes: Buffer.from(encoded, "base64"),
+            contentType: part.inlineData?.mimeType ?? "image/png",
+            revisedPrompt: null
+        };
+    }
+    async callOpenAILayoutAnalysis(input) {
+        const response = await fetch("https://api.openai.com/v1/chat/completions", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: JSON.stringify({
+                model: input.model,
+                temperature: 0.1,
+                response_format: { type: "json_object" },
+                messages: [
+                    {
+                        role: "system",
+                        content: "Analyze a 9:16 slideshow image and return JSON with zone, align, maxWidthPercent, justification. Prefer negative space and avoid covering a subject."
+                    },
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "text",
+                                text: `The exact overlay text is: ${input.overlayText}\nChoose zone from top, center, bottom. Choose align from left, center, right. maxWidthPercent must be between 52 and 88.`
+                            },
+                            {
+                                type: "image_url",
+                                image_url: {
+                                    url: input.imageUrl
+                                }
+                            }
+                        ]
+                    }
+                ]
+            })
+        });
+        if (response.status === 401) {
+            throw new ProviderAuthError("openai authentication failed");
+        }
+        if (response.status === 429) {
+            throw new ProviderRateLimitError("openai rate limited");
+        }
+        if (!response.ok) {
+            throw new Error(`openai layout analysis returned ${response.status}`);
+        }
+        const data = await response.json();
+        return String(data.choices?.[0]?.message?.content ?? "");
+    }
+    async callGeminiLayoutAnalysis(input) {
+        const image = await fetch(input.imageUrl);
+        if (!image.ok) {
+            throw new Error(`could not fetch image for gemini layout analysis: ${image.status}`);
+        }
+        const bytes = Buffer.from(await image.arrayBuffer());
+        const mimeType = image.headers.get("content-type") || "image/png";
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${input.model}:generateContent?key=${input.apiKey}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                contents: [{
+                        parts: [
+                            {
+                                text: [
+                                    "Analyze this 9:16 slideshow image and return JSON with keys zone, align, maxWidthPercent, justification.",
+                                    "zone must be one of top, center, bottom.",
+                                    "align must be one of left, center, right.",
+                                    "maxWidthPercent must be between 52 and 88.",
+                                    "Prefer negative space and avoid covering the subject.",
+                                    `Exact overlay text: ${input.overlayText}`
+                                ].join("\n")
+                            },
+                            {
+                                inline_data: {
+                                    mime_type: mimeType,
+                                    data: bytes.toString("base64")
+                                }
+                            }
+                        ]
+                    }],
+                generationConfig: {
+                    responseMimeType: "application/json"
+                }
+            })
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("gemini authentication failed");
+        }
+        if (response.status === 429) {
+            throw new ProviderRateLimitError("gemini rate limited");
+        }
+        if (!response.ok) {
+            throw new Error(`gemini layout analysis returned ${response.status}`);
+        }
+        const data = await response.json();
+        const text = data.candidates?.[0]?.content?.parts?.map((part) => part.text ?? "").join("\n") ?? "";
+        return String(text);
+    }
+    async callProvider(input) {
+        if (input.provider === "gemini") {
+            return this.callGemini({
+                provider: "gemini",
+                model: input.model,
+                prompt: input.prompt,
+                temperature: input.temperature,
+                apiKey: input.apiKey
+            });
+        }
+        return this.callOpenAICompatible(input);
+    }
+    async callOpenAICompatible(input) {
+        const endpoint = input.provider === "openrouter"
+            ? "https://openrouter.ai/api/v1/chat/completions"
+            : input.provider === "perplexity"
+                ? "https://api.perplexity.ai/chat/completions"
+                : "https://api.openai.com/v1/chat/completions";
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: JSON.stringify({
+                model: input.model,
+                temperature: input.temperature ?? 0.7,
+                messages: [{ role: "user", content: input.prompt }]
+            })
+        });
+        if (response.status === 401) {
+            throw new ProviderAuthError(`${input.provider} authentication failed`);
+        }
+        if (response.status === 429) {
+            throw new ProviderRateLimitError(`${input.provider} rate limited`);
+        }
+        if (!response.ok) {
+            throw new Error(`${input.provider} returned ${response.status}`);
+        }
+        const data = await response.json();
+        return {
+            text: data.choices?.[0]?.message?.content ?? "",
+            usage: {
+                inputTokens: Number(data.usage?.prompt_tokens ?? 0),
+                outputTokens: Number(data.usage?.completion_tokens ?? 0),
+                costUsd: 0
+            }
+        };
+    }
+    async callGemini(input) {
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${input.model}:generateContent?key=${input.apiKey}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                contents: [{ parts: [{ text: input.prompt }] }],
+                generationConfig: {
+                    temperature: input.temperature ?? 0.7
+                }
+            })
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("Gemini authentication failed");
+        }
+        if (response.status === 429) {
+            throw new ProviderRateLimitError("Gemini rate limited");
+        }
+        if (!response.ok) {
+            throw new Error(`Gemini returned ${response.status}`);
+        }
+        const data = await response.json();
+        return {
+            text: data.candidates?.[0]?.content?.parts?.map((part) => part.text ?? "").join("\n") ?? "",
+            usage: {
+                inputTokens: Number(data.usageMetadata?.promptTokenCount ?? 0),
+                outputTokens: Number(data.usageMetadata?.candidatesTokenCount ?? 0),
+                costUsd: 0
+            }
+        };
+    }
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function buildMockSlideSvg(prompt) {
+    const escaped = escapeXml(prompt.slice(0, 220));
+    return `
+  <svg xmlns="http://www.w3.org/2000/svg" width="1080" height="1920" viewBox="0 0 1080 1920">
+    <defs>
+      <linearGradient id="bg" x1="0" x2="1" y1="0" y2="1">
+        <stop offset="0%" stop-color="#31241c" />
+        <stop offset="52%" stop-color="#866245" />
+        <stop offset="100%" stop-color="#d7c0a4" />
+      </linearGradient>
+    </defs>
+    <rect width="1080" height="1920" fill="url(#bg)" />
+    <rect x="94" y="1180" width="892" height="470" rx="44" fill="rgba(0,0,0,0.18)" stroke="rgba(255,255,255,0.25)" />
+    <text x="108" y="170" fill="#f7f0e7" font-size="54" font-family="Times New Roman, serif">Mock AI image</text>
+    <text x="108" y="240" fill="#f7f0e7" font-size="34" font-family="Times New Roman, serif">${escaped}</text>
+    <text x="108" y="1280" fill="#f7f0e7" font-size="42" font-family="Times New Roman, serif">Reserved text-safe zone</text>
+  </svg>`;
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}

package/dist/src/services/remotion.js

@@ -0,0 +1,158 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { bundle } from "@remotion/bundler";
+import { getRenderProgress, renderMediaOnLambda } from "@remotion/lambda";
+import { getCompositions, renderMedia } from "@remotion/renderer";
+import { config } from "../config.js";
+import { createId } from "../lib/ids.js";
+export class RemotionService {
+    async render(input) {
+        if ((config.REMOTION_MODE === "local" || (config.REMOTION_MODE === "auto" && input.entryPoint)) && input.entryPoint) {
+            return this.renderLocal({
+                compositionId: input.compositionId,
+                entryPoint: input.entryPoint,
+                outputKey: input.outputKey,
+                inputProps: input.inputProps
+            });
+        }
+        const serveUrl = input.serveUrl ?? config.REMOTION_SERVE_URL;
+        if (config.REMOTION_MODE === "mock" || !config.REMOTION_FUNCTION_NAME || !serveUrl || !config.REMOTION_BUCKET_NAME) {
+            return {
+                renderId: createId("render"),
+                outputUrl: null,
+                metadata: {
+                    mode: "mock",
+                    compositionId: input.compositionId,
+                    inputProps: input.inputProps
+                }
+            };
+        }
+        return withRemotionCredentials(async () => {
+            const render = await renderMediaOnLambda({
+                region: config.REMOTION_REGION,
+                functionName: config.REMOTION_FUNCTION_NAME,
+                serveUrl,
+                composition: input.compositionId,
+                inputProps: input.inputProps,
+                codec: "h264",
+                privacy: "public",
+                forceBucketName: config.REMOTION_BUCKET_NAME,
+                forceWidth: 1080,
+                forceHeight: 1920,
+                framesPerLambda: 40,
+                crf: 18,
+                overwrite: true
+            });
+            const startedAt = Date.now();
+            for (;;) {
+                const progress = await getRenderProgress({
+                    region: config.REMOTION_REGION,
+                    functionName: config.REMOTION_FUNCTION_NAME,
+                    bucketName: config.REMOTION_BUCKET_NAME,
+                    renderId: render.renderId
+                });
+                if (progress.done) {
+                    if (!progress.outputFile) {
+                        throw new Error("Remotion render completed without an output file.");
+                    }
+                    return {
+                        renderId: render.renderId,
+                        outputUrl: progress.outputFile,
+                        metadata: {
+                            mode: "lambda",
+                            bucketName: render.bucketName,
+                            compositionId: input.compositionId,
+                            serveUrl,
+                            overallProgress: progress.overallProgress,
+                            renderSize: progress.renderSize
+                        }
+                    };
+                }
+                if (Date.now() - startedAt > 10 * 60 * 1000) {
+                    throw new Error("Timed out waiting for Remotion render output.");
+                }
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+            }
+        });
+    }
+    async renderLocal(input) {
+        const renderId = createId("render");
+        const bundled = await getOrCreateBundle(input.entryPoint);
+        const compositions = await getCompositions(bundled, {
+            inputProps: input.inputProps
+        });
+        const composition = compositions.find((item) => item.id === input.compositionId);
+        if (!composition) {
+            throw new Error(`Composition ${input.compositionId} not found in ${input.entryPoint}`);
+        }
+        const outputKey = input.outputKey ?? `renders/${renderId}.mp4`;
+        const outputLocation = path.join(config.VIDFARM_DATA_DIR, "storage", outputKey);
+        mkdirSync(path.dirname(outputLocation), { recursive: true });
+        await renderMedia({
+            serveUrl: bundled,
+            composition,
+            codec: "h264",
+            inputProps: input.inputProps,
+            outputLocation,
+            overwrite: true
+        });
+        return {
+            renderId,
+            outputUrl: `${config.PUBLIC_BASE_URL}/storage/${encodeURIComponent(outputKey)}`,
+            metadata: {
+                mode: "local",
+                compositionId: input.compositionId,
+                entryPoint: input.entryPoint,
+                outputKey
+            }
+        };
+    }
+}
+const bundleCache = new Map();
+function getOrCreateBundle(entryPoint) {
+    const existing = bundleCache.get(entryPoint);
+    if (existing) {
+        return existing;
+    }
+    const created = bundle({
+        entryPoint,
+        onProgress: () => undefined
+    });
+    bundleCache.set(entryPoint, created);
+    return created;
+}
+async function withRemotionCredentials(work) {
+    const previousAccessKeyId = process.env.AWS_ACCESS_KEY_ID;
+    const previousSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+    const previousRegion = process.env.AWS_REGION;
+    if (config.REMOTION_AWS_ACCESS_KEY_ID) {
+        process.env.AWS_ACCESS_KEY_ID = config.REMOTION_AWS_ACCESS_KEY_ID;
+    }
+    if (config.REMOTION_AWS_SECRET_ACCESS_KEY) {
+        process.env.AWS_SECRET_ACCESS_KEY = config.REMOTION_AWS_SECRET_ACCESS_KEY;
+    }
+    process.env.AWS_REGION = config.REMOTION_REGION;
+    try {
+        return await work();
+    }
+    finally {
+        if (previousAccessKeyId === undefined) {
+            delete process.env.AWS_ACCESS_KEY_ID;
+        }
+        else {
+            process.env.AWS_ACCESS_KEY_ID = previousAccessKeyId;
+        }
+        if (previousSecretAccessKey === undefined) {
+            delete process.env.AWS_SECRET_ACCESS_KEY;
+        }
+        else {
+            process.env.AWS_SECRET_ACCESS_KEY = previousSecretAccessKey;
+        }
+        if (previousRegion === undefined) {
+            delete process.env.AWS_REGION;
+        }
+        else {
+            process.env.AWS_REGION = previousRegion;
+        }
+    }
+}