@mevdragon/vidfarm-devcli 0.6.0 → 0.7.1

package/dist/src/primitive-registry.js

@@ -6,6 +6,7 @@ import { z } from "zod";
 import { config } from "./config.js";
 import { definePrimitive } from "./primitive-sdk.js";
 import { PrimitiveMediaLambdaService } from "./services/primitive-media-lambda.js";
+import { estimateGhostcutCostUsd, isGhostcutConfigured, pollStatus as pollGhostcutStatus, submitSubtitleRemoval } from "./services/ghostcut.js";
 import { buildHtmlImageCompositionHtml, buildMediaDedupeCompositionHtml, DEDUPE_DEFAULT_EFFECTS } from "./primitives/hyperframes-media.js";
 const imageProviderSchema = z.enum(["openai", "gemini", "openrouter"]);
 const videoProviderSchema = z.enum(["openai", "gemini", "openrouter"]);
@@ -360,6 +361,9 @@ const trimAudioPayloadSchema = z.object({
 const probeVideoPayloadSchema = z.object({
     source_video_url: mediaSourceUrlSchema
 });
+const removeVideoCaptionsPayloadSchema = z.object({
+    source_video_url: mediaSourceUrlSchema
+});
 const probeAudioPayloadSchema = z.object({
     source_audio_url: mediaSourceUrlSchema
 });
@@ -408,6 +412,14 @@ const downloadVideoPayloadSchema = z.preprocess((raw) => {
     quality: z.enum(["best", "hd", "full_hd"]).default("best"),
     save_manifest: z.boolean().default(true)
 }));
+// Ingest of an already-uploaded video file (Add Template → upload). The URL is
+// server-minted (our own storage), so no social-host restrictions apply.
+const ingestVideoPayloadSchema = z.object({
+    source_video_url: z.string().url(),
+    title: z.string().min(1).max(300).optional(),
+    file_name: z.string().min(1).max(300).optional(),
+    save_manifest: z.boolean().default(true)
+});
 const brainstormHooksPayloadSchema = z.preprocess(normalizeOfferDescriptionPayload, z.object({
     offer_description: z.string().min(10).max(12_000),
     count: brainstormCountSchema,
@@ -476,7 +488,9 @@ const PRIMITIVE_VIDEO_GENERATE_ID = "primitive:video_generate";
 const PRIMITIVE_VIDEO_RENDER_SLIDES_ID = "primitive:video_render_slides";
 const PRIMITIVE_VIDEO_NORMALIZE_ID = "primitive:video_normalize";
 const PRIMITIVE_VIDEO_DOWNLOAD_ID = "primitive:video_download";
+const PRIMITIVE_VIDEO_INGEST_ID = "primitive:video_ingest";
 const PRIMITIVE_VIDEO_TRIM_ID = "primitive:video_trim";
+const PRIMITIVE_VIDEO_REMOVE_CAPTIONS_ID = "primitive:video_remove_captions";
 const PRIMITIVE_VIDEO_EXTRACT_AUDIO_ID = "primitive:video_extract_audio";
 const PRIMITIVE_AUDIO_TRIM_ID = "primitive:audio_trim";
 const PRIMITIVE_VIDEO_PROBE_ID = "primitive:video_probe";
@@ -1183,6 +1197,132 @@ const videoDownloadPrimitive = definePrimitive({
         }
     }
 });
+// Upload-based sibling of video_download: the source video already sits in our
+// storage (uploaded via the Add Template flow), so there is no social lookup —
+// just mirror it into a durable job artifact, probe duration, and grab a
+// thumbnail frame. Output shape matches video_download so the inspiration
+// finalizer treats both identically.
+const videoIngestPrimitive = definePrimitive({
+    id: PRIMITIVE_VIDEO_INGEST_ID,
+    kind: "video_ingest",
+    operations: {
+        run: {
+            description: "Ingest an uploaded source video file into a durable reusable platform MP4 with probed metadata and a thumbnail.",
+            inputSchema: ingestVideoPayloadSchema,
+            workflow: "run"
+        }
+    },
+    jobs: {
+        async run(ctx, input) {
+            const payload = ingestVideoPayloadSchema.parse(input);
+            const sourceUrl = payload.source_video_url;
+            const sourceHost = safeUrlHost(sourceUrl);
+            ctx.logger.progress(0.12, "Fetching uploaded source video", { sourceUrl, sourceHost });
+            const remoteVideo = await fetchRemoteBinary(sourceUrl, "video/mp4");
+            const contentType = normalizeVideoContentType(remoteVideo.contentType);
+            const extension = videoExtensionForContentType(contentType);
+            const storedVideo = await storePrimitiveVideo(ctx, {
+                key: `source-video.${extension}`,
+                bytes: remoteVideo.bytes,
+                contentType,
+                metadata: {
+                    primitive: "video_ingest",
+                    operation: "ingest-video",
+                    source_url: sourceUrl,
+                    source_host: sourceHost,
+                    file_name: payload.file_name ?? null
+                }
+            });
+            // Best-effort enrichment: a probe past the duration cap or a failed
+            // thumbnail must not sink the ingest — the card still finalizes and the
+            // template can decompose later.
+            let durationSeconds = null;
+            ctx.logger.progress(0.55, "Probing uploaded video metadata");
+            try {
+                const probed = await executePrimitiveMediaOperation(ctx, {
+                    operation: "video_probe",
+                    payload: { source_video_url: storedVideo.url },
+                    outputKey: "probe.json"
+                });
+                const probedDuration = Number(probed.metadata?.durationSeconds);
+                durationSeconds = Number.isFinite(probedDuration) && probedDuration > 0 ? probedDuration : null;
+            }
+            catch (error) {
+                ctx.logger.progress(0.6, "Video probe skipped", {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+            let thumbnailUrl = null;
+            ctx.logger.progress(0.7, "Extracting thumbnail frame");
+            try {
+                const frame = await executePrimitiveMediaOperation(ctx, {
+                    operation: "video_extract_frame",
+                    payload: { source_video_url: storedVideo.url, at_ms: 0, output_format: "jpeg" },
+                    outputKey: "thumbnail.jpg"
+                });
+                thumbnailUrl = frame.publicUrl;
+            }
+            catch (error) {
+                ctx.logger.progress(0.75, "Thumbnail extraction skipped", {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+            const manifest = {
+                primitive: "video_ingest",
+                operation: "ingest-video",
+                sourceUrl,
+                sourceHost,
+                // Caller-chosen title only — never the file name. Untitled ingests
+                // finalize with title null so the template displays as its id.
+                title: payload.title ?? null,
+                thumbnail: thumbnailUrl,
+                duration: durationSeconds,
+                source: "upload",
+                videoUrl: storedVideo.url
+            };
+            const manifestArtifact = payload.save_manifest
+                ? await ctx.storage.putJson("manifest.json", manifest)
+                : null;
+            await ctx.billing.record({
+                type: "cpu_estimate",
+                costUsd: config.RAPIDAPI_VIDEO_DOWNLOAD_LAMBDA_COST_USD,
+                costCenterSlug: "video_ingest_lambda",
+                idempotencyKey: `video_ingest_lambda:${sourceUrl}:${storedVideo.key}`,
+                occurredAtMs: Date.now(),
+                metadata: {
+                    operation: "ingest-video",
+                    source_url: sourceUrl,
+                    source_host: sourceHost,
+                    output_key: storedVideo.key,
+                    content_type: contentType,
+                    bytes: remoteVideo.bytes.length
+                }
+            });
+            ctx.logger.progress(1, "Video ingest complete", {
+                videoUrl: storedVideo.url,
+                durationSeconds,
+                thumbnailUrl
+            });
+            return {
+                progress: 1,
+                output: {
+                    files: compactUrls([storedVideo.url, thumbnailUrl, manifestArtifact?.url]),
+                    sourceUrl,
+                    sourceHost,
+                    videoUrl: storedVideo.url,
+                    sourceVideoUrl: storedVideo.url,
+                    primary_file_url: storedVideo.url,
+                    title: manifest.title,
+                    thumbnail: thumbnailUrl,
+                    duration: durationSeconds,
+                    // Manifest CONTENT (not the artifact record) so the inspiration
+                    // finalizer can read thumbnail/title/duration directly.
+                    manifest
+                }
+            };
+        }
+    }
+});
 const videoTrimPrimitive = definePrimitive({
     id: PRIMITIVE_VIDEO_TRIM_ID,
     kind: "video_trim",
@@ -1222,6 +1362,125 @@ const videoTrimPrimitive = definePrimitive({
         }
     }
 });
+// GhostCut task polling budget. The job runner lambda has a 15-minute
+// timeout; probe + submit + mirror take up the rest. GhostCut usually clears
+// a sub-3-minute clip in a few minutes.
+const REMOVE_CAPTIONS_POLL_TIMEOUT_MS = 12 * 60 * 1000;
+const REMOVE_CAPTIONS_POLL_INTERVAL_MS = 5000;
+// Removes burned-in captions/subtitles/on-screen text from a source video via
+// the GhostCut inpainting service — the same plumbing auto-decompose uses
+// through src/services/ghostcut.ts. Unlike the fork-scoped
+// /remove-video-captions(-poll) composition routes, where the CLIENT drives
+// completion to keep per-request lambda time bounded, this primitive runs
+// inside the job runner and polls GhostCut to completion itself.
+const videoRemoveCaptionsPrimitive = definePrimitive({
+    id: PRIMITIVE_VIDEO_REMOVE_CAPTIONS_ID,
+    kind: "video_remove_captions",
+    operations: {
+        run: {
+            description: "Remove burned-in captions/subtitles/on-screen text from a source video into a reusable caption-free platform MP4.",
+            inputSchema: removeVideoCaptionsPayloadSchema,
+            workflow: "run"
+        }
+    },
+    jobs: {
+        async run(ctx, input) {
+            const payload = removeVideoCaptionsPayloadSchema.parse(input);
+            if (!isGhostcutConfigured()) {
+                throw new Error("Caption removal is unavailable: GHOSTCUT_KEY/GHOSTCUT_SECRET are not configured on this deployment.");
+            }
+            // Probe first: confirms the source actually has a video stream and
+            // captures the duration that prices the GhostCut task (per-30s chunks).
+            ctx.logger.progress(0.05, "Probing source video");
+            const probed = await executePrimitiveMediaOperation(ctx, {
+                operation: "video_probe",
+                payload: { source_video_url: payload.source_video_url },
+                outputKey: "probe.json"
+            });
+            const probeMetadata = (probed.metadata ?? {});
+            if (probeMetadata.hasVideo === false) {
+                throw new Error("source_video_url has no video stream — caption removal only works on videos.");
+            }
+            const probedDurationSeconds = Number(probeMetadata.durationSeconds ?? 0);
+            const durationSeconds = Number.isFinite(probedDurationSeconds) && probedDurationSeconds > 0 ? probedDurationSeconds : 30;
+            const cost = estimateGhostcutCostUsd(durationSeconds);
+            ctx.logger.progress(0.12, "Submitting caption-removal task", {
+                durationSeconds: Number(durationSeconds.toFixed(3)),
+                estimatedChunks: cost.chunks,
+                estimatedUsd: cost.usd
+            });
+            const submission = await submitSubtitleRemoval(payload.source_video_url);
+            const startedAtMs = Date.now();
+            let cleanedVideoUrl = null;
+            while (cleanedVideoUrl === null) {
+                if (Date.now() - startedAtMs > REMOVE_CAPTIONS_POLL_TIMEOUT_MS) {
+                    throw new Error(`GhostCut task ${submission.taskId} did not finish within ${Math.round(REMOVE_CAPTIONS_POLL_TIMEOUT_MS / 60000)} minutes.`);
+                }
+                const status = await pollGhostcutStatus(submission.taskId);
+                if (status.state === "failed") {
+                    throw new Error(`GhostCut task ${submission.taskId} failed: ${status.reason}`);
+                }
+                if (status.state === "done") {
+                    cleanedVideoUrl = status.videoUrl;
+                    break;
+                }
+                const upstreamProgress = Math.max(0, Math.min(100, status.progress));
+                ctx.logger.progress(0.15 + (upstreamProgress / 100) * 0.65, "Removing burned-in captions", {
+                    taskId: submission.taskId,
+                    upstreamProgress
+                });
+                await new Promise((resolve) => setTimeout(resolve, REMOVE_CAPTIONS_POLL_INTERVAL_MS));
+            }
+            // GhostCut hosts results on a short-lived third-party CDN — mirror the
+            // cleaned MP4 into platform storage so the output URL is durable.
+            ctx.logger.progress(0.85, "Mirroring caption-free video to platform storage");
+            const remoteVideo = await fetchRemoteBinary(cleanedVideoUrl, "video/mp4");
+            const stored = await storePrimitiveVideo(ctx, {
+                key: "captions-removed.mp4",
+                bytes: remoteVideo.bytes,
+                contentType: "video/mp4",
+                metadata: {
+                    primitive: "video_remove_captions",
+                    operation: "remove-video-captions",
+                    source_video_url: payload.source_video_url,
+                    ghostcut_task_id: submission.taskId
+                }
+            });
+            await ctx.billing.record({
+                type: "cpu_estimate",
+                costUsd: cost.usd,
+                costCenterSlug: "ghostcut_subtitle_removal",
+                idempotencyKey: `ghostcut_subtitle_removal:${submission.taskId}`,
+                occurredAtMs: Date.now(),
+                metadata: {
+                    operation: "remove-video-captions",
+                    source_video_url: payload.source_video_url,
+                    duration_seconds: Number(durationSeconds.toFixed(3)),
+                    chunk_count: cost.chunks,
+                    usd_per_chunk: cost.usdPerChunk,
+                    chunk_seconds: 30,
+                    task_id: submission.taskId
+                }
+            });
+            ctx.logger.progress(1, "Caption removal complete", { videoUrl: stored.url });
+            return {
+                progress: 1,
+                output: {
+                    files: compactUrls([payload.source_video_url, stored.url]),
+                    sourceVideoUrl: payload.source_video_url,
+                    captionsRemovedVideoUrl: stored.url,
+                    primary_file_url: stored.url,
+                    video: {
+                        file_url: stored.url,
+                        content_type: stored.contentType,
+                        duration_seconds: Number(durationSeconds.toFixed(3)),
+                        ghostcut_task_id: submission.taskId
+                    }
+                }
+            };
+        }
+    }
+});
 const videoExtractAudioPrimitive = definePrimitive({
     id: PRIMITIVE_VIDEO_EXTRACT_AUDIO_ID,
     kind: "video_extract_audio",
@@ -1863,7 +2122,9 @@ class PrimitiveRegistry {
         [mediaDedupePrimitive.id, mediaDedupePrimitive],
         [videoNormalizePrimitive.id, videoNormalizePrimitive],
         [videoDownloadPrimitive.id, videoDownloadPrimitive],
+        [videoIngestPrimitive.id, videoIngestPrimitive],
         [videoTrimPrimitive.id, videoTrimPrimitive],
+        [videoRemoveCaptionsPrimitive.id, videoRemoveCaptionsPrimitive],
         [videoExtractAudioPrimitive.id, videoExtractAudioPrimitive],
         [audioTrimPrimitive.id, audioTrimPrimitive],
         [videoProbePrimitive.id, videoProbePrimitive],

package/dist/src/services/billing.js

@@ -162,6 +162,7 @@ function resolveCostCenterSlug(input) {
             || explicitSlug === "video_normalization"
             || explicitSlug === "rapidapi_video_download"
             || explicitSlug === "video_download_lambda"
+            || explicitSlug === "video_ingest_lambda"
             || explicitSlug === "rapidapi_remove_background"
             || explicitSlug === "primitive_media_lambda"
             || explicitSlug === "job_runner_lambda"

package/dist/src/services/hyperframes.js

@@ -13,7 +13,7 @@ import ffprobeStatic from "ffprobe-static";
 import { parseHTML } from "linkedom";
 import { config } from "../config.js";
 import { devErrorFields, devLog } from "../lib/dev-log.js";
-import { buildHyperframeCompositionHtml } from "../hyperframes/composition.js";
+import { KEN_BURNS_CSS, KEN_BURNS_STYLE_MARKER, buildHyperframeCompositionHtml } from "../hyperframes/composition.js";
 import { applyMarkupUsd } from "./billing-pricing.js";
 let stackCache = null;
 const SMART_DECOMPOSE_TEMP_PREFIX = "vidfarm-smart-decompose-";
@@ -2027,6 +2027,31 @@ export function normalizePublishHtml(html) {
             continue;
         html.style.zIndex = String(trackIndex);
     }
+    // Ken Burns motion must span exactly the clip: timeline edits touch
+    // data-duration only, so re-derive the inline --vf-kb-dur (which drives
+    // animation-duration) from data-duration on every [data-kenburns] layer.
+    // Also make sure the shared keyframes stylesheet travels with compositions
+    // stored before the builder started embedding it.
+    const kenBurnsLayers = Array.from(document.querySelectorAll("[data-kenburns]"));
+    for (const el of kenBurnsLayers) {
+        const duration = Number.parseFloat(el.getAttribute("data-duration") || "");
+        if (!Number.isFinite(duration) || duration <= 0)
+            continue;
+        const styleValue = el.getAttribute("style") || "";
+        const durDecl = `--vf-kb-dur:${Number(duration.toFixed(3))}s`;
+        const nextStyle = /(^|;)\s*--vf-kb-dur\s*:[^;]*/i.test(styleValue)
+            ? styleValue.replace(/(^|;)\s*--vf-kb-dur\s*:[^;]*/i, (_match, lead) => `${lead}${durDecl}`)
+            : styleValue.length === 0 || styleValue.endsWith(";")
+                ? `${styleValue}${durDecl}`
+                : `${styleValue};${durDecl}`;
+        if (nextStyle !== styleValue)
+            el.setAttribute("style", nextStyle);
+    }
+    if (kenBurnsLayers.length > 0 && !html.includes(KEN_BURNS_STYLE_MARKER)) {
+        const styleEl = document.createElement("style");
+        styleEl.textContent = KEN_BURNS_CSS;
+        (document.head ?? document.documentElement)?.appendChild(styleEl);
+    }
     // Editor sessions occasionally leave inline style attributes with double
     // quotes inside CSS values (font-family: "TikTok Sans"). When serialized into
     // an HTML attribute, those quotes become &quot; entities. The render lambda

package/dist/src/services/storage.js

@@ -30,6 +30,12 @@ export class StorageService {
     legacyUserAttachmentKey(customerId, attachmentId, fileName) {
         return joinStorageKey("users", customerId, attachmentId, fileName);
     }
+    // Add Template → upload a video file: staging area for uploaded inspiration
+    // sources. Lives under users/ so the bucket's public-read policy covers it —
+    // the video_ingest job and the editor fetch it by plain URL.
+    inspirationUploadKey(customerId, uploadId, fileName) {
+        return joinStorageKey("users", customerId, "inspiration-uploads", uploadId, fileName);
+    }
     userTemporaryFileKey(customerId, fileId, fileName, folderPath) {
         return joinStorageKey("users", customerId, "temporary", folderPath || "", fileId, fileName);
     }

package/dist/src/services/upstream.js

@@ -0,0 +1,248 @@
+import { config } from "../config.js";
+import { StorageService } from "./storage.js";
+import { serverlessRecords } from "./serverless-records.js";
+// Cloud passthrough for `vidfarm serve`. A locally-booted box keeps the
+// editor, storage, and render fully local, but mirrors the upstream (prod)
+// deployment for everything catalog-shaped: /discover and /library list the
+// cloud data, templates/forks seed onto local disk on demand, and a render
+// can be handed off to the cloud renderer. The upstream host + API key are
+// injected by the serve command (VIDFARM_UPSTREAM_HOST / _API_KEY); deployed
+// environments never set them, so every helper here is a no-op in the cloud.
+const UPSTREAM_TIMEOUT_MS = 15_000;
+export function upstreamHost() {
+    const raw = (config.VIDFARM_UPSTREAM_HOST ?? "").trim().replace(/\/+$/, "");
+    if (!raw)
+        return null;
+    if (!/^https?:\/\//i.test(raw))
+        return null;
+    return raw;
+}
+// Passthrough only ever activates on a fully-local box. STORAGE_DRIVER=local
+// is the serve fingerprint (same signal the editor's liveReload uses).
+export function isUpstreamEnabled() {
+    return config.STORAGE_DRIVER === "local" && Boolean(upstreamHost());
+}
+export function upstreamApiKey() {
+    const key = (config.VIDFARM_UPSTREAM_API_KEY ?? "").trim();
+    return key || null;
+}
+export function hasUpstreamKey() {
+    return isUpstreamEnabled() && Boolean(upstreamApiKey());
+}
+export function upstreamAuthHeaders(extra) {
+    const headers = { accept: "application/json", ...(extra ?? {}) };
+    const key = upstreamApiKey();
+    if (key)
+        headers["vidfarm-api-key"] = key;
+    return headers;
+}
+// One-shot JSON fetch against the upstream host. Never throws on HTTP or
+// network errors — callers treat a failed upstream as "no cloud data" and
+// fall back to local-only behavior.
+export async function upstreamJson(pathWithQuery, init) {
+    const host = upstreamHost();
+    if (!host)
+        return { ok: false, status: 0, json: null };
+    try {
+        const response = await fetch(`${host}${pathWithQuery}`, {
+            method: init?.method ?? "GET",
+            headers: upstreamAuthHeaders(init?.body !== undefined ? { "content-type": "application/json" } : undefined),
+            body: init?.body !== undefined ? JSON.stringify(init.body) : undefined,
+            signal: AbortSignal.timeout(init?.timeoutMs ?? UPSTREAM_TIMEOUT_MS)
+        });
+        const json = await response.json().catch(() => null);
+        return { ok: response.ok, status: response.status, json };
+    }
+    catch (error) {
+        console.warn(`[upstream] ${init?.method ?? "GET"} ${pathWithQuery} failed: ${error instanceof Error ? error.message : String(error)}`);
+        return { ok: false, status: 0, json: null };
+    }
+}
+// Forward the incoming request to the same path on the upstream host with the
+// upstream API key swapped in for the local session. Used as a fallback when
+// a resource id (approved post, inspiration) doesn't resolve locally — the id
+// then almost certainly belongs to the cloud account this box mirrors.
+// requireKey defaults to true so authed reads/mutations never proxy without
+// cloud credentials; public-data GET fallbacks pass requireKey: false.
+export async function proxyRequestToUpstream(c, options) {
+    const host = upstreamHost();
+    if (!host || !isUpstreamEnabled())
+        return null;
+    if ((options?.requireKey ?? true) && !hasUpstreamKey())
+        return null;
+    const incoming = new URL(c.req.url);
+    const target = `${host}${incoming.pathname}${incoming.search}`;
+    const method = c.req.method.toUpperCase();
+    const headers = upstreamAuthHeaders();
+    let body;
+    if (method !== "GET" && method !== "HEAD") {
+        body = await c.req.text().catch(() => "");
+        const contentType = c.req.header("content-type");
+        if (contentType)
+            headers["content-type"] = contentType;
+    }
+    try {
+        const response = await fetch(target, {
+            method,
+            headers,
+            body,
+            signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS)
+        });
+        const payload = Buffer.from(await response.arrayBuffer());
+        return new Response(payload, {
+            status: response.status,
+            headers: {
+                "content-type": response.headers.get("content-type") ?? "application/json",
+                "x-vidfarm-upstream": host
+            }
+        });
+    }
+    catch (error) {
+        console.warn(`[upstream] proxy ${method} ${incoming.pathname} failed: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// On-demand seeding: pull a cloud fork's composition onto local disk and mint
+// the matching local template + fork records so the local editor resolves it.
+// Same behavior as `vidfarm serve <templateId>` boot seeding, but callable
+// from the /editor route when the user clicks a proxied catalog entry.
+// ---------------------------------------------------------------------------
+function seedAuthHeaders(shareToken) {
+    const headers = { accept: "text/html,application/json" };
+    const key = upstreamApiKey();
+    if (key)
+        headers["vidfarm-api-key"] = key;
+    if (shareToken)
+        headers["vidfarm-share-token"] = shareToken;
+    return headers;
+}
+// /editor/<template_id> issues a 302 → /editor/<template_id>?fork=<id>
+// whenever the caller (or the template's default fork) has one. Follow the
+// redirect once by hand so we can read the fork id off the query string.
+async function resolveUpstreamForkId(input) {
+    try {
+        const res = await fetch(`${input.host}/editor/${encodeURIComponent(input.templateId)}`, {
+            method: "GET",
+            redirect: "manual",
+            headers: seedAuthHeaders(input.shareToken),
+            signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS)
+        });
+        if (res.status >= 300 && res.status < 400) {
+            const location = res.headers.get("location");
+            if (location) {
+                const target = new URL(location, input.host);
+                const fork = target.searchParams.get("fork");
+                if (fork)
+                    return fork;
+            }
+        }
+    }
+    catch {
+        // fall through to null — caller starts empty
+    }
+    return null;
+}
+// Best-effort: returns null (and logs) instead of throwing so callers can
+// fall back to their template-not-found behavior.
+export async function seedFromUpstream(input) {
+    const host = upstreamHost();
+    if (!host || !isUpstreamEnabled())
+        return null;
+    const storage = new StorageService();
+    const headers = seedAuthHeaders(input.shareToken);
+    // 1. Resolve the source fork: explicit fork wins, else the template's
+    //    default fork (grabs the shared decomposition even if another user owns it).
+    let cloudForkId = input.forkId ?? null;
+    if (!cloudForkId && input.templateId) {
+        cloudForkId = await resolveUpstreamForkId({ host, templateId: input.templateId, shareToken: input.shareToken });
+    }
+    if (!cloudForkId) {
+        console.warn(`[upstream] seed: no fork resolvable for template ${input.templateId ?? "<none>"}`);
+        return null;
+    }
+    // 2. Read the serialized fork for its template id + title.
+    const forkMeta = (await upstreamJson(`/api/v1/compositions/${encodeURIComponent(cloudForkId)}`)).json;
+    const templateId = input.templateId ?? (typeof forkMeta?.template_id === "string" ? forkMeta.template_id : null);
+    if (!templateId || !templateId.startsWith("template_")) {
+        console.warn(`[upstream] seed: could not determine a template id for fork ${cloudForkId}`);
+        return null;
+    }
+    const title = (typeof forkMeta?.title === "string" && forkMeta.title) || `Local · ${templateId}`;
+    // 3. Materialize the local template record (the editor 404s without it).
+    const existingTemplate = await serverlessRecords.getTemplate(templateId);
+    if (!existingTemplate) {
+        await serverlessRecords.createTemplate({
+            id: templateId,
+            inspirationId: `local:${templateId}`,
+            customerId: input.customerId,
+            originalUrl: typeof forkMeta?.original_url === "string" ? forkMeta.original_url : "",
+            sourceHost: "local",
+            title,
+            visibility: "public"
+        });
+    }
+    // 4. Materialize the local fork (reuse the cloud id for stable URLs — the
+    //    shared id is also what lets a later "Render in Cloud" find its source).
+    const existingFork = await serverlessRecords.getCompositionFork(cloudForkId);
+    if (!existingFork) {
+        await serverlessRecords.createCompositionFork({
+            id: cloudForkId,
+            customerId: input.customerId,
+            templateId,
+            title,
+            visibility: "private"
+        });
+    }
+    // 5. Pull composition.html/json onto disk (skip if present unless refetch,
+    //    so local edits aren't clobbered).
+    const htmlKey = storage.compositionForkWorkingKey(cloudForkId, "composition.html");
+    const jsonKey = storage.compositionForkWorkingKey(cloudForkId, "composition.json");
+    const hasLocalHtml = Boolean(await storage.readText(htmlKey));
+    if (!hasLocalHtml || input.refetch) {
+        try {
+            const htmlRes = await fetch(`${host}/api/v1/compositions/${encodeURIComponent(cloudForkId)}/composition.html`, {
+                headers,
+                signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS)
+            });
+            if (!htmlRes.ok) {
+                console.warn(`[upstream] seed: could not fetch composition.html for ${cloudForkId} (${htmlRes.status})`);
+                return null;
+            }
+            const compositionHtml = await htmlRes.text();
+            await storage.putText(htmlKey, compositionHtml, "text/html; charset=utf-8");
+            // Backfill the local template's preview metadata from the composition
+            // itself (no single-template REST read exists) so the seeded copy also
+            // renders a card on the LOCAL /discover feed.
+            const sourceVideoMatch = compositionHtml.match(/data-source-video="([^"]+)"/i);
+            const durationMatch = compositionHtml.match(/data-duration="([^"]+)"/i);
+            const template = await serverlessRecords.getTemplate(templateId);
+            if (template && !template.videoUrl && sourceVideoMatch?.[1]) {
+                const durationSeconds = durationMatch ? Number.parseFloat(durationMatch[1]) : NaN;
+                await serverlessRecords.updateTemplate({
+                    templateId,
+                    patch: {
+                        videoUrl: sourceVideoMatch[1].replace(/&amp;/g, "&"),
+                        ...(Number.isFinite(durationSeconds) && durationSeconds > 0 ? { durationSeconds } : {})
+                    }
+                }).catch(() => undefined);
+            }
+            const jsonRes = await fetch(`${host}/api/v1/compositions/${encodeURIComponent(cloudForkId)}/composition.json`, {
+                headers,
+                signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS)
+            });
+            if (jsonRes.ok)
+                await storage.putBuffer(jsonKey, Buffer.from(await jsonRes.text(), "utf8"), "application/json");
+            console.log(`[upstream] seeded fork ${cloudForkId} from ${host}`);
+        }
+        catch (error) {
+            console.warn(`[upstream] seed: composition fetch failed for ${cloudForkId}: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    // 6. Point the template's default fork at the local copy so a bare
+    //    /editor/:templateId resolves it too.
+    await serverlessRecords.stampDefaultForkIfUnset({ templateId, forkId: cloudForkId });
+    return { templateId, forkId: cloudForkId };
+}
+//# sourceMappingURL=upstream.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mevdragon/vidfarm-devcli",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Local bridge for the Vidfarm Trackpad Editor. `vidfarm serve <template_id>` boots the FULL editor on localhost (disk-backed records/storage, free in-process render); edit composition.html on disk (Claude Code, Codex, etc.) and the browser live-morphs it.",
   "type": "module",
   "bin": {