@mevdragon/vidfarm-devcli 0.1.0

package/README.md

@@ -0,0 +1,151 @@
+# Vidfarm
+
+Vidfarm is a single-container Node.js control plane for async video template pipelines. It follows the architecture in [video-pipeline-architecture-draft.md](/Users/localghost/Projects/OfficeX/OfficeX/ZoomGTM/vidfarm/video-pipeline-architecture-draft.md) and [PLATFORM_SPEC.md](/Users/localghost/Projects/OfficeX/OfficeX/ZoomGTM/vidfarm/PLATFORM_SPEC.md): Hono API, SQLite-backed jobs and provider-key leasing, S3-compatible storage, and an in-process worker suitable for Docker on EC2.
+
+## What Is Included
+
+- Async template API under `/templates/:templateId/*`
+- Email OTP login with API key issuance
+- Customer-scoped provider key vault with encryption at rest
+- SQLite-backed job queue and provider-key lease coordination
+- Structured job logs, artifacts, billing events, and webhook delivery queue
+- Local storage mode plus S3-compatible mode for AWS
+- Remotion adapter seam and a sample `demo-template` slideshow pipeline
+
+## Quick Start
+
+```bash
+npm install
+cp .env.example .env
+npm run dev
+```
+
+The service starts on `http://localhost:3000` by default and creates SQLite plus local artifact storage under `./data`.
+
+## Template Developer CLI
+
+For local template development, use the bundled CLI instead of manually wiring auth, provider keys, SQLite, and Remotion:
+
+```bash
+npm install
+npx @officexapp/vidfarm-devcli dev --port 3310 --reset
+```
+
+What it does:
+
+- starts the same REST API and in-process worker as production
+- provisions a local SQLite database automatically
+- uses local filesystem storage as an S3 stand-in
+- seeds a dev customer and API key
+- seeds provider keys from local `.env` variables like `OPENAI_API_KEY`, `GEMINI_API_KEY`, and `OPENROUTER_API_KEY`
+- falls back to mock provider keys plus mocked AI responses when no env keys are present
+- renders Remotion compositions locally instead of using Lambda
+
+Useful commands:
+
+```bash
+npx @officexapp/vidfarm-devcli dev --port 3310 --reset
+npx @officexapp/vidfarm-devcli session
+```
+
+After install, the package also exposes `vidfarm` and `vidfarm-devcli` as local binaries.
+
+`vidfarm session` prints reusable auth headers and a sample `curl` request for the local REST API.
+
+## Environment
+
+Primary variables:
+
+- `PORT`
+- `VIDFARM_DB_PATH`
+- `VIDFARM_DATA_DIR`
+- `ENCRYPTION_SECRET`
+- `API_KEY_SALT`
+- `STORAGE_DRIVER=local|s3`
+- `AWS_REGION`
+- `AWS_S3_BUCKET`
+- `PUBLIC_BASE_URL`
+- `RESEND_API_KEY`
+- `WEBHOOK_SECRET`
+- `MOCK_PROVIDER_RESPONSES=true|false`
+
+Remotion-specific variables:
+
+- `REMOTION_REGION`
+- `REMOTION_FUNCTION_NAME`
+- `REMOTION_BUCKET_NAME`
+- `REMOTION_SITE_NAME`
+- `REMOTION_SERVE_URL`
+- `REMOTION_COMPOSITION_ID`
+- `REMOTION_AWS_ACCESS_KEY_ID`
+- `REMOTION_AWS_SECRET_ACCESS_KEY`
+
+When `MOCK_PROVIDER_RESPONSES=true`, AI provider calls use the real key-leasing flow but return mocked content. This makes local end-to-end testing possible without burning customer API calls.
+
+When using `npx @officexapp/vidfarm-devcli dev`, the CLI automatically chooses local-friendly defaults:
+
+- `STORAGE_DRIVER=local`
+- `REMOTION_MODE=local`
+- a local SQLite path under `.vidfarm/local`
+- `MOCK_PROVIDER_RESPONSES=false` if real provider env keys are present, otherwise `true`
+
+## Remotion AWS
+
+For shared Remotion AWS infra, use [AWS_REMOTION_HANDOFF.md](/Users/localghost/Projects/OfficeX/OfficeX/ZoomGTM/vidfarm/AWS_REMOTION_HANDOFF.md) as the operating contract.
+
+The key points verified on `2026-05-16` are:
+
+- region: `us-east-1`
+- shared Lambda function: `remotion-render-4-0-355-mem2048mb-disk2048mb-180sec`
+- shared bucket: `remotionlambda-useast1-ujg7c0h43q`
+- Remotion package version to pin: `4.0.355`
+
+This repo also has separate Remotion AWS runner credentials available in local production env config via:
+
+- `REMOTION_AWS_ACCESS_KEY_ID`
+- `REMOTION_AWS_SECRET_ACCESS_KEY`
+
+Use those for Remotion site publish/render work rather than assuming the generic app AWS credentials are the right identity.
+
+Recommended repo-level config for real Remotion work:
+
+```env
+REMOTION_REGION=us-east-1
+REMOTION_FUNCTION_NAME=remotion-render-4-0-355-mem2048mb-disk2048mb-180sec
+REMOTION_BUCKET_NAME=remotionlambda-useast1-ujg7c0h43q
+REMOTION_SITE_NAME=your-site-name
+REMOTION_SERVE_URL=https://remotionlambda-useast1-ujg7c0h43q.s3.us-east-1.amazonaws.com/sites/your-site-name/index.html
+REMOTION_COMPOSITION_ID=YourComposition
+```
+
+If you wire real Lambda rendering into `src/services/remotion.ts`, preserve the current platform contract and make the service read these env vars rather than hard-coding one-off values.
+
+## API Flow
+
+1. `POST /auth/request-otp`
+2. `POST /auth/verify-otp`
+3. `POST /me/provider-keys`
+4. `POST /templates/demo-template/config`
+5. `POST /templates/demo-template/operations/generate`
+6. Poll `GET /templates/demo-template/jobs/:jobId`
+7. Stream timeline data from `GET /templates/demo-template/jobs/:jobId/logs`
+
+## Docker
+
+```bash
+docker compose up --build
+```
+
+For AWS/EC2, mount `/app/data` onto durable storage if SQLite is local, or switch artifacts to S3 with:
+
+```env
+STORAGE_DRIVER=s3
+AWS_REGION=us-east-1
+AWS_S3_BUCKET=your-vidfarm-bucket
+PUBLIC_BASE_URL=https://your-domain.example
+```
+
+## Notes
+
+- `demo-template` is the canonical sample internal template. Add more templates by registering them in [src/registry.ts](/Users/localghost/Projects/OfficeX/OfficeX/ZoomGTM/vidfarm/src/registry.ts).
+- Remotion is still stubbed behind [src/services/remotion.ts](/Users/localghost/Projects/OfficeX/OfficeX/ZoomGTM/vidfarm/src/services/remotion.ts). When upgrading it to real Lambda submission, follow [AWS_REMOTION_HANDOFF.md](/Users/localghost/Projects/OfficeX/OfficeX/ZoomGTM/vidfarm/AWS_REMOTION_HANDOFF.md) and use the Remotion-specific AWS credentials already available in local production env config.

package/dist/src/app.js

@@ -0,0 +1,224 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { Hono } from "hono";
+import { z } from "zod";
+import { config } from "./config.js";
+import { database } from "./db.js";
+import { renderDevApp } from "./dev-app.js";
+import { encryptString } from "./lib/crypto.js";
+import { createId } from "./lib/ids.js";
+import { templateRegistry } from "./registry.js";
+import { AuthService } from "./services/auth.js";
+import { JobsService } from "./services/jobs.js";
+import { StorageService } from "./services/storage.js";
+const auth = new AuthService();
+const jobs = new JobsService();
+const storage = new StorageService();
+const app = new Hono();
+const otpRequestSchema = z.object({
+    email: z.string().email()
+});
+const otpVerifySchema = z.object({
+    email: z.string().email(),
+    code: z.string().min(6).max(6),
+    name: z.string().optional()
+});
+const providerKeySchema = z.object({
+    provider: z.enum(["openai", "gemini", "openrouter", "perplexity"]),
+    label: z.string().optional(),
+    secret: z.string().min(8),
+    weight: z.number().int().min(1).max(100).default(1)
+});
+const workspacePresignSchema = z.object({
+    path: z.string().min(1),
+    contentType: z.string().min(3).default("application/octet-stream")
+});
+app.use("*", async (c, next) => {
+    c.header("x-powered-by", "vidfarm");
+    await next();
+});
+app.get("/", (c) => c.json({ name: "vidfarm", version: "0.1.0", environment: config.NODE_ENV }));
+app.get("/health", (c) => c.json({ ok: true, time: new Date().toISOString() }));
+app.get("/dev", (c) => c.html(renderDevApp({
+    environment: config.NODE_ENV,
+    templates: templateRegistry.list().map((template) => ({
+        id: template.id,
+        version: template.version,
+        description: template.description,
+        operations: Object.entries(template.operations).map(([name, operation]) => ({
+            name,
+            description: operation.description,
+            workflow: operation.workflow,
+            providerHint: operation.providerHint ?? null
+        }))
+    }))
+})));
+app.post("/auth/request-otp", async (c) => {
+    const body = otpRequestSchema.parse(await c.req.json());
+    await auth.requestOtp(body.email);
+    return c.json({ ok: true });
+});
+app.post("/auth/verify-otp", async (c) => {
+    const body = otpVerifySchema.parse(await c.req.json());
+    return c.json(auth.verifyOtp(body.email, body.code, body.name));
+});
+function requireCustomer(c) {
+    return c.get("customer");
+}
+const requireAuth = async (c, next) => {
+    try {
+        const customer = auth.authenticate(c.req.header("vidfarm-user-id"), c.req.header("vidfarm-api-key"));
+        c.set("customer", customer);
+        await next();
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : "Unauthorized" }, 401);
+    }
+};
+app.use("/me/*", requireAuth);
+app.use("/templates/*", requireAuth);
+app.get("/templates", (c) => c.json({
+    templates: templateRegistry.list().map((template) => ({
+        id: template.id,
+        version: template.version,
+        description: template.description,
+        operations: Object.entries(template.operations).map(([name, operation]) => ({
+            name,
+            description: operation.description,
+            workflow: operation.workflow,
+            providerHint: operation.providerHint ?? null
+        }))
+    }))
+}));
+app.get("/templates/:templateId", (c) => {
+    const template = templateRegistry.get(c.req.param("templateId"));
+    if (!template) {
+        return c.json({ error: "Template not found" }, 404);
+    }
+    return c.json({
+        id: template.id,
+        version: template.version,
+        description: template.description,
+        operations: Object.entries(template.operations).map(([name, operation]) => ({
+            name,
+            description: operation.description,
+            providerHint: operation.providerHint ?? null
+        }))
+    });
+});
+app.post("/templates/:templateId/config", async (c) => {
+    const customer = requireCustomer(c);
+    const template = templateRegistry.get(c.req.param("templateId"));
+    if (!template) {
+        return c.json({ error: "Template not found" }, 404);
+    }
+    const body = z.object({ config: z.record(z.string(), z.unknown()) }).parse(await c.req.json());
+    const parsed = template.configSchema.parse(body.config);
+    database.upsertTemplateConfig({
+        id: createId("cfg"),
+        customerId: customer.id,
+        templateId: template.id,
+        config: parsed
+    });
+    return c.json({ ok: true, template_id: template.id, config: parsed });
+});
+app.post("/templates/:templateId/operations/:operationName", async (c) => {
+    const customer = requireCustomer(c);
+    const template = templateRegistry.get(c.req.param("templateId"));
+    if (!template) {
+        return c.json({ error: "Template not found" }, 404);
+    }
+    const operation = template.operations[c.req.param("operationName")];
+    if (!operation) {
+        return c.json({ error: "Operation not found" }, 404);
+    }
+    const body = z.object({
+        tracer: z.string().min(3),
+        payload: z.record(z.string(), z.unknown()),
+        webhook_url: z.string().url().optional()
+    }).parse(await c.req.json());
+    const payload = operation.inputSchema.parse(body.payload);
+    const job = jobs.createRootJob({
+        templateId: template.id,
+        operationName: c.req.param("operationName"),
+        workflowName: operation.workflow,
+        tracer: body.tracer,
+        payload,
+        webhookUrl: body.webhook_url,
+        customer,
+        providerHint: operation.providerHint
+    });
+    return c.json({ job_id: job.id, tracer: job.tracer, status: job.status }, 202);
+});
+app.get("/templates/:templateId/jobs/:jobId", (c) => {
+    const customer = requireCustomer(c);
+    const job = jobs.getJob(c.req.param("jobId"));
+    if (!job || job.customerId !== customer.id || job.templateId !== c.req.param("templateId")) {
+        return c.json({ error: "Job not found" }, 404);
+    }
+    return c.json({
+        job_id: job.id,
+        tracer: job.tracer,
+        status: job.status,
+        progress: job.progress,
+        result: job.result,
+        error: job.error,
+        created_at: job.createdAt,
+        updated_at: job.updatedAt
+    });
+});
+app.get("/templates/:templateId/jobs/:jobId/logs", (c) => {
+    const customer = requireCustomer(c);
+    const job = jobs.getJob(c.req.param("jobId"));
+    if (!job || job.customerId !== customer.id || job.templateId !== c.req.param("templateId")) {
+        return c.json({ error: "Job not found" }, 404);
+    }
+    const logs = jobs.listLogs(job.id, c.req.query("logs_from") || undefined, Number(c.req.query("limit") ?? 100));
+    return c.json({ job_id: job.id, tracer: job.tracer, logs });
+});
+app.post("/templates/:templateId/jobs/:jobId/cancel", (c) => {
+    const customer = requireCustomer(c);
+    const job = jobs.getJob(c.req.param("jobId"));
+    if (!job || job.customerId !== customer.id || job.templateId !== c.req.param("templateId")) {
+        return c.json({ error: "Job not found" }, 404);
+    }
+    jobs.cancelJob(job.id);
+    return c.json({ ok: true, job_id: job.id, status: "cancelled" });
+});
+app.get("/me", (c) => c.json({ customer: requireCustomer(c) }));
+app.get("/me/jobs", (c) => c.json({ jobs: jobs.listJobs(requireCustomer(c).id, c.req.query("template_id") || undefined) }));
+app.get("/me/provider-keys", (c) => c.json({ provider_keys: database.listProviderKeys(requireCustomer(c).id) }));
+app.post("/me/provider-keys", async (c) => {
+    const customer = requireCustomer(c);
+    const body = providerKeySchema.parse(await c.req.json());
+    database.createProviderKey({
+        id: createId("pkey"),
+        customerId: customer.id,
+        provider: body.provider,
+        label: body.label ?? null,
+        encryptedSecret: encryptString(body.secret, config.ENCRYPTION_SECRET),
+        weight: body.weight
+    });
+    return c.json({ ok: true }, 201);
+});
+app.post("/me/workspace/presign", async (c) => {
+    const customer = requireCustomer(c);
+    const body = workspacePresignSchema.parse(await c.req.json());
+    return c.json(await storage.createPresignedWorkspaceUpload(customer.id, body.path, body.contentType));
+});
+app.get("/storage/:key", (c) => {
+    const key = decodeURIComponent(c.req.param("key"));
+    try {
+        const object = storage.readLocalObject(key);
+        return new Response(object.body, {
+            headers: {
+                "content-type": object.contentType
+            }
+        });
+    }
+    catch {
+        return c.json({ error: "Artifact not found" }, 404);
+    }
+});
+app.get("/docs/spec", (c) => c.text(readFileSync(path.resolve("PLATFORM_SPEC.md"), "utf8")));
+export default app;

package/dist/src/cli.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import dotenv from "dotenv";
+void main().catch((error) => {
+    console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exit(1);
+});
+async function main() {
+    const command = process.argv[2] ?? "dev";
+    if (command === "session") {
+        await runSessionCommand(process.argv.slice(3));
+        return;
+    }
+    if (command === "dev") {
+        await runDevCommand(process.argv.slice(3));
+        return;
+    }
+    throw new Error(`Unknown command: ${command}`);
+}
+async function runDevCommand(argv) {
+    const parsed = parseArgs({
+        args: argv,
+        options: {
+            port: { type: "string", default: "3000" },
+            "data-dir": { type: "string", default: ".vidfarm/local" },
+            "env-file": { type: "string", default: ".env" },
+            email: { type: "string", default: "dev@vidfarm.local" },
+            name: { type: "string", default: "Vidfarm Local Dev" },
+            "api-key": { type: "string" },
+            reset: { type: "boolean", default: false },
+            "mock-ai": { type: "boolean" }
+        }
+    });
+    const port = Number(parsed.values.port);
+    const root = process.cwd();
+    const dataDir = path.resolve(root, parsed.values["data-dir"]);
+    const dbPath = path.join(dataDir, "vidfarm.sqlite");
+    const sessionPath = path.join(dataDir, "session.json");
+    dotenv.config({
+        path: path.resolve(root, parsed.values["env-file"]),
+        override: false
+    });
+    if (parsed.values.reset) {
+        rmSync(dataDir, { recursive: true, force: true });
+    }
+    mkdirSync(dataDir, { recursive: true });
+    const hasProviderEnvKey = Boolean(process.env.OPENAI_API_KEY ||
+        process.env.GEMINI_API_KEY ||
+        process.env.OPENROUTER_API_KEY ||
+        process.env.PERPLEXITY_API_KEY);
+    process.env.NODE_ENV = process.env.NODE_ENV || "development";
+    process.env.PORT = String(port);
+    process.env.VIDFARM_DATA_DIR = dataDir;
+    process.env.VIDFARM_DB_PATH = dbPath;
+    process.env.STORAGE_DRIVER = "local";
+    process.env.PUBLIC_BASE_URL = `http://127.0.0.1:${port}`;
+    process.env.REMOTION_MODE = "local";
+    process.env.MOCK_PROVIDER_RESPONSES =
+        parsed.values["mock-ai"] ? "true" : process.env.MOCK_PROVIDER_RESPONSES ?? (hasProviderEnvKey ? "false" : "true");
+    const [{ startRuntime }, { database }, { config }, { createId }, crypto] = await Promise.all([
+        import("./runtime.js"),
+        import("./db.js"),
+        import("./config.js"),
+        import("./lib/ids.js"),
+        import("./lib/crypto.js")
+    ]);
+    const customer = database.getCustomerByEmail(parsed.values.email) ?? database.upsertCustomer({
+        id: createId("cus"),
+        email: parsed.values.email,
+        name: parsed.values.name
+    });
+    const rawApiKey = parsed.values["api-key"] ?? `vf_local_${Math.random().toString(36).slice(2, 12)}`;
+    database.insertApiKey({
+        id: createId("api"),
+        customerId: customer.id,
+        keyHash: crypto.hashSecret(rawApiKey + config.API_KEY_SALT),
+        label: "Local CLI session"
+    });
+    seedEnvProviderKeys({
+        customerId: customer.id,
+        database,
+        createId,
+        encryptString: crypto.encryptString,
+        encryptionSecret: config.ENCRYPTION_SECRET,
+        allowMockPlaceholders: config.mockProviders
+    });
+    writeFileSync(sessionPath, JSON.stringify({
+        baseUrl: process.env.PUBLIC_BASE_URL,
+        customerId: customer.id,
+        apiKey: rawApiKey,
+        email: customer.email,
+        dbPath,
+        dataDir
+    }, null, 2));
+    printStartupBanner({
+        baseUrl: process.env.PUBLIC_BASE_URL,
+        customerId: customer.id,
+        apiKey: rawApiKey,
+        email: customer.email,
+        dataDir,
+        dbPath,
+        sessionPath,
+        mockProviders: config.mockProviders
+    });
+    const runtime = startRuntime();
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+        process.on(signal, () => {
+            runtime.shutdown();
+            process.exit(0);
+        });
+    }
+}
+async function runSessionCommand(argv) {
+    const parsed = parseArgs({
+        args: argv,
+        options: {
+            "data-dir": { type: "string", default: ".vidfarm/local" }
+        }
+    });
+    const sessionPath = path.resolve(process.cwd(), parsed.values["data-dir"], "session.json");
+    const session = JSON.parse(readFileSync(sessionPath, "utf8"));
+    console.log(JSON.stringify({
+        base_url: session.baseUrl,
+        email: session.email,
+        headers: {
+            "vidfarm-user-id": session.customerId,
+            "vidfarm-api-key": session.apiKey,
+            "content-type": "application/json"
+        },
+        curl_example: [
+            `curl -X POST ${session.baseUrl}/templates/demo-template/operations/generate \\`,
+            `  -H 'vidfarm-user-id: ${session.customerId}' \\`,
+            `  -H 'vidfarm-api-key: ${session.apiKey}' \\`,
+            "  -H 'content-type: application/json' \\",
+            "  -d '{\"tracer\":\"local-test\",\"payload\":{\"slides\":[[\"a cinematic founder at a desk\",\"Exact text on slide one\"]],\"secondsPerSlide\":4}}'"
+        ].join("\n")
+    }, null, 2));
+}
+function seedEnvProviderKeys(input) {
+    const entries = [
+        { provider: "openai", secret: process.env.OPENAI_API_KEY ?? "", placeholder: "mock-openai-key" },
+        { provider: "gemini", secret: process.env.GEMINI_API_KEY ?? "", placeholder: "mock-gemini-key" },
+        { provider: "openrouter", secret: process.env.OPENROUTER_API_KEY ?? "", placeholder: "mock-openrouter-key" },
+        { provider: "perplexity", secret: process.env.PERPLEXITY_API_KEY ?? "", placeholder: "mock-perplexity-key" }
+    ];
+    const existing = input.database.listProviderKeys(input.customerId);
+    for (const entry of entries) {
+        const secret = entry.secret || (input.allowMockPlaceholders ? entry.placeholder : "");
+        if (!secret) {
+            continue;
+        }
+        const alreadySeeded = existing.some((row) => row.provider === entry.provider && row.label === "Local CLI env key");
+        if (alreadySeeded) {
+            continue;
+        }
+        input.database.createProviderKey({
+            id: input.createId("pkey"),
+            customerId: input.customerId,
+            provider: entry.provider,
+            label: "Local CLI env key",
+            encryptedSecret: input.encryptString(secret, input.encryptionSecret),
+            weight: 1
+        });
+    }
+}
+function printStartupBanner(input) {
+    console.log("");
+    console.log("Vidfarm local dev runtime");
+    console.log(`Base URL: ${input.baseUrl}`);
+    console.log(`Dev user: ${input.email}`);
+    console.log(`vidfarm-user-id: ${input.customerId}`);
+    console.log(`vidfarm-api-key: ${input.apiKey}`);
+    console.log(`Session file: ${input.sessionPath}`);
+    console.log(`Data dir: ${input.dataDir}`);
+    console.log(`SQLite: ${input.dbPath}`);
+    console.log(`AI mode: ${input.mockProviders ? "mock provider responses" : "real provider env keys"}`);
+    console.log("");
+    console.log("REST API:");
+    console.log(`  ${input.baseUrl}/health`);
+    console.log(`  ${input.baseUrl}/dev`);
+    console.log("");
+    console.log("Get reusable auth headers:");
+    console.log("  vidfarm session");
+    console.log("");
+}

package/dist/src/config.js

@@ -0,0 +1,52 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import dotenv from "dotenv";
+import { z } from "zod";
+dotenv.config();
+const schema = z.object({
+    NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
+    PORT: z.coerce.number().default(3000),
+    VIDFARM_DB_PATH: z.string().default("./data/vidfarm.sqlite"),
+    VIDFARM_DATA_DIR: z.string().default("./data"),
+    ENCRYPTION_SECRET: z.string().default("development-encryption-secret-change-me"),
+    API_KEY_SALT: z.string().default("development-api-key-salt"),
+    WORKER_POLL_MS: z.coerce.number().default(1500),
+    WORKER_BATCH_SIZE: z.coerce.number().default(4),
+    WEBHOOK_SECRET: z.string().default("development-webhook-secret"),
+    DEFAULT_JOB_DELAY_SECONDS: z.coerce.number().default(20),
+    STORAGE_DRIVER: z.enum(["local", "s3"]).default("local"),
+    AWS_REGION: z.string().default("us-east-1"),
+    AWS_S3_BUCKET: z.string().default(""),
+    AWS_S3_ENDPOINT: z.string().optional(),
+    AWS_ACCESS_KEY_ID: z.string().optional(),
+    AWS_SECRET_ACCESS_KEY: z.string().optional(),
+    PUBLIC_BASE_URL: z.string().optional(),
+    RESEND_API_KEY: z.string().optional(),
+    RESEND_FROM_EMAIL: z.string().default("noreply@example.com"),
+    OPENAI_API_KEY: z.string().optional(),
+    OPENROUTER_API_KEY: z.string().optional(),
+    GEMINI_API_KEY: z.string().optional(),
+    PERPLEXITY_API_KEY: z.string().optional(),
+    REMOTION_REGION: z.string().default("us-east-1"),
+    REMOTION_BUCKET_NAME: z.string().optional(),
+    REMOTION_SITE_NAME: z.string().optional(),
+    REMOTION_FUNCTION_NAME: z.string().optional(),
+    REMOTION_SERVE_URL: z.string().optional(),
+    REMOTION_COMPOSITION_ID: z.string().default("demo-template"),
+    REMOTION_AWS_ACCESS_KEY_ID: z.string().optional(),
+    REMOTION_AWS_SECRET_ACCESS_KEY: z.string().optional(),
+    REMOTION_MODE: z.enum(["auto", "mock", "local", "lambda"]).default("auto"),
+    MOCK_PROVIDER_RESPONSES: z.string().default("true")
+});
+const parsed = schema.parse(process.env);
+const dataDir = path.resolve(parsed.VIDFARM_DATA_DIR);
+mkdirSync(dataDir, { recursive: true });
+const publicBaseUrl = parsed.PUBLIC_BASE_URL || `http://localhost:${parsed.PORT}`;
+export const config = {
+    ...parsed,
+    VIDFARM_DB_PATH: path.resolve(parsed.VIDFARM_DB_PATH),
+    VIDFARM_DATA_DIR: dataDir,
+    PUBLIC_BASE_URL: publicBaseUrl,
+    isProduction: parsed.NODE_ENV === "production",
+    mockProviders: parsed.MOCK_PROVIDER_RESPONSES !== "false"
+};