@mevdragon/vidfarm-devcli 0.5.3 → 0.7.0

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/dist/src/services/video-normalization.js

@@ -0,0 +1,2 @@
+export { estimateNormalizationCostUsd, normalizeVideoAsset } from "./media-processing.js";
+//# sourceMappingURL=video-normalization.js.map

package/dist/src/services/webhooks.js

@@ -0,0 +1,62 @@
+import { createHmac } from "node:crypto";
+import { config } from "../config.js";
+import { serverlessRecords } from "./serverless-records.js";
+import { createId } from "../lib/ids.js";
+import { addSeconds, nowIso } from "../lib/time.js";
+export class WebhookService {
+    async queueJobEvent(input) {
+        await serverlessRecords.queueWebhookDelivery({
+            id: createId("whd"),
+            jobId: input.jobId,
+            customerId: input.customerId,
+            destinationUrl: input.destinationUrl,
+            eventType: input.eventType,
+            payload: input.payload
+        });
+    }
+    async flushPending(limit = 20) {
+        const deliveries = await serverlessRecords.listPendingWebhookDeliveries(limit);
+        for (const delivery of deliveries) {
+            const payload = String(delivery.payload_json);
+            const signature = createHmac("sha256", config.WEBHOOK_SECRET).update(payload).digest("hex");
+            const attemptCount = Number(delivery.attempt_count) + 1;
+            try {
+                const response = await fetch(String(delivery.destination_url), {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-vidfarm-signature": signature,
+                        "x-vidfarm-event": String(delivery.event_type)
+                    },
+                    body: payload
+                });
+                if (!response.ok) {
+                    throw new Error(`Webhook returned ${response.status}`);
+                }
+                await serverlessRecords.markWebhookDelivery({
+                    id: String(delivery.id),
+                    status: "delivered",
+                    attemptCount
+                });
+            }
+            catch (error) {
+                const retriesLeft = attemptCount < 6;
+                await serverlessRecords.markWebhookDelivery({
+                    id: String(delivery.id),
+                    status: retriesLeft ? "retrying" : "failed",
+                    attemptCount,
+                    nextAttemptAt: retriesLeft ? addSeconds(new Date(), Math.min(300, attemptCount * 30)) : undefined,
+                    lastError: error instanceof Error ? error.message : "Unknown webhook error"
+                });
+            }
+        }
+    }
+    buildJobPayload(eventType, job) {
+        return {
+            type: eventType,
+            emitted_at: nowIso(),
+            job
+        };
+    }
+}
+//# sourceMappingURL=webhooks.js.map