@mevdragon/vidfarm-devcli 0.2.14 → 0.3.1

package/dist/src/cli.js

@@ -1,1572 +1,180 @@
 #!/usr/bin/env node
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { execFile } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
-import os from "node:os";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { parseArgs } from "node:util";
-import { promisify } from "node:util";
-import dotenv from "dotenv";
-import { CAPTION_STANDARD_VERSION, TIKTOK_CAPTION_SHADOWS, STARTER_TEMPLATE_FONT_OPTIONS, STARTER_TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS, TIKTOK_CAPTION_RENDERING_RULES, TIKTOK_CAPTION_STYLE_PRESETS, TIKTOK_TEXT_BACKGROUND_RENDERING } 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);
-function printDeprecationBanner() {
-    const red = "\x1b[31m";
-    const yellow = "\x1b[33m";
-    const bold = "\x1b[1m";
-    const reset = "\x1b[0m";
-    const line = `${red}${bold}${"═".repeat(78)}${reset}`;
-    console.warn("");
-    console.warn(line);
-    console.warn(`${red}${bold}  ⚠  DEPRECATED: @mevdragon/vidfarm-devcli is no longer maintained.${reset}`);
-    console.warn(line);
-    console.warn(`${yellow}  Vidfarm has migrated from the old REST-API template model to the${reset}`);
-    console.warn(`${yellow}  Trackpad Editor (timeline-based composition editor in the browser).${reset}`);
-    console.warn("");
-    console.warn(`${yellow}  This CLI was built around the OLD paradigm — REST-API templates with${reset}`);
-    console.warn(`${yellow}  src/template.ts, workflows, operations, viral DNA extraction, and the${reset}`);
-    console.warn(`${yellow}  hosted publish/approve/activate release flow. That paradigm is gone.${reset}`);
-    console.warn("");
-    console.warn(`${yellow}  Directors: open ${bold}https://vidfarm.cc/editor/${reset}${yellow} to edit compositions.${reset}`);
-    console.warn(`${yellow}  Template authors: see SKILL.platform.md and auto-create-hyperframe-templates/.${reset}`);
-    console.warn("");
-    console.warn(`${yellow}  Commands may partially work but are not supported. No fixes will land.${reset}`);
-    console.warn(line);
-    console.warn("");
-}
+// vidfarm-devcli — thin CLI that pairs a local composition directory with the
+// hosted Trackpad Editor at https://vidfarm.cc/editor/. Point it at a template
+// id, and it: resolves the user's fork, downloads the current composition,
+// starts a local dev-serve, and prints the editor URL to open in the browser.
+const DEFAULT_HOST = "https://vidfarm.cc";
+const DEFAULT_PORT = 4321;
+const HELP = `vidfarm-devcli — local editor bridge for the Vidfarm Trackpad Editor
+
+Usage:
+  vidfarm-devcli <template_id> [options]        Start local editor session
+  vidfarm-devcli dev-serve [options]            Serve an existing local dir only
+  vidfarm-devcli --help                         Show this help
+
+Options (edit mode):
+  --port <n>          Local dev-serve port (default: ${DEFAULT_PORT})
+  --dir <path>        Local composition directory (default: .vidfarm/<template_id>)
+  --host <url>        Vidfarm host to fetch from (default: ${DEFAULT_HOST})
+  --fork <id>         Fork id to fetch (default: auto-resolve for the current user)
+  --api-key <key>     Vidfarm API key (or set VIDFARM_API_KEY)
+  --share <token>     Share token for a shared fork (public read)
+  --refetch           Overwrite local composition files with the latest remote copy
+
+Options (dev-serve mode):
+  --dir <path>        Directory to serve (default: current dir)
+  --port <n>          Port to listen on (default: ${DEFAULT_PORT})
+`;
 void main().catch((error) => {
     console.error(error instanceof Error ? error.stack ?? error.message : String(error));
     process.exit(1);
 });
 async function main() {
-    printDeprecationBanner();
-    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));
+    const argv = process.argv.slice(2);
+    if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+        process.stdout.write(HELP);
         return;
     }
+    const command = argv[0];
     if (command === "dev-serve") {
         const { runDevServeCommand } = await import("./dev-serve.js");
-        await runDevServeCommand(process.argv.slice(3));
-        return;
-    }
-    if (command === "validate-template") {
-        await runValidateTemplateCommand(process.argv.slice(3));
-        return;
-    }
-    if (command === "import-source") {
-        await runImportSourceCommand(process.argv.slice(3));
-        return;
-    }
-    if (command === "import-source-prod") {
-        await runImportSourceProdCommand(process.argv.slice(3));
-        return;
-    }
-    if (command === "register-source-hosted") {
-        await runRegisterSourceHostedCommand(process.argv.slice(3));
-        return;
-    }
-    if (command === "publish-update-hosted") {
-        await runPublishUpdateHostedCommand(process.argv.slice(3));
-        return;
-    }
-    if (command === "register-source-prod") {
-        await runRegisterSourceProdCommand(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 === "autocreate-template" || command === "autocreate") {
-        await runAutocreateTemplateCommand(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));
+        await runDevServeCommand(argv.slice(1));
         return;
     }
-    if (command === "analyze-visual-dna") {
-        await runAnalyzeTemplateDnaCommand("visual", process.argv.slice(3));
+    if (command === "edit") {
+        await runEditCommand(argv.slice(1));
         return;
     }
-    if (command === "presign-preview-media") {
-        await runPresignPreviewMediaCommand(process.argv.slice(3));
+    if (!command.startsWith("-")) {
+        // Positional template id → default `edit` command.
+        await runEditCommand(argv);
         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 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_RUNTIME_BACKEND = "serverless";
-    process.env.STORAGE_DRIVER = "local";
-    process.env.PUBLIC_BASE_URL = `http://127.0.0.1:${port}`;
-    process.env.REMOTION_MODE = "local";
-    process.env.VIDFARM_ADMIN_EMAILS = process.env.VIDFARM_ADMIN_EMAILS || parsed.values.email;
-    process.env.MOCK_PROVIDER_RESPONSES =
-        parsed.values["mock-ai"] ? "true" : process.env.MOCK_PROVIDER_RESPONSES ?? (hasProviderEnvKey ? "false" : "true");
-    const [{ startRuntime }, { ServerlessAuthService }, { ServerlessProviderKeyService }, { config }, { createId }, crypto] = await Promise.all([
-        import("./runtime.js"),
-        import("./services/serverless-auth.js"),
-        import("./services/serverless-provider-keys.js"),
-        import("./config.js"),
-        import("./lib/ids.js"),
-        import("./lib/crypto.js")
-    ]);
-    const auth = new ServerlessAuthService();
-    const providerKeys = new ServerlessProviderKeyService();
-    const customer = await auth.getCustomerByEmailPublic(parsed.values.email) ?? await auth.upsertCustomer({
-        id: createId("cus"),
-        email: parsed.values.email,
-        name: parsed.values.name,
-        isDeveloper: true,
-        isPaidPlan: true,
-        planTier: "standalone"
-    });
-    const rawApiKey = parsed.values["api-key"] ?? `vf_local_${Math.random().toString(36).slice(2, 12)}`;
-    await auth.insertApiKey({
-        id: createId("api"),
-        customerId: customer.id,
-        keyHash: crypto.hashSecret(rawApiKey + config.API_KEY_SALT),
-        rawValue: rawApiKey,
-        label: "Local CLI session"
-    });
-    await seedEnvProviderKeys({
-        customerId: customer.id,
-        providerKeys,
-        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,
-        dataDir
-    }, null, 2));
-    printStartupBanner({
-        baseUrl: process.env.PUBLIC_BASE_URL,
-        customerId: customer.id,
-        apiKey: rawApiKey,
-        email: customer.email,
-        dataDir,
-        sessionPath,
-        mockProviders: config.mockProviders
-    });
-    const runtime = await startRuntime();
-    for (const signal of ["SIGINT", "SIGTERM"]) {
-        process.on(signal, () => {
-            runtime.shutdown();
-            process.exit(0);
-        });
-    }
-}
-async function runValidateTemplateCommand(argv) {
-    const parsed = parseArgs({
-        args: argv,
-        options: {
-            "template-id": { type: "string" },
-            "module-path": { type: "string" },
-            "skill-path": { type: "string" }
-        }
-    });
-    const [{ templateRegistry }, { TemplateCertificationService }, { loadTemplateFromModule }] = await Promise.all([
-        import("./registry.js"),
-        import("./services/template-certification.js"),
-        import("./services/template-loader.js")
-    ]);
-    const certification = new TemplateCertificationService();
-    let template;
-    let skillPath;
-    if (parsed.values["module-path"]) {
-        const modulePath = path.resolve(process.cwd(), parsed.values["module-path"]);
-        template = await loadTemplateFromModule(modulePath);
-        skillPath = path.resolve(process.cwd(), parsed.values["skill-path"] ?? "SKILL.md");
-        const report = await certification.certify({ template, skillPath, modulePath });
-        console.log(JSON.stringify(report, null, 2));
-        if (!report.passed) {
-            process.exitCode = 1;
-        }
-        return;
-    }
-    else {
-        await templateRegistry.ensureInitialized();
-        const templateId = parsed.values["template-id"];
-        if (!templateId) {
-            throw new Error("Provide --template-id or --module-path.");
-        }
-        template = templateRegistry.get(templateId);
-        if (!template) {
-            throw new Error(`Unknown template: ${templateId}`);
-        }
-        skillPath = template.skillPath;
-    }
-    if (!template || !skillPath) {
-        throw new Error("Template or skill path not found for certification.");
-    }
-    const report = await certification.certify({ template, skillPath });
-    console.log(JSON.stringify(report, null, 2));
-    if (!report.passed) {
-        process.exitCode = 1;
-    }
-}
-async function runImportSourceCommand(argv) {
-    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" },
-            activate: { type: "boolean", default: true }
-        }
-    });
-    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("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")
-    ]);
-    const sources = new TemplateSourceService();
-    const registration = await sources.registerSource({
-        templateId,
-        slugId,
-        repoUrl,
-        branch: parsed.values.branch,
-        templateModulePath,
-        skillPath,
-        installCommand: parsed.values["install-command"],
-        buildCommand: parsed.values["build-command"]
-    });
-    const release = await sources.importRelease({
-        sourceId: registration.source.id,
-        commitSha: parsed.values["commit-sha"] ?? null
-    });
-    let sourceRecord = registration.source;
-    let activated = null;
-    if (parsed.values.activate) {
-        sourceRecord = sources.approveSource({ sourceId: registration.source.id });
-        sources.approveRelease({ releaseId: release.id });
-        const result = await sources.activateRelease({ releaseId: release.id });
-        templateRegistry.registerRuntimeTemplate(result.template);
-        activated = result.release;
-    }
-    console.log(JSON.stringify({
-        source: sourceRecord,
-        registration_action: registration.action,
-        sync: registration.sync,
-        release,
-        activated_release: activated
-    }, null, 2));
-}
-async function runGenerateTemplateCommand(argv) {
-    const parsed = parseArgs({
-        args: argv,
-        options: {
-            "template-id": { type: "string" },
-            "slug-id": { type: "string" },
-            "template-dir": { type: "string" },
-            "project-name": { type: "string" },
-            "github-repo": { type: "string" },
-            "site-name": { type: "string" },
-            "link-to-original": { type: "string" },
-            "source-notes-path": { type: "string" },
-            "source-preview-dir": { type: "string" },
-            "dna-env-file": { type: "string", default: ".env" },
-            "dna-model": { type: "string" },
-            "skip-dna-analysis": { type: "boolean", default: false },
-            branch: { type: "string", default: "production" },
-            force: { type: "boolean", default: false }
-        }
-    });
-    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.");
-    }
-    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 (!input.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", "package-lock.json"].includes(name);
-        }
-    });
-    const projectName = input.projectName ?? toProjectName(destinationFolderName);
-    const compositionId = slugId.replace(/_/g, "-");
-    const siteName = input.siteName ?? compositionId;
-    const githubRepo = input.githubRepo ?? `mevdragon/${projectName}`;
-    rewriteTemplateStarter(destinationDir, [
-        ["mevdragon/vidfarm_template_0000", githubRepo],
-        ["vidfarm_template_0000", projectName],
-        ["vidfarm-template-0000", siteName],
-        ["template_0000", slugId],
-        ["template-0000", compositionId],
-        ["4c7a7e1a-7f35-4f30-9f86-9c8a63c7f2db", templateId],
-        ['"production"', JSON.stringify(input.branch ?? "production")]
-    ]);
-    const stagedInputs = stageTemplateDnaInputs({
-        templateDir: destinationDir,
-        sourceNotesPath: input.sourceNotesPath,
-        sourcePreviewDir: input.sourcePreviewDir
-    });
-    const moduleSync = syncTemplateDnaModule({
-        templateDir: destinationDir,
-        linkToOriginal: input.linkToOriginal
-    });
-    const dnaRuns = [];
-    if (!input.skipDnaAnalysis && hasTemplatePreviewMedia(destinationDir)) {
-        dnaRuns.push(await analyzeTemplateDna({
-            mode: "viral",
-            templateDir: destinationDir,
-            envFile: input.dnaEnvFile ?? ".env",
-            model: input.dnaModel,
-            linkToOriginal: input.linkToOriginal
-        }));
-        dnaRuns.push(await analyzeTemplateDna({
-            mode: "visual",
-            templateDir: destinationDir,
-            envFile: input.dnaEnvFile ?? ".env",
-            model: input.dnaModel,
-            linkToOriginal: input.linkToOriginal
-        }));
-    }
-    return {
-        template_id: templateId,
-        slug_id: slugId,
-        template_dir: destinationDir,
-        project_name: projectName,
-        github_repo: githubRepo,
-        site_name: siteName,
-        research: stagedInputs,
-        template_dna_module: moduleSync,
-        dna_analysis_runs: dnaRuns,
-        required_template_contract: {
-            template_fields: [
-                "id",
-                "slugId",
-                "version",
-                "about.title",
-                "about.description",
-                "about.difficulty",
-                "about.viral_dna",
-                "about.visual_dna",
-                "about.preview_media",
-                "about.link_to_original",
-                "about.links_to_inspiration",
-                "about.sound",
-                "about.sound.sound_title",
-                "about.sound.sound_url",
-                "about.proposal_generator",
-                "about.skeleton_prompt",
-                "about.sample_prompts",
-                "examples",
-                "configSchema",
-            ],
-            operation_fields: [
-                "operations.<name>.workflow",
-                "operations.<name>.smokeTestPayload",
-                "jobs.<workflow>",
-            ],
-            files: [
-                "src/template.ts",
-                "SKILL.md",
-            ],
-        },
-        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.",
-            "Verify AI calls use ctx.providers.* so the platform resolves an active customer provider key before generation. Operation payload provider fields must be optional explicit overrides, not z.enum(...).default(...), and parser helpers must not silently fall back to a provider the customer may not have.",
-            "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.`,
-        ],
-    };
+    throw new Error(`Unknown option before command: ${command}\n\n${HELP}`);
 }
-async function runAutocreateTemplateCommand(argv) {
+async function runEditCommand(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,
-        developer_skill_context: harnessSnapshot?.developer_skill_path ?? resolveDeveloperSkillPath(),
-        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) {
-    const input = parseProdTemplateCommandArgs(argv, {
-        envFile: ".env.production",
-        baseUrl: "https://vidfarm.cc",
-        activate: false
-    });
-    const registration = await registerSourceViaApi(input);
-    console.log(JSON.stringify({
-        mode: "prod-register-source",
-        base_url: input.baseUrl,
-        source: registration.source,
-        registration_action: registration.registration_action,
-        sync: registration.sync ?? null
-    }, null, 2));
-}
-async function runRegisterSourceHostedCommand(argv) {
-    const input = parseProdTemplateCommandArgs(argv, {
-        envFile: ".env",
-        baseUrl: process.env.VIDFARM_BASE_URL ?? "https://vidfarm.cc",
-        activate: false
-    });
-    const registration = await registerSourceViaApi(input);
-    console.log(JSON.stringify({
-        mode: "hosted-register-source",
-        base_url: input.baseUrl,
-        source: registration.source,
-        registration_action: registration.registration_action,
-        sync: registration.sync ?? null,
-        next_step: "Platform admin reviews the source, imports a release, approves it, and activates it."
-    }, null, 2));
-}
-async function runPublishUpdateHostedCommand(argv) {
-    const input = parseProdTemplateCommandArgs(argv, {
-        envFile: ".env",
-        baseUrl: process.env.VIDFARM_BASE_URL ?? "https://vidfarm.cc",
-        activate: false
-    });
-    if (!input.commitSha) {
-        throw new Error("publish-update-hosted requires --commit-sha.");
-    }
-    const registration = await registerSourceViaApi(input);
-    const artifact = await packageTemplateArtifact(input.repoDir, input.commitSha);
-    const presign = await postProdTemplateApi(input, `/api/v1/templates/sources/${registration.source.id}/artifacts/presign`, {
-        method: "POST",
-        body: JSON.stringify({
-            commit_sha: input.commitSha
-        })
-    });
-    await uploadArtifactArchive(presign, artifact.buffer);
-    const payload = await postProdTemplateApi(input, `/api/v1/templates/sources/${registration.source.id}/publish`, {
-        method: "POST",
-        body: JSON.stringify({
-            commit_sha: input.commitSha,
-            artifact_sha256: artifact.sha256
-        })
-    });
-    console.log(JSON.stringify({
-        mode: "hosted-publish-update",
-        base_url: input.baseUrl,
-        source: payload.source,
-        release: payload.release,
-        artifact: {
-            artifact_key: presign.artifact_key,
-            artifact_manifest_key: presign.artifact_manifest_key,
-            sha256: artifact.sha256
-        },
-        publish_action: payload.publish_action,
-        developer_handoff: payload.developer_handoff ?? null
-    }, null, 2));
-}
-async function runImportSourceProdCommand(argv) {
-    const input = parseProdTemplateCommandArgs(argv, {
-        envFile: ".env.production",
-        baseUrl: "https://vidfarm.cc",
-        activate: true
-    });
-    const result = await importSourceIntoProd(input);
-    console.log(JSON.stringify({
-        mode: "prod-import-source",
-        base_url: input.baseUrl,
-        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",
-        baseUrl: "https://vidfarm.cc",
-        stackName: "VidfarmProdStack",
-        activate: true
-    });
-    if (!input.stackName) {
-        throw new Error("deploy-template-cycle requires --stack-name.");
-    }
-    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,
-        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,
-        required_template_contract: {
-            template_fields: [
-                "id",
-                "slugId",
-                "version",
-                "about.title",
-                "about.description",
-                "about.difficulty",
-                "about.viral_dna",
-                "about.visual_dna",
-                "about.preview_media",
-                "about.link_to_original",
-                "about.links_to_inspiration",
-                "about.sound",
-                "about.sound.sound_title",
-                "about.sound.sound_url",
-                "about.proposal_generator",
-                "about.skeleton_prompt",
-                "about.sample_prompts",
-                "examples",
-                "configSchema",
-            ],
-            operation_fields: [
-                "operations.<name>.workflow",
-                "operations.<name>.smokeTestPayload",
-                "jobs.<workflow>",
-            ],
-            files: [
-                "src/template.ts",
-                "SKILL.md",
-            ],
-        },
-        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, 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));
-}
-async function runAnalyzeTemplateDnaCommand(mode, argv) {
-    const parsed = parseArgs({
-        args: argv,
-        options: {
-            "template-dir": { type: "string", default: "." },
-            "env-file": { type: "string", default: ".env" },
-            model: { type: "string" },
-            "notes-path": { type: "string" },
-            "preview-dir": { type: "string" },
-            "output-path": { type: "string" },
-            "link-to-original": { type: "string" },
-            "sync-template-module": { type: "boolean", default: true }
-        }
-    });
-    const result = await analyzeTemplateDna({
-        mode,
-        templateDir: parsed.values["template-dir"],
-        envFile: parsed.values["env-file"],
-        model: parsed.values.model,
-        notesPath: parsed.values["notes-path"],
-        previewDir: parsed.values["preview-dir"],
-        outputPath: parsed.values["output-path"],
-        linkToOriginal: parsed.values["link-to-original"],
-        syncTemplateModule: parsed.values["sync-template-module"]
-    });
-    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" },
+            port: { type: "string", default: String(DEFAULT_PORT) },
+            dir: { type: "string" },
+            host: { type: "string", default: DEFAULT_HOST },
+            fork: { type: "string" },
             "api-key": { type: "string" },
-            "env-file": { type: "string", default: ".env" }
+            share: { type: "string" },
+            refetch: { type: "boolean", default: false }
         }
     });
-    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 templateId = parsed.positionals[0];
+    if (!templateId) {
+        throw new Error(`edit requires a template id.\n\n${HELP}`);
     }
-    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 port = Number(parsed.values.port);
+    if (!Number.isFinite(port) || port <= 0) {
+        throw new Error(`Invalid --port: ${parsed.values.port}`);
     }
-    const contentType = parsed.values["content-type"]
-        ?? inferUploadContentType(fileName);
-    const baseUrl = normalizeBaseUrl(parsed.values["base-url"] ?? process.env.VIDFARM_BASE_URL ?? "https://vidfarm.cc");
+    const host = trimTrailingSlash(parsed.values.host);
     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}.`);
-    }
-    let uploadResult = null;
-    if (filePath) {
-        const body = readFileSync(filePath);
-        const uploadResponse = await fetch(String(payload.upload?.url), {
-            method: String(payload.upload?.method ?? "PUT"),
-            headers: payload.upload?.headers,
-            body
-        });
-        if (!uploadResponse.ok) {
-            const errorText = await uploadResponse.text().catch(() => "");
-            throw new Error(`Preview-media upload failed with ${uploadResponse.status}${errorText ? `: ${errorText}` : "."}`);
+    const shareToken = parsed.values.share;
+    const rootDir = path.resolve(process.cwd(), parsed.values.dir ?? path.join(".vidfarm", templateId));
+    mkdirSync(rootDir, { recursive: true });
+    const forkId = parsed.values.fork ?? await resolveForkId({ host, templateId, apiKey, shareToken });
+    if (!forkId) {
+        throw new Error(`Could not resolve a fork id for template ${templateId}. Pass --fork <id>, or open ${host}/editor/${templateId} once so a fork is created.`);
+    }
+    await fetchCompositionFiles({
+        host,
+        forkId,
+        dir: rootDir,
+        apiKey,
+        shareToken,
+        refetch: parsed.values.refetch
+    });
+    const devSource = `http://localhost:${port}`;
+    const editorUrl = `${host}/editor/${encodeURIComponent(templateId)}?fork=${encodeURIComponent(forkId)}&dev=${encodeURIComponent(devSource)}`;
+    printEditorBanner({ templateId, forkId, dir: rootDir, port, editorUrl });
+    const { runDevServeCommand } = await import("./dev-serve.js");
+    await runDevServeCommand(["--dir", rootDir, "--port", String(port)]);
+}
+async function resolveForkId(input) {
+    // /editor/<template_id> issues a 302 → /editor/<template_id>?fork=<id>
+    // whenever the caller (or the template's default fork) has one. Follow the
+    // redirect once by hand so we can read the fork id off the query string.
+    const url = `${input.host}/editor/${encodeURIComponent(input.templateId)}`;
+    const res = await fetch(url, {
+        method: "GET",
+        redirect: "manual",
+        headers: buildAuthHeaders(input)
+    });
+    if (res.status >= 300 && res.status < 400) {
+        const location = res.headers.get("location");
+        if (location) {
+            try {
+                const target = new URL(location, input.host);
+                const fork = target.searchParams.get("fork");
+                if (fork)
+                    return fork;
+            }
+            catch {
+                // fall through
+            }
         }
-        uploadResult = {
-            uploaded: true,
-            size_bytes: statSync(filePath).size,
-            method: payload.upload?.method ?? "PUT",
-            status: uploadResponse.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,
-        public_url: payload.public_url ?? payload.preview_media_url,
-        upload_result: uploadResult,
-        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,
-        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,
-        starter_style_options: {
-            caption_standard_version: CAPTION_STANDARD_VERSION,
-            fonts: STARTER_TEMPLATE_FONT_OPTIONS,
-            text_background_colors: STARTER_TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS,
-            text_background_rendering: TIKTOK_TEXT_BACKGROUND_RENDERING,
-            caption_shadows: TIKTOK_CAPTION_SHADOWS,
-            caption_rendering_rules: TIKTOK_CAPTION_RENDERING_RULES,
-            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,
-            "content-type": "application/json"
-        },
-        curl_example: [
-            `curl -X POST ${session.baseUrl}/api/v1/primitives/image/operations/run \\`,
-            `  -H 'vidfarm-api-key: ${session.apiKey}' \\`,
-            "  -H 'content-type: application/json' \\",
-            "  -d '{\"tracer\":\"local-test\",\"payload\":{\"prompt\":\"a cinematic founder at a desk\",\"width\":1080,\"height\":1920}}'"
-        ].join("\n")
-    }, null, 2));
+    return null;
 }
-async 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 = await input.providerKeys.listProviderKeys(input.customerId);
-    for (const entry of entries) {
-        const secret = entry.secret || (input.allowMockPlaceholders ? entry.placeholder : "");
-        if (!secret) {
+async function fetchCompositionFiles(input) {
+    const files = ["composition.html", "composition.json", "manifest.json"];
+    for (const filename of files) {
+        const target = path.join(input.dir, filename);
+        if (existsSync(target) && !input.refetch) {
+            console.log(`[vidfarm] keep local ${filename} (use --refetch to overwrite)`);
             continue;
         }
-        const alreadySeeded = existing.some((row) => row.provider === entry.provider && row.label === "Local CLI env key");
-        if (alreadySeeded) {
+        const url = `${input.host}/api/v1/compositions/${encodeURIComponent(input.forkId)}/${filename}`;
+        const res = await fetch(url, { headers: buildAuthHeaders(input) });
+        if (!res.ok) {
+            console.warn(`[vidfarm] skip ${filename}: ${res.status} ${res.statusText} (${url})`);
             continue;
         }
-        await input.providerKeys.createProviderKey({
-            id: input.createId("pkey"),
-            customerId: input.customerId,
-            provider: entry.provider,
-            label: "Local CLI env key",
-            encryptedSecret: input.encryptString(secret, input.encryptionSecret)
-        });
+        const body = Buffer.from(await res.arrayBuffer());
+        writeFileSync(target, body);
+        console.log(`[vidfarm] fetched ${filename} (${body.length} bytes)`);
     }
 }
-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-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("Runtime state: DynamoDB-backed services");
-    console.log(`AI mode: ${input.mockProviders ? "mock provider responses" : "real provider env keys"}`);
+function buildAuthHeaders(input) {
+    const headers = { accept: "text/html,application/json" };
+    if (input.apiKey)
+        headers.authorization = `Bearer ${input.apiKey}`;
+    if (input.shareToken)
+        headers["x-vidfarm-share-token"] = input.shareToken;
+    return headers;
+}
+function printEditorBanner(input) {
+    const bold = "\x1b[1m";
+    const green = "\x1b[32m";
+    const cyan = "\x1b[36m";
+    const dim = "\x1b[2m";
+    const reset = "\x1b[0m";
+    const line = `${dim}${"─".repeat(74)}${reset}`;
     console.log("");
-    console.log("REST API:");
-    console.log(`  ${input.baseUrl}/health`);
-    console.log(`  ${input.baseUrl}/dev`);
+    console.log(line);
+    console.log(`${bold}${green}  Vidfarm local editor${reset}`);
+    console.log(line);
+    console.log(`  template    ${input.templateId}`);
+    console.log(`  fork        ${input.forkId}`);
+    console.log(`  local dir   ${input.dir}`);
+    console.log(`  dev-serve   http://localhost:${input.port}`);
     console.log("");
-    console.log("Get reusable auth headers:");
-    console.log("  vidfarm session");
+    console.log(`  ${bold}Open in browser:${reset}`);
+    console.log(`  ${cyan}${input.editorUrl}${reset}`);
+    console.log(line);
     console.log("");
 }
-function rewriteTemplateStarter(root, replacements) {
-    for (const entry of readdirSync(root, { withFileTypes: true })) {
-        const target = path.join(root, entry.name);
-        if (entry.name === ".git" || entry.name === "node_modules" || entry.name === "dist") {
-            continue;
-        }
-        if (entry.isDirectory()) {
-            rewriteTemplateStarter(target, replacements);
-            continue;
-        }
-        const original = readFileSync(target, "utf8");
-        const next = replacements.reduce((value, [from, to]) => value.split(from).join(to), original);
-        if (next !== original) {
-            writeFileSync(target, next);
-        }
-    }
-}
-function toProjectName(folderName) {
-    return folderName
-        .replace(/[^a-zA-Z0-9_-]+/g, "_")
-        .replace(/-+/g, "_")
-        .replace(/^_+|_+$/g, "")
-        .toLowerCase();
-}
-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, "..", "demos", "vidfarm_template_0000"),
-        path.resolve(import.meta.dirname, "..", "..", "demos", "vidfarm_template_0000")
-    ];
-    for (const candidate of candidates) {
-        if (existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    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 resolveDeveloperSkillPath() {
-    const candidates = [
-        path.resolve(process.cwd(), "SKILL.platform.md"),
-        path.resolve(import.meta.dirname, "..", "SKILL.platform.md"),
-        path.resolve(import.meta.dirname, "..", "..", "SKILL.platform.md")
-    ];
-    for (const candidate of candidates) {
-        if (existsSync(candidate)) {
-            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));
-        }
-    }
-    const developerSkillPath = resolveDeveloperSkillPath();
-    const developerSkillDestination = path.join(destinationDir, "SKILL.platform.md");
-    if (existsSync(developerSkillPath)) {
-        cpSync(developerSkillPath, developerSkillDestination);
-    }
-    return {
-        harness_dir: destinationDir,
-        entry: path.join(destinationDir, "AUTO_CREATE_TEMPLATES.md"),
-        developer_skill_path: existsSync(developerSkillDestination)
-            ? developerSkillDestination
-            : developerSkillPath
-    };
-}
-function renderAutocreateAgentPrompt(manifest) {
-    return [
-        "# Vidfarm Autocreate Template Handoff",
-        "",
-        "Cacheable context, read first and keep before run-specific artifacts in your working context:",
-        "",
-        `1. Developer standard: ${manifest.developer_skill_context}`,
-        `2. Auto-create harness: ${manifest.harness_snapshot?.entry ?? manifest.harness_entry}`,
-        manifest.harness_snapshot?.harness_dir
-            ? `3. Harness snapshot directory: ${manifest.harness_snapshot.harness_dir}`
-            : "3. Harness snapshot directory: not created; use the live harness path above.",
-        "",
-        "These files are stable across runs and are intended to be prompt-cache friendly. Read them before loading source media, analyzer outputs, or run-specific JSON.",
-        "",
-        `Use ${manifest.harness_snapshot?.entry ?? manifest.harness_entry} as the harness.`,
-        `Use ${manifest.developer_skill_context} as the developer template standard context.`,
-        `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. Validate storage boundaries: use only `ctx.storage` with job-relative keys; do not generate direct AWS/S3 clients, generic `AWS_*` credential handling, `REMOTION_AWS_*` handling, or absolute keys like `templates/${templateId}/users/${ctx.customer.id}/...`.",
-        "9. 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,
-        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" },
-            "repo-dir": { type: "string", default: "." },
-            "env-file": { type: "string", default: defaults.envFile },
-            "base-url": { type: "string", default: defaults.baseUrl },
-            "api-key": { type: "string" },
-            "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);
-    loadEnvFile(parsed.values["env-file"]);
-    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 the selected env file.");
-    }
-    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,
-        repoDir: path.resolve(process.cwd(), parsed.values["repo-dir"]),
-        envFile: parsed.values["env-file"],
-        baseUrl: normalizeBaseUrl(parsed.values["base-url"]),
-        apiKey,
-        stackName: parsed.values["stack-name"] || undefined,
-        activate: defaults.activate
-    };
-}
-async function importSourceIntoProd(input) {
-    const registration = await registerSourceViaApi(input);
-    const source = await postProdTemplateApi(input, `/api/v1/templates/sources/${registration.source.id}/approve`, { method: "POST" });
-    const releaseResponse = await postProdTemplateApi(input, `/api/v1/templates/sources/${registration.source.id}/import`, {
-        method: "POST",
-        body: JSON.stringify({
-            commit_sha: input.commitSha ?? undefined
-        })
-    });
-    const approvedRelease = await postProdTemplateApi(input, `/api/v1/templates/releases/${releaseResponse.release.id}/approve`, { method: "POST" });
-    const activatedRelease = input.activate
-        ? await postProdTemplateApi(input, `/api/v1/templates/releases/${releaseResponse.release.id}/activate`, { method: "POST" })
-        : null;
-    return {
-        payload: {
-            source: source.source,
-            release: approvedRelease.release,
-            activated_release: activatedRelease?.release ?? null
-        }
-    };
-}
-async function registerSourceViaApi(input) {
-    return postProdTemplateApi(input, "/api/v1/templates/sources", {
-        method: "POST",
-        body: JSON.stringify({
-            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
-        })
-    });
-}
-async function postProdTemplateApi(input, pathname, init) {
-    const response = await fetch(`${input.baseUrl}${pathname}`, {
-        ...init,
-        headers: {
-            "content-type": "application/json",
-            "vidfarm-api-key": input.apiKey,
-            ...(init.headers ?? {})
-        }
-    });
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok) {
-        throw new Error(typeof payload.error === "string" ? payload.error : `Request failed with ${response.status}.`);
-    }
-    return payload;
-}
-async function packageTemplateArtifact(repoDir, commitSha) {
-    const tempDir = mkdtempSync(path.join(os.tmpdir(), "vidfarm-template-artifact-"));
-    const repoRoot = (await execFileAsync("git", ["-C", repoDir, "rev-parse", "--show-toplevel"])).stdout.trim();
-    const artifactPath = path.join(tempDir, "template-source.tar.gz");
-    try {
-        await execFileAsync("git", ["-C", repoRoot, "archive", "--format=tar.gz", `--output=${artifactPath}`, commitSha], {
-            cwd: repoRoot
-        });
-        const buffer = readFileSync(artifactPath);
-        return {
-            buffer,
-            sha256: createHash("sha256").update(buffer).digest("hex")
-        };
-    }
-    finally {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-}
-async function uploadArtifactArchive(presign, buffer) {
-    const response = await fetch(presign.upload.url, {
-        method: presign.upload.method,
-        headers: presign.upload.headers,
-        body: new Uint8Array(buffer)
-    });
-    if (!response.ok) {
-        const body = await response.text().catch(() => "");
-        throw new Error(body || `Artifact upload failed with ${response.status}.`);
-    }
-}
-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) {
+function trimTrailingSlash(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";
-    }
-}
-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));
-}
 //# sourceMappingURL=cli.js.map