@mevdragon/vidfarm-devcli 0.20.5 → 0.20.8

package/dist/src/services/billing.js

@@ -1,241 +0,0 @@
-import { createHash } from "node:crypto";
-import { serverlessRecords } from "./serverless-records.js";
-import { createId } from "../lib/ids.js";
-import { config } from "../config.js";
-const BILLING_COST_EVENTS_PATH = "/v1/cost-events";
-const BILLING_WALLET_GRANTS_PATH = "/v1/wallet-grants";
-const PAID_SIGNUP_BONUS_GRANT_TYPE = "paid_signup_bonus";
-const PAID_SIGNUP_BONUS_USD = 5;
-export class BillingService {
-    async getWalletSummary(customerId) {
-        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
-            throw new Error("Billing service is not configured.");
-        }
-        const response = await fetch(new URL(`/v1/wallets/${encodeURIComponent(customerId)}`, config.VIDFARM_BILLING_URL), {
-            headers: {
-                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
-            }
-        });
-        if (!response.ok) {
-            const body = await response.text().catch(() => "");
-            throw new Error(`Billing wallet lookup failed (${response.status}): ${body || response.statusText}`);
-        }
-        const payload = await response.json();
-        return {
-            currency: typeof payload.currency === "string" ? payload.currency : "USD",
-            balanceUsd: Number(payload.balance_usd ?? 0),
-            balanceMicrosUsd: Number(payload.balance_micros_usd ?? 0)
-        };
-    }
-    async getJobBillingSummary(input) {
-        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
-            return {
-                currency: "USD",
-                eventCount: 0,
-                totalBaseCostUsd: 0,
-                totalChargeUsd: 0,
-                unavailableReason: "Billing service is not configured."
-            };
-        }
-        const url = new URL(`/v1/jobs/${encodeURIComponent(input.jobId)}/billing`, config.VIDFARM_BILLING_URL);
-        url.searchParams.set("customer_id", input.customerId);
-        if (input.templateId) {
-            url.searchParams.set("template_id", input.templateId);
-        }
-        const response = await fetch(url, {
-            headers: {
-                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
-            }
-        });
-        if (!response.ok) {
-            const body = await response.text().catch(() => "");
-            throw new Error(`Billing job summary lookup failed (${response.status}): ${body || response.statusText}`);
-        }
-        const payload = await response.json();
-        return {
-            currency: typeof payload.currency === "string" ? payload.currency : "USD",
-            eventCount: Number(payload.event_count ?? 0),
-            totalBaseCostUsd: Number(payload.total_base_cost_usd ?? 0),
-            totalChargeUsd: Number(payload.total_charge_usd ?? 0),
-            unavailableReason: null
-        };
-    }
-    async record(input) {
-        const normalizedCostCenterSlug = resolveCostCenterSlug(input);
-        const normalizedIdempotencyKey = resolveIdempotencyKey(input, normalizedCostCenterSlug);
-        const remoteEventCostCenterSlug = normalizedCostCenterSlug ?? null;
-        if (!remoteEventCostCenterSlug) {
-            return;
-        }
-        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
-            throw new Error(`Billing URL/secret missing for cost center ${remoteEventCostCenterSlug}.`);
-        }
-        const response = await fetch(new URL(BILLING_COST_EVENTS_PATH, config.VIDFARM_BILLING_URL), {
-            method: "POST",
-            headers: {
-                "content-type": "application/json",
-                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
-            },
-            body: JSON.stringify({
-                idempotency_key: normalizedIdempotencyKey ?? `${remoteEventCostCenterSlug}:${input.jobId}:${input.templateId}:${input.type}`,
-                customer_id: input.customerId,
-                job_id: input.jobId,
-                tracer: input.tracer,
-                cost_center_slug: remoteEventCostCenterSlug,
-                base_cost_usd: input.costUsd,
-                metadata: {
-                    ...input.metadata,
-                    template_id: input.templateId,
-                    local_charge_usd: input.chargeUsd
-                },
-                occurred_at_ms: input.occurredAtMs ?? Date.now()
-            })
-        });
-        if (!response.ok) {
-            const body = await response.text().catch(() => "");
-            throw new Error(`Billing service rejected cost event (${response.status}): ${body || response.statusText}`);
-        }
-        await response.json().catch(() => ({}));
-    }
-    async grantPaidSignupBonus(customerId, metadata) {
-        const customer = await serverlessRecords.getCustomerById(customerId);
-        if (!customer) {
-            throw new Error("Customer not found.");
-        }
-        if (!customer.isPaidPlan) {
-            return { granted: false, reason: "customer_not_paid" };
-        }
-        if (await serverlessRecords.hasCustomerCreditGrant(customerId, PAID_SIGNUP_BONUS_GRANT_TYPE)) {
-            return { granted: false, reason: "already_granted" };
-        }
-        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
-            throw new Error("Billing service is not configured.");
-        }
-        const response = await fetch(new URL(BILLING_WALLET_GRANTS_PATH, config.VIDFARM_BILLING_URL), {
-            method: "POST",
-            headers: {
-                "content-type": "application/json",
-                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
-            },
-            body: JSON.stringify({
-                idempotency_key: `${PAID_SIGNUP_BONUS_GRANT_TYPE}:${customerId}`,
-                customer_id: customerId,
-                amount_usd: PAID_SIGNUP_BONUS_USD,
-                grant_type: PAID_SIGNUP_BONUS_GRANT_TYPE,
-                occurred_at_ms: Date.now(),
-                metadata: {
-                    ...(metadata ?? {}),
-                    grant_type: PAID_SIGNUP_BONUS_GRANT_TYPE
-                }
-            })
-        });
-        if (!response.ok) {
-            const body = await response.text().catch(() => "");
-            throw new Error(`Billing service rejected signup wallet grant (${response.status}): ${body || response.statusText}`);
-        }
-        try {
-            await serverlessRecords.insertCustomerCreditGrant({
-                id: createId("grant"),
-                customerId,
-                grantType: PAID_SIGNUP_BONUS_GRANT_TYPE,
-                amountUsd: PAID_SIGNUP_BONUS_USD,
-                metadata: metadata ?? {}
-            });
-        }
-        catch (error) {
-            if (!isUniqueConstraintError(error)) {
-                throw error;
-            }
-        }
-        return {
-            granted: true,
-            reason: "granted",
-            amountUsd: PAID_SIGNUP_BONUS_USD,
-            grantType: PAID_SIGNUP_BONUS_GRANT_TYPE
-        };
-    }
-}
-function resolveCostCenterSlug(input) {
-    if (input.costCenterSlug?.trim()) {
-        const explicitSlug = input.costCenterSlug.trim();
-        return explicitSlug === "hyperframes_lambda"
-            || explicitSlug === "video_normalization"
-            || explicitSlug === "rapidapi_video_download"
-            || explicitSlug === "video_download_lambda"
-            || explicitSlug === "video_ingest_lambda"
-            || explicitSlug === "rapidapi_remove_background"
-            // Local sharp chroma-key background removal + the 2-step media-overlay
-            // primitive (BYOK image gen + chroma key): platform compute/convenience.
-            || explicitSlug === "greenscreen_chroma_key"
-            || explicitSlug === "media_overlay"
-            // Platform ElevenLabs audio (music / TTS / STT) run on the wallet when the
-            // caller opts into use_wallet_credits (the audio-primitive default).
-            || explicitSlug === "elevenlabs_music"
-            || explicitSlug === "elevenlabs_tts"
-            || explicitSlug === "elevenlabs_stt"
-            || explicitSlug === "primitive_media_lambda"
-            || explicitSlug === "job_runner_lambda"
-            || explicitSlug === "step_functions_standard"
-            // Clip hunting (long-form → short-form): AWS compute only — the AI
-            // tagging/embedding spend is BYOK and deliberately NOT wallet-billed.
-            || explicitSlug === "clip_scan_lambda"
-            ? explicitSlug
-            : null;
-    }
-    return null;
-}
-function resolveIdempotencyKey(input, costCenterSlug) {
-    if (input.idempotencyKey?.trim()) {
-        return input.idempotencyKey.trim();
-    }
-    const renderId = typeof input.metadata?.render_id === "string"
-        ? input.metadata.render_id
-        : typeof input.metadata?.renderId === "string"
-            ? input.metadata.renderId
-            : null;
-    if (costCenterSlug === "hyperframes_lambda" && renderId) {
-        return `hyperframes_lambda:${renderId}`;
-    }
-    return buildBillingEventFingerprint(input, costCenterSlug);
-}
-function buildBillingEventFingerprint(input, costCenterSlug) {
-    const fingerprintPayload = {
-        customerId: input.customerId,
-        jobId: input.jobId,
-        templateId: input.templateId,
-        tracer: input.tracer ?? null,
-        type: input.type,
-        costCenterSlug,
-        costUsd: roundUsd(input.costUsd),
-        chargeUsd: input.chargeUsd == null ? null : roundUsd(input.chargeUsd),
-        occurredAtMs: input.occurredAtMs ?? null,
-        metadata: sortJsonValue(input.metadata ?? {})
-    };
-    const digest = createHash("sha256")
-        .update(JSON.stringify(fingerprintPayload))
-        .digest("hex")
-        .slice(0, 24);
-    return `${costCenterSlug ?? input.type}:${input.jobId}:${digest}`;
-}
-function sortJsonValue(value) {
-    if (Array.isArray(value)) {
-        return value.map(sortJsonValue);
-    }
-    if (value && typeof value === "object") {
-        return Object.entries(value)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .reduce((acc, [key, nestedValue]) => {
-            acc[key] = sortJsonValue(nestedValue);
-            return acc;
-        }, {});
-    }
-    return value;
-}
-function roundUsd(value) {
-    return Number(value.toFixed(6));
-}
-function isUniqueConstraintError(error) {
-    return Boolean(error instanceof Error && /unique constraint/i.test(error.message));
-}
-export { PAID_SIGNUP_BONUS_GRANT_TYPE, PAID_SIGNUP_BONUS_USD, resolveCostCenterSlug, resolveIdempotencyKey };
-//# sourceMappingURL=billing.js.map

package/dist/src/services/cast.js

@@ -1,127 +0,0 @@
-import { extractVideoFrameAsset } from "./media-processing.js";
-// ==========================================================================
-// Cast pass state — persisted per fork under
-//   compositions/forks/{forkId}/working/cast.json
-// and copied on fork/clone/version so the identified cast (and its reference
-// stills) travel with every descendant composition. Drives the async
-// /cast-poll flow, mirroring the ghostcut.json state machine: /auto-decompose
-// seeds it "pending", and /cast-poll advances it one unit of work per call
-// (analyze -> per-member still -> per-member isolation -> done).
-//
-// The cast/ reference images live under the same public fork prefix, so their
-// URLs are directly fetchable by every user and by AI generation primitives
-// (as input_references / prompt_attachments) without a proxy hop.
-// ==========================================================================
-export const CAST_STATE_VERSION = 1;
-export function buildPendingCastState(input) {
-    return {
-        version: CAST_STATE_VERSION,
-        status: "pending",
-        stage: "analyze",
-        savedAtMs: Date.now(),
-        compositionId: input.compositionId,
-        sourceUrl: input.sourceUrl,
-        title: input.title,
-        provider: null,
-        model: null,
-        durationSeconds: 0,
-        width: 0,
-        height: 0,
-        members: []
-    };
-}
-export function castMemberFromRaw(raw) {
-    return {
-        slug: raw.slug,
-        name: raw.name,
-        role: raw.role,
-        description: raw.description,
-        wardrobe: raw.wardrobe,
-        appears_in: raw.appears_in,
-        best_frame_ms: Math.max(0, Math.round(raw.best_frame_seconds * 1000)),
-        bbox: raw.bbox,
-        is_primary: raw.is_primary,
-        still_url: null,
-        reference_url: null,
-        status: "pending"
-    };
-}
-// The registry's default image model per provider is module-private; mirror it
-// here so the cast isolation edit picks a supported model without importing
-// the whole primitive registry.
-function defaultImageModelForProvider(provider) {
-    switch (provider) {
-        case "gemini":
-            return "gemini-2.5-flash-image";
-        case "openrouter":
-            return "google/gemini-2.5-flash-image-preview";
-        default:
-            return "gpt-image-2";
-    }
-}
-// Pick the customer's best available image-capable provider. Order mirrors the
-// vision fallback (gemini -> openai -> openrouter). perplexity has no image
-// capability so it's never a candidate.
-export function pickImageProvider(keys) {
-    if (keys.gemini)
-        return "gemini";
-    if (keys.openai)
-        return "openai";
-    if (keys.openrouter)
-        return "openrouter";
-    return null;
-}
-function describeBbox(bbox) {
-    if (!bbox)
-        return "";
-    const pct = (v) => `${Math.round(v * 100)}%`;
-    const cx = bbox.x + bbox.width / 2;
-    const horizontal = cx < 0.34 ? "on the left" : cx > 0.66 ? "on the right" : "in the center";
-    return ` They are located ${horizontal} of the frame (roughly x=${pct(bbox.x)}, y=${pct(bbox.y)}, width=${pct(bbox.width)}, height=${pct(bbox.height)}).`;
-}
-export function buildCastIsolationInstruction(member) {
-    const wardrobe = member.wardrobe ? ` They are wearing: ${member.wardrobe}.` : "";
-    return [
-        `Isolate ONLY the single person described as: ${member.description}.${wardrobe}${describeBbox(member.bbox)}`,
-        "Cut that one person out cleanly and place them on a fully transparent background.",
-        "Preserve their exact face, hairstyle, skin tone, body proportions, and clothing without alteration.",
-        "Remove every other person and the entire original background. If multiple people are present, keep only the described one.",
-        "Output a single-subject cutout suitable for reuse as a character reference."
-    ].join(" ");
-}
-// Extracts the best-frame still for a member and stores it under the fork's
-// public working/cast/ prefix. Returns the public URL (or null if the key is
-// not in a public prefix, which shouldn't happen for fork keys).
-export async function extractCastStill(input) {
-    const frame = await extractVideoFrameAsset({
-        sourceUrl: input.sourceUrl,
-        atMs: input.member.best_frame_ms,
-        format: "png"
-    });
-    const key = input.storage.compositionForkWorkingKey(input.forkId, `cast/${input.member.slug}-still.png`);
-    const stored = await input.storage.putBuffer(key, frame.bytes, frame.contentType);
-    return { url: stored.url ?? input.storage.getPublicUrl(key) };
-}
-// Runs the image-edit "isolate this person on transparent background" pass over
-// the extracted still and stores the cutout under the fork's public prefix.
-// There is no true person-segmentation primitive in the platform, so this
-// approximates instance masking via a prompt-driven edit (bbox-guided).
-export async function isolateCastMember(input) {
-    const provider = pickImageProvider(input.keys);
-    if (!provider) {
-        throw new Error("No image-capable provider key available for cast isolation");
-    }
-    const edited = await input.providers.editImage({
-        customerId: input.customerId,
-        jobId: input.jobId,
-        workerId: `cast-isolate:${input.member.slug}`,
-        provider,
-        model: defaultImageModelForProvider(provider),
-        sourceImageUrl: input.stillUrl,
-        instruction: buildCastIsolationInstruction(input.member)
-    });
-    const key = input.storage.compositionForkWorkingKey(input.forkId, `cast/${input.member.slug}.png`);
-    const stored = await input.storage.putBuffer(key, edited.bytes, edited.contentType ?? "image/png");
-    return { url: stored.url ?? input.storage.getPublicUrl(key) };
-}
-//# sourceMappingURL=cast.js.map

package/dist/src/services/chat-threads.js

@@ -1,92 +0,0 @@
-import { createId } from "../lib/ids.js";
-import { nowIso } from "../lib/time.js";
-import { serverlessRecords } from "./serverless-records.js";
-import { StorageService } from "./storage.js";
-const storage = new StorageService();
-function normalizeTracerList(values) {
-    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
-}
-function buildThreadStoragePrefix(customerId, templateId, threadId) {
-    return storage.developerScopedKey(customerId, "chat-threads", templateId, threadId);
-}
-function buildThreadChunkKey(prefix, createdAt) {
-    const sortableTime = createdAt.replace(/[^0-9]/g, "");
-    return `${prefix}/chunks/${sortableTime}-${createId("chunk")}.json`;
-}
-async function readChunkMessages(key) {
-    const raw = await storage.readText(key);
-    if (!raw) {
-        return [];
-    }
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed.messages) ? parsed.messages : [];
-}
-export const chatThreads = {
-    async listThreads(input) {
-        const threads = await serverlessRecords.listChatThreadMetas(input);
-        if (input.includeMessages === false) {
-            return threads;
-        }
-        const withMessages = await Promise.all(threads.map(async (thread) => ({
-            ...thread,
-            messages: await this.loadThreadMessages(thread)
-        })));
-        return withMessages;
-    },
-    async getThread(input) {
-        const thread = await serverlessRecords.getChatThreadMeta(input.customerId, input.threadId);
-        if (!thread) {
-            return null;
-        }
-        return {
-            ...thread,
-            messages: await this.loadThreadMessages(thread)
-        };
-    },
-    async appendExchange(input) {
-        const createdAt = nowIso();
-        const storagePrefix = buildThreadStoragePrefix(input.customerId, input.templateId, input.threadId);
-        const chunk = {
-            version: 1,
-            threadId: input.threadId,
-            customerId: input.customerId,
-            templateId: input.templateId,
-            createdAt,
-            messages: input.messages
-        };
-        await storage.putJson(buildThreadChunkKey(storagePrefix, createdAt), chunk);
-        const updated = await serverlessRecords.appendChatThreadMessages({
-            threadId: input.threadId,
-            customerId: input.customerId,
-            title: input.title || "New chat",
-            templateId: input.templateId,
-            storagePrefix,
-            tracers: normalizeTracerList(input.tracers),
-            messageCountDelta: input.messages.length,
-            lastMessageAt: createdAt
-        });
-        return updated ? this.getThread({ customerId: input.customerId, threadId: updated.id }) : null;
-    },
-    async updateThread(input) {
-        const updated = await serverlessRecords.updateChatThreadState({
-            ...input,
-            tracers: input.tracers ? normalizeTracerList(input.tracers) : undefined
-        });
-        return updated ? this.getThread({ customerId: input.customerId, threadId: updated.id }) : null;
-    },
-    async deleteThread(input) {
-        const existing = await serverlessRecords.deleteChatThread(input.customerId, input.threadId);
-        if (!existing) {
-            return null;
-        }
-        const keys = await storage.listKeys(`${existing.storagePrefix}/`);
-        await Promise.all(keys.map((key) => storage.deleteObject(key)));
-        return existing;
-    },
-    async loadThreadMessages(thread) {
-        const keys = (await storage.listKeys(`${thread.storagePrefix}/chunks/`)).sort();
-        const messageGroups = await Promise.all(keys.map((key) => readChunkMessages(key)));
-        return messageGroups.flat();
-    }
-};
-//# sourceMappingURL=chat-threads.js.map