@mevdragon/vidfarm-devcli 0.20.5 → 0.20.8

package/dist/src/services/upstream.js

@@ -1,248 +0,0 @@
-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 path.
-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 match = target.pathname.match(/^\/editor\/[^/]+\/fork\/([^/]+)\/?$/);
-                if (match)
-                    return decodeURIComponent(match[1]);
-            }
-        }
-    }
-    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

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

package/dist/src/services/webhooks.js

@@ -1,62 +0,0 @@
-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