@mevdragon/vidfarm-devcli 0.5.2 → 0.6.0

package/dist/src/primitive-context.js

@@ -0,0 +1,357 @@
+import { readFile } from "node:fs/promises";
+import * as Sentry from "@sentry/node";
+import { config } from "./config.js";
+import { devErrorFields, devLog } from "./lib/dev-log.js";
+import { createId } from "./lib/ids.js";
+import { jobLogStore } from "./services/job-logs.js";
+import { estimateNormalizationCostUsd, normalizeVideoAsset } from "./services/video-normalization.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) ?? buildPlatformMediaUrl(storageKey);
+    // Billing records are written after the billable work (render, normalize,
+    // etc.) has already succeeded. A transient billing failure must never fail
+    // the job — the customer would retry and pay for the expensive work twice.
+    const recordBillingNonFatal = async (record) => {
+        try {
+            await input.billing.record(record);
+        }
+        catch (error) {
+            Sentry.captureException(error);
+            devLog("billing.record_failed_nonfatal", {
+                job_id: input.job.id,
+                customer_id: input.customer.id,
+                template_id: input.primitive.id,
+                cost_center_slug: record.costCenterSlug ?? null,
+                idempotency_key: record.idempotencyKey ?? null,
+                ...devErrorFields(error)
+            }, "warn");
+        }
+    };
+    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
+                });
+                void input.jobs.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);
+                await 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);
+                await 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);
+                await 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}`);
+            },
+            resolveKey(key) {
+                return `${prefix}/${key}`;
+            }
+        },
+        billing: {
+            async record(record) {
+                await recordBillingNonFatal({
+                    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: {
+            listAvailableProviders() {
+                return input.providers.listAvailableProviders(input.customer.id);
+            },
+            async generateText(request) {
+                return input.providers.generateText({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    workerId: input.workerId,
+                    ...request
+                });
+            },
+            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
+                });
+            },
+            async generateVideo(request) {
+                return input.providers.generateVideo({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    workerId: input.workerId,
+                    ...request
+                });
+            }
+        },
+        hyperframes: {
+            async render(request) {
+                const hyperframesOutputKey = `renders/vidfarm/primitives/${input.primitive.id}/${input.customer.id}/${input.job.id}/output.mp4`;
+                const render = await input.hyperframes.render({
+                    ...request,
+                    outputKey: hyperframesOutputKey,
+                    wait: true
+                });
+                let outputUrl = render.outputUrl;
+                let platformOutputKey = null;
+                const localOutputLocation = typeof render.metadata.outputLocation === "string"
+                    ? render.metadata.outputLocation
+                    : null;
+                if (render.outputS3Uri) {
+                    const output = await input.hyperframes.readRenderOutput(render.outputS3Uri);
+                    platformOutputKey = `${prefix}/${request.outputKey || "output.mp4"}`;
+                    const stored = await input.storage.putBuffer(platformOutputKey, output.bytes, output.contentType);
+                    outputUrl = buildArtifactUrl(stored.key, stored.url);
+                    await insertArtifact("video", stored.key, outputUrl, {
+                        operation: "hyperframes-render",
+                        contentType: output.contentType,
+                        renderId: render.renderId,
+                        outputS3Uri: render.outputS3Uri
+                    });
+                }
+                else if (localOutputLocation) {
+                    // In-process (local) render writes the MP4 to ephemeral local disk and
+                    // returns no S3 URI. On serverless boxes that disk is per-invocation
+                    // and the `renders/` prefix is not publicly served, so the raw
+                    // outputUrl 404s ("Artifact not found"). Persist the bytes into the
+                    // public job-scoped prefix — S3 on cloud, local disk on serve boxes —
+                    // exactly like the cloud branch above.
+                    const bytes = await readFile(localOutputLocation);
+                    platformOutputKey = `${prefix}/${request.outputKey || "output.mp4"}`;
+                    const stored = await input.storage.putBuffer(platformOutputKey, bytes, "video/mp4");
+                    outputUrl = buildArtifactUrl(stored.key, stored.url);
+                    await insertArtifact("video", stored.key, outputUrl, {
+                        operation: "hyperframes-render-local",
+                        contentType: "video/mp4",
+                        renderId: render.renderId,
+                        outputLocation: localOutputLocation
+                    });
+                }
+                const estimatedCostUsd = typeof render.metadata.estimatedCostUsd === "number" ? render.metadata.estimatedCostUsd : null;
+                const chargeUsd = typeof render.metadata.chargeUsd === "number" ? render.metadata.chargeUsd : null;
+                if (estimatedCostUsd !== null && estimatedCostUsd > 0) {
+                    await recordBillingNonFatal({
+                        customerId: input.customer.id,
+                        jobId: input.job.id,
+                        tracer: input.job.tracer,
+                        templateId: input.primitive.id,
+                        type: "render",
+                        costUsd: estimatedCostUsd,
+                        chargeUsd: typeof chargeUsd === "number" ? chargeUsd : undefined,
+                        costCenterSlug: "hyperframes_lambda",
+                        idempotencyKey: `hyperframes_lambda:${render.renderId}`,
+                        occurredAtMs: Date.now(),
+                        metadata: {
+                            ...render.metadata,
+                            render_id: render.renderId,
+                            output_url: outputUrl,
+                            signed_output_url: render.outputUrl,
+                            output_s3_uri: render.outputS3Uri,
+                            platform_output_key: platformOutputKey
+                        }
+                    });
+                }
+                return {
+                    renderId: render.renderId,
+                    outputUrl,
+                    outputS3Uri: render.outputS3Uri,
+                    metadata: {
+                        ...render.metadata,
+                        outputUrl,
+                        signedOutputUrl: render.outputUrl,
+                        platformOutputKey
+                    }
+                };
+            },
+            async renderStill(request) {
+                const extension = (request.imageFormat ?? "png") === "jpeg" ? "jpg" : (request.imageFormat ?? "png");
+                const localOutputKey = `renders/vidfarm/primitives/${input.primitive.id}/${input.customer.id}/${input.job.id}/${request.outputKey || `output.${extension}`}`;
+                const rendered = await input.hyperframes.renderStill({
+                    compositionHtml: request.compositionHtml,
+                    compositionId: request.compositionId,
+                    imageFormat: request.imageFormat,
+                    outputKey: localOutputKey
+                });
+                // renderStill writes to ephemeral local disk under the non-public
+                // `renders/` prefix. Persist it into the public job-scoped prefix (S3 on
+                // cloud, local disk on serve boxes) so the artifact URL resolves — same
+                // fix as render() above.
+                const platformKey = `${prefix}/${request.outputKey || `output.${extension}`}`;
+                const contentType = extension === "jpg" ? "image/jpeg" : extension === "webp" ? "image/webp" : "image/png";
+                const bytes = await readFile(rendered.outputLocation);
+                const stored = await input.storage.putBuffer(platformKey, bytes, contentType);
+                const outputUrl = buildArtifactUrl(stored.key, stored.url);
+                await insertArtifact("image", stored.key, outputUrl, {
+                    operation: "hyperframes-render-still",
+                    renderId: rendered.renderId,
+                    imageFormat: request.imageFormat ?? "png"
+                });
+                return {
+                    renderId: rendered.renderId,
+                    outputUrl,
+                    metadata: rendered.metadata
+                };
+            }
+        },
+        media: {
+            async normalizeVideo(request) {
+                const normalized = await normalizeVideoAsset({
+                    sourceUrl: request.sourceUrl,
+                    maxWidth: request.maxWidth,
+                    maxHeight: request.maxHeight,
+                    crf: request.crf,
+                    preset: request.preset,
+                    maxVideoBitrateKbps: request.maxVideoBitrateKbps,
+                    audioBitrateKbps: request.audioBitrateKbps
+                });
+                const stored = await input.storage.putBuffer(`${prefix}/${request.outputKey}`, normalized.bytes, normalized.contentType);
+                const artifactUrl = buildArtifactUrl(stored.key, stored.url);
+                await insertArtifact("video", stored.key, artifactUrl, {
+                    ...(request.metadata ?? {}),
+                    operation: "normalize-video",
+                    contentType: normalized.contentType,
+                    normalization: normalized.metadata
+                });
+                await recordBillingNonFatal({
+                    customerId: input.customer.id,
+                    jobId: input.job.id,
+                    tracer: input.job.tracer,
+                    templateId: input.primitive.id,
+                    type: "cpu_estimate",
+                    costUsd: estimateNormalizationCostUsd(normalized.metadata),
+                    costCenterSlug: "video_normalization",
+                    idempotencyKey: `video_normalization:${input.job.id}:${request.outputKey}`,
+                    occurredAtMs: Date.now(),
+                    metadata: {
+                        ...(request.metadata ?? {}),
+                        operation: "normalize-video",
+                        source_url: request.sourceUrl,
+                        output_key: `${prefix}/${request.outputKey}`,
+                        normalization: normalized.metadata
+                    }
+                });
+                return {
+                    ...stored,
+                    url: artifactUrl,
+                    contentType: normalized.contentType,
+                    normalization: normalized.metadata
+                };
+            }
+        }
+    };
+    async function insertArtifact(kind, storageKey, publicUrl, metadata) {
+        await input.jobs.insertArtifact({
+            id: createId("art"),
+            jobId: input.job.id,
+            customerId: input.customer.id,
+            templateId: input.primitive.id,
+            kind,
+            storageKey,
+            publicUrl,
+            metadata
+        });
+    }
+}
+function buildPlatformMediaUrl(storageKey) {
+    return `${config.PUBLIC_BASE_URL.replace(/\/$/, "")}/template-media?key=${encodeURIComponent(storageKey)}`;
+}
+//# sourceMappingURL=primitive-context.js.map