@mevdragon/vidfarm-devcli 0.1.0

package/dist/src/domain.js

@@ -0,0 +1 @@
+export {};

package/dist/src/index.js

@@ -0,0 +1,8 @@
+import { startRuntime } from "./runtime.js";
+const runtime = startRuntime();
+for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, () => {
+        runtime.shutdown();
+        process.exit(0);
+    });
+}

package/dist/src/lib/crypto.js

@@ -0,0 +1,30 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
+function deriveKey(secret) {
+    return scryptSync(secret, "vidfarm", 32);
+}
+export function hashSecret(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function safeEqualHash(raw, hashed) {
+    const left = Buffer.from(hashSecret(raw), "hex");
+    const right = Buffer.from(hashed, "hex");
+    return left.length === right.length && timingSafeEqual(left, right);
+}
+export function encryptString(value, secret) {
+    const iv = randomBytes(12);
+    const key = deriveKey(secret);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const encrypted = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([iv, tag, encrypted]).toString("base64");
+}
+export function decryptString(value, secret) {
+    const raw = Buffer.from(value, "base64");
+    const iv = raw.subarray(0, 12);
+    const tag = raw.subarray(12, 28);
+    const encrypted = raw.subarray(28);
+    const key = deriveKey(secret);
+    const decipher = createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString("utf8");
+}

package/dist/src/lib/ids.js

@@ -0,0 +1,4 @@
+import { randomUUID } from "node:crypto";
+export function createId(prefix) {
+    return `${prefix}_${randomUUID().replace(/-/g, "")}`;
+}

package/dist/src/lib/images.js

@@ -0,0 +1,18 @@
+import sharp from "sharp";
+export async function normalizeToPortraitFrame(input, target = { width: 1080, height: 1920 }) {
+    const buffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+    const output = await sharp(buffer, { density: 144 })
+        .rotate()
+        .resize(target.width, target.height, {
+        fit: "cover",
+        position: sharp.strategy.attention
+    })
+        .png()
+        .toBuffer();
+    return {
+        bytes: output,
+        contentType: "image/png",
+        width: target.width,
+        height: target.height
+    };
+}

package/dist/src/lib/json.js

@@ -0,0 +1,14 @@
+export function parseJson(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function stringifyJson(value) {
+    return JSON.stringify(value ?? null);
+}

package/dist/src/lib/time.js

@@ -0,0 +1,6 @@
+export function nowIso() {
+    return new Date().toISOString();
+}
+export function addSeconds(date, seconds) {
+    return new Date(date.getTime() + seconds * 1000).toISOString();
+}

package/dist/src/registry.js

@@ -0,0 +1,10 @@
+import { demoTemplate } from "../templates/template_0000/demo-template.js";
+const templates = [demoTemplate];
+export const templateRegistry = {
+    list() {
+        return templates;
+    },
+    get(templateId) {
+        return templates.find((template) => template.id === templateId) ?? null;
+    }
+};

package/dist/src/runtime.js

@@ -0,0 +1,19 @@
+import { serve } from "@hono/node-server";
+import app from "./app.js";
+import { config } from "./config.js";
+import { Worker } from "./worker.js";
+export function startRuntime() {
+    const worker = new Worker();
+    worker.start();
+    const server = serve({
+        fetch: app.fetch,
+        port: config.PORT
+    }, (info) => {
+        console.log(`[vidfarm] listening on http://localhost:${info.port}`);
+    });
+    const shutdown = () => {
+        worker.stop();
+        server.close();
+    };
+    return { server, worker, shutdown };
+}

package/dist/src/services/auth.js

@@ -0,0 +1,80 @@
+import { randomInt } from "node:crypto";
+import { config } from "../config.js";
+import { database } from "../db.js";
+import { hashSecret, safeEqualHash } from "../lib/crypto.js";
+import { createId } from "../lib/ids.js";
+import { addSeconds, nowIso } from "../lib/time.js";
+export class AuthService {
+    async requestOtp(email) {
+        const code = `${randomInt(100000, 999999)}`;
+        database.insertOtpChallenge({
+            id: createId("otp"),
+            email,
+            codeHash: hashSecret(code),
+            expiresAt: addSeconds(new Date(), 600)
+        });
+        if (config.RESEND_API_KEY) {
+            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.`
+                })
+            });
+        }
+        else {
+            console.log(`[vidfarm] OTP for ${email}: ${code}`);
+        }
+    }
+    verifyOtp(email, code, name) {
+        const challenge = database.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.");
+        }
+        database.consumeOtpChallenge(String(challenge.id));
+        const customer = database.getCustomerByEmail(email) ?? database.upsertCustomer({
+            id: createId("cus"),
+            email,
+            name: name ?? null
+        });
+        const rawApiKey = `vf_${createId("key")}`;
+        database.insertApiKey({
+            id: createId("api"),
+            customerId: customer.id,
+            keyHash: hashSecret(rawApiKey + config.API_KEY_SALT),
+            label: `Issued ${nowIso()}`
+        });
+        return { customer, apiKey: rawApiKey };
+    }
+    authenticate(userId, apiKey) {
+        if (!userId || !apiKey) {
+            throw new Error("Missing vidfarm-user-id or vidfarm-api-key header.");
+        }
+        const row = database.findApiKeyByHash(hashSecret(apiKey + config.API_KEY_SALT));
+        if (!row || String(row.customer_id) !== userId) {
+            throw new Error("Invalid API credentials.");
+        }
+        database.touchApiKey(String(row.id));
+        return {
+            id: String(row.customer_id),
+            email: String(row.email),
+            name: row.name ? String(row.name) : null,
+            defaultWebhookUrl: row.default_webhook_url ? String(row.default_webhook_url) : null
+        };
+    }
+}

package/dist/src/services/billing.js

@@ -0,0 +1,16 @@
+import { database } from "../db.js";
+import { createId } from "../lib/ids.js";
+export class BillingService {
+    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
+        });
+    }
+}

package/dist/src/services/jobs.js

@@ -0,0 +1,97 @@
+import { config } from "../config.js";
+import { database } from "../db.js";
+import { createId } from "../lib/ids.js";
+import { addSeconds, nowIso } from "../lib/time.js";
+export class JobsService {
+    createRootJob(input) {
+        return database.createJob({
+            id: createId("job"),
+            templateId: input.templateId,
+            operationName: input.operationName,
+            workflowName: input.workflowName,
+            tracer: input.tracer,
+            status: "queued",
+            customerId: input.customer.id,
+            payload: {
+                ...input.payload,
+                _providerHint: input.providerHint ?? null
+            },
+            progress: 0,
+            webhookUrl: input.webhookUrl ?? input.customer.defaultWebhookUrl ?? null,
+            parentJobId: null,
+            priority: 100,
+            attemptCount: 0,
+            maxAttempts: 6,
+            runAfter: nowIso()
+        });
+    }
+    async enqueueChildJob(input) {
+        return database.createJob({
+            id: createId("job"),
+            templateId: input.templateId,
+            operationName: input.operationName,
+            workflowName: input.workflowName,
+            tracer: input.tracer,
+            status: "queued",
+            customerId: input.customerId,
+            payload: {
+                ...input.payload,
+                _providerHint: input.providerHint ?? null
+            },
+            progress: 0,
+            webhookUrl: null,
+            parentJobId: input.parentJobId,
+            priority: 110,
+            attemptCount: 0,
+            maxAttempts: 6,
+            runAfter: nowIso()
+        });
+    }
+    getJob(jobId) {
+        return database.getJob(jobId);
+    }
+    listJobs(customerId, templateId) {
+        return database.listJobsForCustomer(customerId, templateId);
+    }
+    listLogs(jobId, since, limit) {
+        return database.getJobEvents(jobId, since, limit);
+    }
+    cancelJob(jobId) {
+        database.updateJobStatus({
+            id: jobId,
+            status: "cancelled",
+            completedAt: nowIso(),
+            error: { message: "Cancelled by user request." }
+        });
+    }
+    markRunning(jobId) {
+        database.markJobRunning(jobId);
+    }
+    succeedJob(jobId, result, progress = 1) {
+        database.updateJobStatus({
+            id: jobId,
+            status: "succeeded",
+            progress,
+            result,
+            completedAt: nowIso()
+        });
+    }
+    failJob(jobId, error) {
+        database.updateJobStatus({
+            id: jobId,
+            status: "failed",
+            error,
+            completedAt: nowIso()
+        });
+    }
+    requeueJob(job, delaySeconds = config.DEFAULT_JOB_DELAY_SECONDS, error) {
+        const nextStatus = job.attemptCount + 1 >= job.maxAttempts ? "failed" : "queued";
+        database.updateJobStatus({
+            id: job.id,
+            status: nextStatus,
+            error,
+            runAfter: addSeconds(new Date(), delaySeconds),
+            completedAt: nextStatus === "failed" ? nowIso() : null
+        });
+    }
+}