@flatkey-ai/cli 0.1.17 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flatkey-ai/cli",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "Flatkey media generation CLI for image, video, audio, credits, status, and models.",
   "type": "module",
   "bin": {

package/src/api.js

@@ -43,6 +43,10 @@ export function generateVideo(options) {
   return requestJsonFromPlan(options, planVideoRequest(options));
 }
 
+export function getVideo(options, taskId) {
+  return requestJsonFromPlan(options, planVideoStatusRequest(options, taskId));
+}
+
 export function planVideoRequest(options) {
   const model = options.model ?? "seedance-2.0-pro";
   const imageUrls = [
@@ -84,6 +88,10 @@ export function planVideoRequest(options) {
   return planJsonPost(options, "/v1/video/generations", basePayload);
 }
 
+export function planVideoStatusRequest(options, taskId) {
+  return planRequest(options, `/v1/videos/${encodeURIComponent(taskId)}`);
+}
+
 export function generateAudio(options) {
   return requestBinaryArtifactFromPlan(options, planAudioRequest(options));
 }

package/src/artifacts.js

@@ -47,7 +47,7 @@ function expandHomePath(path) {
 }
 
 async function persistItem({ kind, item, outDir, output, index, fetchImpl }) {
-  const dataUrl = getString(item, ["url", "data_url", "dataUrl"]);
+  const dataUrl = getString(item, ["url", "video_url", "data_url", "dataUrl"]);
   if (dataUrl?.startsWith("data:")) {
     const parsed = parseDataUrl(dataUrl);
     const path = artifactPath({ kind, outDir, output, index, extension: parsed.extension });
@@ -90,15 +90,20 @@ async function downloadArtifact({ url, path, fetchImpl }) {
 function extractItems(response) {
   if (Array.isArray(response?.data)) return response.data;
   if (Array.isArray(response?.artifacts)) return response.artifacts;
+  if (Array.isArray(response?.content)) return response.content;
   if (Array.isArray(response?.candidates)) {
     return response.candidates.flatMap((candidate) => candidate.content?.parts ?? []);
   }
+  if (typeof response?.metadata?.url === "string") return [{ url: response.metadata.url }];
+  if (typeof response?.url === "string") return [response];
+  if (typeof response?.video_url?.url === "string") return [{ url: response.video_url.url }];
   return [];
 }
 
 function getString(item, keys) {
   for (const key of keys) {
     if (typeof item?.[key] === "string") return item[key];
+    if (typeof item?.[key]?.url === "string") return item[key].url;
     if (typeof item?.inlineData?.[key] === "string") return item.inlineData[key];
     if (typeof item?.inline_data?.[key] === "string") return item.inline_data[key];
   }

package/src/cli.js

@@ -403,6 +403,7 @@ async function handleGenerate(command, deps) {
     generateImage,
     generateText,
     generateVideo,
+    getVideo,
     planAudioMusicRequest,
     planAudioRequest,
     planAudioSfxRequest,
@@ -428,6 +429,7 @@ async function handleGenerate(command, deps) {
     ...command.options,
     apiKey,
     baseUrl: routerOrigin,
+    env: deps.env ?? process.env,
     fetch: deps.fetch,
   };
   if (command.options.dry_run) {
@@ -461,6 +463,9 @@ async function handleGenerate(command, deps) {
               ? await generateAudioMusic(options)
               : await generateAudio(options)
           : await generateText(options);
+    const artifactResponse = command.group === "video"
+      ? await waitForVideoResult(response, { ...options, getVideo, sleep: deps.sleep })
+      : response;
     if (command.group === "text") {
       const text = extractText(response);
       const output = await writeTextOutput(text, command.options.output);
@@ -468,17 +473,75 @@ async function handleGenerate(command, deps) {
     }
     const artifacts = await persistArtifacts({
       kind: command.group,
-      response,
+      response: artifactResponse,
       outDir: command.options.out ?? "flatkey-output",
       output: command.options.output,
       fetch: deps.fetch,
     });
-    return { kind: command.group, artifacts, response: scrubArtifactResponse(response) };
+    return { kind: command.group, artifacts, response: scrubArtifactResponse(artifactResponse) };
   } finally {
     animation.stop();
   }
 }
 
+async function waitForVideoResult(response, options) {
+  if (hasArtifact(response)) return response;
+  const taskId = videoTaskId(response);
+  if (!taskId) return response;
+
+  const timeoutMs = parsePositiveInteger(
+    options.video_wait_timeout_ms ?? options.env?.FLATKEY_VIDEO_WAIT_TIMEOUT_MS,
+    600_000,
+  );
+  const intervalMs = parsePositiveInteger(
+    options.video_poll_interval_ms ?? options.env?.FLATKEY_VIDEO_POLL_INTERVAL_MS,
+    5_000,
+  );
+  const deadline = Date.now() + timeoutMs;
+  let last = response;
+
+  while (Date.now() <= deadline) {
+    last = await options.getVideo(options, taskId);
+    if (hasArtifact(last) || isVideoDone(last)) return last;
+    if (isVideoFailed(last)) {
+      const message = last?.error?.message ?? last?.message ?? `Video generation failed: ${taskId}`;
+      throw new Error(message);
+    }
+    await delay(intervalMs, { sleep: options.sleep });
+  }
+
+  throw new Error(`Video task still processing after ${Math.round(timeoutMs / 1000)}s: ${taskId}`);
+}
+
+function hasArtifact(response) {
+  return Boolean(
+    response?.metadata?.url
+      || response?.url
+      || response?.video_url?.url
+      || response?.data?.some?.((item) => item?.url || item?.b64_json || item?.base64 || item?.data)
+      || response?.artifacts?.some?.((item) => item?.url || item?.path)
+      || response?.content?.some?.((item) => item?.url || item?.video_url?.url || item?.data_url || item?.b64_json || item?.base64 || item?.data),
+  );
+}
+
+function videoTaskId(response) {
+  return firstNonEmpty(response?.id, response?.task_id, response?.taskId, response?.data?.id, response?.data?.task_id);
+}
+
+function isVideoDone(response) {
+  return ["completed", "succeeded", "success"].includes(String(response?.status ?? "").toLowerCase());
+}
+
+function isVideoFailed(response) {
+  return ["failed", "failure", "cancelled", "canceled"].includes(String(response?.status ?? "").toLowerCase())
+    || Boolean(response?.error);
+}
+
+function parsePositiveInteger(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 function scrubArtifactResponse(value) {
   if (Array.isArray(value)) return value.map(scrubArtifactResponse);
   if (!value || typeof value !== "object") {