Happy Video Gen

{
  "name": "happy-video-gen",
  "version": "0.1.0",
  "description": "Universal AI video generation skill — OpenAI Sora, Google Veo, Runway, Pika, Luma, FAL, Ark Seedance, Bailian Wanx, MiniMax Hailuo, Vidu",
  "type": "module",
  "private": true,
  "engines": {
    "bun": ">=1.1.0"
  },
  "scripts": {
    "gen": "bun scripts/main.ts"
  }
}

import path from "node:path";
import { readFile } from "node:fs/promises";
import { fileURLToPath } from "node:url";
import type { CliArgs, Provider, ProviderModule, Quality } from "./types";
import { ConfigError, ProviderError } from "./types";
import { writeBytesToFile } from "./utils/output";
import { validateVideoMagic } from "./utils/async";

const KNOWN_PROVIDERS: Provider[] = [
  "openai",
  "google",
  "runway",
  "pika",
  "luma",
  "fal",
  "ark",
  "bailian",
  "minimax",
  "vidu",
];

const IMPLEMENTED: Set<Provider> = new Set(KNOWN_PROVIDERS);

function printUsage(): void {
  console.log(`happy-video-gen — universal AI video generation CLI

Usage:
  bun scripts/main.ts --prompt "camera pans across a meadow" --video out.mp4
  bun scripts/main.ts --prompt "..." --image first.png --video out.mp4
  bun scripts/main.ts --prompt "..." --image first.png --last-frame end.png --video out.mp4

Options:
  -p, --prompt <text>        Prompt text
  --promptfiles <files...>   Read prompt from files (concatenated)
  --video <path>             Output video path (REQUIRED)
  --image <path>             First-frame reference (image-to-video mode)
  --last-frame <path>        Last-frame reference (only a few providers support this)
  --duration <seconds>       Target duration in seconds (provider-capped)
  --fps <n>                  Frame rate override (provider-capped)
  --provider <id>            openai | google | runway | pika | luma | fal | ark | bailian | minimax | vidu
  -m, --model <id>           Provider-specific model id
  --ar <ratio>               Aspect ratio (16:9, 9:16, 1:1, 4:3, 3:4)
  --resolution <label>       480p | 720p | 1080p (provider-dependent)
  --quality <preset>         draft | hd (default) | ultra
  --poll-timeout <seconds>   Max time to wait for an async job (default 600)
  --poll-interval <seconds>  Poll cadence (default 5)
  --json                     Emit JSON result to stdout
  --setup                    Print first-time setup guide and exit
  -h, --help                 Show this message

Environment variables (one per provider; set at least one):
  OPENAI_API_KEY, GOOGLE_API_KEY (or GEMINI_API_KEY), RUNWAY_API_KEY,
  PIKA_API_KEY, LUMA_API_KEY, FAL_KEY, ARK_API_KEY, DASHSCOPE_API_KEY,
  MINIMAX_API_KEY, VIDU_API_KEY

See references/providers.md for per-provider notes and references/async-protocol.md
for how to recover from interrupted jobs using the external id in --json output.
`);
}

async function printSetupGuide(): Promise<void> {
  const here = path.dirname(fileURLToPath(import.meta.url));
  const guidePath = path.resolve(here, "../references/config/first-time-setup.md");
  try {
    const guide = await readFile(guidePath, "utf8");
    console.log(guide);
  } catch {
    console.log("No first-time-setup.md found. Set a provider env var (e.g., FAL_KEY) and rerun.");
  }
}

function parseArgs(argv: string[]): CliArgs {
  const args: CliArgs = {
    prompt: null,
    promptFiles: [],
    videoPath: null,
    imagePath: null,
    lastFramePath: null,
    duration: null,
    fps: null,
    provider: null,
    model: null,
    aspectRatio: null,
    resolution: null,
    quality: null,
    pollTimeoutMs: 600_000,
    pollIntervalMs: 5_000,
    json: false,
    setup: false,
    help: false,
  };

  const tokens = [...argv];
  while (tokens.length > 0) {
    const token = tokens.shift()!;
    switch (token) {
      case "-p":
      case "--prompt":
        args.prompt = tokens.shift() ?? null;
        break;
      case "--promptfiles":
        while (tokens.length > 0 && !tokens[0]!.startsWith("--") && tokens[0] !== "-p") {
          args.promptFiles.push(tokens.shift()!);
        }
        break;
      case "--video":
        args.videoPath = tokens.shift() ?? null;
        break;
      case "--image":
        args.imagePath = tokens.shift() ?? null;
        break;
      case "--last-frame":
      case "--lastframe":
        args.lastFramePath = tokens.shift() ?? null;
        break;
      case "--duration":
        args.duration = Number(tokens.shift() || 0);
        break;
      case "--fps":
        args.fps = Number(tokens.shift() || 0);
        break;
      case "--provider":
        args.provider = tokens.shift() as Provider | null;
        break;
      case "-m":
      case "--model":
        args.model = tokens.shift() ?? null;
        break;
      case "--ar":
      case "--aspect":
        args.aspectRatio = tokens.shift() ?? null;
        break;
      case "--resolution":
      case "--res":
        args.resolution = tokens.shift() ?? null;
        break;
      case "--quality":
        args.quality = tokens.shift() as Quality | null;
        break;
      case "--poll-timeout":
        args.pollTimeoutMs = Math.max(10, Number(tokens.shift() || 600)) * 1000;
        break;
      case "--poll-interval":
        args.pollIntervalMs = Math.max(1, Number(tokens.shift() || 5)) * 1000;
        break;
      case "--json":
        args.json = true;
        break;
      case "--setup":
        args.setup = true;
        break;
      case "-h":
      case "--help":
        args.help = true;
        break;
      default:
        if (!token.startsWith("-") && args.prompt === null && args.promptFiles.length === 0) {
          args.prompt = token;
        } else {
          console.error(`Unknown argument: ${token}`);
          args.help = true;
        }
    }
  }
  return args;
}

async function resolvePrompt(args: CliArgs): Promise<string> {
  if (args.prompt && args.promptFiles.length === 0) return args.prompt;
  if (args.promptFiles.length > 0) {
    const parts: string[] = [];
    if (args.prompt) parts.push(args.prompt);
    for (const file of args.promptFiles) {
      parts.push(await readFile(file, "utf8"));
    }
    return parts.join("\n\n").trim();
  }
  throw new ConfigError("No prompt provided. Use --prompt or --promptfiles.");
}

function detectProvider(explicit: Provider | null): Provider {
  if (explicit) {
    if (!KNOWN_PROVIDERS.includes(explicit)) {
      throw new ConfigError(`Unknown provider: ${explicit}. Known: ${KNOWN_PROVIDERS.join(", ")}`);
    }
    return explicit;
  }
  if (process.env.FAL_KEY) return "fal";
  if (process.env.ARK_API_KEY) return "ark";
  if (process.env.MINIMAX_API_KEY) return "minimax";
  if (process.env.RUNWAY_API_KEY) return "runway";
  if (process.env.LUMA_API_KEY) return "luma";
  if (process.env.PIKA_API_KEY) return "pika";
  if (process.env.VIDU_API_KEY) return "vidu";
  if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY) return "google";
  if (process.env.DASHSCOPE_API_KEY) return "bailian";
  if (process.env.OPENAI_API_KEY) return "openai";
  throw new ConfigError(
    "No provider selected and no video-capable API key found. Pass --provider or set one of the env vars listed in --help."
  );
}

async function loadProvider(provider: Provider): Promise<ProviderModule> {
  if (!IMPLEMENTED.has(provider)) {
    throw new ConfigError(
      `Provider '${provider}' is not implemented in this release. Available: ${[...IMPLEMENTED].join(", ")}.`
    );
  }
  const mod = (await import(`./providers/${provider}.ts`)) as ProviderModule;
  if (typeof mod.defaultModel !== "function" || typeof mod.generate !== "function") {
    throw new ConfigError(`Provider module '${provider}' missing defaultModel/generate exports.`);
  }
  return mod;
}

async function run(argv: string[]): Promise<number> {
  const args = parseArgs(argv);

  if (args.help) {
    printUsage();
    return 0;
  }
  if (args.setup) {
    await printSetupGuide();
    return 0;
  }
  if (!args.videoPath) {
    console.error("--video is required (output path).");
    printUsage();
    return 2;
  }

  const prompt = await resolvePrompt(args);
  const provider = detectProvider(args.provider);
  const mod = await loadProvider(provider);
  const model = args.model ?? mod.defaultModel();
  if (!args.quality) args.quality = "hd";
  if (args.duration == null) args.duration = 5;

  const bytes = await mod.generate(prompt, model, args);
  await writeBytesToFile(bytes, args.videoPath);
  const kind = validateVideoMagic(bytes);

  if (args.json) {
    console.log(
      JSON.stringify(
        {
          success: true,
          provider,
          model,
          video: path.resolve(args.videoPath),
          size_bytes: bytes.byteLength,
          format: kind,
        },
        null,
        2
      )
    );
  } else {
    console.log(
      `✓ Generated ${kind.toUpperCase()} (${(bytes.byteLength / 1024).toFixed(1)} KB) via ${provider}/${model}`
    );
    console.log(`  ${path.resolve(args.videoPath)}`);
  }
  return 0;
}

run(process.argv.slice(2))
  .then((code) => process.exit(code))
  .catch((err) => {
    if (err instanceof ProviderError) {
      console.error(`[${err.provider}] ${err.message}`);
    } else if (err instanceof ConfigError) {
      console.error(`config: ${err.message}`);
    } else if (err instanceof Error) {
      console.error(err.stack || err.message);
    } else {
      console.error(String(err));
    }
    process.exit(1);
  });

import path from "node:path";
import type { CliArgs } from "../types";
import { ProviderError } from "../types";
import { downloadToBytes, pollUntilDone } from "../utils/async";
import { imagePathToDataUri } from "../utils/output";

const API_BASE = process.env.ARK_BASE_URL || "https://ark.cn-beijing.volces.com/api/v3";

export function defaultModel(): string {
  // Seedance 1.5 Pro (text-to-video + image-to-video). Users can override via --model
  // or ARK_VIDEO_MODEL to point at their own endpoint id.
  return process.env.ARK_VIDEO_MODEL || "doubao-seedance-1-0-lite-t2v-250408";
}

function requireApiKey(): string {
  const key = process.env.ARK_API_KEY;
  if (!key) {
    throw new ProviderError(
      "ARK_API_KEY not set. Get one at https://console.volcengine.com/ark",
      "ark"
    );
  }
  return key;
}

type TaskResponse = {
  id?: string;
  status?: "queued" | "running" | "succeeded" | "failed" | "cancelled";
  content?: { video_url?: string };
  error?: { code?: string; message?: string };
};

export async function generate(prompt: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();

  const content: Array<Record<string, unknown>> = [];
  // Seedance accepts a single text block plus optional image (first-frame).
  // Per Volc docs the text block encodes direction flags inline: e.g. "镜头推近 --rs 720p --rt 16:9".
  const directives: string[] = [];
  if (args.duration) directives.push(`--dur ${args.duration}`);
  if (args.resolution) directives.push(`--rs ${args.resolution}`);
  if (args.aspectRatio) directives.push(`--rt ${args.aspectRatio}`);

  const textWithDirectives = directives.length > 0 ? `${prompt} ${directives.join(" ")}`.trim() : prompt;
  content.push({ type: "text", text: textWithDirectives });

  if (args.imagePath) {
    content.push({
      type: "image_url",
      image_url: { url: await imagePathToDataUri(args.imagePath) },
      role: "first_frame",
    });
  }
  if (args.lastFramePath) {
    content.push({
      type: "image_url",
      image_url: { url: await imagePathToDataUri(args.lastFramePath) },
      role: "last_frame",
    });
  }

  const body = { model, content };

  const createRes = await fetch(`${API_BASE}/contents/generations/tasks`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!createRes.ok) {
    const text = await createRes.text();
    throw new ProviderError(`Ark create ${createRes.status}: ${text}`, "ark");
  }

  const created = (await createRes.json()) as TaskResponse;
  const taskId = created.id;
  if (!taskId) {
    throw new ProviderError(
      `Ark did not return a task id: ${created.error?.message ?? JSON.stringify(created)}`,
      "ark"
    );
  }

  const finished = await pollUntilDone<TaskResponse>(args, async () => {
    const r = await fetch(`${API_BASE}/contents/generations/tasks/${taskId}`, {
      headers: { Authorization: `Bearer ${apiKey}` },
    });
    if (!r.ok) {
      const text = await r.text();
      return { state: "failed", reason: `Ark poll ${r.status}: ${text}` };
    }
    const payload = (await r.json()) as TaskResponse;
    if (payload.status === "succeeded") return { state: "done", value: payload };
    if (payload.status === "failed" || payload.status === "cancelled") {
      return { state: "failed", reason: `Ark task ${payload.status}: ${payload.error?.message ?? "(no detail)"}` };
    }
    return { state: "pending" };
  }).catch((err) => {
    throw new ProviderError(`${err instanceof Error ? err.message : String(err)} (taskId: ${taskId})`, "ark");
  });

  const videoUrl = finished.content?.video_url;
  if (!videoUrl) {
    throw new ProviderError("Ark task succeeded but no video_url in response", "ark");
  }

  try {
    return await downloadToBytes(videoUrl);
  } catch (err) {
    throw new ProviderError(
      `Failed to download Ark video: ${err instanceof Error ? err.message : String(err)}`,
      "ark"
    );
  }
}

// re-export path helper so tests can import it
export { path };

import type { CliArgs } from "../types";
import { ProviderError } from "../types";
import { downloadToBytes, pollUntilDone } from "../utils/async";
import { imagePathToDataUri } from "../utils/output";

const API_BASE =
  process.env.DASHSCOPE_BASE_URL || "https://dashscope.aliyuncs.com/api/v1";

export function defaultModel(): string {
  return process.env.DASHSCOPE_VIDEO_MODEL || "wanx2.1-i2v-turbo";
}

function requireApiKey(): string {
  const key = process.env.DASHSCOPE_API_KEY;
  if (!key) {
    throw new ProviderError(
      "DASHSCOPE_API_KEY not set. Get one at https://dashscope.console.aliyun.com/apiKey",
      "bailian"
    );
  }
  return key;
}

type SubmitResponse = {
  output?: { task_id?: string; task_status?: string };
  message?: string;
};

type QueryResponse = {
  output?: {
    task_id?: string;
    task_status?: "PENDING" | "RUNNING" | "SUCCEEDED" | "FAILED" | "UNKNOWN";
    video_url?: string;
    message?: string;
  };
  message?: string;
};

export async function generate(prompt: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();

  const input: Record<string, unknown> = { prompt };
  if (args.imagePath) {
    input.image_url = await imagePathToDataUri(args.imagePath);
  }

  const parameters: Record<string, unknown> = {};
  if (args.duration) parameters.duration = args.duration;
  if (args.resolution) parameters.resolution = args.resolution;
  if (args.aspectRatio) parameters.aspect_ratio = args.aspectRatio;

  const body = { model, input, parameters };

  const submitRes = await fetch(`${API_BASE}/services/aigc/video-generation/video-synthesis`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
      "X-DashScope-Async": "enable",
    },
    body: JSON.stringify(body),
  });

  if (!submitRes.ok) {
    const text = await submitRes.text();
    throw new ProviderError(`Bailian submit ${submitRes.status}: ${text}`, "bailian");
  }

  const submit = (await submitRes.json()) as SubmitResponse;
  const taskId = submit.output?.task_id;
  if (!taskId) {
    throw new ProviderError(
      `Bailian submit returned no task id: ${submit.message ?? JSON.stringify(submit)}`,
      "bailian"
    );
  }

  const finished = await pollUntilDone<QueryResponse>(args, async () => {
    const r = await fetch(`${API_BASE}/tasks/${taskId}`, {
      headers: { Authorization: `Bearer ${apiKey}` },
    });
    if (!r.ok) {
      const text = await r.text();
      return { state: "failed", reason: `Bailian poll ${r.status}: ${text}` };
    }
    const payload = (await r.json()) as QueryResponse;
    const status = payload.output?.task_status;
    if (status === "SUCCEEDED") return { state: "done", value: payload };
    if (status === "FAILED" || status === "UNKNOWN") {
      return {
        state: "failed",
        reason: `Bailian task ${status}: ${payload.output?.message ?? "(no detail)"}`,
      };
    }
    return { state: "pending" };
  }).catch((err) => {
    throw new ProviderError(
      `${err instanceof Error ? err.message : String(err)} (task id: ${taskId})`,
      "bailian"
    );
  });

  const videoUrl = finished.output?.video_url;
  if (!videoUrl) {
    throw new ProviderError("Bailian task succeeded but no video_url in response", "bailian");
  }
  return downloadToBytes(videoUrl);
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";
import { downloadToBytes, pollUntilDone } from "../utils/async";
import { imagePathToDataUri } from "../utils/output";

const QUEUE_BASE = "https://queue.fal.run";

export function defaultModel(): string {
  // Kling v2.5 turbo pro is a good default; cheap, reliable. Wan / Veo / Sora wrappers are also available on FAL.
  return process.env.FAL_VIDEO_MODEL || "fal-ai/kling-video/v2.5-turbo/pro/text-to-video";
}

function requireApiKey(): string {
  const key = process.env.FAL_KEY;
  if (!key) {
    throw new ProviderError("FAL_KEY not set. Get one at https://fal.ai/dashboard/keys", "fal");
  }
  return key;
}

type QueueSubmit = {
  request_id?: string;
  response_url?: string;
  status_url?: string;
  error?: string;
};

type QueueStatus = {
  status?: "IN_QUEUE" | "IN_PROGRESS" | "COMPLETED" | "FAILED" | "CANCELLED";
  response_url?: string;
  error?: string;
};

type KlingResponse = {
  video?: { url?: string };
  video_url?: string;
  output?: { video?: { url?: string } } | { url?: string };
};

function extractVideoUrl(payload: KlingResponse): string | null {
  if (payload.video?.url) return payload.video.url;
  if (payload.video_url) return payload.video_url;
  if (payload.output && typeof payload.output === "object") {
    if ("url" in payload.output && typeof payload.output.url === "string") return payload.output.url;
    if ("video" in payload.output && payload.output.video?.url) return payload.output.video.url;
  }
  return null;
}

export async function generate(prompt: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();
  const input: Record<string, unknown> = { prompt };
  if (args.duration) input.duration = String(args.duration);
  if (args.aspectRatio) input.aspect_ratio = args.aspectRatio;
  if (args.imagePath) {
    input.image_url = await imagePathToDataUri(args.imagePath);
  }

  const submitRes = await fetch(`${QUEUE_BASE}/${model.replace(/^\/+/, "")}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Key ${apiKey}`,
    },
    body: JSON.stringify(input),
  });

  if (!submitRes.ok) {
    const text = await submitRes.text();
    throw new ProviderError(`FAL submit ${submitRes.status}: ${text}`, "fal");
  }

  const submit = (await submitRes.json()) as QueueSubmit;
  const statusUrl = submit.status_url;
  const responseUrl = submit.response_url;
  if (!statusUrl || !responseUrl) {
    throw new ProviderError(
      `FAL submit returned no status/response url: ${submit.error ?? JSON.stringify(submit)}`,
      "fal"
    );
  }

  const finalStatus = await pollUntilDone<QueueStatus>(args, async () => {
    const r = await fetch(statusUrl, { headers: { Authorization: `Key ${apiKey}` } });
    if (!r.ok) {
      const text = await r.text();
      return { state: "failed", reason: `FAL poll ${r.status}: ${text}` };
    }
    const payload = (await r.json()) as QueueStatus;
    if (payload.status === "COMPLETED") return { state: "done", value: payload };
    if (payload.status === "FAILED" || payload.status === "CANCELLED") {
      return { state: "failed", reason: `FAL job ${payload.status}: ${payload.error ?? "(no detail)"}` };
    }
    return { state: "pending" };
  }).catch((err) => {
    throw new ProviderError(
      `${err instanceof Error ? err.message : String(err)} (request_id: ${submit.request_id})`,
      "fal"
    );
  });

  const resultUrl = finalStatus.response_url ?? responseUrl;
  const resRes = await fetch(resultUrl, { headers: { Authorization: `Key ${apiKey}` } });
  if (!resRes.ok) {
    const text = await resRes.text();
    throw new ProviderError(`FAL fetch result ${resRes.status}: ${text}`, "fal");
  }
  const payload = (await resRes.json()) as KlingResponse;
  const videoUrl = extractVideoUrl(payload);
  if (!videoUrl) {
    throw new ProviderError(
      `FAL result contained no video url. Raw payload: ${JSON.stringify(payload)}`,
      "fal"
    );
  }
  return downloadToBytes(videoUrl);
}

import path from "node:path";
import { readFile } from "node:fs/promises";
import type { CliArgs } from "../types";
import { ProviderError } from "../types";
import { downloadToBytes, pollUntilDone } from "../utils/async";
import { getImageMimeType } from "../utils/output";

const API_BASE = "https://generativelanguage.googleapis.com/v1beta";

export function defaultModel(): string {
  return process.env.GOOGLE_VIDEO_MODEL || "veo-3.0-generate-preview";
}

function requireApiKey(): string {
  const key = process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
  if (!key) {
    throw new ProviderError(
      "GOOGLE_API_KEY or GEMINI_API_KEY not set. Get one at https://aistudio.google.com/app/apikey",
      "google"
    );
  }
  return key;
}

type OperationResponse = {
  name?: string;
  done?: boolean;
  response?: {
    videos?: Array<{ bytesBase64Encoded?: string; video?: { uri?: string } }>;
  };
  error?: { message?: string; code?: number };
};

export async function generate(prompt: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();

  const instance: Record<string, unknown> = { prompt };
  if (args.imagePath) {
    const bytes = await readFile(args.imagePath);
    instance.image = {
      bytesBase64Encoded: Buffer.from(bytes).toString("base64"),
      mimeType: getImageMimeType(path.basename(args.imagePath)),
    };
  }

  const parameters: Record<string, unknown> = {};
  if (args.aspectRatio) parameters.aspectRatio = args.aspectRatio;
  if (args.duration) parameters.durationSeconds = args.duration;
  if (args.resolution) parameters.resolution = args.resolution;

  const createUrl = `${API_BASE}/models/${model}:predictLongRunning?key=${encodeURIComponent(apiKey)}`;
  const createRes = await fetch(createUrl, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ instances: [instance], parameters }),
  });

  if (!createRes.ok) {
    const text = await createRes.text();
    throw new ProviderError(`Veo create ${createRes.status}: ${text}`, "google");
  }

  const created = (await createRes.json()) as OperationResponse;
  const name = created.name;
  if (!name) {
    throw new ProviderError(`Veo did not return an operation name: ${JSON.stringify(created)}`, "google");
  }

  const finished = await pollUntilDone<OperationResponse>(args, async () => {
    const r = await fetch(`${API_BASE}/${name}?key=${encodeURIComponent(apiKey)}`);
    if (!r.ok) {
      const text = await r.text();
      return { state: "failed", reason: `Veo poll ${r.status}: ${text}` };
    }
    const payload = (await r.json()) as OperationResponse;
    if (payload.error) {
      return { state: "failed", reason: `Veo error: ${payload.error.message ?? "(no detail)"}` };
    }
    if (payload.done) return { state: "done", value: payload };
    return { state: "pending" };
  }).catch((err) => {
    throw new ProviderError(
      `${err instanceof Error ? err.message : String(err)} (operation: ${name})`,
      "google"
    );
  });

  const video = finished.response?.videos?.[0];
  if (video?.bytesBase64Encoded) {
    return Uint8Array.from(Buffer.from(video.bytesBase64Encoded, "base64"));
  }
  if (video?.video?.uri) {
    // URI form — authenticated download with API key.
    return downloadToBytes(`${video.video.uri}?key=${encodeURIComponent(apiKey)}`);
  }
  throw new ProviderError("Veo operation completed but returned no video data", "google");
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";
import { downloadToBytes, pollUntilDone } from "../utils/async";
import { imagePathToDataUri } from "../utils/output";

const API_BASE = process.env.LUMA_BASE_URL || "https://api.lumalabs.ai/dream-machine/v1";

export function defaultModel(): string {
  return process.env.LUMA_VIDEO_MODEL || "ray-2";
}

function requireApiKey(): string {
  const key = process.env.LUMA_API_KEY;
  if (!key) {
    throw new ProviderError(
      "LUMA_API_KEY not set. Get one at https://lumalabs.ai/dream-machine/api/keys",
      "luma"
    );
  }
  return key;
}

type GenerationResponse = {
  id?: string;
  state?: "queued" | "dreaming" | "completed" | "failed";
  failure_reason?: string;
  assets?: { video?: string };
};

export async function generate(prompt: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();

  const body: Record<string, unknown> = { model, prompt };
  if (args.aspectRatio) body.aspect_ratio = args.aspectRatio;
  if (args.duration) body.duration = `${args.duration}s`;
  if (args.resolution) body.resolution = args.resolution;
  if (args.imagePath) {
    const keyframes: Record<string, { type: string; url: string }> = {
      frame0: { type: "image", url: await imagePathToDataUri(args.imagePath) },
    };
    if (args.lastFramePath) {
      keyframes.frame1 = { type: "image", url: await imagePathToDataUri(args.lastFramePath) };
    }
    body.keyframes = keyframes;
  }

  const createRes = await fetch(`${API_BASE}/generations`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!createRes.ok) {
    const text = await createRes.text();
    throw new ProviderError(`Luma create ${createRes.status}: ${text}`, "luma");
  }

  const created = (await createRes.json()) as GenerationResponse;
  const genId = created.id;
  if (!genId) {
    throw new ProviderError(`Luma create returned no id: ${JSON.stringify(created)}`, "luma");
  }

  const finished = await pollUntilDone<GenerationResponse>(args, async () => {
    const r = await fetch(`${API_BASE}/generations/${genId}`, {
      headers: { Authorization: `Bearer ${apiKey}` },
    });
    if (!r.ok) {
      const text = await r.text();
      return { state: "failed", reason: `Luma poll ${r.status}: ${text}` };
    }
    const payload = (await r.json()) as GenerationResponse;
    if (payload.state === "completed") return { state: "done", value: payload };
    if (payload.state === "failed") {
      return { state: "failed", reason: `Luma generation failed: ${payload.failure_reason ?? "(no detail)"}` };
    }
    return { state: "pending" };
  }).catch((err) => {
    throw new ProviderError(
      `${err instanceof Error ? err.message : String(err)} (generation id: ${genId})`,
      "luma"
    );
  });

  const videoUrl = finished.assets?.video;
  if (!videoUrl) {
    throw new ProviderError("Luma generation completed but returned no video url", "luma");
  }
  return downloadToBytes(videoUrl);
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";
import { downloadToBytes, pollUntilDone } from "../utils/async";
import { imagePathToDataUri } from "../utils/output";

const API_BASE = process.env.MINIMAX_BASE_URL || "https://api.minimax.io/v1";

export function defaultModel(): string {
  return process.env.MINIMAX_VIDEO_MODEL || "MiniMax-Hailuo-02";
}

function requireApiKey(): string {
  const key = process.env.MINIMAX_API_KEY;
  if (!key) {
    throw new ProviderError(
      "MINIMAX_API_KEY not set. Get one at https://platform.minimaxi.com/user-center/basic-information",
      "minimax"
    );
  }
  return key;
}

type CreateResponse = {
  task_id?: string;
  base_resp?: { status_code?: number; status_msg?: string };
};

type QueryResponse = {
  task_id?: string;
  status?: "Queueing" | "Preparing" | "Processing" | "Success" | "Fail";
  file_id?: string;
  base_resp?: { status_code?: number; status_msg?: string };
};

type FileResponse = {
  file?: { download_url?: string };
  base_resp?: { status_code?: number; status_msg?: string };
};

export async function generate(prompt: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();

  const body: Record<string, unknown> = { model, prompt };
  if (args.duration) body.duration = args.duration;
  if (args.resolution) body.resolution = args.resolution;
  if (args.aspectRatio) body.aspect_ratio = args.aspectRatio;
  if (args.imagePath) {
    body.first_frame_image = await imagePathToDataUri(args.imagePath);
  }

  const submitRes = await fetch(`${API_BASE}/video_generation`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!submitRes.ok) {
    const text = await submitRes.text();
    throw new ProviderError(`MiniMax submit ${submitRes.status}: ${text}`, "minimax");
  }

  const submit = (await submitRes.json()) as CreateResponse;
  const taskId = submit.task_id;
  if (!taskId) {
    throw new ProviderError(
      `MiniMax submit returned no task_id: ${submit.base_resp?.status_msg ?? JSON.stringify(submit)}`,
      "minimax"
    );
  }

  const finished = await pollUntilDone<QueryResponse>(args, async () => {
    const r = await fetch(`${API_BASE}/query/video_generation?task_id=${taskId}`, {
      headers: { Authorization: `Bearer ${apiKey}` },
    });
    if (!r.ok) {
      const text = await r.text();
      return { state: "failed", reason: `MiniMax poll ${r.status}: ${text}` };
    }
    const payload = (await r.json()) as QueryResponse;
    if (payload.status === "Success" && payload.file_id) return { state: "done", value: payload };
    if (payload.status === "Fail") {
      return { state: "failed", reason: `MiniMax task Fail: ${payload.base_resp?.status_msg ?? "(no detail)"}` };
    }
    return { state: "pending" };
  }).catch((err) => {
    throw new ProviderError(
      `${err instanceof Error ? err.message : String(err)} (task_id: ${taskId})`,
      "minimax"
    );
  });

  const fileId = finished.file_id!;
  const fileRes = await fetch(`${API_BASE}/files/retrieve?file_id=${fileId}`, {
    headers: { Authorization: `Bearer ${apiKey}` },
  });
  if (!fileRes.ok) {
    const text = await fileRes.text();
    throw new ProviderError(`MiniMax file retrieve ${fileRes.status}: ${text}`, "minimax");
  }
  const filePayload = (await fileRes.json()) as FileResponse;
  const downloadUrl = filePayload.file?.download_url;
  if (!downloadUrl) {
    throw new ProviderError(
      `MiniMax file retrieve returned no download_url: ${filePayload.base_resp?.status_msg ?? JSON.stringify(filePayload)}`,
      "minimax"
    );
  }
  return downloadToBytes(downloadUrl);
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";
import { downloadToBytes, pollUntilDone } from "../utils/async";
import { imagePathToDataUri } from "../utils/output";

const API_BASE = process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";

export function defaultModel(): string {
  return process.env.OPENAI_VIDEO_MODEL || "sora-2";
}

function requireApiKey(): string {
  const key = process.env.OPENAI_API_KEY;
  if (!key) {
    throw new ProviderError(
      "OPENAI_API_KEY not set. Sora also requires your org to have video access enabled.",
      "openai"
    );
  }
  return key;
}

type VideoJob = {
  id?: string;
  status?: "queued" | "in_progress" | "completed" | "failed";
  error?: { message?: string };
  result?: { url?: string };
  video_url?: string;
};

export async function generate(prompt: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();

  const body: Record<string, unknown> = { model, prompt };
  if (args.duration) body.duration_seconds = args.duration;
  if (args.aspectRatio) body.aspect_ratio = args.aspectRatio;
  if (args.resolution) body.resolution = args.resolution;
  if (args.imagePath) {
    body.input_image = await imagePathToDataUri(args.imagePath);
  }

  const createRes = await fetch(`${API_BASE}/videos`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!createRes.ok) {
    const text = await createRes.text();
    throw new ProviderError(`OpenAI videos ${createRes.status}: ${text}`, "openai");
  }

  const created = (await createRes.json()) as VideoJob;
  const jobId = created.id;
  if (!jobId) {
    throw new ProviderError(`OpenAI videos returned no job id: ${JSON.stringify(created)}`, "openai");
  }

  const finished = await pollUntilDone<VideoJob>(args, async () => {
    const r = await fetch(`${API_BASE}/videos/${jobId}`, {
      headers: { Authorization: `Bearer ${apiKey}` },
    });
    if (!r.ok) {
      const text = await r.text();
      return { state: "failed", reason: `OpenAI poll ${r.status}: ${text}` };
    }
    const payload = (await r.json()) as VideoJob;
    if (payload.status === "completed") return { state: "done", value: payload };
    if (payload.status === "failed") {
      return { state: "failed", reason: `OpenAI video failed: ${payload.error?.message ?? "(no detail)"}` };
    }
    return { state: "pending" };
  }).catch((err) => {
    throw new ProviderError(
      `${err instanceof Error ? err.message : String(err)} (job_id: ${jobId})`,
      "openai"
    );
  });

  const videoUrl = finished.result?.url ?? finished.video_url;
  if (!videoUrl) {
    throw new ProviderError("OpenAI video job completed but returned no url", "openai");
  }
  return downloadToBytes(videoUrl, { Authorization: `Bearer ${apiKey}` });
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";
import { downloadToBytes, pollUntilDone } from "../utils/async";
import { imagePathToDataUri } from "../utils/output";

const API_BASE = process.env.PIKA_BASE_URL || "https://api.pika.art/v1";

export function defaultModel(): string {
  return process.env.PIKA_VIDEO_MODEL || "pika-2.2";
}

function requireApiKey(): string {
  const key = process.env.PIKA_API_KEY;
  if (!key) {
    throw new ProviderError(
      "PIKA_API_KEY not set. Request API access at https://pika.art",
      "pika"
    );
  }
  return key;
}

type JobResponse = {
  id?: string;
  status?: "queued" | "processing" | "completed" | "failed";
  video_url?: string;
  videos?: Array<{ url?: string }>;
  error?: string;
};

export async function generate(prompt: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();

  const body: Record<string, unknown> = { model, prompt };
  if (args.duration) body.duration = args.duration;
  if (args.aspectRatio) body.aspect_ratio = args.aspectRatio;
  if (args.resolution) body.resolution = args.resolution;
  if (args.imagePath) body.image = await imagePathToDataUri(args.imagePath);

  const createRes = await fetch(`${API_BASE}/generations`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!createRes.ok) {
    const text = await createRes.text();
    throw new ProviderError(`Pika create ${createRes.status}: ${text}`, "pika");
  }

  const created = (await createRes.json()) as JobResponse;
  const jobId = created.id;
  if (!jobId) {
    throw new ProviderError(`Pika create returned no id: ${JSON.stringify(created)}`, "pika");
  }

  const finished = await pollUntilDone<JobResponse>(args, async () => {
    const r = await fetch(`${API_BASE}/generations/${jobId}`, {
      headers: { Authorization: `Bearer ${apiKey}` },
    });
    if (!r.ok) {
      const text = await r.text();
      return { state: "failed", reason: `Pika poll ${r.status}: ${text}` };
    }
    const payload = (await r.json()) as JobResponse;
    if (payload.status === "completed") return { state: "done", value: payload };
    if (payload.status === "failed") {
      return { state: "failed", reason: `Pika job failed: ${payload.error ?? "(no detail)"}` };
    }
    return { state: "pending" };
  }).catch((err) => {
    throw new ProviderError(
      `${err instanceof Error ? err.message : String(err)} (job id: ${jobId})`,
      "pika"
    );
  });

  const videoUrl = finished.video_url ?? finished.videos?.[0]?.url;
  if (!videoUrl) {
    throw new ProviderError("Pika job completed but returned no video url", "pika");
  }
  return downloadToBytes(videoUrl);
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";
import { downloadToBytes, pollUntilDone } from "../utils/async";
import { imagePathToDataUri } from "../utils/output";

const API_BASE = process.env.RUNWAY_BASE_URL || "https://api.dev.runwayml.com/v1";
const API_VERSION = process.env.RUNWAY_API_VERSION || "2024-11-06";

export function defaultModel(): string {
  return process.env.RUNWAY_VIDEO_MODEL || "gen4_turbo";
}

function requireApiKey(): string {
  const key = process.env.RUNWAY_API_KEY;
  if (!key) {
    throw new ProviderError(
      "RUNWAY_API_KEY not set. Get one at https://dev.runwayml.com",
      "runway"
    );
  }
  return key;
}

type TaskResponse = {
  id?: string;
  status?: "PENDING" | "THROTTLED" | "RUNNING" | "SUCCEEDED" | "FAILED" | "CANCELLED";
  output?: string[];
  error?: string;
};

export async function generate(prompt: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();

  const isImageToVideo = !!args.imagePath;
  const endpoint = isImageToVideo ? "image_to_video" : "text_to_video";

  const body: Record<string, unknown> = {
    model,
    promptText: prompt,
  };
  if (args.aspectRatio) body.ratio = args.aspectRatio;
  if (args.duration) body.duration = args.duration;
  if (args.imagePath) {
    body.promptImage = await imagePathToDataUri(args.imagePath);
  }

  const createRes = await fetch(`${API_BASE}/${endpoint}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
      "X-Runway-Version": API_VERSION,
    },
    body: JSON.stringify(body),
  });

  if (!createRes.ok) {
    const text = await createRes.text();
    throw new ProviderError(`Runway create ${createRes.status}: ${text}`, "runway");
  }

  const created = (await createRes.json()) as TaskResponse;
  const taskId = created.id;
  if (!taskId) {
    throw new ProviderError(`Runway create returned no task id: ${JSON.stringify(created)}`, "runway");
  }

  const finished = await pollUntilDone<TaskResponse>(args, async () => {
    const r = await fetch(`${API_BASE}/tasks/${taskId}`, {
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "X-Runway-Version": API_VERSION,
      },
    });
    if (!r.ok) {
      const text = await r.text();
      return { state: "failed", reason: `Runway poll ${r.status}: ${text}` };
    }
    const payload = (await r.json()) as TaskResponse;
    if (payload.status === "SUCCEEDED") return { state: "done", value: payload };
    if (payload.status === "FAILED" || payload.status === "CANCELLED") {
      return { state: "failed", reason: `Runway task ${payload.status}: ${payload.error ?? "(no detail)"}` };
    }
    return { state: "pending" };
  }).catch((err) => {
    throw new ProviderError(
      `${err instanceof Error ? err.message : String(err)} (task id: ${taskId})`,
      "runway"
    );
  });

  const outputUrl = finished.output?.[0];
  if (!outputUrl) {
    throw new ProviderError("Runway task succeeded but returned no output url", "runway");
  }
  return downloadToBytes(outputUrl);
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";
import { downloadToBytes, pollUntilDone } from "../utils/async";
import { imagePathToDataUri } from "../utils/output";

const API_BASE = process.env.VIDU_BASE_URL || "https://api.vidu.com/ent/v2";

export function defaultModel(): string {
  return process.env.VIDU_VIDEO_MODEL || "viduq1";
}

function requireApiKey(): string {
  const key = process.env.VIDU_API_KEY || process.env.VIDU_API_TOKEN;
  if (!key) {
    throw new ProviderError(
      "VIDU_API_KEY not set. Get one at https://platform.vidu.com",
      "vidu"
    );
  }
  return key;
}

type CreateResponse = { task_id?: string; state?: string; message?: string };
type QueryResponse = {
  state?: "created" | "queueing" | "processing" | "success" | "failed";
  creations?: Array<{ url?: string; cover_url?: string }>;
  err_code?: string;
  message?: string;
};

export async function generate(prompt: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();
  const endpoint = args.imagePath ? "img2video" : "text2video";

  const body: Record<string, unknown> = { model, prompt };
  if (args.duration) body.duration = args.duration;
  if (args.resolution) body.resolution = args.resolution;
  if (args.aspectRatio) body.aspect_ratio = args.aspectRatio;
  if (args.imagePath) {
    body.images = [await imagePathToDataUri(args.imagePath)];
  }

  const createRes = await fetch(`${API_BASE}/${endpoint}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Token ${apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!createRes.ok) {
    const text = await createRes.text();
    throw new ProviderError(`Vidu create ${createRes.status}: ${text}`, "vidu");
  }

  const created = (await createRes.json()) as CreateResponse;
  const taskId = created.task_id;
  if (!taskId) {
    throw new ProviderError(
      `Vidu create returned no task id: ${created.message ?? JSON.stringify(created)}`,
      "vidu"
    );
  }

  const finished = await pollUntilDone<QueryResponse>(args, async () => {
    const r = await fetch(`${API_BASE}/tasks/${taskId}/creations`, {
      headers: { Authorization: `Token ${apiKey}` },
    });
    if (!r.ok) {
      const text = await r.text();
      return { state: "failed", reason: `Vidu poll ${r.status}: ${text}` };
    }
    const payload = (await r.json()) as QueryResponse;
    if (payload.state === "success") return { state: "done", value: payload };
    if (payload.state === "failed") {
      return { state: "failed", reason: `Vidu task failed: ${payload.message ?? payload.err_code ?? "(no detail)"}` };
    }
    return { state: "pending" };
  }).catch((err) => {
    throw new ProviderError(
      `${err instanceof Error ? err.message : String(err)} (task id: ${taskId})`,
      "vidu"
    );
  });

  const videoUrl = finished.creations?.[0]?.url;
  if (!videoUrl) {
    throw new ProviderError("Vidu task succeeded but no video url", "vidu");
  }
  return downloadToBytes(videoUrl);
}