@mevdragon/vidfarm-devcli 0.2.8 → 0.2.9

package/dist/src/primitive-context.js

@@ -0,0 +1,163 @@
+import { config } from "./config.js";
+import { database } from "./db.js";
+import { createId } from "./lib/ids.js";
+import { jobLogStore } from "./services/job-logs.js";
+export function createPrimitiveJobContext(input) {
+    const prefix = input.storage.primitiveJobPrefix(input.primitive.id, input.customer.id, input.job.id);
+    const buildArtifactUrl = (storageKey, fallbackUrl) => fallbackUrl ?? input.storage.getPublicUrl(storageKey);
+    return {
+        env: config.isProduction ? "production" : "development",
+        customer: input.customer,
+        logger: {
+            debug(message, metadata = {}) {
+                jobLogStore.addEvent({
+                    id: createId("evt"),
+                    jobId: input.job.id,
+                    level: "debug",
+                    message,
+                    metadata,
+                    progress: null,
+                    artifactKey: null
+                });
+            },
+            info(message, metadata = {}) {
+                jobLogStore.addEvent({
+                    id: createId("evt"),
+                    jobId: input.job.id,
+                    level: "info",
+                    message,
+                    metadata,
+                    progress: null,
+                    artifactKey: null
+                });
+            },
+            warn(message, metadata = {}) {
+                jobLogStore.addEvent({
+                    id: createId("evt"),
+                    jobId: input.job.id,
+                    level: "warn",
+                    message,
+                    metadata,
+                    progress: null,
+                    artifactKey: null
+                });
+            },
+            error(message, metadata = {}) {
+                jobLogStore.addEvent({
+                    id: createId("evt"),
+                    jobId: input.job.id,
+                    level: "error",
+                    message,
+                    metadata,
+                    progress: null,
+                    artifactKey: null
+                });
+            },
+            progress(progress, message, metadata = {}) {
+                jobLogStore.addEvent({
+                    id: createId("evt"),
+                    jobId: input.job.id,
+                    level: "info",
+                    message,
+                    metadata,
+                    progress,
+                    artifactKey: typeof metadata.artifactKey === "string" ? metadata.artifactKey : null
+                });
+                database.updateJobStatus({
+                    id: input.job.id,
+                    status: "running",
+                    progress
+                });
+            }
+        },
+        storage: {
+            async putJson(key, value) {
+                const stored = await input.storage.putJson(`${prefix}/${key}`, value);
+                const artifactUrl = buildArtifactUrl(stored.key, stored.url);
+                insertArtifact("json", stored.key, artifactUrl, {});
+                return { ...stored, url: artifactUrl };
+            },
+            async putText(key, value, contentType = "text/plain; charset=utf-8") {
+                const stored = await input.storage.putText(`${prefix}/${key}`, value, contentType);
+                const artifactUrl = buildArtifactUrl(stored.key, stored.url);
+                insertArtifact("text", stored.key, artifactUrl, { contentType });
+                return { ...stored, url: artifactUrl };
+            },
+            async putBuffer(key, value, options = {}) {
+                const stored = await input.storage.putBuffer(`${prefix}/${key}`, value, options.contentType);
+                const artifactUrl = buildArtifactUrl(stored.key, stored.url);
+                insertArtifact(options.kind ?? "binary", stored.key, artifactUrl, {
+                    ...(options.metadata ?? {}),
+                    contentType: options.contentType ?? null
+                });
+                return { ...stored, url: artifactUrl };
+            },
+            getPublicUrl(key) {
+                return input.storage.getPublicUrl(`${prefix}/${key}`);
+            }
+        },
+        billing: {
+            async record(record) {
+                await input.billing.record({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    tracer: input.job.tracer,
+                    templateId: input.primitive.id,
+                    type: record.type,
+                    costUsd: record.costUsd,
+                    chargeUsd: record.chargeUsd ?? Number((record.costUsd * 1.2).toFixed(4)),
+                    costCenterSlug: record.costCenterSlug,
+                    idempotencyKey: record.idempotencyKey,
+                    occurredAtMs: record.occurredAtMs,
+                    metadata: record.metadata
+                });
+            }
+        },
+        providers: {
+            async generateImage(request) {
+                return input.providers.generateImage({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    workerId: input.workerId,
+                    ...request
+                });
+            },
+            async editImage(request) {
+                return input.providers.editImage({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    workerId: input.workerId,
+                    ...request
+                });
+            },
+            async inpaintImage(request) {
+                return input.providers.inpaintImage({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    workerId: input.workerId,
+                    ...request
+                });
+            }
+        },
+        remotion: {
+            async renderStill(request) {
+                return input.remotion.renderStill({
+                    ...request,
+                    outputKey: request.outputKey ? `${prefix}/${request.outputKey}` : undefined
+                });
+            }
+        }
+    };
+    function insertArtifact(kind, storageKey, publicUrl, metadata) {
+        database.insertArtifact({
+            id: createId("art"),
+            jobId: input.job.id,
+            customerId: input.customer.id,
+            templateId: input.primitive.id,
+            kind,
+            storageKey,
+            publicUrl,
+            metadata
+        });
+    }
+}

package/dist/src/primitive-registry.js

@@ -0,0 +1,340 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import sharp from "sharp";
+import { z } from "zod";
+import { definePrimitive } from "./primitive-sdk.js";
+const imageProviderSchema = z.enum(["openai", "gemini", "openrouter"]);
+const outputFormatSchema = z.enum(["png", "jpeg", "webp"]);
+const aspectRatioSchema = z.enum(["1:1", "4:3", "3:4", "16:9", "9:16"]).optional();
+const imageSizeSchema = z.enum(["1K", "2K", "4K"]).optional();
+const generateImagePayloadSchema = z.object({
+    provider: imageProviderSchema.default("gemini"),
+    model: z.string().min(1).optional(),
+    prompt: z.string().min(3).max(8000),
+    prompt_attachments: z.array(z.string().url()).max(12).default([]),
+    aspect_ratio: aspectRatioSchema,
+    size: z.string().min(1).max(40).optional(),
+    image_size: imageSizeSchema,
+    output_format: outputFormatSchema.default("png")
+});
+const editImagePayloadSchema = z.object({
+    provider: imageProviderSchema.default("gemini"),
+    model: z.string().min(1).optional(),
+    source_image_url: z.string().url(),
+    instruction: z.string().min(3).max(8000),
+    reference_attachments: z.array(z.string().url()).max(12).default([]),
+    aspect_ratio: aspectRatioSchema,
+    size: z.string().min(1).max(40).optional(),
+    image_size: imageSizeSchema,
+    output_format: outputFormatSchema.default("png")
+});
+const inpaintImagePayloadSchema = z.object({
+    provider: imageProviderSchema.default("openai"),
+    model: z.string().min(1).optional(),
+    source_image_url: z.string().url(),
+    mask_url: z.string().url(),
+    instruction: z.string().min(3).max(8000),
+    reference_attachments: z.array(z.string().url()).max(12).default([]),
+    aspect_ratio: aspectRatioSchema,
+    size: z.string().min(1).max(40).optional(),
+    image_size: imageSizeSchema,
+    output_format: outputFormatSchema.default("png")
+});
+const renderHtmlImagePayloadSchema = z.object({
+    width: z.number().int().min(16).max(4096).default(1080),
+    height: z.number().int().min(16).max(4096).default(1920),
+    html: z.string().min(1).max(200_000),
+    css: z.string().max(200_000).optional(),
+    background_color: z.string().min(1).max(64).default("#ffffff"),
+    output_format: outputFormatSchema.default("png")
+});
+const PRIMITIVE_IMAGE_GENERATE_ID = "primitive:image_generate";
+const PRIMITIVE_IMAGE_EDIT_ID = "primitive:image_edit";
+const PRIMITIVE_IMAGE_INPAINT_ID = "primitive:image_inpaint";
+const PRIMITIVE_IMAGE_RENDER_HTML_ID = "primitive:image_render_html";
+const HTML_IMAGE_ENTRY_POINT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "primitives", "remotion", "html-image.tsx");
+const HTML_IMAGE_COMPOSITION_ID = "primitive-html-image";
+const imageGeneratePrimitive = definePrimitive({
+    id: PRIMITIVE_IMAGE_GENERATE_ID,
+    kind: "image_generate",
+    operations: {
+        run: {
+            description: "Generate a new image and persist it as a reusable platform URL.",
+            inputSchema: generateImagePayloadSchema,
+            workflow: "run"
+        }
+    },
+    jobs: {
+        async run(ctx, input) {
+            const payload = generateImagePayloadSchema.parse(input);
+            ctx.logger.progress(0.12, "Generating primitive image");
+            const provider = payload.provider;
+            const model = payload.model ?? defaultImageModelForProvider(provider);
+            const generated = await ctx.providers.generateImage({
+                provider,
+                model,
+                prompt: payload.prompt,
+                promptAttachments: payload.prompt_attachments,
+                aspectRatio: payload.aspect_ratio,
+                size: payload.size,
+                imageSize: payload.image_size
+            });
+            const normalized = await normalizePrimitiveImageOutput(generated.bytes, payload.output_format);
+            const stored = await storePrimitiveImage(ctx, {
+                key: `output.${extensionForOutputFormat(payload.output_format)}`,
+                bytes: normalized.bytes,
+                contentType: normalized.contentType,
+                metadata: {
+                    primitive: "image_generate",
+                    provider,
+                    model,
+                    prompt: payload.prompt,
+                    revisedPrompt: generated.revisedPrompt
+                }
+            });
+            ctx.logger.progress(1, "Primitive image generation complete");
+            return {
+                progress: 1,
+                output: buildImagePrimitiveOutput({
+                    fileUrl: stored.url,
+                    contentType: stored.contentType,
+                    revisedPrompt: generated.revisedPrompt,
+                    files: stored.url ? [stored.url] : []
+                })
+            };
+        }
+    }
+});
+const imageEditPrimitive = definePrimitive({
+    id: PRIMITIVE_IMAGE_EDIT_ID,
+    kind: "image_edit",
+    operations: {
+        run: {
+            description: "Edit an existing image into a new reusable platform URL.",
+            inputSchema: editImagePayloadSchema,
+            workflow: "run"
+        }
+    },
+    jobs: {
+        async run(ctx, input) {
+            const payload = editImagePayloadSchema.parse(input);
+            ctx.logger.progress(0.12, "Editing primitive image");
+            const provider = payload.provider;
+            const model = payload.model ?? defaultImageModelForProvider(provider);
+            const edited = await ctx.providers.editImage({
+                provider,
+                model,
+                sourceImageUrl: payload.source_image_url,
+                instruction: payload.instruction,
+                referenceAttachments: payload.reference_attachments,
+                aspectRatio: payload.aspect_ratio,
+                size: payload.size,
+                imageSize: payload.image_size
+            });
+            const normalized = await normalizePrimitiveImageOutput(edited.bytes, payload.output_format);
+            const stored = await storePrimitiveImage(ctx, {
+                key: `output.${extensionForOutputFormat(payload.output_format)}`,
+                bytes: normalized.bytes,
+                contentType: normalized.contentType,
+                metadata: {
+                    primitive: "image_edit",
+                    provider,
+                    model,
+                    sourceImageUrl: payload.source_image_url,
+                    instruction: payload.instruction,
+                    revisedPrompt: edited.revisedPrompt
+                }
+            });
+            ctx.logger.progress(1, "Primitive image edit complete");
+            return {
+                progress: 1,
+                output: buildImagePrimitiveOutput({
+                    fileUrl: stored.url,
+                    contentType: stored.contentType,
+                    revisedPrompt: edited.revisedPrompt,
+                    derivedFromUrl: payload.source_image_url,
+                    files: stored.url ? [stored.url] : []
+                })
+            };
+        }
+    }
+});
+const imageInpaintPrimitive = definePrimitive({
+    id: PRIMITIVE_IMAGE_INPAINT_ID,
+    kind: "image_inpaint",
+    operations: {
+        run: {
+            description: "Inpaint a masked region of an existing image into a new reusable platform URL.",
+            inputSchema: inpaintImagePayloadSchema,
+            workflow: "run"
+        }
+    },
+    jobs: {
+        async run(ctx, input) {
+            const payload = inpaintImagePayloadSchema.parse(input);
+            ctx.logger.progress(0.12, "Inpainting primitive image");
+            const provider = payload.provider;
+            const model = payload.model ?? defaultImageModelForProvider(provider);
+            const edited = await ctx.providers.inpaintImage({
+                provider,
+                model,
+                sourceImageUrl: payload.source_image_url,
+                maskUrl: payload.mask_url,
+                instruction: payload.instruction,
+                referenceAttachments: payload.reference_attachments,
+                aspectRatio: payload.aspect_ratio,
+                size: payload.size,
+                imageSize: payload.image_size
+            });
+            const normalized = await normalizePrimitiveImageOutput(edited.bytes, payload.output_format);
+            const stored = await storePrimitiveImage(ctx, {
+                key: `output.${extensionForOutputFormat(payload.output_format)}`,
+                bytes: normalized.bytes,
+                contentType: normalized.contentType,
+                metadata: {
+                    primitive: "image_inpaint",
+                    provider,
+                    model,
+                    sourceImageUrl: payload.source_image_url,
+                    maskUrl: payload.mask_url,
+                    instruction: payload.instruction,
+                    revisedPrompt: edited.revisedPrompt
+                }
+            });
+            ctx.logger.progress(1, "Primitive image inpaint complete");
+            return {
+                progress: 1,
+                output: buildImagePrimitiveOutput({
+                    fileUrl: stored.url,
+                    contentType: stored.contentType,
+                    revisedPrompt: edited.revisedPrompt,
+                    derivedFromUrl: payload.source_image_url,
+                    maskUrl: payload.mask_url,
+                    files: stored.url ? [stored.url] : []
+                })
+            };
+        }
+    }
+});
+const imageRenderHtmlPrimitive = definePrimitive({
+    id: PRIMITIVE_IMAGE_RENDER_HTML_ID,
+    kind: "image_render_html",
+    operations: {
+        run: {
+            description: "Render an HTML-driven Remotion still image into a reusable platform URL.",
+            inputSchema: renderHtmlImagePayloadSchema,
+            workflow: "run"
+        }
+    },
+    jobs: {
+        async run(ctx, input) {
+            const payload = renderHtmlImagePayloadSchema.parse(input);
+            ctx.logger.progress(0.18, "Rendering primitive HTML image");
+            const rendered = await ctx.remotion.renderStill({
+                compositionId: HTML_IMAGE_COMPOSITION_ID,
+                entryPoint: HTML_IMAGE_ENTRY_POINT,
+                imageFormat: payload.output_format,
+                outputKey: `output.${extensionForOutputFormat(payload.output_format)}`,
+                inputProps: {
+                    width: payload.width,
+                    height: payload.height,
+                    html: payload.html,
+                    css: payload.css ?? "",
+                    backgroundColor: payload.background_color
+                }
+            });
+            ctx.logger.progress(1, "Primitive HTML image render complete");
+            return {
+                progress: 1,
+                output: {
+                    files: rendered.outputUrl ? [rendered.outputUrl] : [],
+                    primary_file_url: rendered.outputUrl,
+                    image: {
+                        file_url: rendered.outputUrl,
+                        content_type: contentTypeForOutputFormat(payload.output_format),
+                        width: payload.width,
+                        height: payload.height
+                    },
+                    render: rendered
+                }
+            };
+        }
+    }
+});
+class PrimitiveRegistry {
+    definitions = new Map([
+        [imageGeneratePrimitive.id, imageGeneratePrimitive],
+        [imageEditPrimitive.id, imageEditPrimitive],
+        [imageInpaintPrimitive.id, imageInpaintPrimitive],
+        [imageRenderHtmlPrimitive.id, imageRenderHtmlPrimitive]
+    ]);
+    get(id) {
+        return this.definitions.get(id) ?? null;
+    }
+    list() {
+        return [...this.definitions.values()];
+    }
+}
+export const primitiveRegistry = new PrimitiveRegistry();
+async function storePrimitiveImage(ctx, input) {
+    const stored = await ctx.storage.putBuffer(input.key, input.bytes, {
+        contentType: input.contentType,
+        kind: "image",
+        metadata: input.metadata
+    });
+    return { ...stored, contentType: input.contentType };
+}
+function buildImagePrimitiveOutput(input) {
+    return {
+        files: input.files,
+        primary_file_url: input.fileUrl,
+        image: {
+            file_url: input.fileUrl,
+            content_type: input.contentType,
+            ...(input.revisedPrompt !== undefined ? { revised_prompt: input.revisedPrompt } : {}),
+            ...(input.derivedFromUrl ? { derived_from_url: input.derivedFromUrl } : {}),
+            ...(input.maskUrl ? { mask_url: input.maskUrl } : {})
+        }
+    };
+}
+function defaultImageModelForProvider(provider) {
+    switch (provider) {
+        case "openai":
+            return "gpt-image-1";
+        case "openrouter":
+            return "google/gemini-2.5-flash-image-preview";
+        default:
+            return "gemini-2.5-flash-image";
+    }
+}
+function extensionForOutputFormat(format) {
+    return format === "jpeg" ? "jpg" : format;
+}
+function contentTypeForOutputFormat(format, fallback) {
+    if (format === "jpeg") {
+        return "image/jpeg";
+    }
+    if (format === "webp") {
+        return "image/webp";
+    }
+    return fallback && fallback !== "image/svg+xml" ? fallback : "image/png";
+}
+async function normalizePrimitiveImageOutput(bytes, format) {
+    const buffer = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
+    if (format === "jpeg") {
+        return {
+            bytes: await sharp(buffer).jpeg({ quality: 92 }).toBuffer(),
+            contentType: "image/jpeg"
+        };
+    }
+    if (format === "webp") {
+        return {
+            bytes: await sharp(buffer).webp({ quality: 92 }).toBuffer(),
+            contentType: "image/webp"
+        };
+    }
+    return {
+        bytes: await sharp(buffer).png().toBuffer(),
+        contentType: "image/png"
+    };
+}

package/dist/src/primitive-sdk.js

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

package/dist/src/primitives/remotion/html-image.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AbsoluteFill, Composition } from "remotion";
+const defaultProps = {
+    width: 1080,
+    height: 1920,
+    html: "<div>Empty primitive HTML image.</div>",
+    css: "",
+    backgroundColor: "#ffffff"
+};
+const HtmlImageComposition = ({ html, css = "", backgroundColor = "#ffffff" }) => {
+    return (_jsxs(AbsoluteFill, { style: {
+            backgroundColor,
+            overflow: "hidden",
+            fontFamily: "Arial, sans-serif"
+        }, children: [css ? _jsx("style", { dangerouslySetInnerHTML: { __html: css } }) : null, _jsx("div", { style: {
+                    width: "100%",
+                    height: "100%"
+                }, dangerouslySetInnerHTML: { __html: html } })] }));
+};
+export const PrimitiveHtmlImageRoot = () => {
+    return (_jsx(Composition, { id: "primitive-html-image", component: HtmlImageComposition, width: 1080, height: 1920, fps: 30, durationInFrames: 1, defaultProps: defaultProps, calculateMetadata: ({ props }) => ({
+            width: typeof props.width === "number" ? Math.max(1, Math.round(props.width)) : 1080,
+            height: typeof props.height === "number" ? Math.max(1, Math.round(props.height)) : 1920,
+            durationInFrames: 1,
+            fps: 30
+        }) }));
+};
+export default PrimitiveHtmlImageRoot;

package/dist/src/react-page-shell.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { renderToStaticMarkup } from "react-dom/server";
+import { escapeHtml } from "./page-shell.js";
+function extractTagContent(documentHtml, tagName) {
+    const match = documentHtml.match(new RegExp(`<${tagName}[^>]*>([\\s\\S]*?)<\\/${tagName}>`, "i"));
+    return match?.[1] ?? "";
+}
+export function parseLegacyDocument(documentHtml) {
+    return {
+        title: extractTagContent(documentHtml, "title"),
+        bodyHtml: extractTagContent(documentHtml, "body"),
+        styleText: extractTagContent(documentHtml, "style")
+    };
+}
+function ReactDocument(input) {
+    const runtimeBoot = input.runtimeBoot ?? {
+        pageKind: "legacy",
+        title: input.title || "VidFarm AI"
+    };
+    return (_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [_jsx("meta", { charSet: "utf-8" }), _jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }), _jsx("title", { children: input.title }), _jsx("link", { rel: "icon", href: "/assets/favicon.ico", sizes: "any" }), _jsx("link", { rel: "preconnect", href: "https://fonts.googleapis.com" }), _jsx("link", { rel: "preconnect", href: "https://fonts.gstatic.com", crossOrigin: "" }), _jsx("link", { href: "https://fonts.googleapis.com/css2?family=Instrument+Serif:ital@0;1&family=Manrope:wght@400;500;600;700;800&display=swap", rel: "stylesheet" }), _jsx("style", { dangerouslySetInnerHTML: { __html: input.styleText } })] }), _jsxs("body", { children: [_jsx("div", { dangerouslySetInnerHTML: { __html: input.bodyHtml } }), _jsx("div", { id: "page-runtime-root", hidden: true }), _jsx("script", { id: "page-runtime-boot", type: "application/json", dangerouslySetInnerHTML: { __html: JSON.stringify(runtimeBoot).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026") } }), _jsx("script", { type: "module", src: "/assets/page-runtime-client-app.js" })] })] }));
+}
+export function renderParsedDocument(input) {
+    return `<!doctype html>${renderToStaticMarkup(_jsx(ReactDocument, { ...input }))}`;
+}
+export function renderLegacyPageAsReact(documentHtml, runtimeBoot) {
+    const parsed = parseLegacyDocument(documentHtml);
+    const safeTitle = parsed.title ? parsed.title : escapeHtml("VidFarm AI");
+    return renderParsedDocument({
+        title: safeTitle,
+        bodyHtml: parsed.bodyHtml,
+        styleText: parsed.styleText,
+        runtimeBoot
+    });
+}