@mevdragon/vidfarm-devcli 0.5.2 → 0.6.0

package/dist/src/services/template-certification.js

@@ -0,0 +1,413 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+const APPROVED_TEMPLATE_MODEL_IDS = new Set([
+    "gpt-5.4",
+    "gemini-3.1-flash-lite",
+    "gemini-3.1-flash-lite-preview",
+    "gemini-2.5-flash-lite",
+    "qwen/qwen3.6-plus",
+    "sonar",
+    "gpt-image-1",
+    "gpt-image-2",
+    "gemini-3.1-flash-image-preview",
+    "gemini-2.5-flash-image",
+    "gemini-3-pro-image-preview",
+    "google/gemini-3.1-flash-image-preview",
+    "google/gemini-2.5-flash-image-preview",
+    "bytedance/seedance-2.0",
+    "bytedance-seed/seedream-4.5",
+    "google/gemini-3.1-flash-tts-preview",
+    "gemini-3.1-flash-tts-preview",
+    "gemini-2.5-flash-preview-tts",
+    "gpt-4o-mini-tts-2025-12-15",
+    "openai/gpt-4o-mini-transcribe",
+    "gpt-4o-mini-transcribe-2025-12-15",
+    "sora-2",
+    "veo-3.0-generate-001"
+]);
+const TEMPLATE_DIRECT_PROVIDER_ACCESS_PATTERNS = [
+    /process\.env\.(OPENAI_API_KEY|GEMINI_API_KEY|OPENROUTER_API_KEY|PERPLEXITY_API_KEY)/,
+    /https?:\/\/api\.openai\.com/,
+    /https?:\/\/generativelanguage\.googleapis\.com/,
+    /https?:\/\/openrouter\.ai/,
+    /https?:\/\/api\.perplexity\.ai/,
+    /\bAuthorization\s*:/,
+    /\bapiKey\s*:/,
+    /\bapi_key\s*:/
+];
+const TEMPLATE_OPERATION_PROVIDER_DEFAULT_PATTERN = /(?:^|[\s,{])(?:provider|text_provider|image_provider|tts_provider|speech_provider|transcription_provider)\s*:\s*z\.enum\([^;\n]+\.default\(/;
+const TEMPLATE_GEMINI_PROVIDER_FALLBACK_PATTERN = /(?:default(?:Text|Image)?Provider|textProvider|imageProvider|ttsProvider|voiceProvider|transcriptionProvider)\s*:\s*z\.enum\([^;\n]+\.default\(["']gemini["']\)|return\s+["']gemini["'];/g;
+const TEMPLATE_MODEL_LITERAL_PATTERN = /["'`](dall-e-3|dall-e|gpt-[^"'`]+|gemini-[^"'`]+|google\/gemini-[^"'`]+|openai\/gpt-[^"'`]+|qwen\/qwen[^"'`]+|bytedance\/[^"'`]+|bytedance-seed\/[^"'`]+|sora-[^"'`]+|veo-[^"'`]+|sonar(?:-[^"'`]+)?)["'`]/g;
+const TEMPLATE_UNSAFE_MODEL_PASSTHROUGH_PATTERN = /String\(ctx\.templateConfig\.[A-Za-z_]*Model|ctx\.templateConfig\.[A-Za-z_]*Model\s*\?\?|payload\.[A-Za-z_]*model\s*\?\?|sanitizeConfiguredModel\([^;\n]*(?:textModel|imageModel|layoutModel|ttsModel|transcriptionModel|speechModel|payload\.model|payload\.tts_model|payload\.transcription_model|payload\.speech_model)/g;
+export class TemplateCertificationService {
+    async certify(input) {
+        const checks = [];
+        const { template, skillPath } = input;
+        checks.push(this.check("template.metadata", Boolean(template.id &&
+            template.slugId &&
+            template.version &&
+            template.about &&
+            typeof template.about.title === "string" &&
+            typeof template.about.description === "string" &&
+            ["easy", "medium", "hard", "expert"].includes(template.about.difficulty) &&
+            typeof template.about.viral_dna === "string" &&
+            typeof template.about.visual_dna === "string" &&
+            Array.isArray(template.about.preview_media) &&
+            template.about.preview_media.every((entry) => typeof entry === "string") &&
+            typeof template.about.link_to_original === "string" &&
+            Array.isArray(template.about.links_to_inspiration) &&
+            template.about.links_to_inspiration.every((entry) => typeof entry === "string") &&
+            template.about.sound &&
+            typeof template.about.sound.sound_title === "string" &&
+            typeof template.about.sound.sound_url === "string" &&
+            typeof template.about.proposal_generator === "string" &&
+            typeof template.about.skeleton_prompt === "string" &&
+            template.about.skeleton_prompt.length > 0 &&
+            Array.isArray(template.about.sample_prompts) &&
+            template.about.sample_prompts.every((entry) => typeof entry === "string") &&
+            template.about.sample_prompts.length > 0 &&
+            Array.isArray(template.examples) &&
+            template.examples.every((example) => Array.isArray(example) && example.every((entry) => (entry &&
+                typeof entry.media_url === "string" &&
+                typeof entry.note === "string")))), "Template must define id, slugId, version, examples, and complete about metadata, including difficulty, links_to_inspiration, sound, proposal_generator, skeleton_prompt, and sample prompts.", {
+            templateId: template.id,
+            slugId: template.slugId,
+            version: template.version,
+            difficulty: template.about?.difficulty ?? null,
+            inspirationLinkCount: template.about?.links_to_inspiration?.length ?? 0,
+            hasSound: Boolean(template.about?.sound),
+            exampleCount: template.examples?.length ?? 0,
+            previewMediaCount: template.about?.preview_media?.length ?? 0,
+            hasProposalGenerator: typeof template.about?.proposal_generator === "string" && template.about.proposal_generator.length > 0,
+            hasSkeletonPrompt: typeof template.about?.skeleton_prompt === "string" && template.about.skeleton_prompt.length > 0,
+            samplePromptCount: template.about?.sample_prompts?.length ?? 0
+        }));
+        checks.push(this.check("template.operations", Object.keys(template.operations).length > 0, "Template must define at least one operation."));
+        checks.push(this.checkSkill(skillPath));
+        checks.push(...this.checkProviderPolicy({ modulePath: input.modulePath }));
+        for (const [operationName, operation] of Object.entries(template.operations)) {
+            checks.push(this.check(`operation.${operationName}.workflow`, typeof template.jobs[operation.workflow] === "function", `Operation ${operationName} must reference an existing workflow.`, { workflow: operation.workflow }));
+            checks.push(this.check(`operation.${operationName}.smoke_payload`, Boolean(operation.smokeTestPayload), `Operation ${operationName} must define smokeTestPayload for certification.`));
+            if (!operation.smokeTestPayload) {
+                continue;
+            }
+            try {
+                const payload = operation.inputSchema.parse(operation.smokeTestPayload);
+                const workflow = template.jobs[operation.workflow];
+                const smoke = createSmokeContext(template.id);
+                const result = await workflow(smoke.ctx, payload);
+                checks.push(this.check(`operation.${operationName}.smoke_run`, Boolean(result && (result.output || result.progress !== undefined)), `Operation ${operationName} smoke run completed.`, {
+                    logCount: smoke.logCount,
+                    storageWrites: smoke.storageWrites,
+                    billingCalls: smoke.billingCalls,
+                    providerCalls: smoke.providerCalls,
+                    remotionCalls: smoke.remotionCalls
+                }));
+                checks.push(this.check(`operation.${operationName}.logs`, smoke.logCount > 0, `Operation ${operationName} must emit at least one log/progress event during smoke run.`));
+            }
+            catch (error) {
+                checks.push(this.check(`operation.${operationName}.smoke_run`, false, error instanceof Error ? error.message : "Smoke run failed."));
+            }
+        }
+        return {
+            passed: checks.every((check) => check.ok),
+            checks
+        };
+    }
+    check(code, ok, message, details) {
+        return { code, ok, message, details };
+    }
+    checkSkill(skillPath) {
+        try {
+            const contents = readFileSync(skillPath, "utf8").trim();
+            return this.check("template.skill", contents.length >= 40, "Template must include a non-trivial SKILL.md for customer agents.", { skillPath });
+        }
+        catch (error) {
+            return this.check("template.skill", false, error instanceof Error ? error.message : "Unable to read SKILL.md.", { skillPath });
+        }
+    }
+    checkProviderPolicy(input) {
+        if (!input.modulePath) {
+            return [
+                this.check("template.provider_policy.source", true, "Template module path was not provided; skipped provider policy source validation.")
+            ];
+        }
+        const moduleContents = readFileSync(input.modulePath, "utf8");
+        const directProviderAccess = TEMPLATE_DIRECT_PROVIDER_ACCESS_PATTERNS
+            .flatMap((pattern) => collectPatternMatches(moduleContents, pattern))
+            .map((match) => ({
+            line: lineNumberForOffset(moduleContents, match.index),
+            text: match.text.slice(0, 140)
+        }));
+        const providerDefaults = collectPatternMatches(moduleContents, TEMPLATE_OPERATION_PROVIDER_DEFAULT_PATTERN)
+            .map((match) => ({
+            line: lineNumberForOffset(moduleContents, match.index),
+            text: match.text.slice(0, 140)
+        }));
+        const geminiFallbacks = collectPatternMatches(moduleContents, TEMPLATE_GEMINI_PROVIDER_FALLBACK_PATTERN)
+            .map((match) => ({
+            line: lineNumberForOffset(moduleContents, match.index),
+            text: match.text.slice(0, 140)
+        }));
+        const unsupportedModels = collectUnsupportedModelLiterals(moduleContents);
+        const unsafeModelPassthrough = collectPatternMatches(moduleContents, TEMPLATE_UNSAFE_MODEL_PASSTHROUGH_PATTERN)
+            .filter((match) => !isInsideSafeProviderModelResolver(moduleContents, match.index))
+            .map((match) => ({
+            line: lineNumberForOffset(moduleContents, match.index),
+            text: match.text.slice(0, 140)
+        }));
+        return [
+            this.check("template.provider_policy.keys", directProviderAccess.length === 0, "Templates must use ctx.providers so AI calls lease the customer's saved provider keys; direct provider env/API usage is not allowed.", directProviderAccess.length > 0 ? { modulePath: input.modulePath, matches: directProviderAccess.slice(0, 10) } : { modulePath: input.modulePath }),
+            this.check("template.provider_policy.operation_defaults", providerDefaults.length === 0, "Operation payload provider fields must be optional explicit overrides; provider defaults belong in saved template config.", providerDefaults.length > 0 ? { modulePath: input.modulePath, matches: providerDefaults.slice(0, 10) } : { modulePath: input.modulePath }),
+            this.check("template.provider_policy.provider_fallbacks", geminiFallbacks.length === 0, "Templates must not hide Gemini provider defaults or parser fallbacks. AI calls must use ctx.providers so platform resolution can choose from the customer's saved active keys first.", geminiFallbacks.length > 0 ? { modulePath: input.modulePath, matches: geminiFallbacks.slice(0, 10) } : { modulePath: input.modulePath }),
+            this.check("template.provider_policy.models", unsupportedModels.length === 0, "Templates may only reference model IDs from the approved Vidfarm provider allowlist.", unsupportedModels.length > 0 ? { modulePath: input.modulePath, models: unsupportedModels.slice(0, 20) } : { modulePath: input.modulePath }),
+            this.check("template.provider_policy.model_resolution", unsafeModelPassthrough.length === 0, "Template model config and payload overrides must be validated against the selected provider/model allowlist before calling ctx.providers.", unsafeModelPassthrough.length > 0 ? { modulePath: input.modulePath, matches: unsafeModelPassthrough.slice(0, 10) } : { modulePath: input.modulePath })
+        ];
+    }
+}
+const MOCK_PNG_BYTES = Uint8Array.from(Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACXBIWXMAAAPoAAAD6AG1e1JrAAAADUlEQVR4nGP4////fwAJ+wP9KobjigAAAABJRU5ErkJggg==", "base64"));
+function createSmokeContext(templateId) {
+    let logCount = 0;
+    let storageWrites = 0;
+    let billingCalls = 0;
+    let providerCalls = 0;
+    let remotionCalls = 0;
+    const prefix = `templates/${templateId}/users/certification-user/jobs/certification-job`;
+    const ctx = {
+        env: "development",
+        customer: {
+            id: "certification-user",
+            email: "certification@vidfarm.local",
+            name: "Certification",
+            defaultWebhookUrl: null,
+            isDeveloper: true,
+            isAgency: false,
+            isPaidPlan: true,
+            planTier: "standalone",
+            about: null,
+            groupchatUrl: null,
+            flockposterApiKey: null,
+            createdAt: new Date(0).toISOString(),
+            updatedAt: new Date(0).toISOString()
+        },
+        template: {
+            id: templateId,
+            slugId: "certification-template",
+            previewMediaUrls: [],
+            previewMediaPolicy: "auto"
+        },
+        templateConfig: {},
+        logger: {
+            debug() { logCount += 1; },
+            info() { logCount += 1; },
+            warn() { logCount += 1; },
+            error() { logCount += 1; },
+            progress() { logCount += 1; }
+        },
+        jobs: {
+            async enqueueChild() {
+                return { jobId: "child-certification-job" };
+            }
+        },
+        storage: {
+            async putJson(key) {
+                storageWrites += 1;
+                return { key: `${prefix}/${key}`, url: `https://certification.local/${encodeURIComponent(key)}` };
+            },
+            async putText(key) {
+                storageWrites += 1;
+                return { key: `${prefix}/${key}`, url: `https://certification.local/${encodeURIComponent(key)}` };
+            },
+            async putBuffer(key) {
+                storageWrites += 1;
+                return { key: `${prefix}/${key}`, url: `https://certification.local/${encodeURIComponent(key)}` };
+            },
+            getPublicUrl(key) {
+                return `https://certification.local/${encodeURIComponent(`${prefix}/${key}`)}`;
+            }
+        },
+        billing: {
+            async record() {
+                billingCalls += 1;
+            }
+        },
+        providers: {
+            listAvailableProviders() {
+                return ["openai", "gemini", "openrouter", "perplexity"];
+            },
+            async generateText() {
+                providerCalls += 1;
+                return { text: "certification text", usage: { inputTokens: 1, outputTokens: 1, costUsd: 0 } };
+            },
+            async generateSpeech() {
+                providerCalls += 1;
+                return { bytes: Uint8Array.from([0, 1, 2, 3]), contentType: "audio/mpeg", usage: { inputTokens: 1, outputTokens: 1, costUsd: 0 } };
+            },
+            async generateImage() {
+                providerCalls += 1;
+                return { bytes: MOCK_PNG_BYTES, contentType: "image/png", revisedPrompt: null };
+            },
+            async analyzeImageLayout() {
+                providerCalls += 1;
+                return {
+                    zone: "bottom",
+                    align: "center",
+                    maxWidthPercent: 80,
+                    justification: "Certification mock layout."
+                };
+            },
+            async transcribeSpeech() {
+                providerCalls += 1;
+                return { text: "certification transcript", usage: { inputTokens: 1, outputTokens: 1, costUsd: 0 } };
+            }
+        },
+        hyperframes: {
+            async render() {
+                remotionCalls += 1;
+                return {
+                    renderId: "hyperframes-render-certification",
+                    outputUrl: "https://certification.local/hyperframes-render.mp4",
+                    outputS3Uri: null,
+                    metadata: { mode: "certification-mock", architecture: "timeline_layers" }
+                };
+            }
+        },
+        media: {
+            async normalizeVideo(input) {
+                storageWrites += 1;
+                return {
+                    key: `${prefix}/${input.outputKey}`,
+                    url: `https://certification.local/${encodeURIComponent(input.outputKey)}`,
+                    contentType: "video/mp4",
+                    normalization: {
+                        source: {
+                            durationSeconds: 5,
+                            width: 1080,
+                            height: 1920,
+                            videoCodec: "h264",
+                            audioCodec: "aac",
+                            videoBitrateKbps: 2000,
+                            audioBitrateKbps: 128,
+                            formatBitrateKbps: 2200,
+                            hasAudio: true,
+                            hasVideo: true,
+                            sampleRateHz: 48_000,
+                            channels: 2,
+                            frameRate: 30,
+                            formatName: "mp4",
+                            bytes: 1_000_000,
+                            url: input.sourceUrl
+                        },
+                        normalized: {
+                            durationSeconds: 5,
+                            width: 1080,
+                            height: 1920,
+                            videoCodec: "h264",
+                            audioCodec: "aac",
+                            videoBitrateKbps: 1500,
+                            audioBitrateKbps: 128,
+                            formatBitrateKbps: 1650,
+                            hasAudio: true,
+                            hasVideo: true,
+                            sampleRateHz: 48_000,
+                            channels: 2,
+                            frameRate: 30,
+                            formatName: "mp4",
+                            bytes: 750_000
+                        },
+                        compressionRatio: 0.75
+                    }
+                };
+            }
+        }
+    };
+    return {
+        ctx,
+        get logCount() { return logCount; },
+        get storageWrites() { return storageWrites; },
+        get billingCalls() { return billingCalls; },
+        get providerCalls() { return providerCalls; },
+        get remotionCalls() { return remotionCalls; }
+    };
+}
+function findTemplateRoot(modulePath) {
+    let current = path.dirname(modulePath);
+    for (let index = 0; index < 10; index += 1) {
+        if (existsSync(path.join(current, "template.config.json"))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return null;
+}
+function nonBlankString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+function collectTemplateSourceFiles(templateRoot) {
+    const files = [];
+    const stack = [templateRoot];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+            continue;
+        }
+        for (const entry of readdirSync(current, { withFileTypes: true })) {
+            if (entry.name === "node_modules" || entry.name === "build" || entry.name === "dist" || entry.name.startsWith(".")) {
+                continue;
+            }
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            if (/\.(?:[cm]?[jt]sx?)$/i.test(entry.name)) {
+                files.push(fullPath);
+            }
+        }
+    }
+    return files;
+}
+function collectPatternMatches(contents, pattern) {
+    const source = pattern.global ? pattern : new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`);
+    const matches = [];
+    for (const match of contents.matchAll(source)) {
+        matches.push({ index: match.index ?? 0, text: match[0] });
+    }
+    return matches;
+}
+function collectUnsupportedModelLiterals(contents) {
+    const seen = new Map();
+    for (const match of contents.matchAll(TEMPLATE_MODEL_LITERAL_PATTERN)) {
+        const model = match[1]?.trim();
+        if (!model || APPROVED_TEMPLATE_MODEL_IDS.has(model) || seen.has(model)) {
+            continue;
+        }
+        seen.set(model, {
+            model,
+            line: lineNumberForOffset(contents, match.index ?? 0)
+        });
+    }
+    return [...seen.values()];
+}
+function lineNumberForOffset(contents, offset) {
+    let line = 1;
+    for (let index = 0; index < offset; index += 1) {
+        if (contents.charCodeAt(index) === 10) {
+            line += 1;
+        }
+    }
+    return line;
+}
+function isInsideSafeProviderModelResolver(contents, offset) {
+    const prefix = contents.slice(Math.max(0, offset - 80), offset);
+    return prefix.includes("sanitizeProviderModel(");
+}
+//# sourceMappingURL=template-certification.js.map

package/dist/src/services/template-loader.js

@@ -0,0 +1,99 @@
+import { pathToFileURL } from "node:url";
+export async function loadTemplateFromModule(modulePath) {
+    const loaded = await import(pathToFileURL(modulePath).href);
+    const candidates = Object.values(loaded);
+    for (const candidate of candidates) {
+        if (isTemplateDefinition(candidate)) {
+            return normalizeTemplateDefinition(candidate);
+        }
+    }
+    throw new Error(`No template definition export found in ${modulePath}`);
+}
+function normalizeTemplateDefinition(template) {
+    return {
+        ...template,
+        about: {
+            ...template.about,
+            // Older runtime template releases may predate prompt metadata fields.
+            difficulty: template.about.difficulty ?? "easy",
+            links_to_inspiration: normalizeTemplateInspirationLinks(template.about.links_to_inspiration, template.about.link_to_original),
+            sound: normalizeTemplateSound(template.about.sound),
+            proposal_generator: template.about.proposal_generator ?? "",
+            skeleton_prompt: template.about.skeleton_prompt ?? "",
+            sample_prompts: template.about.sample_prompts ?? []
+        },
+        examples: template.examples ?? []
+    };
+}
+function isTemplateDefinition(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    const about = typeof candidate.about === "object" && candidate.about !== null
+        ? candidate.about
+        : null;
+    const previewMedia = about && Array.isArray(about.preview_media)
+        ? about.preview_media
+        : null;
+    const samplePrompts = about && Array.isArray(about.sample_prompts)
+        ? about.sample_prompts
+        : null;
+    const sound = about && typeof about.sound === "object" && about.sound !== null
+        ? about.sound
+        : null;
+    const linksToInspiration = about && Array.isArray(about.links_to_inspiration)
+        ? about.links_to_inspiration
+        : null;
+    const examples = Array.isArray(candidate.examples)
+        ? candidate.examples
+        : null;
+    return (typeof candidate.id === "string" &&
+        typeof candidate.slugId === "string" &&
+        typeof candidate.version === "string" &&
+        about !== null &&
+        typeof about.title === "string" &&
+        typeof about.description === "string" &&
+        (["easy", "medium", "hard", "expert"].includes(String(about.difficulty)) || typeof about.difficulty === "undefined") &&
+        typeof about.viral_dna === "string" &&
+        typeof about.visual_dna === "string" &&
+        Array.isArray(previewMedia) &&
+        previewMedia.every((entry) => typeof entry === "string") &&
+        typeof about.link_to_original === "string" &&
+        (linksToInspiration === null || linksToInspiration.every((entry) => typeof entry === "string")) &&
+        (sound === null || (typeof sound.sound_title === "string" &&
+            typeof sound.sound_url === "string")) &&
+        (typeof about.proposal_generator === "string" || typeof about.proposal_generator === "undefined") &&
+        (typeof about.skeleton_prompt === "string" || typeof about.skeleton_prompt === "undefined") &&
+        (samplePrompts === null || samplePrompts.every((entry) => typeof entry === "string")) &&
+        (examples === null || examples.every((example) => Array.isArray(example) && example.every((entry) => {
+            if (!entry || typeof entry !== "object") {
+                return false;
+            }
+            const media = entry;
+            return typeof media.media_url === "string" && typeof media.note === "string";
+        }))) &&
+        typeof candidate.configSchema === "object" &&
+        typeof candidate.operations === "object" &&
+        typeof candidate.jobs === "object");
+}
+function normalizeTemplateSound(value) {
+    if (!value || typeof value !== "object") {
+        return {
+            sound_title: "",
+            sound_url: ""
+        };
+    }
+    const sound = value;
+    return {
+        sound_title: typeof sound.sound_title === "string" ? sound.sound_title : "",
+        sound_url: typeof sound.sound_url === "string" ? sound.sound_url : ""
+    };
+}
+function normalizeTemplateInspirationLinks(value, linkToOriginal) {
+    if (Array.isArray(value)) {
+        return value.filter((entry) => typeof entry === "string");
+    }
+    return linkToOriginal ? [linkToOriginal] : [];
+}
+//# sourceMappingURL=template-loader.js.map