@mevdragon/vidfarm-devcli 0.5.3 → 0.7.0

package/dist/src/cli.js

@@ -43,6 +43,11 @@ Local editor loop:
   serve [template_id] [opts]  Boot the FULL editor locally (single origin, disk-backed).
                               Records + storage run on disk; render runs in-process on
                               this box for FREE (no cloud, no wallet charge).
+                              /discover and /library still list the CLOUD catalog —
+                              opening a cloud template seeds it onto local disk, and
+                              the editor's Render button can hand off to the cloud
+                              renderer (needs the cloud --api-key). Only the editor
+                              and its data are local.
                               With a template_id or --fork, pulls that composition
                               (or the template's default/shared decomposition) from
                               the cloud host onto local disk to edit offline.
@@ -51,8 +56,9 @@ Local editor loop:
     --key <api-key>           Bootstrap/browser key (default: VIDFARM_API_KEY or a dev key)
     --fork <id>               Pull + open a specific cloud fork
     --host <url>              Cloud host to pull from (default: ${DEFAULT_HOST})
-    --api-key <key>           Cloud key for the pull (default: VIDFARM_API_KEY)
+    --api-key <key>           Cloud key for pulls/library/cloud render (default: VIDFARM_API_KEY)
     --refetch                 Overwrite local composition with the cloud copy
+    --no-cloud                Fully local: no cloud catalog, seeding, or cloud render
     --no-open                 Don't auto-open the browser
   <template_id> [opts]      Alias for 'serve <template_id>' (boot the local editor)
   publish [template_id]     Push local composition.html/json to your fork  → PUT/PATCH composition + POST versions
@@ -104,8 +110,9 @@ Generate AI media and drop it on the timeline (for local coding agents):
     --track <n>             Timeline layer index (auto if omitted)
     --x --y --width --height   Geometry as % (default full canvas 0/0/100/100)
     --object-fit <fit>      cover|contain|fill|none|scale-down (default cover)
-  ghostcut <forkId>         Read the two video sources: original vs      → GET  .../compositions/:forkId/ghostcut
-                            decomposed (caption-free), non-billing
+  remove-video-captions <forkId>   Read the two video sources:        → GET  .../compositions/:forkId/remove-video-captions
+                            original vs decomposed (caption-free),
+                            non-billing (alias: ghostcut)
   versions <forkId>         List immutable version snapshots             → GET  .../compositions/:forkId/versions
   snapshot <forkId>         Save the working state as a new version      → POST .../compositions/:forkId/versions
   render <forkId>           Render the fork to MP4 (--wait to poll)      → POST .../compositions/:forkId/render
@@ -244,8 +251,9 @@ async function main() {
         case "decompose":
             await runDecomposeCommand(rest);
             return;
+        case "remove-video-captions":
         case "ghostcut":
-            await runGhostcutCommand(rest);
+            await runRemoveVideoCaptionsCommand(rest);
             return;
         case "versions":
             await runVersionsCommand(rest);
@@ -454,7 +462,10 @@ async function runServeCommand(argv) {
             share: { type: "string" },
             refetch: { type: "boolean", default: false },
             open: { type: "boolean", default: true },
-            "no-open": { type: "boolean", default: false }
+            "no-open": { type: "boolean", default: false },
+            // Disable the cloud passthrough entirely: /discover and /library list
+            // only local data and the editor offers no "Render in Cloud".
+            "no-cloud": { type: "boolean", default: false }
         }
     });
     const port = Number(parsed.values.port);
@@ -476,16 +487,27 @@ async function runServeCommand(argv) {
     const templateId = parsed.positionals[0];
     const forkFlag = parsed.values.fork;
     // Env MUST be set before importing runtime — config.ts reads it at module
-    // load. Force the fully-local drivers; keep any cloud creds already present
-    // in the environment so render passthrough still works.
+    // load. Force the fully-local drivers.
     process.env.RECORDS_DRIVER = "local";
     process.env.STORAGE_DRIVER = "local";
     process.env.AWS_S3_BUCKET = "";
+    // A dev-shell .env can carry the staging Step Functions ARN, which would
+    // silently route this box's renders to the cloud state machine. serve is
+    // local-render by definition — cloud rendering is the EXPLICIT
+    // render_target="cloud" upstream handoff (the editor's "Render in Cloud").
+    process.env.VIDFARM_JOB_STATE_MACHINE_ARN = "";
     process.env.VIDFARM_DATA_DIR = dataDir;
     process.env.VIDFARM_API_KEY = apiKey;
     process.env.PORT = String(port);
     if (!process.env.NODE_ENV)
         process.env.NODE_ENV = "development";
+    // Cloud passthrough: only the editor is local — /discover and /library keep
+    // listing the upstream (cloud) catalog, templates seed onto disk on demand,
+    // and the editor's Render button can hand off to the cloud renderer. The
+    // upstream key is the AMBIENT cloud key (never the local bootstrap key).
+    const cloudEnabled = !parsed.values["no-cloud"];
+    process.env.VIDFARM_UPSTREAM_HOST = cloudEnabled ? host : "";
+    process.env.VIDFARM_UPSTREAM_API_KEY = cloudEnabled ? (cloudApiKey ?? "") : "";
     const { startRuntime } = await import("./runtime.js");
     await startRuntime();
     // If a template/fork was requested, pull its composition from the cloud host
@@ -493,13 +515,14 @@ async function runServeCommand(argv) {
     // resolves it. Best-effort: a failure just drops us to /discover.
     let openTemplateId = templateId;
     let openForkId = forkFlag;
-    if (templateId || forkFlag) {
+    if ((templateId || forkFlag) && !cloudEnabled) {
+        console.warn("[vidfarm] serve: --no-cloud set — skipping cloud seed of the requested template/fork.");
+    }
+    else if (templateId || forkFlag) {
         try {
             const seeded = await seedForkFromCloud({
-                host,
                 templateId,
                 forkId: forkFlag,
-                cloudApiKey,
                 shareToken: parsed.values.share,
                 bootstrapKey: apiKey,
                 refetch: parsed.values.refetch
@@ -518,105 +541,45 @@ async function runServeCommand(argv) {
         ? `/editor/${encodeURIComponent(openTemplateId)}${openForkId ? `?fork=${encodeURIComponent(openForkId)}` : ""}`
         : "/discover";
     const openUrl = `${base}/auto-login?api_key=${encodeURIComponent(apiKey)}&redirect=${encodeURIComponent(editorPath)}`;
-    printServeBanner({ base, dataDir, openUrl, editorPath });
+    printServeBanner({ base, dataDir, openUrl, editorPath, cloud: cloudEnabled ? { host, hasKey: Boolean(cloudApiKey) } : null });
     const shouldOpen = parsed.values.open && !parsed.values["no-open"];
     if (shouldOpen)
         openInBrowser(openUrl);
     // startRuntime() keeps the process alive via its HTTP server; nothing else to do.
 }
 // Pull a cloud fork's composition onto local disk and create the local
-// template + fork records so the editor resolves it. The fork is either an
-// explicit --fork or the template's default fork (which may be another user's
-// public decomposition). Media stays on cloud URLs — only the composition +
-// records are localized. Runs in-process after startRuntime(), so it shares the
-// server's disk-backed records/storage singletons.
+// template + fork records so the editor resolves it. Thin wrapper over
+// services/upstream.ts seedFromUpstream (which reads VIDFARM_UPSTREAM_HOST/
+// _API_KEY — set above from --host/--api-key). Runs in-process after
+// startRuntime(), so it shares the server's disk-backed records/storage.
 async function seedForkFromCloud(input) {
-    const { serverlessRecords } = await import("./services/serverless-records.js");
-    const { StorageService } = await import("./services/storage.js");
     const { ServerlessAuthService } = await import("./services/serverless-auth.js");
-    const storage = new StorageService();
-    const auth = new ServerlessAuthService();
+    const { seedFromUpstream } = await import("./services/upstream.js");
     // Ensure the local bootstrap customer exists and grab its id to own the seed.
-    const customer = await auth.authenticate(input.bootstrapKey);
-    const authHeaders = buildAuthHeaders({ apiKey: input.cloudApiKey, shareToken: input.shareToken });
-    // 1. Resolve the source fork: explicit --fork wins, else the template's
-    //    default fork (grabs the shared decomposition even if another user owns it).
-    let cloudForkId = input.forkId ?? null;
-    if (!cloudForkId && input.templateId) {
-        cloudForkId = await resolveForkId({ host: input.host, templateId: input.templateId, apiKey: input.cloudApiKey, shareToken: input.shareToken });
-    }
-    if (!cloudForkId) {
-        console.warn("[vidfarm] serve: no --fork and no default fork resolvable from cloud; starting empty.");
-        return null;
-    }
-    // 2. Read the serialized fork for its template id + title.
-    const forkMetaRes = await fetch(`${input.host}/api/v1/compositions/${encodeURIComponent(cloudForkId)}`, { headers: authHeaders });
-    const forkMeta = forkMetaRes.ok ? (await forkMetaRes.json().catch(() => null)) : null;
-    const templateId = input.templateId ?? (typeof forkMeta?.template_id === "string" ? forkMeta.template_id : null);
-    if (!templateId || !templateId.startsWith("template_")) {
-        console.warn(`[vidfarm] serve: could not determine a template id for fork ${cloudForkId}; starting empty.`);
-        return null;
-    }
-    const title = (typeof forkMeta?.title === "string" && forkMeta.title) || `Local · ${templateId}`;
-    // 3. Materialize the local template record (the editor 404s without it).
-    const existingTemplate = await serverlessRecords.getTemplate(templateId);
-    if (!existingTemplate) {
-        await serverlessRecords.createTemplate({
-            id: templateId,
-            inspirationId: `local:${templateId}`,
-            customerId: customer.id,
-            originalUrl: typeof forkMeta?.original_url === "string" ? forkMeta.original_url : "",
-            sourceHost: "local",
-            title,
-            visibility: "public"
-        });
-    }
-    // 4. Materialize the local fork (reuse the cloud id for stable URLs).
-    const localForkId = cloudForkId;
-    const existingFork = await serverlessRecords.getCompositionFork(localForkId);
-    if (!existingFork) {
-        await serverlessRecords.createCompositionFork({
-            id: localForkId,
-            customerId: customer.id,
-            templateId,
-            title,
-            visibility: "private"
-        });
-    }
-    // 5. Pull composition.html/json onto disk (skip if present unless --refetch,
-    //    so local edits aren't clobbered on re-serve).
-    const htmlKey = storage.compositionForkWorkingKey(localForkId, "composition.html");
-    const jsonKey = storage.compositionForkWorkingKey(localForkId, "composition.json");
-    const hasLocalHtml = Boolean(await storage.readText(htmlKey));
-    if (!hasLocalHtml || input.refetch) {
-        const htmlRes = await fetch(`${input.host}/api/v1/compositions/${encodeURIComponent(cloudForkId)}/composition.html`, { headers: authHeaders });
-        if (!htmlRes.ok) {
-            console.warn(`[vidfarm] serve: could not fetch composition.html for ${cloudForkId} (${htmlRes.status}); starting empty.`);
-            return null;
-        }
-        await storage.putText(htmlKey, await htmlRes.text(), "text/html; charset=utf-8");
-        const jsonRes = await fetch(`${input.host}/api/v1/compositions/${encodeURIComponent(cloudForkId)}/composition.json`, { headers: authHeaders });
-        if (jsonRes.ok)
-            await storage.putBuffer(jsonKey, Buffer.from(await jsonRes.text(), "utf8"), "application/json");
-        console.log(`[vidfarm] seeded fork ${localForkId} from ${input.host}`);
-    }
-    else {
-        console.log(`[vidfarm] fork ${localForkId} already local (use --refetch to overwrite)`);
-    }
-    // 6. Point the template's default fork at the local copy so a bare
-    //    /editor/:templateId resolves it too.
-    await serverlessRecords.stampDefaultForkIfUnset({ templateId, forkId: localForkId });
-    return { templateId, forkId: localForkId };
+    const customer = await new ServerlessAuthService().authenticate(input.bootstrapKey);
+    return seedFromUpstream({
+        customerId: customer.id,
+        templateId: input.templateId,
+        forkId: input.forkId,
+        shareToken: input.shareToken,
+        refetch: input.refetch
+    });
 }
 function printServeBanner(input) {
     const line = `${DIM}${"─".repeat(74)}${RESET}`;
     console.log("");
     console.log(line);
-    console.log(`${BOLD}${GREEN}  Vidfarm local server${RESET}  ${DIM}(fully local — records + storage on disk)${RESET}`);
+    console.log(`${BOLD}${GREEN}  Vidfarm local server${RESET}  ${DIM}(local editor — records + storage on disk)${RESET}`);
     console.log(line);
     console.log(`  server      ${input.base}`);
     console.log(`  data dir    ${input.dataDir}`);
-    console.log(`  render      ${DIM}cloud (submitted to the deployed renderer)${RESET}`);
+    console.log(`  render      ${DIM}local (in-process HyperFrames render — free, no cloud charge)${RESET}`);
+    if (input.cloud) {
+        console.log(`  cloud       ${input.cloud.host} ${DIM}(/discover + /library list the cloud catalog; templates seed locally on open${input.cloud.hasKey ? "; Render can hand off to the cloud renderer" : "; set VIDFARM_API_KEY for /library + cloud render"})${RESET}`);
+    }
+    else {
+        console.log(`  cloud       ${DIM}off (--no-cloud) — local data only${RESET}`);
+    }
     console.log("");
     console.log(`  ${DIM}Agents: edit composition files under ${input.dataDir}/storage — the`);
     console.log(`  browser live-reloads on save. Multiple forks can be edited at once.${RESET}`);
@@ -1249,18 +1212,18 @@ async function runDecomposeCommand(argv) {
     });
     assertApiOk(result, "decompose");
     if (!ctx.json && result.json?.ghostcut_pending) {
-        console.log(`${DIM}GhostCut subtitle-removal is running in the background — poll \`vidfarm api POST /api/v1/compositions/${forkId}/ghostcut-poll\` or GET .../ghostcut until done.${RESET}`);
+        console.log(`${DIM}Subtitle removal (GhostCut) is running in the background — poll \`vidfarm api POST /api/v1/compositions/${forkId}/remove-video-captions-poll\` or GET .../remove-video-captions until done.${RESET}`);
     }
     emitResult(result, ctx.json);
 }
-async function runGhostcutCommand(argv) {
+async function runRemoveVideoCaptionsCommand(argv) {
     const parsed = parseArgs({ args: argv, allowPositionals: true, options: commonOptions() });
     const forkId = parsed.positionals[0];
     if (!forkId)
-        throw new Error("ghostcut requires a fork id.");
+        throw new Error("remove-video-captions requires a fork id.");
     const ctx = commonContext(parsed.values);
-    const result = await apiRequest({ method: "GET", host: ctx.host, path: `/api/v1/compositions/${encodeURIComponent(forkId)}/ghostcut`, auth: ctx.auth });
-    assertApiOk(result, "ghostcut");
+    const result = await apiRequest({ method: "GET", host: ctx.host, path: `/api/v1/compositions/${encodeURIComponent(forkId)}/remove-video-captions`, auth: ctx.auth });
+    assertApiOk(result, "remove-video-captions");
     emitResult(result, ctx.json);
 }
 async function runVersionsCommand(argv) {