@mevdragon/vidfarm-devcli 0.2.7 → 0.2.9

package/dist/src/services/billing.js

@@ -1,16 +1,255 @@
+import { createHash } from "node:crypto";
 import { database } from "../db.js";
 import { createId } from "../lib/ids.js";
+import { config } from "../config.js";
+const BILLING_COST_EVENTS_PATH = "/v1/cost-events";
+const BILLING_WALLET_FUNDING_INTENTS_PATH = "/v1/wallet-funding-intents";
+const BILLING_WALLET_FUNDING_CONFIRMED_PATH = "/v1/wallet-funding-confirmed";
+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) {
-        database.insertBillingEvent({
-            id: createId("bill"),
-            customerId: input.customerId,
-            jobId: input.jobId,
-            templateId: input.templateId,
-            type: input.type,
-            costUsd: input.costUsd,
-            chargeUsd: input.chargeUsd,
-            metadata: input.metadata
+        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 = database.getCustomerById(customerId);
+        if (!customer) {
+            throw new Error("Customer not found.");
+        }
+        if (!customer.isPaidPlan) {
+            return { granted: false, reason: "customer_not_paid" };
+        }
+        if (database.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 clientReferenceId = buildPaidSignupBonusClientReferenceId(customerId);
+        const stripeEventId = `${PAID_SIGNUP_BONUS_GRANT_TYPE}:${customerId}`;
+        const intentResponse = await fetch(new URL(BILLING_WALLET_FUNDING_INTENTS_PATH, config.VIDFARM_BILLING_URL), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
+            },
+            body: JSON.stringify({
+                customer_id: customerId,
+                client_reference_id: clientReferenceId,
+                occurred_at_ms: Date.now(),
+                metadata: {
+                    ...(metadata ?? {}),
+                    grant_type: PAID_SIGNUP_BONUS_GRANT_TYPE
+                }
+            })
+        });
+        if (!intentResponse.ok) {
+            const body = await intentResponse.text().catch(() => "");
+            if (!/TransactionCanceledException|ConditionalCheckFailed|duplicate/i.test(body)) {
+                throw new Error(`Billing service rejected wallet funding intent (${intentResponse.status}): ${body || intentResponse.statusText}`);
+            }
+        }
+        const response = await fetch(new URL(BILLING_WALLET_FUNDING_CONFIRMED_PATH, config.VIDFARM_BILLING_URL), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
+            },
+            body: JSON.stringify({
+                client_reference_id: clientReferenceId,
+                amount_usd: PAID_SIGNUP_BONUS_USD,
+                stripe_event_id: stripeEventId,
+                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 funding (${response.status}): ${body || response.statusText}`);
+        }
+        try {
+            database.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 === "remotion_lambda" ? explicitSlug : null;
+    }
+    if (input.type === "render" && input.metadata?.mode === "lambda") {
+        return "remotion_lambda";
     }
+    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 === "remotion_lambda" && renderId) {
+        return `remotion_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));
+}
+function buildPaidSignupBonusClientReferenceId(customerId) {
+    const digest = createHash("sha256").update(`${PAID_SIGNUP_BONUS_GRANT_TYPE}:${customerId}`).digest("hex");
+    const part1 = digest.slice(0, 8);
+    const part2 = digest.slice(8, 12);
+    const part3 = `4${digest.slice(13, 16)}`;
+    const variantNibble = (8 + (Number.parseInt(digest.slice(16, 17), 16) % 4)).toString(16);
+    const part4 = `${variantNibble}${digest.slice(17, 20)}`;
+    const part5 = digest.slice(20, 32);
+    return `vidfarm_wallet_topup_${part1}-${part2}-${part3}-${part4}-${part5}`;
 }
+export { PAID_SIGNUP_BONUS_GRANT_TYPE, PAID_SIGNUP_BONUS_USD, resolveCostCenterSlug, resolveIdempotencyKey };

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

@@ -0,0 +1,88 @@
+import { createId } from "../lib/ids.js";
+import { nowIso } from "../lib/time.js";
+import { database } from "../db.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 = database.listChatThreadMetas(input);
+        const withMessages = await Promise.all(threads.map(async (thread) => ({
+            ...thread,
+            messages: await this.loadThreadMessages(thread)
+        })));
+        return withMessages;
+    },
+    async getThread(input) {
+        const thread = database.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 = database.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 = database.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 = database.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();
+    }
+};

package/dist/src/services/job-logs.js

@@ -32,11 +32,18 @@ export class JobLogStore {
         }
     }
     async listEvents(input) {
-        const limit = Math.max(1, Math.min(input.limit ?? 100, 500));
         const persisted = await this.readPersistedEvents(input);
         const buffered = this.readBufferedEvents(input);
-        const merged = dedupeAndSort([...persisted, ...buffered]);
-        return merged.slice(-limit);
+        const merged = dedupeAndSort([...persisted, ...buffered]).reverse();
+        const filtered = input.cursor
+            ? merged.filter((event) => (Date.parse(event.createdAt) < Date.parse(input.cursor.createdAt)
+                || (event.createdAt === input.cursor.createdAt && event.id < input.cursor.id)))
+            : merged;
+        if (input.limit === undefined) {
+            return filtered;
+        }
+        const limit = Math.max(1, Math.min(input.limit, 501));
+        return filtered.slice(0, limit);
     }
     async shutdown() {
         clearInterval(this.flushTimer);

package/dist/src/services/jobs.js

@@ -4,6 +4,13 @@ import { createId } from "../lib/ids.js";
 import { addSeconds, nowIso } from "../lib/time.js";
 import { jobLogStore } from "./job-logs.js";
 const PENDING_JOB_STATUSES = ["queued", "running", "waiting_for_child", "waiting_for_human"];
+function normalizeWebhookUrl(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
 export class JobsService {
     assertQueueCapacity(customerId) {
         if (config.MAX_PENDING_JOBS_GLOBAL <= 0 && config.MAX_PENDING_JOBS_PER_CUSTOMER <= 0) {
@@ -36,7 +43,7 @@ export class JobsService {
                 _providerHint: input.providerHint ?? null
             },
             progress: 0,
-            webhookUrl: input.webhookUrl ?? input.customer.defaultWebhookUrl ?? null,
+            webhookUrl: normalizeWebhookUrl(input.webhookUrl) ?? normalizeWebhookUrl(input.customer.defaultWebhookUrl),
             parentJobId: null,
             priority: 100,
             attemptCount: 0,
@@ -73,6 +80,9 @@ export class JobsService {
     listJobs(input) {
         return database.listJobsForCustomer(input);
     }
+    renameTracer(input) {
+        return database.renameJobsTracer(input);
+    }
     async listLogs(input) {
         return jobLogStore.listEvents(input);
     }
@@ -93,6 +103,7 @@ export class JobsService {
             status: "succeeded",
             progress,
             result,
+            error: null,
             completedAt: nowIso()
         });
     }
@@ -109,7 +120,7 @@ export class JobsService {
         database.updateJobStatus({
             id: job.id,
             status: nextStatus,
-            error,
+            error: nextStatus === "failed" ? error : null,
             runAfter: addSeconds(new Date(), delaySeconds),
             completedAt: nextStatus === "failed" ? nowIso() : null
         });