@mevdragon/vidfarm-devcli 0.20.6 → 0.20.8

package/dist/src/primitive-context.js

@@ -1,416 +0,0 @@
-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 { RenderInProgressError } from "./services/hyperframes.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
-                });
-            },
-            async generateSpeech(request) {
-                return input.providers.generateSpeech({
-                    customerId: input.customer.id,
-                    jobId: input.job.id,
-                    workerId: input.workerId,
-                    ...request
-                });
-            },
-            async transcribeSpeech(request) {
-                return input.providers.transcribeSpeech({
-                    customerId: input.customer.id,
-                    jobId: input.job.id,
-                    workerId: input.workerId,
-                    ...request
-                });
-            },
-            async generateMusic(request) {
-                return input.providers.generateMusic({
-                    customerId: input.customer.id,
-                    jobId: input.job.id,
-                    workerId: input.workerId,
-                    ...request
-                });
-            },
-            async listElevenLabsVoices(request) {
-                return input.providers.listElevenLabsVoices({
-                    customerId: input.customer.id,
-                    ...request
-                });
-            }
-        },
-        hyperframes: {
-            async render(request) {
-                const hyperframesOutputKey = `renders/vidfarm/primitives/${input.primitive.id}/${input.customer.id}/${input.job.id}/output.mp4`;
-                // Re-entrant, non-blocking render: the first invocation dispatches the
-                // render to its own Step Functions state machine and throws
-                // RenderInProgressError so the job runner parks as `waiting_for_render`;
-                // Step Functions waits + re-invokes, and a later invocation resumes the
-                // SAME render (keyed by the deterministic execution name) and finalizes
-                // once it terminates. No single Lambda holds the render open for its
-                // 15-minute lifetime.
-                const step = await input.hyperframes.renderStep({
-                    ...request,
-                    outputKey: hyperframesOutputKey,
-                    executionName: renderExecutionName(input.job.id)
-                });
-                if (step.state === "running") {
-                    throw new RenderInProgressError({
-                        executionArn: step.executionArn,
-                        renderId: step.renderId,
-                        waitSeconds: config.RENDER_POLL_WAIT_SECONDS,
-                        progressFraction: step.progressFraction
-                    });
-                }
-                if (step.state === "failed") {
-                    throw new Error(step.message);
-                }
-                const render = step;
-                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)}`;
-}
-/**
- * Deterministic Step Functions execution name for a job's render. Stable across
- * job-runner re-invocations so each poll resumes the same render execution
- * rather than starting a new one. Step Functions execution names allow
- * [A-Za-z0-9-_] and cap at 80 chars.
- */
-function renderExecutionName(jobId) {
-    return `vfr-${jobId.replace(/[^A-Za-z0-9_-]/g, "-")}`.slice(0, 80);
-}
-//# sourceMappingURL=primitive-context.js.map