@flatkey-ai/cli 0.1.16 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flatkey-ai/cli",
-  "version": "0.1.16",
+  "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,7 +43,20 @@ 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 = [
+    ...arrayOption(options.image_url),
+    ...arrayOption(options.imageUrl),
+    ...arrayOption(options.first_frame_url),
+    ...arrayOption(options.firstFrameUrl),
+    ...arrayOption(options.last_frame_url),
+    ...arrayOption(options.lastFrameUrl),
+  ];
   const ratio = validateOptionalValue(
     optionValue(options, "ratio", "aspect"),
     ["16:9", "9:16", "4:3", "3:4", "21:9", "1:1"],
@@ -54,8 +67,8 @@ export function planVideoRequest(options) {
     ["480p", "720p", "1080p"],
     "resolution",
   );
-  return planJsonPost(options, "/v1/video/generations", cleanObject({
-    model: options.model ?? "veo-3",
+  const basePayload = cleanObject({
+    model,
     prompt: options.prompt,
     duration: parseOptionalInteger(options.duration),
     aspect: ratio,
@@ -63,7 +76,20 @@ export function planVideoRequest(options) {
     resolution,
     quality: resolution,
     fps: parseOptionalInteger(options.fps),
-  }));
+    images: !isSeedanceModel(model) && imageUrls.length > 0 ? imageUrls : undefined,
+  });
+  const seedanceContent = buildSeedanceContent(options);
+  if (isSeedanceModel(model) && seedanceContent.length > 0) {
+    return planJsonPost(options, "/v1/video/generations", cleanObject({
+      ...basePayload,
+      content: seedanceContent,
+    }));
+  }
+  return planJsonPost(options, "/v1/video/generations", basePayload);
+}
+
+export function planVideoStatusRequest(options, taskId) {
+  return planRequest(options, `/v1/videos/${encodeURIComponent(taskId)}`);
 }
 
 export function generateAudio(options) {
@@ -275,6 +301,47 @@ function validateOptionalValue(value, allowed, name) {
   throw new Error(`Invalid ${name}: ${value}. Allowed values: ${allowed.join(", ")}`);
 }
 
+function isSeedanceModel(model) {
+  return /seedance/i.test(model);
+}
+
+function buildSeedanceContent(options) {
+  const content = [];
+  if (options.prompt !== undefined) {
+    content.push({ type: "text", text: options.prompt });
+  }
+  for (const url of arrayOption(options.image_url)) {
+    content.push({ type: "image_url", image_url: { url }, role: "reference_image" });
+  }
+  for (const url of arrayOption(options.imageUrl)) {
+    content.push({ type: "image_url", image_url: { url }, role: "reference_image" });
+  }
+  for (const url of arrayOption(options.first_frame_url)) {
+    content.push({ type: "image_url", image_url: { url }, role: "first_frame" });
+  }
+  for (const url of arrayOption(options.firstFrameUrl)) {
+    content.push({ type: "image_url", image_url: { url }, role: "first_frame" });
+  }
+  for (const url of arrayOption(options.last_frame_url)) {
+    content.push({ type: "image_url", image_url: { url }, role: "last_frame" });
+  }
+  for (const url of arrayOption(options.lastFrameUrl)) {
+    content.push({ type: "image_url", image_url: { url }, role: "last_frame" });
+  }
+  for (const url of arrayOption(options.video_url)) {
+    content.push({ type: "video_url", video_url: { url }, role: "reference_video" });
+  }
+  for (const url of arrayOption(options.videoUrl)) {
+    content.push({ type: "video_url", video_url: { url }, role: "reference_video" });
+  }
+  return content;
+}
+
+function arrayOption(value) {
+  if (value === undefined) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
 function cleanObject(value) {
   return Object.fromEntries(
     Object.entries(value).filter(([, entry]) => entry !== undefined),

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

@@ -16,6 +16,7 @@ const COMMANDS = new Set([
 
 const GROUP_ACTIONS = new Set(["audio", "auth", "image", "text", "video"]);
 const GLOBAL_OPTIONS = new Set(["api_key", "base_url", "dry_run", "help", "json", "output", "out"]);
+const REPEATABLE_OPTIONS = new Set(["image_url", "video_url"]);
 const COMMAND_OPTIONS = {
   "audio generate": new Set(["model", "prompt", "similarity_boost", "stability", "style", "voice_id"]),
   "audio music": new Set(["music_length_ms", "prompt"]),
@@ -35,7 +36,7 @@ const COMMAND_OPTIONS = {
   "text generate": new Set(["model", "prompt"]),
   version: new Set([]),
   video: new Set([]),
-  "video generate": new Set(["aspect", "duration", "fps", "model", "prompt", "ratio", "resolution"]),
+  "video generate": new Set(["aspect", "duration", "first_frame_url", "fps", "image_url", "last_frame_url", "model", "prompt", "ratio", "resolution", "video_url"]),
 };
 
 export function parseArgv(argv) {
@@ -115,12 +116,21 @@ function parseOptions(tokens) {
       options[name] = true;
       continue;
     }
-    options[name] = next;
+    if (REPEATABLE_OPTIONS.has(name)) {
+      options[name] = [...asArray(options[name]), next];
+    } else {
+      options[name] = next;
+    }
     index += 1;
   }
   return options;
 }
 
+function asArray(value) {
+  if (value === undefined) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
 function validateCommandOptions(command) {
   const key = command.action ? `${command.group} ${command.action}` : command.group;
   const allowed = COMMAND_OPTIONS[key] ?? new Set();
@@ -215,15 +225,11 @@ export async function runCommand(command, deps = {}) {
 }
 
 async function handleLogin(command, deps) {
-  const { ensureDeviceId, readConfig, resolveOrigins, writeAuthConfig } = await import("./config.js");
-  const { createDeviceAuthorization, pollDeviceAuthorization } = await import("./api.js");
+  const { ensureDeviceId, readConfig, writeAuthConfig } = await import("./config.js");
+  const { DEFAULT_CONSOLE_URL, createDeviceAuthorization, pollDeviceAuthorization } = await import("./api.js");
   const deviceId = await ensureDeviceId({ configDir: deps.configDir });
   const version = await readPackageVersion();
-  const { consoleOrigin } = await resolveOrigins({
-    consoleUrl: command.options.console_url,
-    env: deps.env ?? process.env,
-    configDir: deps.configDir,
-  });
+  const consoleOrigin = firstNonEmpty(command.options.console_url, DEFAULT_CONSOLE_URL);
   const authorization = await createDeviceAuthorization({
     consoleUrl: consoleOrigin,
     deviceId,
@@ -397,6 +403,7 @@ async function handleGenerate(command, deps) {
     generateImage,
     generateText,
     generateVideo,
+    getVideo,
     planAudioMusicRequest,
     planAudioRequest,
     planAudioSfxRequest,
@@ -422,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) {
@@ -455,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);
@@ -462,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") {

package/src/help.js

@@ -208,20 +208,28 @@ Options:
   video: `Usage: flatkey video generate --prompt <txt> [options]
 
 Options:
-  --model <model>                Model id, default veo-3
+  --model <model>                Model id, default seedance-2.0-pro
   --duration <seconds>            Video duration
   --ratio <value>                 16:9, 9:16, 4:3, 3:4, 21:9, or 1:1
   --resolution <value>            480p, 720p, or 1080p
+  --image-url <url>               Add reference image URL, repeatable
+  --video-url <url>               Add reference video URL, repeatable
+  --first-frame-url <url>         Add first frame image URL
+  --last-frame-url <url>          Add last frame image URL
   --fps <fps>                    Frames per second
   --output, -o <file>             Write video file
   --json                         Print machine-readable JSON`,
   "video generate": `Usage: flatkey video generate --prompt <txt> [options]
 
 Options:
-  --model <model>                Model id, default veo-3
+  --model <model>                Model id, default seedance-2.0-pro
   --duration <seconds>            Video duration
   --ratio <value>                 16:9, 9:16, 4:3, 3:4, 21:9, or 1:1
   --resolution <value>            480p, 720p, or 1080p
+  --image-url <url>               Add reference image URL, repeatable
+  --video-url <url>               Add reference video URL, repeatable
+  --first-frame-url <url>         Add first frame image URL
+  --last-frame-url <url>          Add last frame image URL
   --fps <fps>                    Frames per second
   --output, -o <file>             Write video file
   --json                         Print machine-readable JSON`,