@mevdragon/vidfarm-devcli 0.20.5 → 0.20.8

package/dist/src/runtime.js

@@ -1,35 +0,0 @@
-import { serve } from "@hono/node-server";
-import * as Sentry from "@sentry/node";
-import app from "./app.js";
-import { config } from "./config.js";
-import { templateRegistry } from "./registry.js";
-import { apiCallHistoryStore } from "./services/api-call-history.js";
-import { jobLogStore } from "./services/job-logs.js";
-import { compositionWatch } from "./services/composition-watch.js";
-import { Worker } from "./worker.js";
-export async function startRuntime() {
-    await templateRegistry.ensureInitialized();
-    const worker = new Worker();
-    worker.start();
-    // No-op unless STORAGE_DRIVER=local (i.e. `vidfarm serve`): fans on-disk
-    // composition edits out to open editor tabs over same-origin SSE.
-    compositionWatch.start();
-    const server = serve({
-        fetch: app.fetch,
-        port: config.PORT,
-        serverOptions: {
-            maxHeaderSize: 64 * 1024
-        }
-    }, (info) => {
-        console.log(`[vidfarm] listening on http://localhost:${info.port}`);
-    });
-    const shutdown = async () => {
-        worker.stop();
-        await apiCallHistoryStore.shutdown();
-        await jobLogStore.shutdown();
-        await Sentry.flush(2_000).catch(() => undefined);
-        server.close();
-    };
-    return { server, worker, shutdown };
-}
-//# sourceMappingURL=runtime.js.map

package/dist/src/services/api-call-history.js

@@ -1,249 +0,0 @@
-import { StorageService } from "./storage.js";
-const API_CALL_HISTORY_PREFIX = "api-call-history";
-const CHUNK_INTERVAL_MS = 60_000;
-const CHUNK_MAX_BYTES = 1024 * 1024;
-const FLUSH_INTERVAL_MS = 5_000;
-export class ApiCallHistoryStore {
-    storage = new StorageService();
-    activeChunks = new Map();
-    flushTimer = setInterval(() => {
-        void this.flushExpiredChunks();
-    }, FLUSH_INTERVAL_MS);
-    constructor() {
-        this.flushTimer.unref();
-    }
-    addEntry(entry) {
-        const normalized = {
-            ...entry,
-            createdAt: entry.createdAt ?? new Date().toISOString()
-        };
-        const minuteStartMs = floorToMinute(Date.parse(normalized.createdAt));
-        const activePrefix = this.activeChunkPrefix(normalized.customerId, minuteStartMs);
-        const current = this.findLatestChunk(activePrefix);
-        const entryBytes = serializedEntrySize(normalized);
-        const chunk = current && current.sizeBytes + entryBytes <= CHUNK_MAX_BYTES
-            ? current
-            : this.createChunk(normalized.customerId, minuteStartMs, current ? current.sequence + 1 : 0);
-        chunk.entries.push(normalized);
-        chunk.sizeBytes += entryBytes;
-        chunk.dirty = true;
-        if (chunk.sizeBytes >= CHUNK_MAX_BYTES) {
-            void this.persistChunk(chunk, true);
-        }
-    }
-    async listEntries(input) {
-        const persisted = await this.readPersistedEntries(input);
-        const buffered = this.readBufferedEntries(input);
-        const merged = dedupeAndSort([...persisted, ...buffered]).reverse();
-        const filtered = input.cursor
-            ? merged.filter((entry) => (Date.parse(entry.createdAt) < Date.parse(input.cursor.createdAt)
-                || (entry.createdAt === input.cursor.createdAt && entry.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 listStorageKeys(input) {
-        return this.listRelevantKeys(input);
-    }
-    async renameTracer(input) {
-        const fromTracer = input.fromTracer.trim();
-        const toTracer = input.toTracer.trim();
-        if (!fromTracer || !toTracer || fromTracer === toTracer) {
-            return { updated: 0 };
-        }
-        let updated = 0;
-        for (const chunk of this.activeChunks.values()) {
-            if (chunk.customerId !== input.customerId) {
-                continue;
-            }
-            let chunkChanged = false;
-            for (const entry of chunk.entries) {
-                if (entry.tracer === fromTracer && withinRange(entry.createdAt, input.startTime, input.endTime)) {
-                    entry.tracer = toTracer;
-                    updated += 1;
-                    chunkChanged = true;
-                }
-            }
-            if (chunkChanged) {
-                chunk.dirty = true;
-                chunk.sizeBytes = chunk.entries.reduce((sum, entry) => sum + serializedEntrySize(entry), 0);
-                await this.persistChunk(chunk, false);
-            }
-        }
-        const keys = await this.listRelevantKeys(input);
-        await Promise.all(keys.map(async (key) => {
-            const content = await this.storage.readText(key);
-            const entries = parseChunk(content);
-            let changed = false;
-            for (const entry of entries) {
-                if (entry.customerId === input.customerId
-                    && entry.tracer === fromTracer
-                    && withinRange(entry.createdAt, input.startTime, input.endTime)) {
-                    entry.tracer = toTracer;
-                    updated += 1;
-                    changed = true;
-                }
-            }
-            if (changed) {
-                const body = `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`;
-                await this.storage.putText(key, body, "application/x-ndjson; charset=utf-8");
-            }
-        }));
-        return { updated };
-    }
-    async shutdown() {
-        clearInterval(this.flushTimer);
-        await Promise.all([...this.activeChunks.values()].map((chunk) => this.persistChunk(chunk, true)));
-    }
-    async readPersistedEntries(input) {
-        const keys = await this.listRelevantKeys(input);
-        const entries = await Promise.all(keys.map(async (key) => parseChunk(await this.storage.readText(key))));
-        return entries
-            .flat()
-            .filter((entry) => entry.customerId === input.customerId)
-            .filter((entry) => withinRange(entry.createdAt, input.startTime, input.endTime));
-    }
-    readBufferedEntries(input) {
-        const buffered = [];
-        for (const chunk of this.activeChunks.values()) {
-            if (chunk.customerId !== input.customerId) {
-                continue;
-            }
-            for (const entry of chunk.entries.slice(chunk.lastPersistedEntryCount)) {
-                if (withinRange(entry.createdAt, input.startTime, input.endTime)) {
-                    buffered.push(entry);
-                }
-            }
-        }
-        return buffered;
-    }
-    async listRelevantKeys(input) {
-        const minuteStarts = this.minuteStartsForQuery(input.startTime, input.endTime);
-        if (minuteStarts === null) {
-            return this.storage.listKeys(`${API_CALL_HISTORY_PREFIX}/customer_id=${input.customerId}/`);
-        }
-        const nested = await Promise.all(minuteStarts.map((minuteStartMs) => (this.storage.listKeys(this.minutePrefix(input.customerId, minuteStartMs)))));
-        return nested.flat();
-    }
-    minuteStartsForQuery(startTime, endTime) {
-        if (!startTime && !endTime) {
-            return null;
-        }
-        const startMs = floorToMinute(Date.parse(startTime ?? endTime ?? new Date().toISOString()));
-        const endMs = floorToMinute(Date.parse(endTime ?? startTime ?? new Date().toISOString()));
-        const minMs = Math.min(startMs, endMs);
-        const maxMs = Math.max(startMs, endMs);
-        const minuteStarts = [];
-        for (let cursor = minMs; cursor <= maxMs; cursor += 60_000) {
-            minuteStarts.push(cursor);
-        }
-        return minuteStarts;
-    }
-    async flushExpiredChunks() {
-        const now = Date.now();
-        await Promise.all([...this.activeChunks.values()].map(async (chunk) => {
-            const intervalElapsed = now >= chunk.minuteStartMs + CHUNK_INTERVAL_MS;
-            if (intervalElapsed || chunk.sizeBytes >= CHUNK_MAX_BYTES) {
-                await this.persistChunk(chunk, true);
-                return;
-            }
-            if (chunk.dirty) {
-                await this.persistChunk(chunk, false);
-            }
-        }));
-    }
-    createChunk(customerId, minuteStartMs, sequence) {
-        const chunk = {
-            customerId,
-            minuteStartMs,
-            sequence,
-            entries: [],
-            sizeBytes: 0,
-            lastPersistedEntryCount: 0,
-            dirty: false
-        };
-        this.activeChunks.set(this.chunkKeyForMap(customerId, minuteStartMs, sequence), chunk);
-        return chunk;
-    }
-    findLatestChunk(activePrefix) {
-        const matching = [...this.activeChunks.entries()]
-            .filter(([key]) => key.startsWith(activePrefix))
-            .map(([, chunk]) => chunk)
-            .sort((a, b) => a.sequence - b.sequence);
-        return matching.at(-1) ?? null;
-    }
-    activeChunkPrefix(customerId, minuteStartMs) {
-        return `${customerId}:${minuteStartMs}:`;
-    }
-    chunkKeyForMap(customerId, minuteStartMs, sequence) {
-        return `${this.activeChunkPrefix(customerId, minuteStartMs)}${sequence}`;
-    }
-    async persistChunk(chunk, finalize) {
-        if (!chunk.entries.length) {
-            if (finalize) {
-                this.activeChunks.delete(this.chunkKeyForMap(chunk.customerId, chunk.minuteStartMs, chunk.sequence));
-            }
-            return;
-        }
-        const key = this.objectKeyForChunk(chunk);
-        const body = `${chunk.entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`;
-        await this.storage.putText(key, body, "application/x-ndjson; charset=utf-8");
-        chunk.lastPersistedEntryCount = chunk.entries.length;
-        chunk.dirty = false;
-        if (finalize) {
-            this.activeChunks.delete(this.chunkKeyForMap(chunk.customerId, chunk.minuteStartMs, chunk.sequence));
-        }
-    }
-    objectKeyForChunk(chunk) {
-        const startTs = Math.floor(chunk.entries[0] ? Date.parse(chunk.entries[0].createdAt) / 1000 : chunk.minuteStartMs / 1000);
-        const endTs = Math.floor(chunk.entries.at(-1) ? Date.parse(chunk.entries.at(-1).createdAt) / 1000 : chunk.minuteStartMs / 1000);
-        return `${this.minutePrefix(chunk.customerId, chunk.minuteStartMs)}chunk-${startTs}-${endTs}-${String(chunk.sequence).padStart(4, "0")}.ndjson`;
-    }
-    minutePrefix(customerId, minuteStartMs) {
-        return `${API_CALL_HISTORY_PREFIX}/customer_id=${customerId}/minute=${Math.floor(minuteStartMs / 1000)}/`;
-    }
-}
-export const apiCallHistoryStore = new ApiCallHistoryStore();
-function serializedEntrySize(entry) {
-    return Buffer.byteLength(`${JSON.stringify(entry)}\n`, "utf8");
-}
-function floorToMinute(timestampMs) {
-    return Math.floor(timestampMs / 60_000) * 60_000;
-}
-function parseChunk(content) {
-    if (!content) {
-        return [];
-    }
-    return content
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .map((line) => {
-        const parsed = JSON.parse(line);
-        return {
-            ...parsed,
-            jobId: typeof parsed.jobId === "string" && parsed.jobId.trim() ? parsed.jobId.trim() : null
-        };
-    });
-}
-function dedupeAndSort(entries) {
-    const deduped = new Map();
-    for (const entry of entries) {
-        deduped.set(entry.id, entry);
-    }
-    return [...deduped.values()].sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
-}
-function withinRange(createdAt, startTime, endTime) {
-    const value = Date.parse(createdAt);
-    if (startTime && value < Date.parse(startTime)) {
-        return false;
-    }
-    if (endTime && value > Date.parse(endTime)) {
-        return false;
-    }
-    return true;
-}
-//# sourceMappingURL=api-call-history.js.map

package/dist/src/services/auth.js

@@ -1,152 +0,0 @@
-import { randomInt } from "node:crypto";
-import { config } from "../config.js";
-import { encryptString, hashPassword, hashSecret, safeEqualHash, verifyPassword } from "../lib/crypto.js";
-import { displayNameFromEmail } from "../lib/display-name.js";
-import { createId } from "../lib/ids.js";
-import { addSeconds, nowIso } from "../lib/time.js";
-import { ServerlessAuthService } from "./serverless-auth.js";
-export class AuthService {
-    serverless = new ServerlessAuthService();
-    async requestOtp(email) {
-        const code = `${randomInt(100000, 999999)}`;
-        await this.serverless.insertOtpChallenge({
-            id: createId("otp"),
-            email,
-            codeHash: hashSecret(code),
-            expiresAt: addSeconds(new Date(), 600)
-        });
-        if (config.RESEND_API_KEY) {
-            const response = await fetch("https://api.resend.com/emails", {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${config.RESEND_API_KEY}`
-                },
-                body: JSON.stringify({
-                    from: config.RESEND_FROM_EMAIL,
-                    to: email,
-                    subject: "Your Vidfarm login code",
-                    text: `Your login code is ${code}. It expires in 10 minutes.`
-                })
-            });
-            if (!response.ok) {
-                const body = await response.text();
-                throw new Error(`Unable to send OTP email (${response.status}): ${body || "empty response body"}`);
-            }
-            return {
-                delivery: "email"
-            };
-        }
-        else {
-            console.log(`[vidfarm] OTP for ${email}: ${code}`);
-            return {
-                delivery: "console",
-                code: config.isProduction ? undefined : code
-            };
-        }
-    }
-    async verifyOtp(email, code, name) {
-        const challenge = await this.serverless.findLatestOtpChallenge(email);
-        if (!challenge) {
-            throw new Error("No OTP challenge found for that email.");
-        }
-        if (challenge.consumed_at) {
-            throw new Error("OTP challenge already used.");
-        }
-        if (new Date(String(challenge.expires_at)).getTime() < Date.now()) {
-            throw new Error("OTP challenge expired.");
-        }
-        if (!safeEqualHash(code, String(challenge.code_hash))) {
-            throw new Error("Invalid OTP code.");
-        }
-        await this.serverless.consumeOtpChallenge(email, String(challenge.id));
-        const existing = await this.serverless.getCustomerByEmailPublic(email);
-        const normalizedEmail = email.trim().toLowerCase();
-        const customer = await this.serverless.upsertCustomer({
-            id: existing?.id ?? createId("cus"),
-            email: normalizedEmail,
-            name: name?.trim() || existing?.name || displayNameFromEmail(normalizedEmail),
-            defaultWebhookUrl: existing?.defaultWebhookUrl ?? null,
-            isDeveloper: existing?.isDeveloper || config.adminEmails.includes(normalizedEmail),
-            isPaidPlan: existing?.isPaidPlan ?? false,
-            planTier: existing?.planTier ?? "client"
-        });
-        const rawApiKey = `vf_${createId("key")}`;
-        await this.serverless.insertApiKey({
-            id: createId("api"),
-            customerId: customer.id,
-            keyHash: hashSecret(rawApiKey + config.API_KEY_SALT),
-            rawValue: rawApiKey,
-            label: `Issued ${nowIso()}`
-        });
-        return { customer, apiKey: rawApiKey };
-    }
-    authenticate(apiKey) {
-        throw new Error("Use authenticateAsync; DynamoDB authentication is asynchronous.");
-    }
-    async authenticateAsync(apiKey) {
-        return this.serverless.authenticate(apiKey);
-    }
-    async verifyOtpForBrowserLogin(email, code, name) {
-        const result = await this.verifyOtp(email, code, name);
-        if (!result.customer.isPaidPlan) {
-            return {
-                status: "pricing",
-                customer: result.customer
-            };
-        }
-        return {
-            status: "authenticated",
-            customer: result.customer
-        };
-    }
-    async authenticateWithPassword(email, password) {
-        const row = await this.serverless.getCustomerAuthByEmail(email);
-        if (!row || !row.password_hash || !verifyPassword(password, String(row.password_hash))) {
-            throw new Error("Invalid email or password.");
-        }
-        const customer = await this.serverless.getCustomerById(String(row.customer_id ?? row.id));
-        if (!customer) {
-            throw new Error("Customer not found.");
-        }
-        await this.serverless.updateCustomerPassword(customer.id, String(row.password_hash), encryptString(password, config.ENCRYPTION_SECRET));
-        if (!customer.isPaidPlan) {
-            return {
-                status: "pricing",
-                customer
-            };
-        }
-        return {
-            status: "authenticated",
-            customer
-        };
-    }
-    async createPasswordUser(input) {
-        const normalizedEmail = input.email.trim().toLowerCase();
-        const existing = await this.serverless.getCustomerByEmailPublic(normalizedEmail);
-        return this.serverless.upsertCustomer({
-            id: existing?.id ?? createId("cus"),
-            email: normalizedEmail,
-            name: input.name?.trim() || existing?.name || displayNameFromEmail(normalizedEmail),
-            defaultWebhookUrl: existing?.defaultWebhookUrl ?? null,
-            isDeveloper: existing?.isDeveloper || config.adminEmails.includes(normalizedEmail),
-            isPaidPlan: true,
-            planTier: input.planTier ?? existing?.planTier ?? "client",
-            passwordHash: hashPassword(input.password),
-            encryptedPassword: encryptString(input.password, config.ENCRYPTION_SECRET)
-        });
-    }
-}
-function normalizePlanTier(value) {
-    if (value === "client" || value === "standalone" || value === "agency") {
-        return value;
-    }
-    if (value === "invisible" || value === "starter") {
-        return "client";
-    }
-    if (value === "standard") {
-        return "standalone";
-    }
-    return "client";
-}
-//# sourceMappingURL=auth.js.map

package/dist/src/services/billing-pricing.js

@@ -1,39 +0,0 @@
-// Single source of truth for the render/compute billing markup.
-//
-// The billing lambda debits the wallet by `base_provider_cost * markup` (see
-// infra/lambda/billing.ts). Every surface that *displays* a render's cost — and
-// every place that pre-computes the marked-up `chargeUsd` stashed in render
-// metadata — must apply the SAME markup, otherwise the number shown to the user
-// diverges from what their wallet is actually charged.
-//
-// The markup is expressed in basis points so it matches the billing lambda's
-// integer micros math exactly. It is overridable per-environment via
-// `VIDFARM_BILLING_MARKUP_BPS`; keep that env var in sync across the billing,
-// job-runner, and api lambdas so display and charge never drift.
-export const DEFAULT_MARKUP_BPS = 12_000; // 1.2x
-const BPS_DENOMINATOR = 10_000;
-// Resolve the active markup (basis points). Falls back to the default when the
-// env var is unset, empty, or not a positive integer.
-export function resolveMarkupBps() {
-    const raw = process.env.VIDFARM_BILLING_MARKUP_BPS;
-    if (raw === undefined || raw === null || raw.trim() === "") {
-        return DEFAULT_MARKUP_BPS;
-    }
-    const parsed = Number.parseInt(raw, 10);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        return DEFAULT_MARKUP_BPS;
-    }
-    return parsed;
-}
-export function roundUsd(value) {
-    return Number(value.toFixed(4));
-}
-// Convert a raw provider cost (USD) into the amount the wallet is actually
-// charged. Non-positive or non-finite inputs yield 0 (nothing to bill).
-export function applyMarkupUsd(baseCostUsd, markupBps = resolveMarkupBps()) {
-    if (!Number.isFinite(baseCostUsd) || baseCostUsd <= 0) {
-        return 0;
-    }
-    return roundUsd((baseCostUsd * markupBps) / BPS_DENOMINATOR);
-}
-//# sourceMappingURL=billing-pricing.js.map