@mevdragon/vidfarm-devcli 0.2.1 → 0.2.3

package/dist/src/cli.js

@@ -1,11 +1,16 @@
 #!/usr/bin/env node
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import os from "node:os";
 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 { analyzeTemplateDna, hasTemplatePreviewMedia, stageTemplateDnaInputs, syncTemplateDnaModule } from "./lib/template-dna.js";
+import { assertTemplateFolderNameHasPrefix, defaultSkillPathForTemplateModule, deriveTemplateRootDirFromModulePath } from "./lib/template-paths.js";
+const execFileAsync = promisify(execFile);
 void main().catch((error) => {
     console.error(error instanceof Error ? error.stack ?? error.message : String(error));
     process.exit(1);
@@ -28,10 +33,22 @@ async function main() {
         await runImportSourceCommand(process.argv.slice(3));
         return;
     }
+    if (command === "import-source-prod") {
+        await runImportSourceProdCommand(process.argv.slice(3));
+        return;
+    }
+    if (command === "deploy-template-cycle") {
+        await runDeployTemplateCycleCommand(process.argv.slice(3));
+        return;
+    }
     if (command === "generate-template") {
         await runGenerateTemplateCommand(process.argv.slice(3));
         return;
     }
+    if (command === "copy-reference-template") {
+        await runCopyReferenceTemplateCommand(process.argv.slice(3));
+        return;
+    }
     if (command === "analyze-viral-dna") {
         await runAnalyzeTemplateDnaCommand("viral", process.argv.slice(3));
         return;
@@ -40,6 +57,10 @@ async function main() {
         await runAnalyzeTemplateDnaCommand("visual", process.argv.slice(3));
         return;
     }
+    if (command === "presign-preview-media") {
+        await runPresignPreviewMediaCommand(process.argv.slice(3));
+        return;
+    }
     throw new Error(`Unknown command: ${command}`);
 }
 async function runDevCommand(argv) {
@@ -191,7 +212,7 @@ async function runImportSourceCommand(argv) {
             "repo-url": { type: "string" },
             branch: { type: "string", default: "production" },
             "template-module-path": { type: "string" },
-            "skill-path": { type: "string", default: "SKILL.md" },
+            "skill-path": { type: "string" },
             "install-command": { type: "string", default: "npm install" },
             "build-command": { type: "string", default: "npm run build" },
             "commit-sha": { type: "string" },
@@ -205,6 +226,10 @@ async function runImportSourceCommand(argv) {
     if (!templateId || !slugId || !repoUrl || !templateModulePath) {
         throw new Error("import-source requires --template-id, --slug-id, --repo-url, and --template-module-path.");
     }
+    if (!/(^|\/)template\.ts$/i.test(templateModulePath)) {
+        throw new Error("import-source requires --template-module-path to point at the TypeScript entrypoint, usually src/template.ts.");
+    }
+    const skillPath = parsed.values["skill-path"] ?? defaultSkillPathForTemplateModule(templateModulePath);
     const [{ TemplateSourceService }, { templateRegistry }] = await Promise.all([
         import("./services/template-sources.js"),
         import("./registry.js")
@@ -216,7 +241,7 @@ async function runImportSourceCommand(argv) {
         repoUrl,
         branch: parsed.values.branch,
         templateModulePath,
-        skillPath: parsed.values["skill-path"],
+        skillPath,
         installCommand: parsed.values["install-command"],
         buildCommand: parsed.values["build-command"]
     });
@@ -265,6 +290,8 @@ async function runGenerateTemplateCommand(argv) {
     const root = process.cwd();
     const starterDir = resolveStarterTemplateDir();
     const destinationDir = path.resolve(root, templateDir);
+    const destinationFolderName = path.basename(destinationDir);
+    assertTemplateFolderNameHasPrefix(destinationFolderName);
     if (!existsSync(starterDir)) {
         throw new Error(`Starter template not found: ${starterDir}`);
     }
@@ -281,7 +308,6 @@ async function runGenerateTemplateCommand(argv) {
             return ![".git", "node_modules", "dist", "package-lock.json"].includes(name);
         }
     });
-    const destinationFolderName = path.basename(destinationDir);
     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}`;
@@ -332,6 +358,91 @@ async function runGenerateTemplateCommand(argv) {
         dna_analysis_runs: dnaRuns
     }, null, 2));
 }
+async function runImportSourceProdCommand(argv) {
+    const input = parseProdTemplateCommandArgs(argv, {
+        envFile: ".env.production",
+        stackName: "VidfarmProdStack",
+        activate: true
+    });
+    const result = await importSourceIntoProd(input);
+    console.log(JSON.stringify({
+        mode: "prod-import-source",
+        stack_name: input.stackName,
+        instance_id: result.instanceId,
+        source: result.payload.source,
+        release: result.payload.release,
+        activated_release: result.payload.activated_release ?? null
+    }, null, 2));
+}
+async function runDeployTemplateCycleCommand(argv) {
+    const input = parseProdTemplateCommandArgs(argv, {
+        envFile: ".env.production",
+        stackName: "VidfarmProdStack",
+        activate: true
+    });
+    const importResult = await importSourceIntoProd(input);
+    const currentImage = await getProdCurrentImage({
+        stackName: input.stackName,
+        envFile: input.envFile
+    });
+    await runLocalCommand("bash", [
+        "scripts/deploy-prod-inplace.sh",
+        "--env-file", input.envFile,
+        "--stack-name", input.stackName,
+        "--image-uri", currentImage.image,
+        "--skip-check",
+        "--skip-build",
+        "--tag-suffix", `template-${input.slugId}`
+    ]);
+    console.log(JSON.stringify({
+        mode: "deploy-template-cycle",
+        stack_name: input.stackName,
+        instance_id: importResult.instanceId,
+        release: importResult.payload.activated_release ?? importResult.payload.release,
+        restart_image: currentImage.image
+    }, null, 2));
+}
+async function runCopyReferenceTemplateCommand(argv) {
+    const parsed = parseArgs({
+        args: argv,
+        options: {
+            "template-dir": { type: "string" },
+            force: { type: "boolean", default: false }
+        }
+    });
+    const templateDir = parsed.values["template-dir"];
+    if (!templateDir) {
+        throw new Error("copy-reference-template requires --template-dir.");
+    }
+    const root = process.cwd();
+    const starterDir = resolveStarterTemplateDir();
+    const destinationDir = path.resolve(root, templateDir);
+    const destinationFolderName = path.basename(destinationDir);
+    assertTemplateFolderNameHasPrefix(destinationFolderName);
+    if (!existsSync(starterDir)) {
+        throw new Error(`Starter template not found: ${starterDir}`);
+    }
+    if (existsSync(destinationDir)) {
+        if (!parsed.values.force) {
+            throw new Error(`Destination already exists: ${destinationDir}`);
+        }
+        rmSync(destinationDir, { recursive: true, force: true });
+    }
+    cpSync(starterDir, destinationDir, {
+        recursive: true,
+        filter: (entry) => {
+            const name = path.basename(entry);
+            return ![".git", "node_modules", "dist"].includes(name);
+        }
+    });
+    console.log(JSON.stringify({
+        copied_from: starterDir,
+        template_dir: destinationDir,
+        template_id: "4c7a7e1a-7f35-4f30-9f86-9c8a63c7f2db",
+        slug_id: "template_0000",
+        rewritten: false
+    }, null, 2));
+}
 async function runAnalyzeTemplateDnaCommand(mode, argv) {
     const parsed = parseArgs({
         args: argv,
@@ -359,6 +470,67 @@ async function runAnalyzeTemplateDnaCommand(mode, argv) {
     });
     console.log(JSON.stringify(result, null, 2));
 }
+async function runPresignPreviewMediaCommand(argv) {
+    const parsed = parseArgs({
+        args: argv,
+        options: {
+            file: { type: "string" },
+            "file-name": { type: "string" },
+            "content-type": { type: "string" },
+            directory: { type: "string" },
+            "base-url": { type: "string" },
+            "api-key": { type: "string" },
+            "env-file": { type: "string", default: ".env" }
+        }
+    });
+    loadOptionalEnvFile(parsed.values["env-file"]);
+    const filePath = parsed.values.file ? path.resolve(process.cwd(), parsed.values.file) : null;
+    if (filePath && !existsSync(filePath)) {
+        throw new Error(`Preview media file not found: ${filePath}`);
+    }
+    const fileName = sanitizeCliUploadFileName(parsed.values["file-name"]
+        ?? (filePath ? path.basename(filePath) : undefined));
+    if (!fileName) {
+        throw new Error("presign-preview-media requires --file or --file-name.");
+    }
+    const contentType = parsed.values["content-type"]
+        ?? inferUploadContentType(fileName);
+    const baseUrl = normalizeBaseUrl(parsed.values["base-url"] ?? process.env.VIDFARM_BASE_URL ?? "https://vidfarm.cloud.zoomgtm.com");
+    const apiKey = parsed.values["api-key"] ?? process.env.VIDFARM_API_KEY;
+    if (!apiKey) {
+        throw new Error("Missing Vidfarm API key. Pass --api-key or set VIDFARM_API_KEY in your env file.");
+    }
+    const response = await fetch(`${baseUrl}/api/v1/user/me/developer/preview-media/presign`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "vidfarm-api-key": apiKey
+        },
+        body: JSON.stringify({
+            file_name: fileName,
+            content_type: contentType,
+            directory: parsed.values.directory
+        })
+    });
+    const payload = await response.json();
+    if (!response.ok) {
+        throw new Error(typeof payload.error === "string" ? payload.error : `Preview-media presign failed with ${response.status}.`);
+    }
+    console.log(JSON.stringify({
+        base_url: baseUrl,
+        file_path: filePath,
+        file_name: payload.file_name,
+        content_type: payload.content_type,
+        storage_key: payload.storage_key,
+        preview_media_url: payload.preview_media_url,
+        upload: payload.upload,
+        curl_upload_example: [
+            `curl -X ${payload.upload.method} '${payload.upload.url}' \\`,
+            `  -H 'content-type: ${payload.content_type}' \\`,
+            "  --upload-file <local-preview-file>"
+        ].join("\n")
+    }, null, 2));
+}
 async function runSessionCommand(argv) {
     const parsed = parseArgs({
         args: argv,
@@ -377,13 +549,11 @@ async function runSessionCommand(argv) {
             starter_template_file: "templates/template_0000/src/style-options.ts"
         },
         headers: {
-            "vidfarm-user-id": session.customerId,
             "vidfarm-api-key": session.apiKey,
             "content-type": "application/json"
         },
         curl_example: [
             `curl -X POST ${session.baseUrl}/api/v1/templates/template_0000/operations/create_slideshow \\`,
-            `  -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\",2400]],\"meta_details_prompt\":\"Keep it native, casual, and curiosity-driven.\"}}'"
@@ -422,8 +592,8 @@ function printStartupBanner(input) {
     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(`customer-id (derived via /api/v1/user/me): ${input.customerId}`);
     console.log(`Session file: ${input.sessionPath}`);
     console.log(`Data dir: ${input.dataDir}`);
     console.log(`SQLite: ${input.dbPath}`);
@@ -462,5 +632,283 @@ function toProjectName(folderName) {
         .toLowerCase();
 }
 function resolveStarterTemplateDir() {
-    return path.resolve(import.meta.dirname, "..", "..", "templates", "template_0000");
+    const candidates = [
+        path.resolve(import.meta.dirname, "..", "templates", "template_0000"),
+        path.resolve(import.meta.dirname, "..", "..", "templates", "template_0000")
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function parseProdTemplateCommandArgs(argv, defaults) {
+    const parsed = parseArgs({
+        args: argv,
+        options: {
+            "template-id": { type: "string" },
+            "slug-id": { type: "string" },
+            "repo-url": { type: "string" },
+            branch: { type: "string", default: "production" },
+            "template-module-path": { type: "string" },
+            "skill-path": { type: "string" },
+            "install-command": { type: "string", default: "npm install" },
+            "build-command": { type: "string", default: "npm run build" },
+            "commit-sha": { type: "string" },
+            "env-file": { type: "string", default: defaults.envFile },
+            "stack-name": { type: "string", default: defaults.stackName }
+        }
+    });
+    const templateId = parsed.values["template-id"];
+    const slugId = parsed.values["slug-id"];
+    const repoUrl = parsed.values["repo-url"];
+    const templateModulePath = parsed.values["template-module-path"];
+    if (!templateId || !slugId || !repoUrl || !templateModulePath) {
+        throw new Error("Command requires --template-id, --slug-id, --repo-url, and --template-module-path.");
+    }
+    deriveTemplateRootDirFromModulePath(templateModulePath);
+    return {
+        templateId,
+        slugId,
+        repoUrl,
+        branch: parsed.values.branch,
+        templateModulePath,
+        skillPath: parsed.values["skill-path"] ?? defaultSkillPathForTemplateModule(templateModulePath),
+        installCommand: parsed.values["install-command"],
+        buildCommand: parsed.values["build-command"],
+        commitSha: parsed.values["commit-sha"] ?? undefined,
+        envFile: parsed.values["env-file"],
+        stackName: parsed.values["stack-name"],
+        activate: defaults.activate
+    };
+}
+async function importSourceIntoProd(input) {
+    loadEnvFile(input.envFile);
+    const instanceId = await resolveStackOutput(input.stackName, "VidfarmInstanceId");
+    const containerScript = buildContainerImportCommand(input);
+    const hostScript = [
+        "set -euo pipefail",
+        `sudo docker exec -e GITHUB_TOKEN=${shellQuote(resolveGithubToken())} vidfarm /bin/bash -lc ${shellQuote(containerScript)}`
+    ].join("\n");
+    const stdout = await runSsmScript({
+        instanceId,
+        comment: `Vidfarm import ${input.slugId}`,
+        script: hostScript
+    });
+    return {
+        instanceId,
+        payload: extractLastJson(stdout)
+    };
+}
+function buildContainerImportCommand(input) {
+    const args = [
+        "node",
+        "/app/dist/src/cli.js",
+        "import-source",
+        "--template-id", input.templateId,
+        "--slug-id", input.slugId,
+        "--repo-url", input.repoUrl,
+        "--branch", input.branch,
+        "--template-module-path", input.templateModulePath,
+        "--skill-path", input.skillPath,
+        "--install-command", input.installCommand,
+        "--build-command", input.buildCommand
+    ];
+    if (input.commitSha) {
+        args.push("--commit-sha", input.commitSha);
+    }
+    if (!input.activate) {
+        throw new Error("Non-activating prod import is not implemented.");
+    }
+    const lines = [
+        "set -euo pipefail",
+        "if [ -n \"${GITHUB_TOKEN:-}\" ]; then",
+        "  git config --global url.\"https://x-access-token:${GITHUB_TOKEN}@github.com/\".insteadOf \"https://github.com/\"",
+        "fi",
+        args.map(shellQuote).join(" ")
+    ];
+    return lines.join("\n");
+}
+function loadEnvFile(envFile) {
+    const resolved = path.resolve(process.cwd(), envFile);
+    if (!existsSync(resolved)) {
+        throw new Error(`Missing env file: ${resolved}`);
+    }
+    dotenv.config({
+        path: resolved,
+        override: true
+    });
+}
+function loadOptionalEnvFile(envFile) {
+    const resolved = path.resolve(process.cwd(), envFile);
+    if (!existsSync(resolved)) {
+        return;
+    }
+    dotenv.config({
+        path: resolved,
+        override: false
+    });
+}
+function sanitizeCliUploadFileName(value) {
+    if (!value) {
+        return "";
+    }
+    const normalized = path.basename(value).replace(/[^\w.-]+/g, "_");
+    return normalized.length ? normalized : "upload.bin";
+}
+function normalizeBaseUrl(value) {
+    return value.replace(/\/+$/, "");
+}
+function inferUploadContentType(fileName) {
+    switch (path.extname(fileName).toLowerCase()) {
+        case ".png":
+            return "image/png";
+        case ".gif":
+            return "image/gif";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".webp":
+            return "image/webp";
+        case ".svg":
+            return "image/svg+xml";
+        case ".mp4":
+        case ".m4v":
+            return "video/mp4";
+        case ".mov":
+            return "video/quicktime";
+        case ".webm":
+            return "video/webm";
+        case ".mp3":
+            return "audio/mpeg";
+        case ".wav":
+            return "audio/wav";
+        case ".m4a":
+            return "audio/mp4";
+        case ".aac":
+            return "audio/aac";
+        case ".ogg":
+            return "audio/ogg";
+        case ".pdf":
+            return "application/pdf";
+        case ".md":
+            return "text/markdown; charset=utf-8";
+        case ".txt":
+            return "text/plain; charset=utf-8";
+        default:
+            return "application/octet-stream";
+    }
+}
+function resolveGithubToken() {
+    return process.env.VIDFARM_GITHUB_TOKEN
+        ?? process.env.GITHUB_TOKEN
+        ?? process.env.GH_TOKEN
+        ?? "";
+}
+async function resolveStackOutput(stackName, outputKey) {
+    const { stdout } = await runLocalCommand("aws", [
+        "cloudformation",
+        "describe-stacks",
+        "--stack-name", stackName,
+        "--query", `Stacks[0].Outputs[?OutputKey=='${outputKey}'].OutputValue`,
+        "--output", "text"
+    ]);
+    const value = stdout.trim();
+    if (!value || value === "None") {
+        throw new Error(`Could not resolve ${outputKey} from stack ${stackName}.`);
+    }
+    return value;
+}
+async function getProdCurrentImage(input) {
+    loadEnvFile(input.envFile);
+    const instanceId = await resolveStackOutput(input.stackName, "VidfarmInstanceId");
+    const stdout = await runSsmScript({
+        instanceId,
+        comment: "Read current Vidfarm image",
+        script: [
+            "set -euo pipefail",
+            "sudo docker ps -a --filter name=^/vidfarm$ --format '{{.Image}}' | head -n 1",
+            "sudo systemctl is-active vidfarm || true"
+        ].join("\n")
+    });
+    const [image, status] = stdout.trim().split(/\n+/);
+    if (!image) {
+        throw new Error("Could not determine the current live Docker image.");
+    }
+    return {
+        instanceId,
+        image,
+        status: status ?? ""
+    };
+}
+async function runSsmScript(input) {
+    const tempDir = mkTempDir();
+    try {
+        const commandPath = path.join(tempDir, "commands.json");
+        const scriptB64 = Buffer.from(input.script, "utf8").toString("base64");
+        writeFileSync(commandPath, JSON.stringify({
+            commands: [
+                `echo ${shellQuote(scriptB64)} | base64 --decode > /tmp/vidfarm-operator.sh`,
+                "bash /tmp/vidfarm-operator.sh"
+            ]
+        }));
+        const { stdout: sendStdout } = await runLocalCommand("aws", [
+            "ssm",
+            "send-command",
+            "--instance-ids", input.instanceId,
+            "--document-name", "AWS-RunShellScript",
+            "--comment", input.comment,
+            "--parameters", `file://${commandPath}`,
+            "--query", "Command.CommandId",
+            "--output", "text"
+        ]);
+        const commandId = sendStdout.trim();
+        if (!commandId) {
+            throw new Error(`Unable to start SSM command for ${input.comment}.`);
+        }
+        while (true) {
+            const { stdout } = await runLocalCommand("aws", [
+                "ssm",
+                "get-command-invocation",
+                "--command-id", commandId,
+                "--instance-id", input.instanceId
+            ]);
+            const response = JSON.parse(stdout);
+            if (response.Status === "Success") {
+                return response.StandardOutputContent ?? "";
+            }
+            if (["Failed", "Cancelled", "TimedOut", "Cancelling"].includes(response.Status)) {
+                throw new Error((response.StandardErrorContent ?? "").trim()
+                    || (response.StandardOutputContent ?? "").trim()
+                    || `SSM command failed with status ${response.Status}.`);
+            }
+            await sleep(2000);
+        }
+    }
+    finally {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+}
+async function runLocalCommand(command, args) {
+    return execFileAsync(command, args, {
+        cwd: process.cwd(),
+        env: process.env,
+        maxBuffer: 10 * 1024 * 1024
+    });
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}
+function mkTempDir() {
+    return mkdtempSync(path.join(os.tmpdir(), "vidfarm-operator-"));
+}
+function extractLastJson(stdout) {
+    const trimmed = stdout.trim();
+    const start = trimmed.lastIndexOf("\n{");
+    const jsonText = start >= 0 ? trimmed.slice(start + 1) : trimmed;
+    return JSON.parse(jsonText);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/src/config.js

@@ -41,7 +41,7 @@ const schema = z.object({
     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"),
+    MOCK_PROVIDER_RESPONSES: z.string().optional(),
     VIDFARM_ADMIN_EMAILS: z.string().default(""),
     VIDFARM_DEVELOPER_EMAILS: z.string().default(""),
     TEMPLATE_SOURCE_ROOT: z.string().default("./data/template-sources")
@@ -59,7 +59,8 @@ export const config = {
     TEMPLATE_SOURCE_ROOT: templateSourceRoot,
     PUBLIC_BASE_URL: publicBaseUrl,
     isProduction: parsed.NODE_ENV === "production",
-    mockProviders: parsed.MOCK_PROVIDER_RESPONSES !== "false",
+    mockProviders: parsed.MOCK_PROVIDER_RESPONSES === "true" ||
+        (parsed.MOCK_PROVIDER_RESPONSES == null && parsed.NODE_ENV !== "production"),
     s3PublicRead: parsed.AWS_S3_PUBLIC_READ === "true",
     adminEmails: parsed.VIDFARM_ADMIN_EMAILS
         .split(",")