@mevdragon/vidfarm-devcli 0.2.8 → 0.2.10

package/dist/src/cli.js

@@ -7,7 +7,7 @@ import path from "node:path";
 import { parseArgs } from "node:util";
 import { promisify } from "node:util";
 import dotenv from "dotenv";
-import { STARTER_TEMPLATE_FONT_OPTIONS, STARTER_TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS } from "./lib/template-style-options.js";
+import { CAPTION_STANDARD_VERSION, STARTER_TEMPLATE_FONT_OPTIONS, STARTER_TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS, TIKTOK_CAPTION_STYLE_PRESETS } from "./lib/template-style-options.js";
 import { analyzeTemplateDna, hasTemplatePreviewMedia, stageTemplateDnaInputs, syncTemplateDnaModule } from "./lib/template-dna.js";
 import { assertTemplateFolderNameHasPrefix, defaultSkillPathForTemplateModule, deriveTemplateRootDirFromModulePath } from "./lib/template-paths.js";
 const execFileAsync = promisify(execFile);
@@ -57,6 +57,10 @@ async function main() {
         await runGenerateTemplateCommand(process.argv.slice(3));
         return;
     }
+    if (command === "autocreate-template" || command === "autocreate") {
+        await runAutocreateTemplateCommand(process.argv.slice(3));
+        return;
+    }
     if (command === "copy-reference-template") {
         await runCopyReferenceTemplateCommand(process.argv.slice(3));
         return;
@@ -128,7 +132,8 @@ async function runDevCommand(argv) {
         email: parsed.values.email,
         name: parsed.values.name,
         isDeveloper: true,
-        isPaidPlan: true
+        isPaidPlan: true,
+        planTier: "standard"
     });
     const rawApiKey = parsed.values["api-key"] ?? `vf_local_${Math.random().toString(36).slice(2, 12)}`;
     database.insertApiKey({
@@ -298,9 +303,28 @@ async function runGenerateTemplateCommand(argv) {
             force: { type: "boolean", default: false }
         }
     });
-    const templateId = parsed.values["template-id"] ?? randomUUID();
-    const slugId = parsed.values["slug-id"];
-    const templateDir = parsed.values["template-dir"];
+    const result = await generateTemplateFromStarter({
+        templateId: parsed.values["template-id"],
+        slugId: parsed.values["slug-id"],
+        templateDir: parsed.values["template-dir"],
+        projectName: parsed.values["project-name"],
+        githubRepo: parsed.values["github-repo"],
+        siteName: parsed.values["site-name"],
+        linkToOriginal: parsed.values["link-to-original"],
+        sourceNotesPath: parsed.values["source-notes-path"],
+        sourcePreviewDir: parsed.values["source-preview-dir"],
+        dnaEnvFile: parsed.values["dna-env-file"],
+        dnaModel: parsed.values["dna-model"],
+        skipDnaAnalysis: parsed.values["skip-dna-analysis"],
+        branch: parsed.values.branch,
+        force: parsed.values.force
+    });
+    console.log(JSON.stringify(result, null, 2));
+}
+async function generateTemplateFromStarter(input) {
+    const templateId = input.templateId ?? randomUUID();
+    const slugId = input.slugId;
+    const templateDir = input.templateDir;
     if (!slugId || !templateDir) {
         throw new Error("generate-template requires --slug-id and --template-dir. --template-id is optional and defaults to a new UUIDv4.");
     }
@@ -313,7 +337,7 @@ async function runGenerateTemplateCommand(argv) {
         throw new Error(`Starter template not found: ${starterDir}`);
     }
     if (existsSync(destinationDir)) {
-        if (!parsed.values.force) {
+        if (!input.force) {
             throw new Error(`Destination already exists: ${destinationDir}`);
         }
         rmSync(destinationDir, { recursive: true, force: true });
@@ -325,9 +349,9 @@ async function runGenerateTemplateCommand(argv) {
             return ![".git", "node_modules", "dist", "package-lock.json"].includes(name);
         }
     });
-    const projectName = parsed.values["project-name"] ?? toProjectName(destinationFolderName);
-    const siteName = parsed.values["site-name"] ?? projectName.replace(/_/g, "-");
-    const githubRepo = parsed.values["github-repo"] ?? `mevdragon/${projectName}`;
+    const projectName = input.projectName ?? toProjectName(destinationFolderName);
+    const siteName = input.siteName ?? projectName.replace(/_/g, "-");
+    const githubRepo = input.githubRepo ?? `mevdragon/${projectName}`;
     rewriteTemplateStarter(destinationDir, [
         ["mevdragon/vidfarm_template_0000", githubRepo],
         ["vidfarm_template_0000", projectName],
@@ -335,35 +359,35 @@ async function runGenerateTemplateCommand(argv) {
         ["template_0000", slugId],
         ["template-0000", slugId.replace(/_/g, "-")],
         ["4c7a7e1a-7f35-4f30-9f86-9c8a63c7f2db", templateId],
-        ['"production"', JSON.stringify(parsed.values.branch)]
+        ['"production"', JSON.stringify(input.branch ?? "production")]
     ]);
     const stagedInputs = stageTemplateDnaInputs({
         templateDir: destinationDir,
-        sourceNotesPath: parsed.values["source-notes-path"],
-        sourcePreviewDir: parsed.values["source-preview-dir"]
+        sourceNotesPath: input.sourceNotesPath,
+        sourcePreviewDir: input.sourcePreviewDir
     });
     const moduleSync = syncTemplateDnaModule({
         templateDir: destinationDir,
-        linkToOriginal: parsed.values["link-to-original"]
+        linkToOriginal: input.linkToOriginal
     });
     const dnaRuns = [];
-    if (!parsed.values["skip-dna-analysis"] && hasTemplatePreviewMedia(destinationDir)) {
+    if (!input.skipDnaAnalysis && hasTemplatePreviewMedia(destinationDir)) {
         dnaRuns.push(await analyzeTemplateDna({
             mode: "viral",
             templateDir: destinationDir,
-            envFile: parsed.values["dna-env-file"],
-            model: parsed.values["dna-model"],
-            linkToOriginal: parsed.values["link-to-original"]
+            envFile: input.dnaEnvFile ?? ".env",
+            model: input.dnaModel,
+            linkToOriginal: input.linkToOriginal
         }));
         dnaRuns.push(await analyzeTemplateDna({
             mode: "visual",
             templateDir: destinationDir,
-            envFile: parsed.values["dna-env-file"],
-            model: parsed.values["dna-model"],
-            linkToOriginal: parsed.values["link-to-original"]
+            envFile: input.dnaEnvFile ?? ".env",
+            model: input.dnaModel,
+            linkToOriginal: input.linkToOriginal
         }));
     }
-    console.log(JSON.stringify({
+    return {
         template_id: templateId,
         slug_id: slugId,
         template_dir: destinationDir,
@@ -385,6 +409,7 @@ async function runGenerateTemplateCommand(argv) {
                 "about.preview_media",
                 "about.link_to_original",
                 "about.proposal_generator",
+                "about.skeleton_prompt",
                 "about.sample_prompts",
                 "configSchema",
             ],
@@ -400,11 +425,123 @@ async function runGenerateTemplateCommand(argv) {
         },
         next_steps: [
             "Review src/template.ts and replace the starter proposal_generator with template-specific proposal instructions.",
+            "Review src/template.ts and replace the starter skeleton_prompt with a fill-in-the-blanks prompt that fits the real format.",
             "Review src/template.ts and replace the starter sample_prompts with prompts that fit the new format.",
             "If DNA analysis was skipped or the source research changed, run analyze-viral-dna and analyze-visual-dna.",
             "Update SKILL.md so the usage examples match the template's real operations and payloads.",
             `Run validate-template against ${slugId} and launch at least one real local job before treating the template as ready.`,
         ],
+    };
+}
+async function runAutocreateTemplateCommand(argv) {
+    const parsed = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            "input-path": { type: "string" },
+            "output-path": { type: "string" },
+            "run-id": { type: "string" },
+            "runs-dir": { type: "string", default: "auto-create-templates/runs" },
+            "harness-dir": { type: "string" },
+            "slug-id": { type: "string" },
+            "template-id": { type: "string" },
+            "project-name": { type: "string" },
+            "github-repo": { type: "string" },
+            "site-name": { type: "string" },
+            "link-to-original": { type: "string" },
+            "dna-env-file": { type: "string", default: ".env" },
+            "dna-model": { type: "string" },
+            "skip-dna-analysis": { type: "boolean", default: false },
+            "skip-scaffold": { type: "boolean", default: false },
+            "skip-media-probes": { type: "boolean", default: false },
+            "skip-harness-snapshot": { type: "boolean", default: false },
+            branch: { type: "string", default: "production" },
+            force: { type: "boolean", default: false }
+        }
+    });
+    const positionalInput = parsed.positionals[0];
+    const positionalOutput = parsed.positionals[1];
+    const inputPathRaw = parsed.values["input-path"] ?? positionalInput;
+    const outputPathRaw = parsed.values["output-path"] ?? positionalOutput;
+    if (!inputPathRaw || !outputPathRaw) {
+        throw new Error("autocreate-template requires --input-path and --output-path, or positional args: autocreate-template <input_path> <output_path>.");
+    }
+    const root = process.cwd();
+    const inputPath = path.resolve(root, inputPathRaw);
+    const outputPath = path.resolve(root, outputPathRaw);
+    if (!existsSync(inputPath)) {
+        throw new Error(`Input path not found: ${inputPath}`);
+    }
+    const outputFolderName = path.basename(outputPath);
+    assertTemplateFolderNameHasPrefix(outputFolderName);
+    const slugId = parsed.values["slug-id"] ?? toSlugId(outputFolderName);
+    const runId = parsed.values["run-id"] ?? `${toProjectName(slugId)}-${formatUtcTimestamp(new Date())}`;
+    const runsDir = path.resolve(root, parsed.values["runs-dir"]);
+    const runDir = path.join(runsDir, runId);
+    const sourceDir = path.join(runDir, "source");
+    const previewDir = path.join(sourceDir, "preview");
+    const harnessDir = parsed.values["harness-dir"]
+        ? path.resolve(root, parsed.values["harness-dir"])
+        : resolveAutoCreateHarnessDir();
+    createAutoCreateRunFolders(runDir);
+    stageAutocreateSource({
+        inputPath,
+        sourceDir,
+        previewDir,
+        linkToOriginal: parsed.values["link-to-original"]
+    });
+    const mediaProbe = parsed.values["skip-media-probes"]
+        ? { skipped: true, reason: "skip-media-probes was set" }
+        : await prepareAutocreateMediaArtifacts({ runDir, previewDir });
+    const harnessSnapshot = parsed.values["skip-harness-snapshot"]
+        ? null
+        : snapshotAutoCreateHarness({ harnessDir, runDir });
+    const sourceNotesPath = path.join(sourceDir, "source.md");
+    const scaffold = parsed.values["skip-scaffold"]
+        ? null
+        : await generateTemplateFromStarter({
+            templateId: parsed.values["template-id"],
+            slugId,
+            templateDir: path.relative(root, outputPath),
+            projectName: parsed.values["project-name"],
+            githubRepo: parsed.values["github-repo"],
+            siteName: parsed.values["site-name"],
+            linkToOriginal: parsed.values["link-to-original"],
+            sourceNotesPath,
+            sourcePreviewDir: previewDir,
+            dnaEnvFile: parsed.values["dna-env-file"],
+            dnaModel: parsed.values["dna-model"],
+            skipDnaAnalysis: parsed.values["skip-dna-analysis"],
+            branch: parsed.values.branch,
+            force: parsed.values.force
+        });
+    const agentPromptPath = path.join(runDir, "agent_prompt.md");
+    const manifest = {
+        mode: "autocreate-template",
+        harness_entry: path.join(harnessDir, "AUTO_CREATE_TEMPLATES.md"),
+        harness_snapshot: harnessSnapshot,
+        input_path: inputPath,
+        output_path: outputPath,
+        run_id: runId,
+        run_dir: runDir,
+        source_dir: sourceDir,
+        source_notes_path: sourceNotesPath,
+        source_preview_dir: previewDir,
+        slug_id: slugId,
+        scaffold,
+        media_probe: mediaProbe,
+        required_artifacts: {
+            viral_steering_and_visual_preservation: path.join(runDir, "dna", "preservation_decision.json"),
+            production_graph: path.join(runDir, "extraction", "production_graph.json"),
+            template_plan: path.join(runDir, "plan", "template_plan.json")
+        }
+    };
+    writeFileSync(path.join(runDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", "utf8");
+    writeFileSync(agentPromptPath, renderAutocreateAgentPrompt(manifest), "utf8");
+    console.log(JSON.stringify({
+        ...manifest,
+        agent_prompt_path: agentPromptPath,
+        next_command_for_agent: `Use ${manifest.harness_entry} as the harness. Analyze ${sourceDir} as the source format, use run artifacts in ${runDir}, generate the production graph and template plan, then scaffold and implement a runnable Vidfarm template to ${outputPath}.`
     }, null, 2));
 }
 async function runRegisterSourceProdCommand(argv) {
@@ -574,6 +711,7 @@ async function runCopyReferenceTemplateCommand(argv) {
                 "about.preview_media",
                 "about.link_to_original",
                 "about.proposal_generator",
+                "about.skeleton_prompt",
                 "about.sample_prompts",
                 "configSchema",
             ],
@@ -589,7 +727,7 @@ async function runCopyReferenceTemplateCommand(argv) {
         },
         next_steps: [
             "Treat src/template.ts as the canonical entrypoint and review the required about metadata before copying patterns into a new template.",
-            "Use the starter proposal_generator and sample_prompts as placeholders only; rewrite them for the real format you are building.",
+            "Use the starter proposal_generator, skeleton_prompt, and sample_prompts as placeholders only; rewrite them for the real format you are building.",
             "Keep the template-local SKILL.md aligned with the operations and payloads in code.",
         ],
     }, null, 2));
@@ -716,9 +854,18 @@ async function runSessionCommand(argv) {
         base_url: session.baseUrl,
         email: session.email,
         starter_style_options: {
+            caption_standard_version: CAPTION_STANDARD_VERSION,
             fonts: STARTER_TEMPLATE_FONT_OPTIONS,
             text_background_colors: STARTER_TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS,
-            starter_template_file: "templates/vidfarm_template_0000/src/style-options.ts"
+            presets: TIKTOK_CAPTION_STYLE_PRESETS,
+            package_dependencies: [
+                "@fontsource/tiktok-sans",
+                "@fontsource/montserrat",
+                "@fontsource/source-code-pro",
+                "@fontsource/libre-baskerville"
+            ],
+            standard_file: "src/lib/template-style-options.ts",
+            starter_template_file: "demos/vidfarm_template_0000/src/style-options.ts"
         },
         headers: {
             "vidfarm-api-key": session.apiKey,
@@ -754,8 +901,7 @@ function seedEnvProviderKeys(input) {
             customerId: input.customerId,
             provider: entry.provider,
             label: "Local CLI env key",
-            encryptedSecret: input.encryptString(secret, input.encryptionSecret),
-            weight: 1
+            encryptedSecret: input.encryptString(secret, input.encryptionSecret)
         });
     }
 }
@@ -806,7 +952,9 @@ function toProjectName(folderName) {
 function resolveStarterTemplateDir() {
     const candidates = [
         path.resolve(import.meta.dirname, "..", "templates", "vidfarm_template_0000"),
-        path.resolve(import.meta.dirname, "..", "..", "templates", "vidfarm_template_0000")
+        path.resolve(import.meta.dirname, "..", "..", "templates", "vidfarm_template_0000"),
+        path.resolve(import.meta.dirname, "..", "demos", "vidfarm_template_0000"),
+        path.resolve(import.meta.dirname, "..", "..", "demos", "vidfarm_template_0000")
     ];
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
@@ -815,6 +963,218 @@ function resolveStarterTemplateDir() {
     }
     return candidates[0];
 }
+function resolveAutoCreateHarnessDir() {
+    const candidates = [
+        path.resolve(process.cwd(), "auto-create-templates"),
+        path.resolve(import.meta.dirname, "..", "auto-create-templates"),
+        path.resolve(import.meta.dirname, "..", "..", "auto-create-templates")
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(path.join(candidate, "AUTO_CREATE_TEMPLATES.md"))) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function createAutoCreateRunFolders(runDir) {
+    for (const name of ["source", "frames", "audio", "transcripts", "ocr", "motion", "dna", "extraction", "plan"]) {
+        mkdirSync(path.join(runDir, name), { recursive: true });
+    }
+}
+function stageAutocreateSource(input) {
+    mkdirSync(input.sourceDir, { recursive: true });
+    mkdirSync(input.previewDir, { recursive: true });
+    const stats = statSync(input.inputPath);
+    if (stats.isDirectory()) {
+        const inputHadPreviewDir = existsSync(path.join(input.inputPath, "preview"));
+        copyDirectoryContentsShallow(input.inputPath, input.sourceDir);
+        const existingPreviewDir = path.join(input.sourceDir, "preview");
+        if (!inputHadPreviewDir) {
+            mkdirSync(existingPreviewDir, { recursive: true });
+            for (const mediaFile of listMediaFiles(input.sourceDir)) {
+                cpSync(mediaFile, path.join(existingPreviewDir, path.basename(mediaFile)));
+            }
+        }
+    }
+    else {
+        cpSync(input.inputPath, path.join(input.previewDir, path.basename(input.inputPath)));
+    }
+    const notesPath = path.join(input.sourceDir, "source.md");
+    if (!existsSync(notesPath)) {
+        writeFileSync(notesPath, [
+            "# Source Notes",
+            "",
+            `- input path: ${input.inputPath}`,
+            `- original format URL: ${input.linkToOriginal ?? ""}`,
+            "- creator/account:",
+            "- product/category being adapted:",
+            "- what appears repeatable:",
+            "- constraints:",
+            ""
+        ].join("\n"), "utf8");
+    }
+}
+async function prepareAutocreateMediaArtifacts(input) {
+    const videoFile = listMediaFiles(input.previewDir).find((filePath) => isVideoFile(filePath));
+    if (!videoFile) {
+        return {
+            skipped: true,
+            reason: "No video file found in source preview media.",
+            preview_files: listMediaFiles(input.previewDir)
+        };
+    }
+    const ffprobePath = path.join(input.runDir, "source", "ffprobe.json");
+    const contactSheetPath = path.join(input.runDir, "frames", "contact-sheet.jpg");
+    const audioPath = path.join(input.runDir, "audio", "source.wav");
+    const steps = [];
+    steps.push(await runOptionalLocalCommand("ffprobe", [
+        "-v", "error",
+        "-show_entries", "format=duration:stream=codec_type,width,height,avg_frame_rate",
+        "-of", "json",
+        videoFile
+    ], ffprobePath));
+    steps.push(await runOptionalLocalCommand("ffmpeg", [
+        "-y",
+        "-i", videoFile,
+        "-vf", "fps=1/2,scale=240:-1,tile=3x4",
+        "-frames:v", "1",
+        contactSheetPath
+    ]));
+    steps.push(await runOptionalLocalCommand("ffmpeg", [
+        "-y",
+        "-i", videoFile,
+        "-vn",
+        "-ac", "1",
+        "-ar", "16000",
+        audioPath
+    ]));
+    const result = {
+        skipped: false,
+        video_file: videoFile,
+        ffprobe_path: existsSync(ffprobePath) ? ffprobePath : null,
+        contact_sheet_path: existsSync(contactSheetPath) ? contactSheetPath : null,
+        audio_path: existsSync(audioPath) ? audioPath : null,
+        steps
+    };
+    writeFileSync(path.join(input.runDir, "source", "media_artifacts.json"), JSON.stringify(result, null, 2) + "\n", "utf8");
+    return result;
+}
+function snapshotAutoCreateHarness(input) {
+    if (!existsSync(path.join(input.harnessDir, "AUTO_CREATE_TEMPLATES.md"))) {
+        throw new Error(`Auto-create harness not found: ${input.harnessDir}`);
+    }
+    const destinationDir = path.join(input.runDir, "harness");
+    mkdirSync(destinationDir, { recursive: true });
+    for (const fileName of [
+        "AUTO_CREATE_TEMPLATES.md",
+        "runbook.md",
+        "extractor-system-prompt.md",
+        "production-graph.schema.json",
+        "template-planner-prompt.md",
+        "template-plan.schema.json"
+    ]) {
+        const source = path.join(input.harnessDir, fileName);
+        if (existsSync(source)) {
+            cpSync(source, path.join(destinationDir, fileName));
+        }
+    }
+    return {
+        harness_dir: destinationDir,
+        entry: path.join(destinationDir, "AUTO_CREATE_TEMPLATES.md")
+    };
+}
+function renderAutocreateAgentPrompt(manifest) {
+    return [
+        "# Vidfarm Autocreate Template Handoff",
+        "",
+        `Use ${manifest.harness_entry} as the harness.`,
+        `Analyze ${manifest.source_dir} as the source format.`,
+        `Use the run artifacts in ${manifest.run_dir}.`,
+        `Output the runnable Vidfarm template to ${manifest.output_path}.`,
+        "",
+        "Required work:",
+        "",
+        "1. Inspect source notes and preview media.",
+        "2. Use or create analyzer artifacts in the run folder.",
+        "3. Run or consume viral and visual DNA analysis.",
+        "4. Create `dna/preservation_decision.json`.",
+        "5. Create `extraction/production_graph.json` matching the production graph schema.",
+        "6. Create `plan/template_plan.json` matching the template plan schema.",
+        "7. Implement the template operations, jobs, metadata, prompts, storage outputs, and template-local `SKILL.md`.",
+        "8. Run `vidfarm-devcli validate-template` and at least one real local job before calling it done.",
+        "",
+        "Manifest:",
+        "",
+        "```json",
+        JSON.stringify(manifest, null, 2),
+        "```",
+        ""
+    ].join("\n");
+}
+async function runOptionalLocalCommand(command, args, outputPath) {
+    try {
+        const result = await execFileAsync(command, args, {
+            maxBuffer: 20 * 1024 * 1024
+        });
+        if (outputPath) {
+            writeFileSync(outputPath, result.stdout, "utf8");
+        }
+        return {
+            command,
+            ok: true,
+            output_path: outputPath ?? null,
+            stderr: result.stderr.trim() || null
+        };
+    }
+    catch (error) {
+        return {
+            command,
+            ok: false,
+            output_path: outputPath ?? null,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function copyDirectoryContentsShallow(sourceDir, destinationDir) {
+    mkdirSync(destinationDir, { recursive: true });
+    for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+        if (!entry.name.startsWith(".")) {
+            cpSync(path.join(sourceDir, entry.name), path.join(destinationDir, entry.name), { recursive: true });
+        }
+    }
+}
+function listMediaFiles(dir) {
+    if (!existsSync(dir)) {
+        return [];
+    }
+    const files = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const filePath = path.join(dir, entry.name);
+        if (entry.name.startsWith(".")) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            files.push(...listMediaFiles(filePath));
+            continue;
+        }
+        if (entry.isFile() && isMediaFile(filePath)) {
+            files.push(filePath);
+        }
+    }
+    return files.sort((a, b) => a.localeCompare(b));
+}
+function isMediaFile(filePath) {
+    return [".png", ".jpg", ".jpeg", ".webp", ".mp4", ".mov", ".webm", ".m4v"].includes(path.extname(filePath).toLowerCase());
+}
+function isVideoFile(filePath) {
+    return [".mp4", ".mov", ".webm", ".m4v"].includes(path.extname(filePath).toLowerCase());
+}
+function toSlugId(folderName) {
+    return toProjectName(folderName).replace(/^vidfarm_template_/, "template_");
+}
+function formatUtcTimestamp(date) {
+    return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
 function parseProdTemplateCommandArgs(argv, defaults) {
     const parsed = parseArgs({
         args: argv,

package/dist/src/config.js

@@ -12,7 +12,7 @@ const schema = z.object({
     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(2),
-    WORKER_MAX_CONCURRENT_JOBS: z.coerce.number().default(1),
+    WORKER_MAX_CONCURRENT_JOBS: z.coerce.number().default(2),
     WEBHOOK_SECRET: z.string().default("development-webhook-secret"),
     DEFAULT_JOB_DELAY_SECONDS: z.coerce.number().default(20),
     MAX_PENDING_JOBS_GLOBAL: z.coerce.number().default(0),
@@ -25,8 +25,16 @@ const schema = z.object({
     AWS_ACCESS_KEY_ID: z.string().optional(),
     AWS_SECRET_ACCESS_KEY: z.string().optional(),
     PUBLIC_BASE_URL: z.string().optional(),
+    PUBLIC_EDITOR_CHAT_URL: z.string().url().optional(),
+    EDITOR_CHAT_URL: z.string().url().optional(),
     RESEND_API_KEY: z.string().optional(),
     RESEND_FROM_EMAIL: z.string().default("vidfarm@fwd.zoomgtm.com"),
+    FLOCKPOSTER_API_URL: z.string().url().optional(),
+    VIDFARM_ZIP_LAMBDA_URL: z.string().url().optional(),
+    VIDFARM_ZIP_LAMBDA_SECRET: z.string().optional(),
+    VIDFARM_BILLING_URL: z.string().url().optional(),
+    VIDFARM_BILLING_SECRET: z.string().optional(),
+    VIDFARM_MIN_RENDER_WALLET_BALANCE_USD: z.coerce.number().default(1),
     OPENAI_API_KEY: z.string().optional(),
     OPENROUTER_API_KEY: z.string().optional(),
     GEMINI_API_KEY: z.string().optional(),
@@ -46,7 +54,8 @@ const schema = z.object({
     VIDFARM_ADMIN_EMAILS: z.string().default(""),
     VIDFARM_GITHUB_TOKEN: z.string().optional(),
     GITHUB_TOKEN: z.string().optional(),
-    TEMPLATE_SOURCE_ROOT: z.string().default("./data/template-sources")
+    TEMPLATE_SOURCE_ROOT: z.string().default("./data/template-sources"),
+    VIDFARM_RATE_LIMITS_TABLE_NAME: z.string().optional()
 });
 const parsed = schema.parse(process.env);
 const dataDir = path.resolve(parsed.VIDFARM_DATA_DIR);
@@ -65,6 +74,7 @@ export const config = {
     mockProviders: parsed.MOCK_PROVIDER_RESPONSES === "true" ||
         (parsed.MOCK_PROVIDER_RESPONSES == null && parsed.NODE_ENV !== "production"),
     s3PublicRead: parsed.AWS_S3_PUBLIC_READ === "true",
+    minRenderWalletBalanceUsd: parsed.VIDFARM_MIN_RENDER_WALLET_BALANCE_USD,
     adminEmails: parsed.VIDFARM_ADMIN_EMAILS
         .split(",")
         .map((value) => value.trim().toLowerCase())