videodraft 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,2742 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/version.ts
+var version_exports = {};
+__export(version_exports, {
+  VERSION: () => VERSION
+});
+import fs from "fs";
+function readVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    VERSION = readVersion();
+  }
+});
+
+// src/index.ts
+import { Command, CommanderError } from "commander";
+
+// src/core/errors.ts
+var EXIT = {
+  OK: 0,
+  ERROR: 1,
+  USAGE: 2,
+  AUTH: 3,
+  CREDITS: 4
+};
+var CliError = class extends Error {
+  exitCode;
+  /** One-line remediation shown under the error (human mode only). */
+  hint;
+  constructor(message, exitCode = EXIT.ERROR, hint) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+    this.hint = hint;
+  }
+};
+var AuthError = class extends CliError {
+  constructor(message = "Not authenticated.") {
+    super(
+      message,
+      EXIT.AUTH,
+      "Run `videodraft login` (or set VIDEODRAFT_API_KEY to a vd_mcp_... token from /mcp-keys)."
+    );
+    this.name = "AuthError";
+  }
+};
+var RpcError = class extends CliError {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(`RPC error ${code}: ${message}`);
+    this.name = "RpcError";
+    this.code = code;
+    this.data = data;
+  }
+};
+var CREDIT_ERROR_RE = /insufficient credits|not enough credits|credit balance/i;
+var ToolError = class extends CliError {
+  toolName;
+  constructor(toolName, message) {
+    const isCredits = CREDIT_ERROR_RE.test(message);
+    super(
+      message,
+      isCredits ? EXIT.CREDITS : EXIT.ERROR,
+      isCredits ? "Check your balance with `videodraft credits` or top up at https://app.videodraft.ai/pricing" : void 0
+    );
+    this.name = "ToolError";
+    this.toolName = toolName;
+  }
+};
+var TimeoutError = class extends CliError {
+  constructor(message) {
+    super(message, EXIT.ERROR);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/index.ts
+init_version();
+
+// src/cli/output.ts
+import pc from "picocolors";
+function makeOutput(opts) {
+  const isTTY = Boolean(process.stdout.isTTY);
+  const noColorEnv = Boolean(process.env.NO_COLOR);
+  return {
+    json: Boolean(opts.json),
+    color: (opts.color ?? true) && !noColorEnv && isTTY,
+    isTTY
+  };
+}
+var fmt = {
+  dim: (out, s) => out.color ? pc.dim(s) : s,
+  bold: (out, s) => out.color ? pc.bold(s) : s,
+  green: (out, s) => out.color ? pc.green(s) : s,
+  red: (out, s) => out.color ? pc.red(s) : s,
+  yellow: (out, s) => out.color ? pc.yellow(s) : s,
+  cyan: (out, s) => out.color ? pc.cyan(s) : s
+};
+function emit(out, data, human) {
+  if (out.json) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+    return;
+  }
+  if (human) {
+    human(out);
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+}
+function note(out, message) {
+  if (out.json) return;
+  process.stderr.write(`${message}
+`);
+}
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function spinner(out, text) {
+  if (out.json || !process.stderr.isTTY) {
+    return { update: () => {
+    }, stop: () => {
+    } };
+  }
+  let current = text;
+  let frame = 0;
+  const render = () => {
+    process.stderr.write(`\r\x1B[2K${fmt.cyan(out, FRAMES[frame % FRAMES.length])} ${current}`);
+    frame++;
+  };
+  render();
+  const timer = setInterval(render, 90);
+  timer.unref();
+  return {
+    update(next) {
+      current = next;
+    },
+    stop(finalText) {
+      clearInterval(timer);
+      process.stderr.write("\r\x1B[2K");
+      if (finalText) process.stderr.write(`${finalText}
+`);
+    }
+  };
+}
+function kv(out, rows) {
+  const width = Math.max(...rows.map(([k]) => k.length));
+  for (const [k, v] of rows) {
+    if (v === void 0 || v === null || v === "") continue;
+    process.stdout.write(`${fmt.dim(out, k.padEnd(width))}  ${String(v)}
+`);
+  }
+}
+function table(out, headers, rows) {
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+  const line = (cells, dim = false) => {
+    const s = cells.map((c, i) => c.padEnd(widths[i])).join("  ");
+    process.stdout.write(`${dim ? fmt.dim(out, s) : s}
+`);
+  };
+  line(headers, true);
+  for (const row of rows) line(row);
+}
+
+// src/cli/command-path.ts
+function buildCommandPath(cmd) {
+  const parts = [];
+  let c = cmd;
+  while (c && c.parent) {
+    parts.unshift(c.name());
+    c = c.parent;
+  }
+  return parts.join(" ") || "help";
+}
+
+// src/core/config.ts
+import fs2 from "fs";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+var DEFAULT_BASE_URL = "https://app.videodraft.ai";
+function configDir(env = process.env) {
+  if (env.VIDEODRAFT_CONFIG_DIR) return env.VIDEODRAFT_CONFIG_DIR;
+  const xdg = env.XDG_CONFIG_HOME;
+  return path.join(xdg && xdg.trim() !== "" ? xdg : path.join(os.homedir(), ".config"), "videodraft");
+}
+function configPath(env = process.env) {
+  return path.join(configDir(env), "config.json");
+}
+function emptyConfig() {
+  return { version: 1, active_profile: "default", profiles: {} };
+}
+function readConfig(env = process.env) {
+  try {
+    const raw = fs2.readFileSync(configPath(env), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || !parsed.profiles) return emptyConfig();
+    return parsed;
+  } catch {
+    return emptyConfig();
+  }
+}
+function writeConfig(config, env = process.env) {
+  const dir = configDir(env);
+  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+  const file = configPath(env);
+  const tmp = path.join(dir, `.config.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`);
+  fs2.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  fs2.renameSync(tmp, file);
+  try {
+    fs2.chmodSync(file, 384);
+  } catch {
+  }
+}
+function updateConfig(mutate, env = process.env) {
+  const config = readConfig(env);
+  mutate(config);
+  writeConfig(config, env);
+  return config;
+}
+function getProfile(name, env = process.env) {
+  const config = readConfig(env);
+  const profileName = name ?? config.active_profile ?? "default";
+  return { name: profileName, profile: config.profiles[profileName], config };
+}
+function anonymousId(env = process.env) {
+  const config = readConfig(env);
+  if (config.anonymous_id) return config.anonymous_id;
+  const id = crypto.randomUUID();
+  updateConfig((c) => {
+    c.anonymous_id = id;
+  }, env);
+  return id;
+}
+var LOCK_STALE_MS = 3e4;
+async function withLock(lockName, fn, env = process.env) {
+  const dir = configDir(env);
+  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+  const lockPath = path.join(dir, `${lockName}.lock`);
+  const deadline = Date.now() + 15e3;
+  for (; ; ) {
+    try {
+      const fd = fs2.openSync(lockPath, "wx");
+      fs2.writeSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
+      fs2.closeSync(fd);
+      break;
+    } catch {
+      try {
+        const stat = fs2.statSync(lockPath);
+        if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+          fs2.rmSync(lockPath, { force: true });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() > deadline) {
+        throw new Error(`Timed out waiting for lock ${lockName} (${lockPath})`);
+      }
+      await new Promise((r) => setTimeout(r, 100));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    fs2.rmSync(lockPath, { force: true });
+  }
+}
+
+// src/cli/telemetry.ts
+init_version();
+var POSTHOG_KEY = process.env.VIDEODRAFT_POSTHOG_KEY ?? "";
+var POSTHOG_HOST = process.env.VIDEODRAFT_POSTHOG_HOST ?? "https://us.i.posthog.com";
+var pending = null;
+function telemetryEnabled(env = process.env) {
+  if (!POSTHOG_KEY) return false;
+  if (env.DO_NOT_TRACK && env.DO_NOT_TRACK !== "0") return false;
+  const flag = env.VIDEODRAFT_TELEMETRY;
+  if (flag && ["0", "false", "off"].includes(flag.toLowerCase())) return false;
+  const config = readConfig(env);
+  if (config.telemetry === false) return false;
+  return true;
+}
+function maybePrintFirstRunNotice(env = process.env) {
+  if (!telemetryEnabled(env)) return;
+  const config = readConfig(env);
+  if (config.anonymous_id) return;
+  process.stderr.write(
+    "videodraft collects anonymous usage data (command name, version, OS \u2014 never prompts or content).\nDisable anytime: videodraft config set telemetry false  (or DO_NOT_TRACK=1)\n\n"
+  );
+}
+function capture(event, properties = {}) {
+  if (!telemetryEnabled()) return;
+  const body = JSON.stringify({
+    api_key: POSTHOG_KEY,
+    event,
+    distinct_id: anonymousId(),
+    properties: {
+      cli_version: VERSION,
+      os: process.platform,
+      arch: process.arch,
+      node_major: Number(process.versions.node.split(".")[0]),
+      is_ci: Boolean(process.env.CI),
+      ...properties
+    }
+  });
+  pending = fetch(`${POSTHOG_HOST}/capture/`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body,
+    signal: AbortSignal.timeout(1500)
+  }).catch(() => void 0);
+}
+async function shutdown() {
+  if (!pending) return;
+  await Promise.race([pending, new Promise((r) => setTimeout(r, 400))]);
+}
+function setTelemetryPreference(enabled) {
+  updateConfig((c) => {
+    c.telemetry = enabled;
+  });
+}
+
+// src/cli/update-check.ts
+init_version();
+var CHECK_EVERY_MS = 24 * 60 * 60 * 1e3;
+function isNewer(latest, current) {
+  const a = latest.split(".").map(Number);
+  const b = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    if (x !== y) return x > y;
+  }
+  return false;
+}
+async function maybeCheckForUpdate() {
+  try {
+    if (!process.stderr.isTTY) return;
+    if (process.env.CI || process.env.DO_NOT_TRACK) return;
+    if (process.env.VIDEODRAFT_NO_UPDATE_CHECK) return;
+    const config = readConfig();
+    if (config.last_update_check && Date.now() - config.last_update_check < CHECK_EVERY_MS) return;
+    updateConfig((c) => {
+      c.last_update_check = Date.now();
+    });
+    const res = await fetch("https://registry.npmjs.org/videodraft/latest", {
+      signal: AbortSignal.timeout(1500),
+      headers: { accept: "application/json" }
+    });
+    if (!res.ok) return;
+    const body = await res.json();
+    const latest = body?.version;
+    if (typeof latest === "string" && isNewer(latest, VERSION)) {
+      process.stderr.write(
+        `
+A new version of videodraft is available: ${VERSION} \u2192 ${latest}
+  npm install -g videodraft
+
+`
+      );
+    }
+  } catch {
+  }
+}
+
+// src/commands/auth.ts
+import { spawn } from "child_process";
+
+// src/auth/oauth.ts
+import http from "http";
+import crypto2 from "crypto";
+var STATIC_CLI_CLIENT_ID = "vd_client_cli";
+var OAUTH_SCOPE = "mcp";
+function b64url(buf) {
+  return buf.toString("base64url");
+}
+function createPkcePair() {
+  const verifier = b64url(crypto2.randomBytes(32));
+  const challenge = b64url(crypto2.createHash("sha256").update(verifier).digest());
+  return { verifier, challenge };
+}
+function buildAuthorizeUrl(params) {
+  const url = new URL("/api/oauth/authorize", params.baseUrl);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("client_id", params.clientId);
+  url.searchParams.set("redirect_uri", params.redirectUri);
+  url.searchParams.set("scope", OAUTH_SCOPE);
+  url.searchParams.set("state", params.state);
+  url.searchParams.set("code_challenge", params.codeChallenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("resource", `${params.baseUrl}/api/mcp`);
+  return url.toString();
+}
+async function probeClientId(baseUrl, clientId, redirectUri, fetchImpl = fetch) {
+  const { challenge } = createPkcePair();
+  const url = buildAuthorizeUrl({
+    baseUrl,
+    clientId,
+    redirectUri,
+    state: "probe",
+    codeChallenge: challenge
+  });
+  const res = await fetchImpl(url, { redirect: "manual", signal: AbortSignal.timeout(15e3) });
+  return res.status >= 300 && res.status < 400;
+}
+async function registerCliClient(baseUrl, fetchImpl = fetch) {
+  const res = await fetchImpl(new URL("/api/oauth/register", baseUrl), {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      client_name: "VideoDraft CLI",
+      redirect_uris: ["http://127.0.0.1/callback"],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none",
+      scope: OAUTH_SCOPE
+    }),
+    signal: AbortSignal.timeout(15e3)
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body?.client_id) {
+    throw new CliError(
+      `OAuth client registration failed: ${body?.error_description ?? body?.error ?? res.status}`
+    );
+  }
+  return body.client_id;
+}
+async function authorizeViaLoopback(params) {
+  const { verifier, challenge } = createPkcePair();
+  const state = b64url(crypto2.randomBytes(16));
+  const server = http.createServer();
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const port = server.address().port;
+  const redirectUri = `http://127.0.0.1:${port}/callback`;
+  const codePromise = new Promise((resolve, reject) => {
+    const timeout = setTimeout(
+      () => reject(new CliError("Timed out waiting for the browser login (5 minutes).")),
+      params.timeoutMs ?? 3e5
+    );
+    timeout.unref();
+    server.on("request", (req, res) => {
+      const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404).end();
+        return;
+      }
+      const err = url.searchParams.get("error");
+      const code = url.searchParams.get("code");
+      const gotState = url.searchParams.get("state");
+      const page = (title, body) => `<!doctype html><html><head><meta charset="utf-8"><title>${title}</title></head><body style="font-family:system-ui,sans-serif;max-width:480px;margin:80px auto;padding:0 20px;text-align:center"><h1 style="font-size:20px">${title}</h1><p style="color:#555">${body}</p></body></html>`;
+      if (err) {
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        res.end(page("Login failed", `${err}. You can close this tab and return to the terminal.`));
+        clearTimeout(timeout);
+        reject(new CliError(`Authorization failed: ${err}`));
+        return;
+      }
+      if (!code || gotState !== state) {
+        res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+        res.end(page("Login failed", "Missing code or state mismatch. Close this tab and retry."));
+        clearTimeout(timeout);
+        reject(new CliError("Authorization response missing code or state mismatch."));
+        return;
+      }
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      res.end(page("You're logged in to VideoDraft", "You can close this tab and return to the terminal."));
+      clearTimeout(timeout);
+      resolve(code);
+    });
+  });
+  codePromise.catch(() => {
+  });
+  try {
+    const authorizeUrl = buildAuthorizeUrl({
+      baseUrl: params.baseUrl,
+      clientId: params.clientId,
+      redirectUri,
+      state,
+      codeChallenge: challenge
+    });
+    await params.onAuthorizeUrl(authorizeUrl);
+    const code = await codePromise;
+    return { code, redirectUri, verifier };
+  } finally {
+    server.close();
+  }
+}
+async function exchangeCode(params) {
+  const fetchImpl = params.fetchImpl ?? fetch;
+  const res = await fetchImpl(new URL("/api/oauth/token", params.baseUrl), {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code: params.code,
+      redirect_uri: params.redirectUri,
+      client_id: params.clientId,
+      code_verifier: params.verifier
+    }).toString(),
+    signal: AbortSignal.timeout(3e4)
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body?.access_token) {
+    throw new CliError(
+      `Token exchange failed: ${body?.error_description ?? body?.error ?? `HTTP ${res.status}`}`
+    );
+  }
+  return body;
+}
+async function refreshAccessToken(params) {
+  const fetchImpl = params.fetchImpl ?? fetch;
+  const res = await fetchImpl(new URL("/api/oauth/token", params.baseUrl), {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: params.refreshToken,
+      client_id: params.clientId
+    }).toString(),
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!res.ok) return null;
+  const body = await res.json().catch(() => null);
+  return body?.access_token ? body : null;
+}
+async function revokeToken(baseUrl, token, fetchImpl = fetch) {
+  try {
+    await fetchImpl(new URL("/api/oauth/revoke", baseUrl), {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({ token }).toString(),
+      signal: AbortSignal.timeout(1e4)
+    });
+  } catch {
+  }
+}
+
+// src/core/rpc.ts
+var VideoDraftClient = class {
+  baseUrl;
+  tokenProvider;
+  fetchImpl;
+  userAgent;
+  requestTimeoutMs;
+  nextId = 1;
+  constructor(options) {
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.tokenProvider = options.tokenProvider;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.userAgent = options.userAgent ?? "videodraft-cli";
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 3e5;
+  }
+  get endpoint() {
+    return `${this.baseUrl}/api/mcp`;
+  }
+  async rpc(method, params) {
+    const token = await this.tokenProvider.getAccessToken();
+    let response = await this.post(method, params, token);
+    if (response.status === 401 && this.tokenProvider.onUnauthorized) {
+      const fresh = await this.tokenProvider.onUnauthorized();
+      if (fresh) response = await this.post(method, params, fresh);
+    }
+    if (response.status === 401) {
+      throw new AuthError("Token is invalid, expired, or revoked.");
+    }
+    if (!response.ok) {
+      let detail = "";
+      try {
+        const body2 = await response.json();
+        detail = body2?.error?.message ?? body2?.error ?? "";
+      } catch {
+      }
+      throw new RpcError(response.status, detail || `HTTP ${response.status} from ${this.endpoint}`);
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      throw new RpcError(0, `Server returned a non-JSON response (HTTP ${response.status}).`);
+    }
+    if (body?.error) {
+      throw new RpcError(body.error.code ?? -1, body.error.message ?? "Unknown RPC error", body.error.data);
+    }
+    return body?.result;
+  }
+  post(method, params, token) {
+    return this.fetchImpl(this.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`,
+        "user-agent": this.userAgent
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: this.nextId++,
+        method,
+        ...params === void 0 ? {} : { params }
+      }),
+      signal: AbortSignal.timeout(this.requestTimeoutMs)
+    });
+  }
+  /**
+   * Batch several JSON-RPC requests into ONE HTTP round trip (the server
+   * implements JSON-RPC 2.0 batching). With N concurrent jobs this turns N
+   * polling requests per tick into 1 — the difference between 50 waiting CLIs
+   * generating ~17 req/s and ~0.3 req/s against /api/mcp.
+   * Results are matched by id (order-independent per spec).
+   */
+  async rpcBatch(calls) {
+    if (calls.length === 0) return [];
+    const token = await this.tokenProvider.getAccessToken();
+    const ids = calls.map(() => this.nextId++);
+    const payload = calls.map((c, i) => ({
+      jsonrpc: "2.0",
+      id: ids[i],
+      method: c.method,
+      ...c.params === void 0 ? {} : { params: c.params }
+    }));
+    const post = (bearer) => this.fetchImpl(this.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${bearer}`,
+        "user-agent": this.userAgent
+      },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(this.requestTimeoutMs)
+    });
+    let response = await post(token);
+    if (response.status === 401 && this.tokenProvider.onUnauthorized) {
+      const fresh = await this.tokenProvider.onUnauthorized();
+      if (fresh) response = await post(fresh);
+    }
+    if (response.status === 401) throw new AuthError("Token is invalid, expired, or revoked.");
+    if (!response.ok) throw new RpcError(response.status, `HTTP ${response.status} from ${this.endpoint}`);
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      throw new RpcError(0, `Server returned a non-JSON response (HTTP ${response.status}).`);
+    }
+    const responses = Array.isArray(body) ? body : [body];
+    const byId = new Map(responses.map((r) => [r?.id, r]));
+    return ids.map((id) => {
+      const r = byId.get(id);
+      if (!r) throw new RpcError(-1, `Batch response missing id ${id}`);
+      if (r.error) throw new RpcError(r.error.code ?? -1, r.error.message ?? "Unknown RPC error", r.error.data);
+      return r.result;
+    });
+  }
+  /**
+   * Call several tools in one batched HTTP request. Per-item failures come
+   * back as { ok:false, error } instead of throwing, so one failed job can't
+   * abort polling of its siblings.
+   */
+  async callToolBatch(calls) {
+    const results = await this.rpcBatch(
+      calls.map((c) => ({ method: "tools/call", params: { name: c.name, arguments: c.args ?? {} } }))
+    );
+    return results.map((result) => {
+      const text = result?.content?.[0]?.text ?? "";
+      if (result?.isError) {
+        return { ok: false, error: text.replace(/^Error:\s*/, "") || "tool failed" };
+      }
+      try {
+        return { ok: true, result: JSON.parse(text) };
+      } catch {
+        return { ok: true, result: text };
+      }
+    });
+  }
+  /**
+   * Call an MCP tool and return its parsed result.
+   * The server wraps results as { content: [{type:"text", text}], isError } —
+   * text is JSON for successes and "Error: ..." for tool failures.
+   */
+  async callTool(name, args = {}) {
+    const result = await this.rpc(
+      "tools/call",
+      { name, arguments: args }
+    );
+    const text = result?.content?.[0]?.text ?? "";
+    if (result?.isError) {
+      throw new ToolError(name, text.replace(/^Error:\s*/, "") || `Tool ${name} failed`);
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  async listTools() {
+    const result = await this.rpc("tools/list");
+    return result?.tools ?? [];
+  }
+  async ping() {
+    await this.rpc("ping");
+  }
+};
+
+// src/auth/token-provider.ts
+var EXPIRY_SKEW_MS = 6e4;
+function isExpiring(profile) {
+  if (!profile.expires_at) return false;
+  return new Date(profile.expires_at).getTime() - Date.now() < EXPIRY_SKEW_MS;
+}
+function saveRotatedTokens(profileName, tokens, env) {
+  updateConfig((config) => {
+    const profile = config.profiles[profileName];
+    if (!profile) return;
+    profile.access_token = tokens.access_token;
+    profile.refresh_token = tokens.refresh_token;
+    profile.expires_at = new Date(Date.now() + tokens.expires_in * 1e3).toISOString();
+  }, env);
+}
+async function refreshUnderLock(profileName, env) {
+  return withLock(
+    "oauth-refresh",
+    async () => {
+      const { profile } = getProfile(profileName, env);
+      if (!profile) return null;
+      if (profile.auth_kind !== "oauth") return profile.access_token;
+      if (!isExpiring(profile)) return profile.access_token;
+      if (!profile.refresh_token || !profile.client_id) return null;
+      const tokens = await refreshAccessToken({
+        baseUrl: profile.base_url || DEFAULT_BASE_URL,
+        clientId: profile.client_id,
+        refreshToken: profile.refresh_token
+      });
+      if (!tokens) return null;
+      saveRotatedTokens(profileName, tokens, env);
+      return tokens.access_token;
+    },
+    env
+  );
+}
+function profileTokenProvider(profileName, env = process.env) {
+  return {
+    async getAccessToken() {
+      const { profile } = getProfile(profileName, env);
+      if (!profile?.access_token) throw new AuthError();
+      if (profile.auth_kind === "oauth" && isExpiring(profile)) {
+        const fresh = await refreshUnderLock(profileName, env);
+        if (!fresh) throw new AuthError("Your session expired and could not be refreshed.");
+        return fresh;
+      }
+      return profile.access_token;
+    },
+    async onUnauthorized() {
+      const { profile } = getProfile(profileName, env);
+      if (profile?.auth_kind !== "oauth") return null;
+      updateConfig((config) => {
+        const p = config.profiles[profileName];
+        if (p) p.expires_at = (/* @__PURE__ */ new Date(0)).toISOString();
+      }, env);
+      return refreshUnderLock(profileName, env);
+    }
+  };
+}
+function resolveAuth(options) {
+  const env = options.env ?? process.env;
+  const envBase = env.VIDEODRAFT_BASE_URL;
+  if (options.token) {
+    return {
+      tokenProvider: { getAccessToken: async () => options.token },
+      baseUrl: options.baseUrl ?? envBase ?? DEFAULT_BASE_URL,
+      source: "flag"
+    };
+  }
+  if (env.VIDEODRAFT_API_KEY) {
+    return {
+      tokenProvider: { getAccessToken: async () => env.VIDEODRAFT_API_KEY },
+      baseUrl: options.baseUrl ?? envBase ?? DEFAULT_BASE_URL,
+      source: "env"
+    };
+  }
+  const { name, profile } = getProfile(options.profile, env);
+  return {
+    tokenProvider: profileTokenProvider(name, env),
+    baseUrl: options.baseUrl ?? envBase ?? profile?.base_url ?? DEFAULT_BASE_URL,
+    source: "profile",
+    profileName: name
+  };
+}
+
+// src/cli/context.ts
+init_version();
+function parseDuration(value, fallbackMs) {
+  if (!value) return fallbackMs;
+  const m = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(value.trim());
+  if (!m) return fallbackMs;
+  const n = Number(m[1]);
+  switch (m[2]) {
+    case "ms":
+      return n;
+    case "m":
+      return n * 6e4;
+    case "h":
+      return n * 36e5;
+    default:
+      return n * 1e3;
+  }
+}
+function buildContext(command) {
+  const flags = command.optsWithGlobals();
+  const out = makeOutput({ json: flags.json, color: flags.color });
+  const auth = resolveAuth({
+    token: flags.token,
+    baseUrl: flags.baseUrl,
+    profile: flags.profile
+  });
+  const client = new VideoDraftClient({
+    tokenProvider: auth.tokenProvider,
+    baseUrl: auth.baseUrl,
+    userAgent: `videodraft-cli/${VERSION}`
+  });
+  return {
+    client,
+    out,
+    flags,
+    baseUrl: auth.baseUrl,
+    profileName: auth.profileName,
+    intervalMs: parseDuration(flags.waitInterval, 3e3),
+    timeoutMs: parseDuration(flags.waitTimeout, 6e5),
+    adaptive: flags.waitInterval === void 0
+  };
+}
+function collect(value, previous = []) {
+  return [...previous, value];
+}
+function compact(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+
+// src/commands/auth.ts
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    const child = spawn(cmd, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" });
+    child.unref();
+  } catch {
+  }
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8").trim();
+}
+function saveProfile(profileName, profile) {
+  updateConfig((config) => {
+    config.profiles[profileName] = profile;
+    config.active_profile = profileName;
+  });
+}
+function registerAuthCommands(program) {
+  program.command("login").description("Authenticate with VideoDraft (browser login; --token for a PAT)").option("--token <vd_mcp_token>", "use a personal access token from /mcp-keys instead of the browser").option("--with-token", "read a personal access token from stdin").option("--no-browser", "print the login URL instead of opening a browser").action(async function() {
+    const opts = this.opts();
+    const globals = this.optsWithGlobals();
+    const baseUrl = (globals.baseUrl ?? process.env.VIDEODRAFT_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    const profileName = globals.profile ?? "default";
+    const ctxOut = buildContext(this).out;
+    let pat = opts.token;
+    if (!pat && opts.withToken) pat = await readStdin();
+    if (pat) {
+      if (!pat.startsWith("vd_mcp_")) {
+        throw new CliError("That does not look like a VideoDraft token (expected vd_mcp_...).", EXIT.USAGE);
+      }
+      const client = new VideoDraftClient({
+        tokenProvider: { getAccessToken: async () => pat },
+        baseUrl
+      });
+      const me = await client.callTool("whoami");
+      saveProfile(profileName, { base_url: baseUrl, auth_kind: "pat", access_token: pat });
+      capture("cli_login", { method: "pat" });
+      emit(ctxOut, { ok: true, method: "pat", user: me }, (o) => {
+        note(o, fmt.green(o, `Logged in as ${me?.email ?? me?.user_id ?? "user"} (PAT, ${baseUrl})`));
+      });
+      return;
+    }
+    const existing = getProfile(profileName).profile;
+    let clientId = existing?.client_id ?? process.env.VIDEODRAFT_OAUTH_CLIENT_ID ?? STATIC_CLI_CLIENT_ID;
+    const known = await probeClientId(baseUrl, clientId, "http://127.0.0.1:1/callback").catch(() => false);
+    if (!known) {
+      note(ctxOut, fmt.dim(ctxOut, `OAuth client ${clientId} not registered on ${baseUrl} \u2014 registering one...`));
+      clientId = await registerCliClient(baseUrl);
+    }
+    const spin = spinner(ctxOut, "Waiting for browser login\u2026");
+    try {
+      const { code, redirectUri, verifier } = await authorizeViaLoopback({
+        baseUrl,
+        clientId,
+        onAuthorizeUrl: (url) => {
+          if (opts.browser !== false) openBrowser(url);
+          note(ctxOut, `
+${fmt.bold(ctxOut, "Open this URL to log in:")}
+  ${url}
+`);
+        }
+      });
+      spin.update("Exchanging authorization code\u2026");
+      const tokens = await exchangeCode({ baseUrl, clientId, code, redirectUri, verifier });
+      saveProfile(profileName, {
+        base_url: baseUrl,
+        auth_kind: "oauth",
+        access_token: tokens.access_token,
+        refresh_token: tokens.refresh_token,
+        expires_at: new Date(Date.now() + tokens.expires_in * 1e3).toISOString(),
+        client_id: clientId
+      });
+      spin.stop();
+      const client = new VideoDraftClient({
+        tokenProvider: { getAccessToken: async () => tokens.access_token },
+        baseUrl
+      });
+      const me = await client.callTool("whoami").catch(() => null);
+      capture("cli_login", { method: "oauth" });
+      emit(ctxOut, { ok: true, method: "oauth", user: me }, (o) => {
+        note(o, fmt.green(o, `Logged in as ${me?.email ?? "user"} (${baseUrl})`));
+        note(o, fmt.dim(o, `Tokens stored in ${process.env.VIDEODRAFT_CONFIG_DIR ?? "~/.config/videodraft"}/config.json`));
+      });
+    } catch (err) {
+      spin.stop();
+      throw err;
+    }
+  });
+  program.command("logout").description("Revoke the current OAuth grant (best-effort) and clear stored credentials").action(async function() {
+    const globals = this.optsWithGlobals();
+    const profileName = globals.profile ?? "default";
+    const ctxOut = buildContext(this).out;
+    const { profile } = getProfile(profileName);
+    if (!profile) {
+      emit(ctxOut, { ok: true, message: "No stored credentials." }, (o) => note(o, "No stored credentials."));
+      return;
+    }
+    if (profile.auth_kind === "oauth") {
+      await revokeToken(profile.base_url, profile.access_token);
+      if (profile.refresh_token) await revokeToken(profile.base_url, profile.refresh_token);
+    }
+    updateConfig((config) => {
+      delete config.profiles[profileName];
+    });
+    capture("cli_logout");
+    emit(ctxOut, { ok: true }, (o) => {
+      note(o, fmt.green(o, "Logged out."));
+      if (profile.auth_kind === "pat") {
+        note(o, fmt.dim(o, "PATs are revoked from the web app: https://app.videodraft.ai/mcp-keys"));
+      }
+    });
+  });
+  program.command("whoami").description("Show the authenticated VideoDraft user").action(async function() {
+    const ctx = buildContext(this);
+    const me = await ctx.client.callTool("whoami");
+    emit(ctx.out, me, (o) => {
+      kv(o, [
+        ["User", me?.email ?? me?.user_id],
+        ["User id", me?.user_id ?? me?.id],
+        ["Workspace", me?.workspace_id ?? me?.workspace ?? "personal"],
+        ["Server", ctx.baseUrl]
+      ]);
+    });
+  });
+}
+
+// src/commands/account.ts
+function registerAccountCommands(program) {
+  program.command("credits").description("Show your credit balance").action(async function() {
+    const ctx = buildContext(this);
+    const balance = await ctx.client.callTool("get_credits_balance");
+    emit(ctx.out, balance, (o) => {
+      kv(o, [
+        ["Available credits", balance?.availableCredits],
+        ["Monthly allowance", balance?.totalCreditsMonthly],
+        ["Used this month", balance?.monthlyCreditsUsed],
+        ["Bonus credits", balance?.bonusCredits],
+        ["Bonus expiry", balance?.bonusCreditsExpiry]
+      ]);
+    });
+  });
+  program.command("costs [model]").description("Show credit costs \u2014 pass a model id plus video settings for an exact estimate").option("--type <type>", "image | video").option("--duration <seconds>", "video duration in seconds").option("--resolution <res>", 'e.g. "720p", "1080p", "1K", "2K"').option("--quality <tier>", 'e.g. "standard", "pro", "fast"').option("--rendering-speed <tier>", 'image speed/cost tier, e.g. Ideogram V4 "Turbo"/"Balanced"/"Quality"').option("--audio", "include native model audio in the estimate").option("--no-audio", "exclude native model audio").option("--num <n>", "image batch size").action(async function(model) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const result = await ctx.client.callTool(
+      "get_model_costs",
+      compact({
+        model_id: model,
+        type: opts.type,
+        duration_seconds: opts.duration ? Number(opts.duration) : void 0,
+        resolution: opts.resolution,
+        quality: opts.quality,
+        rendering_speed: opts.renderingSpeed,
+        generate_audio: opts.audio,
+        num_images: opts.num ? Number(opts.num) : void 0
+      })
+    );
+    emit(ctx.out, result);
+  });
+  program.command("models [kind]").description("List available models: image | video | voices | styles (default: image + video)").action(async function(kind) {
+    const ctx = buildContext(this);
+    const wanted = kind ?? "all";
+    const result = {};
+    if (wanted === "image" || wanted === "all") {
+      result.image = await ctx.client.callTool("list_available_image_models");
+    }
+    if (wanted === "video" || wanted === "all") {
+      result.video = await ctx.client.callTool("list_available_video_models");
+    }
+    if (wanted === "voices") result.voices = await ctx.client.callTool("list_available_voices");
+    if (wanted === "styles") result.styles = await ctx.client.callTool("list_available_styles");
+    emit(ctx.out, result, (o) => {
+      for (const [section, payload] of Object.entries(result)) {
+        const models = Array.isArray(payload) ? payload : payload?.models ?? payload?.voices ?? payload?.styles ?? [];
+        process.stdout.write(`
+${section.toUpperCase()}
+`);
+        if (!Array.isArray(models) || models.length === 0) {
+          process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+          continue;
+        }
+        table(
+          o,
+          ["id", "name", "cost"],
+          models.map((m) => [
+            String(m.id ?? m.model_id ?? m.voice_id ?? ""),
+            String(m.name ?? "").slice(0, 40),
+            String(m.credit_cost ?? m.cost ?? m.pricing?.summary ?? "")
+          ])
+        );
+      }
+    });
+  });
+  program.command("workspaces").description("List your workspaces (the active one is bound to your token)").action(async function() {
+    const ctx = buildContext(this);
+    const result = await ctx.client.callTool("list_workspaces");
+    const workspaces = result?.workspaces ?? result ?? [];
+    emit(ctx.out, result, (o) => {
+      table(
+        o,
+        ["id", "name", "role", "active"],
+        workspaces.map((w) => [
+          String(w.id ?? ""),
+          String(w.name ?? ""),
+          String(w.role ?? ""),
+          w.is_active || w.active ? "\u2713" : ""
+        ])
+      );
+    });
+  });
+  const sessions = program.command("sessions").description("AI Studio sessions");
+  sessions.command("list", { isDefault: true }).description("List AI Studio sessions").option("--project <id>", "filter to a project's sessions").action(async function() {
+    const ctx = buildContext(this);
+    const result = await ctx.client.callTool(
+      "list_ai_studio_sessions",
+      compact({ project_id: this.opts().project })
+    );
+    const rows = result?.sessions ?? result ?? [];
+    emit(ctx.out, result, (o) => {
+      if (!Array.isArray(rows)) return;
+      table(
+        o,
+        ["id", "name", "created"],
+        rows.map((s) => [
+          String(s.id ?? s.session_id ?? ""),
+          String(s.name ?? "").slice(0, 40),
+          String(s.created_at ?? s.createdAt ?? "").slice(0, 19)
+        ])
+      );
+    });
+  });
+  sessions.command("create <name>").description("Create an AI Studio session (reuse its id across standalone generations)").option("--project <id>", "attach the session to a project").action(async function(name) {
+    const ctx = buildContext(this);
+    const result = await ctx.client.callTool(
+      "create_ai_studio_session",
+      compact({ name, project_id: this.opts().project })
+    );
+    emit(ctx.out, result, (o) => {
+      const id = result?.session_id ?? result?.id;
+      process.stdout.write(`${id ?? JSON.stringify(result)}
+`);
+    });
+  });
+}
+
+// src/commands/projects.ts
+import { spawn as spawn2 } from "child_process";
+function registerProjectCommands(program) {
+  const projects = program.command("projects").description("List and manage projects");
+  projects.command("list", { isDefault: true }).description("List projects").option("--limit <n>", "max projects (default 50)").option("--offset <n>", "pagination offset").option("--favorites", "only favorited projects").action(async function() {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const result = await ctx.client.callTool(
+      "list_projects",
+      compact({
+        limit: opts.limit ? Number(opts.limit) : void 0,
+        offset: opts.offset ? Number(opts.offset) : void 0,
+        favorites_only: opts.favorites || void 0
+      })
+    );
+    const rows = result?.projects ?? [];
+    emit(ctx.out, result, (o) => {
+      table(
+        o,
+        ["id", "title", "status", "modified"],
+        rows.map((p) => [
+          String(p.id ?? ""),
+          String(p.title ?? "Untitled").slice(0, 44),
+          String(p.status ?? ""),
+          String(p.lastModified ?? "").slice(0, 19)
+        ])
+      );
+    });
+  });
+  projects.command("get <project_id>").description("Fetch a project (summary view; --raw for the editable blob)").option("--raw", "return the raw editable JSON blob").action(async function(projectId) {
+    const ctx = buildContext(this);
+    const result = await ctx.client.callTool("get_project", {
+      project_id: projectId,
+      view: this.opts().raw ? "raw" : "summary"
+    });
+    emit(ctx.out, result);
+  });
+  projects.command("delete <project_id>").description("Permanently delete a project (cannot be undone)").option("--yes", "skip the confirmation").action(async function(projectId) {
+    const ctx = buildContext(this);
+    if (!this.opts().yes) {
+      throw new CliError(
+        "Refusing to delete without --yes. Deletion is permanent for every collaborator.",
+        EXIT.USAGE
+      );
+    }
+    const result = await ctx.client.callTool("delete_project", { project_id: projectId });
+    emit(ctx.out, result, (o) => note(o, fmt.green(o, `Deleted project ${projectId}.`)));
+  });
+  projects.command("favorite <project_id>").description("Star or unstar a project").option("--remove", "unstar instead of star").action(async function(projectId) {
+    const ctx = buildContext(this);
+    const favorite = !this.opts().remove;
+    const result = await ctx.client.callTool("set_project_favorite", {
+      project_id: projectId,
+      favorite
+    });
+    emit(ctx.out, result, (o) => note(o, favorite ? "Starred." : "Unstarred."));
+  });
+  projects.command("open <project_id>").description("Open the project in your browser").action(async function(projectId) {
+    const ctx = buildContext(this);
+    const result = await ctx.client.callTool("get_project", {
+      project_id: projectId,
+      view: "summary"
+    });
+    const url = result?.urls?.storyboard ?? result?.urls?.script ?? `${ctx.baseUrl}/projects/${projectId}`;
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    try {
+      const child = spawn2(cmd, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" });
+      child.unref();
+    } catch {
+    }
+    emit(ctx.out, { url }, (o) => note(o, url));
+  });
+  const checkpoint = program.command("checkpoint").description("Project version checkpoints");
+  checkpoint.command("create <project_id>").description("Snapshot the project as a new version").option("--name <name>", "version name").option("--description <text>", "version description").action(async function(projectId) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const result = await ctx.client.callTool(
+      "create_project_checkpoint",
+      compact({ project_id: projectId, name: opts.name, description: opts.description })
+    );
+    emit(ctx.out, result);
+  });
+  checkpoint.command("list <project_id>").description("List a project's checkpoints").action(async function(projectId) {
+    const ctx = buildContext(this);
+    const result = await ctx.client.callTool("list_project_checkpoints", { project_id: projectId });
+    emit(ctx.out, result);
+  });
+  checkpoint.command("restore <project_id> [version_number]").description("Restore a project to a saved version (current state is snapshotted first)").option("--checkpoint-id <id>", "restore by checkpoint UUID instead of version number").action(async function(projectId, versionNumber) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    if (!versionNumber && !opts.checkpointId) {
+      throw new CliError("Pass a version_number or --checkpoint-id.", EXIT.USAGE);
+    }
+    const result = await ctx.client.callTool(
+      "restore_project_checkpoint",
+      compact({
+        project_id: projectId,
+        version_number: versionNumber ? Number(versionNumber) : void 0,
+        checkpoint_id: opts.checkpointId
+      })
+    );
+    emit(ctx.out, result);
+  });
+}
+
+// src/commands/generate.ts
+import fs5 from "fs";
+
+// src/core/poll.ts
+function nextPollDelay(baseMs, elapsedMs, adaptive = true) {
+  if (!adaptive) return baseMs;
+  const factor = elapsedMs >= 18e4 ? 3 : elapsedMs >= 6e4 ? 2 : 1;
+  const scaled = Math.min(baseMs * factor, 15e3);
+  const jitter = scaled * 0.1 * (Math.random() * 2 - 1);
+  return Math.max(250, Math.round(scaled + jitter));
+}
+var GENERATION_TERMINAL = /* @__PURE__ */ new Set(["completed", "failed"]);
+var EXPORT_TERMINAL = /* @__PURE__ */ new Set(["finished", "failed"]);
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function extractOutputUrls(payload) {
+  const urls = [];
+  const push = (value) => {
+    if (typeof value === "string" && /^https?:\/\//.test(value)) urls.push(value);
+  };
+  if (Array.isArray(payload?.outputUrls)) payload.outputUrls.forEach(push);
+  if (Array.isArray(payload?.output_urls)) payload.output_urls.forEach(push);
+  push(payload?.outputUrl);
+  push(payload?.output_url);
+  push(payload?.video_url);
+  push(payload?.videoUrl);
+  push(payload?.image_url);
+  push(payload?.imageUrl);
+  push(payload?.url);
+  push(payload?.audio_url);
+  push(payload?.audioUrl);
+  push(payload?.speech_url);
+  push(payload?.public_url);
+  return [...new Set(urls)];
+}
+async function pollGeneration(client, jobId, options = {}) {
+  const intervalMs = options.intervalMs ?? 3e3;
+  const timeoutMs = options.timeoutMs ?? 6e5;
+  const startedAt = Date.now();
+  const deadline = startedAt + timeoutMs;
+  for (; ; ) {
+    const payload = await client.callTool("check_generation_status", { job_id: jobId });
+    const status = String(payload?.status ?? "unknown");
+    options.onTick?.(status, payload);
+    if (GENERATION_TERMINAL.has(status)) {
+      return { status, outputUrls: extractOutputUrls(payload), payload };
+    }
+    if (Date.now() > deadline) {
+      throw new TimeoutError(
+        `Timed out after ${Math.round(timeoutMs / 1e3)}s waiting for job ${jobId} (last status: ${status}). It is still running server-side \u2014 check later with: videodraft status ${jobId}`
+      );
+    }
+    await sleep(nextPollDelay(intervalMs, Date.now() - startedAt, options.adaptive));
+  }
+}
+async function pollGenerationsBatch(client, jobIds, options = {}) {
+  const intervalMs = options.intervalMs ?? 3e3;
+  const timeoutMs = options.timeoutMs ?? 6e5;
+  const startedAt = Date.now();
+  const deadline = startedAt + timeoutMs;
+  const done = /* @__PURE__ */ new Map();
+  let pending2 = [...new Set(jobIds)];
+  const MAX_BATCH = 25;
+  while (pending2.length > 0) {
+    const replies = [];
+    for (let at = 0; at < pending2.length; at += MAX_BATCH) {
+      const chunk = pending2.slice(at, at + MAX_BATCH);
+      replies.push(
+        ...await client.callToolBatch(
+          chunk.map((id) => ({ name: "check_generation_status", args: { job_id: id } }))
+        )
+      );
+    }
+    const still = [];
+    for (let i = 0; i < pending2.length; i++) {
+      const jobId = pending2[i];
+      const reply = replies[i];
+      if (!reply.ok) {
+        const result = {
+          status: "failed",
+          outputUrls: [],
+          payload: { error: reply.error }
+        };
+        done.set(jobId, result);
+        options.onJobDone?.(jobId, result);
+        continue;
+      }
+      const payload = reply.result;
+      const status = String(payload?.status ?? "unknown");
+      if (GENERATION_TERMINAL.has(status)) {
+        const result = { status, outputUrls: extractOutputUrls(payload), payload };
+        done.set(jobId, result);
+        options.onJobDone?.(jobId, result);
+      } else {
+        still.push(jobId);
+      }
+    }
+    pending2 = still;
+    options.onTick?.(`${done.size}/${jobIds.length} done`, { pending: pending2.length });
+    if (pending2.length === 0) break;
+    if (Date.now() > deadline) {
+      throw new TimeoutError(
+        `Timed out after ${Math.round(timeoutMs / 1e3)}s with ${pending2.length} job(s) still running: ${pending2.join(", ")}. They continue server-side \u2014 resume with: videodraft wait ${pending2.join(" ")}`
+      );
+    }
+    await sleep(nextPollDelay(intervalMs, Date.now() - startedAt, options.adaptive));
+  }
+  return done;
+}
+async function pollExport(client, ref, options = {}) {
+  const intervalMs = options.intervalMs ?? 5e3;
+  const timeoutMs = options.timeoutMs ?? 12e5;
+  const startedAt = Date.now();
+  const deadline = startedAt + timeoutMs;
+  for (; ; ) {
+    const payload = await client.callTool("check_export_status", {
+      ...ref.exportId ? { export_id: ref.exportId } : {},
+      ...ref.projectId ? { project_id: ref.projectId } : {}
+    });
+    const status = String(payload?.status ?? "unknown");
+    options.onTick?.(status, payload);
+    if (EXPORT_TERMINAL.has(status)) {
+      return { status, videoUrl: payload?.video_url ?? payload?.videoUrl, payload };
+    }
+    if (Date.now() > deadline) {
+      throw new TimeoutError(
+        `Timed out waiting for export${ref.exportId ? ` ${ref.exportId}` : ""} (last status: ${status}).`
+      );
+    }
+    await sleep(nextPollDelay(intervalMs, Date.now() - startedAt, options.adaptive));
+  }
+}
+
+// src/core/download.ts
+import fs3 from "fs";
+import path2 from "path";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+function extFromUrl(url, fallback = "bin") {
+  try {
+    const pathname = new URL(url).pathname;
+    const ext = path2.extname(pathname).replace(/^\./, "");
+    return ext || fallback;
+  } catch {
+    return fallback;
+  }
+}
+function renderTemplate(template, vars) {
+  const hasPlaceholders = /\{(job_id|index|ext|name)\}/.test(template);
+  if (!hasPlaceholders) {
+    const looksLikeFile = path2.extname(template) !== "";
+    if (looksLikeFile) {
+      if (vars.index > 0) {
+        const ext = path2.extname(template);
+        return `${template.slice(0, -ext.length)}_${vars.index}${ext}`;
+      }
+      return template;
+    }
+    return path2.join(template, `${vars.job_id ?? vars.name ?? "output"}_${vars.index}.${vars.ext}`);
+  }
+  return template.replaceAll("{job_id}", vars.job_id ?? "job").replaceAll("{index}", String(vars.index)).replaceAll("{ext}", vars.ext).replaceAll("{name}", vars.name ?? "output");
+}
+async function downloadUrl(url, destPath, fetchImpl = fetch) {
+  const res = await fetchImpl(url, { signal: AbortSignal.timeout(6e5) });
+  if (!res.ok || !res.body) {
+    throw new CliError(`Download failed (HTTP ${res.status}): ${url}`);
+  }
+  fs3.mkdirSync(path2.dirname(path2.resolve(destPath)), { recursive: true });
+  await pipeline(Readable.fromWeb(res.body), fs3.createWriteStream(destPath));
+  const bytes = fs3.statSync(destPath).size;
+  return { url, path: destPath, bytes };
+}
+async function downloadOutputs(urls, template, vars, fetchImpl = fetch) {
+  const files = [];
+  for (let i = 0; i < urls.length; i++) {
+    const url = urls[i];
+    const dest = renderTemplate(template, {
+      job_id: vars.job_id,
+      name: vars.name,
+      index: i,
+      ext: extFromUrl(url)
+    });
+    files.push(await downloadUrl(url, dest, fetchImpl));
+  }
+  return files;
+}
+
+// src/core/upload.ts
+import fs4 from "fs";
+import path3 from "path";
+var MIME_BY_EXT = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  heic: "image/heic",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm",
+  m4v: "video/x-m4v",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  ogg: "audio/ogg",
+  flac: "audio/flac"
+};
+function guessContentType(filename) {
+  const ext = path3.extname(filename).replace(/^\./, "").toLowerCase();
+  return MIME_BY_EXT[ext];
+}
+async function uploadFile(client, localPath, options = {}) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const resolved = path3.resolve(localPath);
+  if (!fs4.existsSync(resolved)) {
+    throw new CliError(`File not found: ${resolved}`);
+  }
+  const filename = path3.basename(resolved);
+  const contentType = options.contentType ?? guessContentType(filename);
+  if (!contentType) {
+    throw new CliError(
+      `Cannot infer media type for "${filename}". Pass --content-type (image/*, video/* or audio/*).`
+    );
+  }
+  const created = await client.callTool("create_media_upload", {
+    filename,
+    content_type: contentType
+  });
+  const uploadUrl = created?.upload_url;
+  const filePath = created?.file_path;
+  if (!uploadUrl || !filePath) {
+    throw new CliError("create_media_upload did not return upload_url/file_path.");
+  }
+  const body = fs4.readFileSync(resolved);
+  const putRes = await fetchImpl(uploadUrl, {
+    method: "PUT",
+    headers: { "content-type": contentType },
+    body,
+    signal: AbortSignal.timeout(6e5)
+  });
+  if (!putRes.ok) {
+    throw new CliError(`Upload PUT failed (HTTP ${putRes.status}). The presigned URL may have expired \u2014 retry.`);
+  }
+  const finalized = await client.callTool("finalize_media_upload", {
+    file_path: filePath,
+    original_filename: filename
+  });
+  const url = finalized?.url ?? finalized?.cdn_url;
+  if (!url) {
+    throw new CliError("finalize_media_upload did not return a public url.");
+  }
+  return { ...finalized, url, file_path: filePath };
+}
+
+// src/commands/generate.ts
+var URI_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
+async function resolveRefs(ctx, refs) {
+  const resolved = [];
+  for (const ref of refs) {
+    if (URI_SCHEME.test(ref)) {
+      resolved.push(ref);
+      continue;
+    }
+    if (!fs5.existsSync(ref)) {
+      throw new Error(`"${ref}" is neither a URL nor an existing local file.`);
+    }
+    note(ctx.out, fmt.dim(ctx.out, `Uploading ${ref}\u2026`));
+    const uploaded = await uploadFile(ctx.client, ref);
+    resolved.push(uploaded.url);
+  }
+  return resolved;
+}
+function parseSegments(values) {
+  return values.map((v) => {
+    const i = v.lastIndexOf(":");
+    if (i <= 0 || i === v.length - 1) {
+      throw new CliError(`--segment expects "prompt:seconds", got: ${v}`, EXIT.USAGE);
+    }
+    const prompt = v.slice(0, i).trim();
+    const duration = Number(v.slice(i + 1));
+    if (!prompt || !Number.isFinite(duration) || duration <= 0) {
+      throw new CliError(`--segment "${v}" must be "<prompt>:<positive seconds>".`, EXIT.USAGE);
+    }
+    return { prompt, duration };
+  });
+}
+async function printEstimate(ctx, params) {
+  const estimate = await ctx.client.callTool(
+    "get_model_costs",
+    compact({
+      model_id: params.model,
+      type: params.type,
+      duration_seconds: params.duration,
+      resolution: params.resolution,
+      quality: params.quality,
+      rendering_speed: params.renderingSpeed,
+      generate_audio: params.audio,
+      num_images: params.num
+    })
+  );
+  emit(ctx.out, { estimate, note: "No credits were spent (--estimate)." });
+}
+async function handleAsyncJob(ctx, submitted, options) {
+  const jobId = submitted?.job_id ?? submitted?.jobId;
+  if (!jobId || !options.wait) {
+    emit(ctx.out, submitted, (o) => {
+      note(o, `Submitted${jobId ? ` \u2014 job ${jobId}` : ""}.`);
+      if (jobId) note(o, fmt.dim(o, `Poll with: videodraft status ${jobId}`));
+    });
+    return;
+  }
+  const spin = spinner(ctx.out, `${options.label} (job ${jobId})\u2026`);
+  try {
+    const result = await pollGeneration(ctx.client, jobId, {
+      intervalMs: ctx.intervalMs,
+      timeoutMs: ctx.timeoutMs,
+      adaptive: ctx.adaptive,
+      onTick: (status) => spin.update(`${options.label} \u2014 ${status} (job ${jobId})`)
+    });
+    spin.stop();
+    if (result.status === "failed") {
+      emit(ctx.out, { job_id: jobId, ...result.payload }, (o) => {
+        note(o, fmt.red(o, `Job ${jobId} failed: ${result.payload?.error ?? "unknown error"}`));
+      });
+      process.exitCode = 1;
+      return;
+    }
+    let downloaded;
+    if (options.download && result.outputUrls.length > 0) {
+      downloaded = await downloadOutputs(result.outputUrls, options.download, { job_id: jobId });
+    }
+    emit(
+      ctx.out,
+      { job_id: jobId, status: result.status, outputs: result.outputUrls, downloaded_files: downloaded },
+      (o) => {
+        note(o, fmt.green(o, `Completed \u2014 job ${jobId}`));
+        for (const url of result.outputUrls) process.stdout.write(`${url}
+`);
+        for (const file of downloaded ?? []) note(o, fmt.dim(o, `saved ${file.path}`));
+      }
+    );
+  } catch (err) {
+    spin.stop();
+    throw err;
+  }
+}
+function registerGenerateCommands(program) {
+  const generate = program.command("generate").description("Generate images, video, voiceovers and music");
+  generate.command("image <prompt...>").description("Generate an image (async; waits by default)").option("--model <id>", "image model id (default nano-banana-2)").option("--ar <ratio>", 'aspect ratio, e.g. "16:9"').option("--resolution <res>", 'e.g. "1K", "2K", "4K"').option("--quality <tier>", "model-specific quality tier").option("--rendering-speed <tier>", 'Ideogram speed/cost tier, e.g. V4 "Turbo"/"Balanced"/"Quality"').option("--num <n>", "variations of this prompt in one call (1-4)").option("--seed <n>", "seed (supported models only, e.g. Flux, Ideogram V4)").option("--ref <url|file>", "reference image (repeatable; local files are uploaded)", collect, []).option("--video-ref <url|file>", "video reference \u2014 nano-banana-2 only (http(s)/gs:///YouTube, or local file)").option("--style <id>", "style preset id").option("--project <id>", "attach to a project").option("--session <id>", "AI Studio session id").option("--scene <n>", "0-based scene index (with --project: writes onto that shot)").option("--shot <n>", "0-based shot index").option("--download <path>", "download outputs (template: {job_id} {index} {ext})").option("--no-wait", "submit and return the job id immediately").option("--estimate", "print the cost estimate and exit (spends nothing)").action(async function(promptWords) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const prompt = promptWords.join(" ");
+    if (opts.estimate) {
+      await printEstimate(ctx, {
+        model: opts.model,
+        type: "image",
+        resolution: opts.resolution,
+        quality: opts.quality,
+        renderingSpeed: opts.renderingSpeed,
+        num: opts.num ? Number(opts.num) : void 0
+      });
+      return;
+    }
+    const [refs, videoRef] = await Promise.all([
+      resolveRefs(ctx, opts.ref ?? []),
+      opts.videoRef ? resolveRefs(ctx, [opts.videoRef]).then((r) => r[0]) : void 0
+    ]);
+    capture("cli_generate", { kind: "image", model: opts.model ?? "default", wait: opts.wait !== false });
+    const submitted = await ctx.client.callTool(
+      "generate_image",
+      compact({
+        prompt,
+        model: opts.model,
+        aspect_ratio: opts.ar,
+        resolution: opts.resolution,
+        quality: opts.quality,
+        rendering_speed: opts.renderingSpeed,
+        num_images: opts.num ? Number(opts.num) : void 0,
+        seed: opts.seed ? Number(opts.seed) : void 0,
+        reference_images: refs.length > 0 ? refs : void 0,
+        video_url: videoRef,
+        style: opts.style,
+        project_id: opts.project,
+        session_id: opts.session,
+        scene_index: opts.scene !== void 0 ? Number(opts.scene) : void 0,
+        shot_index: opts.shot !== void 0 ? Number(opts.shot) : void 0
+      })
+    );
+    await handleAsyncJob(ctx, submitted, {
+      wait: opts.wait !== false,
+      download: opts.download,
+      label: "Generating image"
+    });
+  });
+  generate.command("video [prompt...]").description("Generate a video clip (async; per-second pricing \u2014 see --estimate)").option("--model <id>", "video model id (default google-veo3.1 fast)").option("--ar <ratio>", 'aspect ratio, e.g. "16:9", "9:16"').option("--duration <seconds>", "clip duration in seconds").option("--resolution <res>", 'e.g. "720p", "1080p"').option("--quality <tier>", 'e.g. "fast", "quality", "standard", "pro"').option("--audio", "generate native model audio").option("--no-audio", "disable native model audio").option("--start-image <url|file>", "start frame (image-to-video)").option("--end-image <url|file>", "end frame (supported models only)").option("--ref <url|file>", "reference image (repeatable)", collect, []).option("--ref-video <url|file>", "reference video (repeatable; Seedance 2, Wan 2.7; local files uploaded)", collect, []).option("--ref-audio <url|file>", "reference audio (repeatable; Seedance 2; local files uploaded)", collect, []).option("--segment <prompt:seconds>", "multi-prompt segment (repeatable; Kling 3.0 / 3.0 Turbo / O3)", collect, []).option("--negative <text>", "negative prompt (Kling/Wan/Luma)").option("--seed <n>", "seed").option("--project <id>", "attach to a project").option("--session <id>", "AI Studio session id").option("--scene <n>", "0-based scene index").option("--shot <n>", "0-based shot index").option("--download <path>", "download outputs (template: {job_id} {index} {ext})").option("--no-wait", "submit and return the job id immediately").option("--estimate", "print the cost estimate and exit (spends nothing)").action(async function(promptWords = []) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const prompt = promptWords.join(" ").trim();
+    const duration = opts.duration ? Number(opts.duration) : void 0;
+    if (opts.estimate) {
+      await printEstimate(ctx, {
+        model: opts.model,
+        type: "video",
+        duration,
+        resolution: opts.resolution,
+        quality: opts.quality,
+        audio: opts.audio
+      });
+      return;
+    }
+    const [refs, refVideos, refAudios, startImage, endImage] = await Promise.all([
+      resolveRefs(ctx, opts.ref ?? []),
+      resolveRefs(ctx, opts.refVideo ?? []),
+      resolveRefs(ctx, opts.refAudio ?? []),
+      opts.startImage ? resolveRefs(ctx, [opts.startImage]).then((r) => r[0]) : void 0,
+      opts.endImage ? resolveRefs(ctx, [opts.endImage]).then((r) => r[0]) : void 0
+    ]);
+    const segments = parseSegments(opts.segment ?? []);
+    if (!prompt && segments.length === 0 && !startImage && refVideos.length === 0) {
+      throw new CliError(
+        "Provide a prompt, --segment (multi-prompt), or --start-image.",
+        EXIT.USAGE
+      );
+    }
+    capture("cli_generate", { kind: "video", model: opts.model ?? "default", wait: opts.wait !== false });
+    const submitted = await ctx.client.callTool(
+      "generate_video",
+      compact({
+        prompt: prompt || void 0,
+        model: opts.model,
+        aspect_ratio: opts.ar,
+        duration_seconds: duration,
+        resolution: opts.resolution,
+        quality: opts.quality,
+        generate_audio: opts.audio,
+        start_image_url: startImage,
+        end_image_url: endImage,
+        reference_images: refs.length > 0 ? refs : void 0,
+        reference_videos: refVideos.length > 0 ? refVideos : void 0,
+        reference_audio: refAudios.length > 0 ? refAudios : void 0,
+        multi_prompt: segments.length > 0 ? segments : void 0,
+        negative_prompt: opts.negative,
+        seed: opts.seed ? Number(opts.seed) : void 0,
+        project_id: opts.project,
+        session_id: opts.session,
+        scene_index: opts.scene !== void 0 ? Number(opts.scene) : void 0,
+        shot_index: opts.shot !== void 0 ? Number(opts.shot) : void 0
+      })
+    );
+    await handleAsyncJob(ctx, submitted, {
+      wait: opts.wait !== false,
+      download: opts.download,
+      label: "Generating video"
+    });
+  });
+  generate.command("voiceover <text...>").description("Generate TTS audio (synchronous \u2014 returns an audio URL)").option("--voice <id>", "voice id (see `videodraft models voices`)").option("--language <bcp47>", 'target language, default "en"').option("--project <id>", "attach to a project").option("--scene <n>", "0-based scene index \u2014 wires the audio onto that scene").option("--session <id>", "AI Studio session id").option("--download <path>", "download the audio file").action(async function(textWords) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    capture("cli_generate", { kind: "voiceover" });
+    const result = await ctx.client.callTool(
+      "generate_voiceover",
+      compact({
+        text: textWords.join(" "),
+        voice_id: opts.voice,
+        target_language: opts.language,
+        project_id: opts.project,
+        session_id: opts.session,
+        scene_index: opts.scene !== void 0 ? Number(opts.scene) : void 0
+      })
+    );
+    const urls = extractOutputUrls(result);
+    let downloaded;
+    if (opts.download && urls.length > 0) {
+      downloaded = await downloadOutputs(urls, opts.download, { name: "voiceover" });
+    }
+    emit(ctx.out, { ...result, downloaded_files: downloaded }, (o) => {
+      for (const url of urls) process.stdout.write(`${url}
+`);
+      for (const f of downloaded ?? []) note(o, fmt.dim(o, `saved ${f.path}`));
+    });
+  });
+  generate.command("music <prompt...>").description("Generate background music (Lyria 3)").option("--model <id>", "lyria-3-clip-preview (30s, default) | lyria-3-pro-preview (180s)").option("--ref <url|file>", "reference image to inspire the music (repeatable)", collect, []).option("--project <id>", "link the generation to a project's AI Studio session").option("--attach <project_id>", "also set the track as that project's background music").option("--volume <n>", "0-100 BGM volume when attaching (default 30)").option("--bgm-disabled", "when attaching, store the BGM as disabled (enabled:false)").option("--session <id>", "AI Studio session id").option("--download <path>", "download the audio file").action(async function(promptWords) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const refs = await resolveRefs(ctx, opts.ref ?? []);
+    capture("cli_generate", { kind: "music", model: opts.model ?? "default" });
+    const result = await ctx.client.callTool(
+      "generate_music",
+      compact({
+        prompt: promptWords.join(" "),
+        model: opts.model,
+        image_urls: refs.length > 0 ? refs : void 0,
+        project_id: opts.project,
+        attach_to_project_id: opts.attach,
+        volume: opts.volume ? Number(opts.volume) : void 0,
+        enabled: opts.bgmDisabled ? false : void 0,
+        session_id: opts.session
+      })
+    );
+    const urls = extractOutputUrls(result);
+    let downloaded;
+    if (opts.download && urls.length > 0) {
+      downloaded = await downloadOutputs(urls, opts.download, { name: "music" });
+    }
+    emit(ctx.out, { ...result, downloaded_files: downloaded }, (o) => {
+      for (const url of urls) process.stdout.write(`${url}
+`);
+      for (const f of downloaded ?? []) note(o, fmt.dim(o, `saved ${f.path}`));
+    });
+  });
+  const upscale = program.command("upscale").description("Upscale images and videos (Topaz)");
+  upscale.command("image <url|file>").description("Upscale an image (synchronous)").option("--scale <factor>", '"1x" | "2x" | "4x" (default 2x)').option("--session <id>", "AI Studio session id").option("--download <path>", "download the result").action(async function(source) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const [url] = await resolveRefs(ctx, [source]);
+    capture("cli_upscale", { kind: "image" });
+    const result = await ctx.client.callTool(
+      "upscale_image",
+      compact({ image_url: url, scale: opts.scale, session_id: opts.session })
+    );
+    const urls = extractOutputUrls(result);
+    let downloaded;
+    if (opts.download && urls.length > 0) {
+      downloaded = await downloadOutputs(urls, opts.download, { name: "upscaled" });
+    }
+    emit(ctx.out, { ...result, downloaded_files: downloaded }, (o) => {
+      for (const u of urls) process.stdout.write(`${u}
+`);
+      for (const f of downloaded ?? []) note(o, fmt.dim(o, `saved ${f.path}`));
+    });
+  });
+  upscale.command("video <url|file>").description("Upscale a video (async; waits by default)").option("--scale <factor>", 'e.g. "2x" (default)').option("--session <id>", "AI Studio session id").option("--duration <seconds>", "source duration override (only if auto-probe fails, e.g. >100MB)").option("--width <px>", "source width override (only if auto-probe fails)").option("--height <px>", "source height override (only if auto-probe fails)").option("--download <path>", "download the result").option("--no-wait", "submit and return the job id immediately").action(async function(source) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const [url] = await resolveRefs(ctx, [source]);
+    capture("cli_upscale", { kind: "video" });
+    const submitted = await ctx.client.callTool(
+      "upscale_video",
+      compact({
+        video_url: url,
+        scale: opts.scale,
+        session_id: opts.session,
+        duration_seconds: opts.duration ? Number(opts.duration) : void 0,
+        video_width: opts.width ? Number(opts.width) : void 0,
+        video_height: opts.height ? Number(opts.height) : void 0
+      })
+    );
+    await handleAsyncJob(ctx, submitted, {
+      wait: opts.wait !== false,
+      download: opts.download,
+      label: "Upscaling video"
+    });
+  });
+}
+
+// src/commands/pipeline.ts
+async function resolveMedia(ctx, src) {
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(src)) return src;
+  const uploaded = await uploadFile(ctx.client, src);
+  return uploaded.url;
+}
+function registerPipelineCommands(program) {
+  program.command("create <idea...>").description("Create a storyboard project from an idea (script \u2192 assets \u2192 storyboard)").option("--title <title>", "project title").option("--duration <length>", "short | medium | long | auto").option("--style <style>", 'style preset id, or "custom:<description>"').option("--mood <mood>", "mood hint").option("--ar <ratio>", 'aspect ratio, e.g. "16:9", "9:16"').option("--project <id>", "build into an existing project instead of creating one").option("--image-model <id>", "image model for visual-asset images").option("--no-asset-images", "skip generating visual-asset reference images").option("--shots", "also batch-generate every shot image (spends credits per shot)").option("--grid", "with --shots: grid mode for stronger cross-shot consistency").option("--script-only", "stop at the script (script-stage project, no storyboard)").action(async function(ideaWords) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const idea = ideaWords.join(" ");
+    capture("cli_create", { script_only: Boolean(opts.scriptOnly), shots: Boolean(opts.shots) });
+    const tool = opts.scriptOnly ? "generate_script_from_idea" : "generate_storyboard_from_idea";
+    const spin = spinner(
+      ctx.out,
+      opts.scriptOnly ? "Generating script\u2026" : "Building project (script \u2192 assets \u2192 storyboard)\u2026"
+    );
+    let result;
+    try {
+      result = await ctx.client.callTool(
+        tool,
+        compact({
+          idea,
+          title: opts.title,
+          duration: opts.duration,
+          style: opts.style,
+          mood: opts.mood,
+          aspect_ratio: opts.scriptOnly ? void 0 : opts.ar,
+          project_id: opts.project,
+          image_model: opts.scriptOnly ? void 0 : opts.imageModel,
+          generate_asset_images: opts.scriptOnly ? void 0 : opts.assetImages,
+          generate_shot_images: opts.scriptOnly ? void 0 : opts.shots || void 0,
+          grid: opts.scriptOnly ? void 0 : opts.grid || void 0
+        })
+      );
+    } catch (err) {
+      if (err?.name === "TimeoutError" || /timed? ?out|abort/i.test(String(err?.message))) {
+        throw new CliError(
+          "The request timed out, but the project was likely still created server-side.",
+          EXIT.ERROR,
+          "Run `videodraft projects list`, take the most recent project, and resume with `videodraft create ... --project <id>` (or continue with `videodraft shots <id>`). Do not re-run create from scratch."
+        );
+      }
+      throw err;
+    } finally {
+      spin.stop();
+    }
+    emit(ctx.out, result, (o) => {
+      note(o, fmt.green(o, `Project ${result?.project_id ?? "created"}.`));
+      if (result?.urls?.storyboard) note(o, `  ${result.urls.storyboard}`);
+      if (result?.summary) note(o, fmt.dim(o, String(result.summary).slice(0, 400)));
+      const shotJobs = result?.shot_image_job_ids ?? [];
+      if (shotJobs.length > 0) {
+        note(o, fmt.dim(o, `Shot image jobs: ${shotJobs.join(", ")} \u2014 poll with videodraft status <job>`));
+      }
+    });
+  });
+  program.command("shots <project_id>").description("Batch-generate the storyboard shot images (spends credits per shot)").option("--scene <n>", "0-based scene index (omit for all scenes)").option("--model <id>", "image model id").option("--ar <ratio>", "aspect ratio override").option("--grid", "grid mode (stronger cross-shot consistency)").option("--regenerate-all", "replace existing shot images too").option("--no-wait", "submit and return job ids immediately").option("--estimate", "estimate the cost and exit (spends nothing)").action(async function(projectId) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    if (opts.estimate) {
+      const project = await ctx.client.callTool("get_project", {
+        project_id: projectId,
+        view: "summary"
+      });
+      const costs = await ctx.client.callTool(
+        "get_model_costs",
+        compact({ model_id: opts.model, type: "image" })
+      );
+      emit(ctx.out, {
+        project_scenes: project?.storyboard?.scenes?.length ?? project?.scenes?.length,
+        per_image_costs: costs,
+        note: "Total \u2248 shots missing images \xD7 per-image cost (+1 grid image per scene in grid mode). No credits were spent."
+      });
+      return;
+    }
+    capture("cli_shots", { grid: Boolean(opts.grid) });
+    const submitted = await ctx.client.callTool(
+      "generate_shot_images",
+      compact({
+        project_id: projectId,
+        scene_index: opts.scene !== void 0 ? Number(opts.scene) : void 0,
+        model: opts.model,
+        aspect_ratio: opts.ar,
+        grid: opts.grid || void 0,
+        regenerate_all: opts.regenerateAll || void 0
+      })
+    );
+    const jobIds = submitted?.job_ids ?? (submitted?.job_id ? [submitted.job_id] : []);
+    if (opts.wait === false || jobIds.length === 0) {
+      emit(ctx.out, submitted, (o) => {
+        note(o, `Submitted ${jobIds.length || "?"} job(s).`);
+        for (const id of jobIds) note(o, fmt.dim(o, `  videodraft status ${id}`));
+      });
+      return;
+    }
+    const spin = spinner(ctx.out, `Generating shot images (${jobIds.length} job(s))\u2026`);
+    try {
+      const resultMap = await pollGenerationsBatch(ctx.client, jobIds, {
+        intervalMs: ctx.intervalMs,
+        timeoutMs: ctx.timeoutMs,
+        adaptive: ctx.adaptive,
+        onTick: (progress) => spin.update(`Generating shot images \u2014 ${progress}`)
+      });
+      const results = jobIds.map((id) => resultMap.get(id));
+      spin.stop();
+      const failed = results.filter((r) => r.status === "failed").length;
+      emit(
+        ctx.out,
+        { job_ids: jobIds, results: results.map((r) => ({ status: r.status, outputs: r.outputUrls })) },
+        (o) => {
+          note(
+            o,
+            failed === 0 ? fmt.green(o, `All ${results.length} job(s) completed \u2014 images are on the shot cards.`) : fmt.red(o, `${failed}/${results.length} job(s) failed.`)
+          );
+        }
+      );
+      if (failed > 0) process.exitCode = 1;
+    } catch (err) {
+      spin.stop();
+      throw err;
+    }
+  });
+  program.command("produce <project_id>").description("Produce the storyboard into production \u2014 animatic (default) or full_video AI Production").option("--mode <mode>", "animatic (slideshow, default) | full_video (one Seedance 2 video per scene)").option("--no-auto-videos", "full_video: set up scene videos but don't submit them (no credits spent)").option("--no-voiceover", "skip per-scene voiceovers + captions").option("--no-video-prompts", "skip advisory per-shot motion prompts").option("--shot-duration <seconds>", "per-shot clip length for silent/no-voiceover scenes (default 3)").option("--voice <id>", "TTS voice id for voiceovers").option("--language <bcp47>", "voiceover + caption language").option("--captions", "force burn captions").option("--no-captions", "force no captions (default follows voiceover)").action(async function(projectId) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const captionsSrc = this.getOptionValueSource("captions");
+    capture("cli_produce", { mode: opts.mode ?? "animatic" });
+    const spin = spinner(
+      ctx.out,
+      opts.mode === "full_video" ? "Producing (full_video: composing scenes \u2192 submitting Seedance videos)\u2026" : "Producing project (voiceovers \u2192 captions \u2192 timeline)\u2026"
+    );
+    let result;
+    try {
+      result = await ctx.client.callTool(
+        "produce_project",
+        compact({
+          project_id: projectId,
+          mode: opts.mode,
+          // negatable flags default true; only forward an explicit opt-out.
+          auto_generate_videos: opts.autoVideos === false ? false : void 0,
+          include_voiceover: opts.voiceover === false ? false : void 0,
+          generate_video_prompts: opts.videoPrompts === false ? false : void 0,
+          shot_duration: opts.shotDuration ? Number(opts.shotDuration) : void 0,
+          voice_id: opts.voice,
+          language: opts.language,
+          show_captions: captionsSrc === "cli" ? opts.captions : void 0
+        })
+      );
+    } finally {
+      spin.stop();
+    }
+    const pendingVideos = result?.pending_scene_video_generations ?? result?.pending_generation_ids ?? [];
+    emit(ctx.out, result, (o) => {
+      if (result?.status === "generating_shot_images") {
+        note(o, fmt.yellow(o, "Shot images are still generating \u2014 poll the job ids below, then re-run produce."));
+        for (const id of result?.shot_image_job_ids ?? result?.job_ids ?? [])
+          note(o, fmt.dim(o, `  videodraft status ${id}`));
+      } else if (opts.mode === "full_video" && pendingVideos.length > 0) {
+        note(o, fmt.green(o, `Producing ${pendingVideos.length} scene video(s).`));
+        note(o, fmt.dim(o, "Poll: videodraft generations  \u2192 then: videodraft finalize " + projectId + " \u2192 videodraft export " + projectId));
+      } else {
+        note(o, fmt.green(o, "Produced. Next: videodraft export " + projectId));
+      }
+    });
+  });
+  program.command("finalize <project_id>").description("Swap completed full_video scene videos into the timeline (after produce --mode full_video)").action(async function(projectId) {
+    const ctx = buildContext(this);
+    const result = await ctx.client.callTool("finalize_scene_videos", { project_id: projectId });
+    emit(ctx.out, result, (o) => {
+      note(
+        o,
+        fmt.green(
+          o,
+          `Finalized ${result?.finalized ?? 0}, failed ${result?.failed ?? 0}, still pending ${result?.still_pending ?? result?.pending_remaining ?? 0}.`
+        )
+      );
+      if ((result?.pending_remaining ?? result?.still_pending ?? 0) > 0) {
+        note(o, fmt.dim(o, "Some clips are still rendering \u2014 re-run finalize later (it's idempotent)."));
+      }
+    });
+  });
+  program.command("attach <project_id>").description("Place a clip/image onto a storyboard shot (e.g. a generated video into the timeline)").requiredOption("--scene <n>", "0-based scene index").requiredOption("--shot <n>", "0-based shot index").requiredOption("--media <url|file>", "media to attach (local files are uploaded)").option("--type <type>", "image | video (default image)").option("--duration <seconds>", "clip duration in seconds (recommended for video)").option("--thumbnail <url|file>", "optional thumbnail").action(async function(projectId) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const [mediaUrl, thumbUrl] = await Promise.all([
+      resolveMedia(ctx, opts.media),
+      opts.thumbnail ? resolveMedia(ctx, opts.thumbnail) : void 0
+    ]);
+    capture("cli_attach", { type: opts.type ?? "image" });
+    const result = await ctx.client.callTool(
+      "attach_media_to_shot",
+      compact({
+        project_id: projectId,
+        scene_index: Number(opts.scene),
+        shot_index: Number(opts.shot),
+        media_url: mediaUrl,
+        thumbnail_url: thumbUrl,
+        media_type: opts.type,
+        duration_seconds: opts.duration ? Number(opts.duration) : void 0
+      })
+    );
+    emit(ctx.out, result, (o) => note(o, fmt.green(o, `Attached to scene ${opts.scene}, shot ${opts.shot}.`)));
+  });
+  program.command("export <project_id>").description("Render the final MP4 (project must be produced)").option("--captions", "burn captions into the render").option("--no-captions", "render without captions").option("--download <path>", "download the MP4 when finished").option("--no-wait", "start the export and return the export id").action(async function(projectId) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    capture("cli_export");
+    const started = await ctx.client.callTool(
+      "export_video",
+      compact({ project_id: projectId, show_captions: opts.captions })
+    );
+    const exportId = started?.export_id;
+    if (opts.wait === false) {
+      emit(ctx.out, started, (o) => {
+        note(o, `Export started${exportId ? ` \u2014 ${exportId}` : ""}.`);
+        note(o, fmt.dim(o, `Check with: videodraft export-status ${exportId ?? projectId}`));
+      });
+      return;
+    }
+    const spin = spinner(ctx.out, "Rendering MP4\u2026");
+    try {
+      const result = await pollExport(
+        ctx.client,
+        { exportId, projectId },
+        {
+          intervalMs: Math.max(ctx.intervalMs, 5e3),
+          timeoutMs: Math.max(ctx.timeoutMs, 12e5),
+          adaptive: ctx.adaptive,
+          onTick: (status) => spin.update(`Rendering MP4 \u2014 ${status}`)
+        }
+      );
+      spin.stop();
+      if (result.status === "failed" || !result.videoUrl) {
+        emit(ctx.out, result.payload, (o) => note(o, fmt.red(o, "Export failed.")));
+        process.exitCode = 1;
+        return;
+      }
+      let downloaded;
+      if (opts.download) {
+        downloaded = await downloadOutputs([result.videoUrl], opts.download, {
+          job_id: exportId ?? projectId,
+          name: "export"
+        });
+      }
+      emit(ctx.out, { export_id: exportId, video_url: result.videoUrl, downloaded_files: downloaded }, (o) => {
+        note(o, fmt.green(o, "Export finished."));
+        process.stdout.write(`${result.videoUrl}
+`);
+        for (const f of downloaded ?? []) note(o, fmt.dim(o, `saved ${f.path}`));
+      });
+    } catch (err) {
+      spin.stop();
+      throw err;
+    }
+  });
+  program.command("export-status <id>").description("Check a video export \u2014 pass the export_id (or --project to pass a project id)").option("--project", "treat <id> as a project id (checks its latest export)").option("--wait <seconds>", "block up to N seconds (max 240), re-polling until terminal").action(async function(ref) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const result = await ctx.client.callTool(
+      "check_export_status",
+      compact({
+        export_id: opts.project ? void 0 : ref,
+        project_id: opts.project ? ref : void 0,
+        wait_seconds: opts.wait ? Number(opts.wait) : void 0
+      })
+    );
+    emit(ctx.out, result);
+  });
+  program.command("video-prompts <project_id>").description("Generate advisory per-shot motion/video prompts for a project").option("--ar <ratio>", "aspect ratio").option("--instructions <text>", "authoring instructions").option("--has-voiceover", "tell the generator the project has a voiceover track").option("--video-audio", "tell the generator that generated videos may include native audio").option("--has-bgm", "tell the generator the project has background music").action(async function(projectId) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const result = await ctx.client.callTool(
+      "generate_video_prompts",
+      compact({
+        project_id: projectId,
+        aspect_ratio: opts.ar,
+        instructions: opts.instructions,
+        has_voiceover: opts.hasVoiceover || void 0,
+        generate_video_audio: opts.videoAudio || void 0,
+        has_background_music: opts.hasBgm || void 0
+      })
+    );
+    emit(ctx.out, result);
+  });
+}
+
+// src/commands/jobs.ts
+function registerJobCommands(program) {
+  program.command("status <job_id>").description("Check an async generation job once (no waiting)").option("--project <id>", "project id for fallback lookups").option("--scene-id <id>", "scene id for fallback lookups").action(async function(jobId) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const result = await ctx.client.callTool(
+      "check_generation_status",
+      compact({ job_id: jobId, project_id: opts.project, scene_id: opts.sceneId })
+    );
+    emit(ctx.out, result, (o) => {
+      note(o, `${jobId}: ${result?.status ?? "unknown"}`);
+      for (const url of extractOutputUrls(result)) process.stdout.write(`${url}
+`);
+    });
+  });
+  program.command("wait <job_ids...>").description(
+    "Block until generation job(s) finish. Multiple ids poll in ONE process with ONE batched request per tick \u2014 prefer this over parallel `wait` processes"
+  ).option("--download <path>", "download outputs (template: {job_id} {index} {ext})").action(async function(jobIds) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    if (jobIds.length > 1 && typeof opts.download === "string" && !opts.download.includes("{job_id}") && /\.[A-Za-z0-9]+$/.test(opts.download)) {
+      throw new CliError(
+        `--download "${opts.download}" would be overwritten by each job. Include {job_id} in the template (e.g. "out/{job_id}_{index}.{ext}") or pass a directory.`,
+        EXIT.USAGE
+      );
+    }
+    const label = jobIds.length === 1 ? `job ${jobIds[0]}` : `${jobIds.length} jobs`;
+    const spin = spinner(ctx.out, `Waiting for ${label}\u2026`);
+    try {
+      const results = await pollGenerationsBatch(ctx.client, jobIds, {
+        intervalMs: ctx.intervalMs,
+        timeoutMs: ctx.timeoutMs,
+        adaptive: ctx.adaptive,
+        onTick: (progress) => spin.update(`Waiting for ${label} \u2014 ${progress}`)
+      });
+      spin.stop();
+      const rows = [];
+      let failures = 0;
+      for (const jobId of jobIds) {
+        const result = results.get(jobId);
+        let downloaded;
+        if (result.status === "failed") {
+          failures++;
+        } else if (opts.download && result.outputUrls.length > 0) {
+          downloaded = await downloadOutputs(result.outputUrls, opts.download, { job_id: jobId });
+        }
+        rows.push({
+          job_id: jobId,
+          status: result.status,
+          outputs: result.outputUrls,
+          downloaded_files: downloaded,
+          ...result.status === "failed" ? { error: result.payload?.error } : {}
+        });
+      }
+      emit(ctx.out, jobIds.length === 1 ? rows[0] : rows, (o) => {
+        for (const row of rows) {
+          if (row.status === "failed") {
+            note(o, fmt.red(o, `${row.job_id} failed: ${row.error ?? "unknown"}`));
+            continue;
+          }
+          for (const url of row.outputs) process.stdout.write(`${url}
+`);
+          for (const f of row.downloaded_files ?? []) note(o, fmt.dim(o, `saved ${f.path}`));
+        }
+      });
+      if (failures > 0) process.exitCode = 1;
+    } catch (err) {
+      spin.stop();
+      throw err;
+    }
+  });
+  program.command("generations").description("List recent + in-flight generations").option("--type <type>", "image | video").option("--status <status>", "pending | processing | completed | failed").option("--limit <n>", "max rows (default 30)").action(async function() {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const result = await ctx.client.callTool(
+      "list_recent_generations",
+      compact({
+        type: opts.type,
+        status: opts.status,
+        limit: opts.limit ? Number(opts.limit) : void 0
+      })
+    );
+    const rows = result?.generations ?? result?.items ?? [];
+    emit(ctx.out, result, (o) => {
+      table(
+        o,
+        ["id", "type", "status", "model", "created"],
+        rows.map((g) => [
+          String(g.id ?? g.job_id ?? ""),
+          String(g.type ?? ""),
+          String(g.status ?? ""),
+          String(g.model ?? "").slice(0, 24),
+          String(g.created_at ?? g.createdAt ?? "").slice(0, 19)
+        ])
+      );
+      if (result?.inFlight !== void 0) note(o, fmt.dim(o, `In flight: ${result.inFlight}`));
+    });
+  });
+}
+
+// src/commands/media.ts
+function registerMediaCommands(program) {
+  program.command("upload <file>").description("Upload a local image/video/audio file; prints the public CDN URL").option("--content-type <mime>", "MIME override when the extension is ambiguous").action(async function(file) {
+    const ctx = buildContext(this);
+    capture("cli_upload");
+    const result = await uploadFile(ctx.client, file, {
+      contentType: this.opts().contentType
+    });
+    emit(ctx.out, result, (o) => {
+      process.stdout.write(`${result.url}
+`);
+      note(o, fmt.dim(o, "Use this URL anywhere a public media URL is accepted (--ref, --start-image, ...)"));
+    });
+  });
+  const media = program.command("media").description("Your media library");
+  media.command("list", { isDefault: true }).description("List media library items").option("--type <type>", "image | video | audio").option("--limit <n>", "max rows").option("--offset <n>", "pagination offset").action(async function() {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const result = await ctx.client.callTool(
+      "list_media",
+      compact({
+        type: opts.type,
+        limit: opts.limit ? Number(opts.limit) : void 0,
+        offset: opts.offset ? Number(opts.offset) : void 0
+      })
+    );
+    const rows = result?.media ?? result?.items ?? [];
+    emit(ctx.out, result, (o) => {
+      table(
+        o,
+        ["type", "url", "created"],
+        rows.map((m) => [
+          String(m.type ?? m.media_type ?? ""),
+          String(m.url ?? m.cdn_url ?? m.public_url ?? "").slice(0, 80),
+          String(m.createdAt ?? m.created_at ?? "").slice(0, 19)
+        ])
+      );
+    });
+  });
+  program.command("describe <url|file>").description("Describe an image with a vision model (local files are uploaded first)").action(async function(source) {
+    const ctx = buildContext(this);
+    let url = source;
+    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(source)) {
+      url = (await uploadFile(ctx.client, source)).url;
+    }
+    capture("cli_describe");
+    const result = await ctx.client.callTool("describe_image", { image_url: url });
+    emit(ctx.out, result, (o) => {
+      const text = result?.description ?? result?.text ?? JSON.stringify(result);
+      process.stdout.write(`${text}
+`);
+    });
+  });
+  program.command("download <url>").description("Download a (CDN) URL to a local file").option("-o, --output <path>", "output file or directory (default: basename in cwd)").action(async function(url) {
+    const ctx = buildContext(this);
+    const template = this.opts().output ?? ".";
+    const dest = renderTemplate(template, {
+      index: 0,
+      ext: extFromUrl(url),
+      name: new URL(url).pathname.split("/").pop()?.replace(/\.[^.]+$/, "") ?? "download"
+    });
+    const file = await downloadUrl(url, dest);
+    emit(ctx.out, file, (o) => note(o, fmt.green(o, `saved ${file.path} (${file.bytes} bytes)`)));
+  });
+}
+
+// src/commands/tools.ts
+function coerceArgValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "") return "";
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return raw;
+  }
+}
+function parseKeyValueArgs(pairs) {
+  const args = {};
+  for (const pair of pairs) {
+    const eq = pair.indexOf("=");
+    if (eq <= 0) {
+      throw new CliError(`--arg expects key=value, got: ${pair}`, EXIT.USAGE);
+    }
+    args[pair.slice(0, eq)] = coerceArgValue(pair.slice(eq + 1));
+  }
+  return args;
+}
+function registerToolCommands(program) {
+  const tools = program.command("tools").description("Inspect the full MCP tool catalog");
+  tools.command("list", { isDefault: true }).description("List every available tool").action(async function() {
+    const ctx = buildContext(this);
+    const list = await ctx.client.listTools();
+    emit(ctx.out, list.map((t) => ({ name: t.name, description: t.description })), (o) => {
+      table(
+        o,
+        ["name", "description"],
+        list.map((t) => [t.name, t.description.split(/[.!]\s/)[0].slice(0, 90)])
+      );
+      note(o, fmt.dim(o, `
+${list.length} tools. Inspect one: videodraft tools schema <name>`));
+    });
+  });
+  tools.command("schema <name>").description("Show a tool's description and JSON input schema").action(async function(name) {
+    const ctx = buildContext(this);
+    const list = await ctx.client.listTools();
+    const tool = list.find((t) => t.name === name);
+    if (!tool) {
+      throw new CliError(
+        `Unknown tool: ${name}. List tools with: videodraft tools list`,
+        EXIT.USAGE
+      );
+    }
+    emit(ctx.out, tool);
+  });
+  program.command("call <tool>").description("Call any MCP tool directly (full API coverage)").option("--args <json>", "arguments as a JSON object").option("--arg <key=value>", "single argument (repeatable; values JSON-coerced)", collect, []).option("--stdin", "read the JSON arguments object from stdin").action(async function(toolName) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    let args = {};
+    if (opts.stdin) {
+      const chunks = [];
+      for await (const chunk of process.stdin) chunks.push(chunk);
+      const raw = Buffer.concat(chunks).toString("utf8").trim();
+      if (raw) args = JSON.parse(raw);
+    }
+    if (opts.args) {
+      let parsed;
+      try {
+        parsed = JSON.parse(opts.args);
+      } catch (err) {
+        throw new CliError(`--args is not valid JSON: ${err?.message}`, EXIT.USAGE);
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new CliError("--args must be a JSON object", EXIT.USAGE);
+      }
+      args = { ...args, ...parsed };
+    }
+    if (opts.arg.length > 0) {
+      args = { ...args, ...parseKeyValueArgs(opts.arg) };
+    }
+    capture("cli_call", { tool: toolName });
+    const result = await ctx.client.callTool(toolName, args);
+    emit(ctx.out, result);
+  });
+}
+
+// src/commands/avatar.ts
+import fs6 from "fs";
+function registerAvatarCommands(program) {
+  const avatar = program.command("avatar").description("Avatar / talking-head videos");
+  avatar.command("script <idea...>").description("Generate a ~30s spoken script for an avatar video (free)").option("--style <style>", "narrative | ad-style | casual-talk | promotional | educational").action(async function(ideaWords) {
+    const ctx = buildContext(this);
+    const result = await ctx.client.callTool(
+      "generate_avatar_script",
+      compact({ idea: ideaWords.join(" "), style: this.opts().style })
+    );
+    emit(ctx.out, result);
+  });
+  avatar.command("create <image_url_or_file>").description("Create an avatar video from an image + script (does not render yet)").requiredOption("--script <text>", "the spoken script (~30s)").option("--voice <id>", "TTS voice id").option("--name <name>", "avatar display name").option("--ar <ratio>", 'aspect ratio (default "9:16")').option("--language <bcp47>", "target language").action(async function(source) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    let imageUrl = source;
+    if (!/^https?:\/\//.test(source) && fs6.existsSync(source)) {
+      const uploaded = await uploadFile(ctx.client, source);
+      imageUrl = uploaded.url;
+    }
+    capture("cli_avatar", { step: "create" });
+    const result = await ctx.client.callTool(
+      "create_avatar_video",
+      compact({
+        script: opts.script,
+        character_image_url: imageUrl,
+        voice_id: opts.voice,
+        character_name: opts.name,
+        aspect_ratio: opts.ar,
+        target_language: opts.language
+      })
+    );
+    emit(ctx.out, result, (o) => {
+      note(o, fmt.green(o, `Avatar video ${result?.avatar_video_id ?? "created"}.`));
+      note(o, fmt.dim(o, `Render (paid): videodraft avatar render ${result?.avatar_video_id}`));
+    });
+  });
+  avatar.command("render <avatar_video_id>").description("Render an avatar video (spends credits; waits by default)").option("--resolution <res>", '"480p" | "720p" (default 720p)').option("--no-wait", "queue the render and return immediately").action(async function(avatarVideoId) {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    capture("cli_avatar", { step: "render" });
+    const started = await ctx.client.callTool(
+      "render_avatar_video",
+      compact({ avatar_video_id: avatarVideoId, resolution: opts.resolution })
+    );
+    if (opts.wait === false) {
+      emit(
+        ctx.out,
+        started,
+        (o) => note(o, `Render queued. Check with: videodraft avatar get ${avatarVideoId}`)
+      );
+      return;
+    }
+    const spin = spinner(ctx.out, "Rendering avatar video\u2026");
+    const deadline = Date.now() + ctx.timeoutMs;
+    try {
+      for (; ; ) {
+        const status = await ctx.client.callTool("get_avatar_video", {
+          avatar_video_id: avatarVideoId
+        });
+        const exportStatus = String(status?.export_status ?? "unknown");
+        spin.update(`Rendering avatar video \u2014 ${exportStatus}`);
+        if (exportStatus === "completed") {
+          spin.stop();
+          emit(ctx.out, status, (o) => {
+            note(o, fmt.green(o, "Avatar render completed."));
+            if (status?.video_url) process.stdout.write(`${status.video_url}
+`);
+          });
+          return;
+        }
+        if (exportStatus === "failed") {
+          spin.stop();
+          emit(ctx.out, status, (o) => note(o, fmt.red(o, "Avatar render failed.")));
+          process.exitCode = 1;
+          return;
+        }
+        if (Date.now() > deadline) {
+          throw new TimeoutError(
+            `Timed out waiting for avatar render ${avatarVideoId} (last: ${exportStatus}).`
+          );
+        }
+        await new Promise((r) => setTimeout(r, Math.max(ctx.intervalMs, 5e3)));
+      }
+    } catch (err) {
+      spin.stop();
+      throw err;
+    }
+  });
+  avatar.command("get <avatar_video_id>").description("Fetch one avatar video (status + video_url when rendered)").action(async function(avatarVideoId) {
+    const ctx = buildContext(this);
+    const result = await ctx.client.callTool("get_avatar_video", { avatar_video_id: avatarVideoId });
+    emit(ctx.out, result);
+  });
+  avatar.command("list").description("List your avatar videos").action(async function() {
+    const ctx = buildContext(this);
+    const result = await ctx.client.callTool("list_avatar_videos");
+    const rows = result?.avatar_videos ?? result?.videos ?? result ?? [];
+    emit(ctx.out, result, (o) => {
+      if (!Array.isArray(rows)) return;
+      table(
+        o,
+        ["id", "name", "status"],
+        rows.map((v) => [
+          String(v.id ?? v.avatar_video_id ?? ""),
+          String(v.character_name ?? v.name ?? "").slice(0, 30),
+          String(v.export_status ?? v.status ?? "")
+        ])
+      );
+    });
+  });
+}
+
+// src/commands/skills.ts
+import fs7 from "fs";
+import path4 from "path";
+import os2 from "os";
+import { fileURLToPath } from "url";
+function bundledSkillDir() {
+  const here = path4.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path4.resolve(here, "../skills/videodraft"),
+    // dist/ or src/commands compiled flat
+    path4.resolve(here, "../../skills/videodraft")
+    // src/commands in dev (tsx)
+  ];
+  for (const candidate of candidates) {
+    if (fs7.existsSync(path4.join(candidate, "SKILL.md"))) return candidate;
+  }
+  throw new CliError("Bundled skill not found (package is missing skills/videodraft).");
+}
+function copyDir(src, dest) {
+  fs7.mkdirSync(dest, { recursive: true });
+  for (const entry of fs7.readdirSync(src, { withFileTypes: true })) {
+    const from = path4.join(src, entry.name);
+    const to = path4.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir(from, to);
+    else fs7.copyFileSync(from, to);
+  }
+}
+var KNOWN_AGENTS = ["claude", "codex", "cursor"];
+var AGENT_ALIASES = {
+  claude: "claude",
+  "claude-code": "claude",
+  codex: "codex",
+  "openai-codex": "codex",
+  cursor: "cursor"
+};
+function agentDir(agent) {
+  return { claude: ".claude", codex: ".codex", cursor: ".cursor" }[agent];
+}
+function targetDir(agent, project) {
+  const root = project ? process.cwd() : os2.homedir();
+  return path4.join(root, agentDir(agent), "skills", "videodraft");
+}
+function detectInstalledAgents() {
+  return KNOWN_AGENTS.filter((a) => {
+    try {
+      return fs7.existsSync(path4.join(os2.homedir(), agentDir(a)));
+    } catch {
+      return false;
+    }
+  });
+}
+function resolveAgents(rawValues, all) {
+  if (all) return { agents: [...KNOWN_AGENTS], source: "all" };
+  const requested = rawValues.flatMap((v) => v.split(",")).map((v) => v.trim().toLowerCase()).filter(Boolean);
+  if (requested.length > 0) {
+    const bad = requested.filter((a) => !(a in AGENT_ALIASES));
+    if (bad.length > 0) {
+      throw new CliError(
+        `Unknown agent(s): ${bad.join(", ")}. Use ${KNOWN_AGENTS.join(" | ")} (or --all).`,
+        EXIT.USAGE
+      );
+    }
+    return { agents: [...new Set(requested.map((a) => AGENT_ALIASES[a]))], source: "explicit" };
+  }
+  const detected = detectInstalledAgents();
+  if (detected.length > 0) return { agents: detected, source: "detected" };
+  return { agents: ["claude"], source: "default" };
+}
+function registerSkillCommands(program) {
+  const skills = program.command("skills").description("The VideoDraft agent skill");
+  skills.command("install").description("Install the VideoDraft skill (auto-detects your installed agents by default)").option(
+    "--agent <agents>",
+    "claude | codex | cursor \u2014 repeatable or comma-separated. Omit to auto-detect installed agents.",
+    (v, prev = []) => [...prev, v],
+    []
+  ).option("--all", "install for every supported agent (claude, codex, cursor)").option("--project", "install into the current project (./.claude/skills) instead of globally").option("--force", "overwrite existing installation(s)").action(async function() {
+    const ctx = buildContext(this);
+    const opts = this.opts();
+    const src = bundledSkillDir();
+    const { agents, source } = resolveAgents(opts.agent, Boolean(opts.all));
+    if (source === "detected") {
+      note(ctx.out, fmt.dim(ctx.out, `Detected installed agent(s): ${agents.join(", ")}`));
+    } else if (source === "default") {
+      note(
+        ctx.out,
+        fmt.dim(ctx.out, "No agents detected \u2014 defaulting to claude. Target others with --agent or --all.")
+      );
+    }
+    const results = agents.map((agent) => {
+      const dest = targetDir(agent, Boolean(opts.project));
+      const existed = fs7.existsSync(dest);
+      if (existed && !opts.force) {
+        return { agent, installed_to: dest, status: "skipped", reason: "already installed (use --force)" };
+      }
+      copyDir(src, dest);
+      return { agent, installed_to: dest, status: existed ? "overwritten" : "installed" };
+    });
+    capture("cli_skills_install", {
+      agents: agents.join(","),
+      count: agents.length,
+      source,
+      project: Boolean(opts.project)
+    });
+    const anyInstalled = results.some((r) => r.status !== "skipped");
+    emit(ctx.out, { ok: true, results }, (o) => {
+      for (const r of results) {
+        if (r.status === "skipped") {
+          note(o, fmt.yellow(o, `\u2022 ${r.agent}: skipped \u2014 ${r.reason}`));
+        } else {
+          note(o, fmt.green(o, `\u2022 ${r.agent}: ${r.status} \u2192 ${r.installed_to}`));
+        }
+      }
+      if (agents.includes("codex")) {
+        note(o, fmt.dim(o, 'Codex leans on AGENTS.md \u2014 also add "Use the videodraft skill for video/image generation" there.'));
+      }
+      if (!anyInstalled) {
+        note(o, fmt.dim(o, "Nothing changed. Re-run with --force to overwrite existing installs."));
+      }
+      note(o, fmt.dim(o, "Other agents: npx skills add videodraft-ai/cli"));
+    });
+  });
+  skills.command("path").description("Print the bundled skill's location (for manual installs)").action(async function() {
+    const ctx = buildContext(this);
+    const dir = bundledSkillDir();
+    emit(ctx.out, { path: dir }, () => {
+      process.stdout.write(`${dir}
+`);
+    });
+  });
+}
+
+// src/commands/misc.ts
+import { spawn as spawn3 } from "child_process";
+var DOCS_URL = "https://videodraft.ai/cli";
+function registerMiscCommands(program) {
+  const config = program.command("config").description("CLI configuration");
+  config.command("path").description("Print the config file location").action(async function() {
+    const ctx = buildContext(this);
+    emit(ctx.out, { path: configPath() }, () => process.stdout.write(`${configPath()}
+`));
+  });
+  config.command("get [key]").description("Show config (tokens redacted)").action(async function(key) {
+    const ctx = buildContext(this);
+    const raw = readConfig();
+    const redacted = {
+      ...raw,
+      profiles: Object.fromEntries(
+        Object.entries(raw.profiles).map(([name, p]) => [
+          name,
+          {
+            ...p,
+            access_token: p.access_token ? `${p.access_token.slice(0, 13)}\u2026` : void 0,
+            refresh_token: p.refresh_token ? "vd_rt_\u2026" : void 0
+          }
+        ])
+      )
+    };
+    const value = key ? redacted[key] : redacted;
+    emit(ctx.out, value ?? null);
+  });
+  config.command("set <key> <value>").description("Set a config value (supported keys: telemetry, base_url)").action(async function(key, value) {
+    const ctx = buildContext(this);
+    if (key === "telemetry") {
+      setTelemetryPreference(!["0", "false", "off"].includes(value.toLowerCase()));
+    } else if (key === "base_url") {
+      updateConfig((c) => {
+        const profile = c.profiles[c.active_profile ?? "default"];
+        if (!profile) throw new CliError("No profile yet \u2014 run `videodraft login` first.", EXIT.USAGE);
+        profile.base_url = value.replace(/\/$/, "");
+      });
+    } else {
+      throw new CliError(`Unsupported key "${key}". Supported: telemetry, base_url.`, EXIT.USAGE);
+    }
+    emit(ctx.out, { ok: true, [key]: value }, (o) => note(o, "Saved."));
+  });
+  program.command("completion <shell>").description("Print shell completions (bash | zsh)").action(async function(shell) {
+    const root = this.parent;
+    const names = root.commands.map((c) => c.name()).sort();
+    if (shell === "bash") {
+      process.stdout.write(
+        `_videodraft_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=( $(compgen -W "${names.join(" ")}" -- "$cur") )
+  fi
+}
+complete -F _videodraft_completions videodraft
+`
+      );
+    } else if (shell === "zsh") {
+      process.stdout.write(
+        `#compdef videodraft
+_videodraft() {
+  local -a commands
+  commands=(${names.map((n) => `"${n}"`).join(" ")})
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+  fi
+}
+_videodraft
+`
+      );
+    } else {
+      throw new CliError(`Unsupported shell "${shell}". Use bash or zsh.`, EXIT.USAGE);
+    }
+  });
+  program.command("version").description("Print the CLI version").action(async function() {
+    const { VERSION: VERSION2 } = await Promise.resolve().then(() => (init_version(), version_exports));
+    process.stdout.write(`${VERSION2}
+`);
+  });
+  program.command("docs").description("Open the CLI documentation").action(async function() {
+    const ctx = buildContext(this);
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    try {
+      const child = spawn3(cmd, [DOCS_URL], { stdio: "ignore", detached: true, shell: process.platform === "win32" });
+      child.unref();
+    } catch {
+    }
+    emit(ctx.out, { url: DOCS_URL }, () => process.stdout.write(`${DOCS_URL}
+`));
+  });
+}
+
+// src/index.ts
+async function configureProxy() {
+  if (!process.env.HTTPS_PROXY && !process.env.HTTP_PROXY && !process.env.https_proxy && !process.env.http_proxy) {
+    return;
+  }
+  try {
+    const { EnvHttpProxyAgent, setGlobalDispatcher } = await import("undici");
+    setGlobalDispatcher(new EnvHttpProxyAgent());
+  } catch {
+  }
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("videodraft").description(
+    "Create AI videos, images, voiceovers and music from your terminal.\nAgent-friendly: every command supports --json; exit codes are stable\n(0 ok, 1 error, 2 usage, 3 auth, 4 insufficient credits)."
+  ).version(VERSION, "-v, --version", "print the CLI version").option("--json", "machine-readable JSON output").option("--no-color", "disable colored output (NO_COLOR is also respected)").option("--base-url <url>", "VideoDraft server (default https://app.videodraft.ai; env VIDEODRAFT_BASE_URL)").option("--token <vd_mcp_token>", "bearer token for this invocation (env VIDEODRAFT_API_KEY)").option("--profile <name>", "config profile (default: default)").option("--wait-interval <duration>", "poll interval for --wait, e.g. 3s (default)").option("--wait-timeout <duration>", "max wait for --wait, e.g. 10m (default)").showSuggestionAfterError(true).exitOverride();
+  registerAuthCommands(program);
+  registerAccountCommands(program);
+  registerProjectCommands(program);
+  registerPipelineCommands(program);
+  registerGenerateCommands(program);
+  registerJobCommands(program);
+  registerMediaCommands(program);
+  registerAvatarCommands(program);
+  registerToolCommands(program);
+  registerSkillCommands(program);
+  registerMiscCommands(program);
+  return program;
+}
+async function main() {
+  await configureProxy();
+  maybePrintFirstRunNotice();
+  const program = buildProgram();
+  const startedAt = Date.now();
+  let commandPath = "help";
+  program.hook("preAction", (_thisCommand, actionCommand) => {
+    commandPath = buildCommandPath(actionCommand);
+  });
+  try {
+    await program.parseAsync(process.argv);
+    capture("cli_command", { command: commandPath, ok: true, duration_ms: Date.now() - startedAt });
+    await maybeCheckForUpdate();
+  } catch (err) {
+    if (err instanceof CommanderError) {
+      const code = err.exitCode === 0 ? 0 : EXIT.USAGE;
+      if (code !== 0) {
+        const out = makeOutput({ json: process.argv.includes("--json") });
+        if (out.json) {
+          process.stdout.write(
+            `${JSON.stringify({ error: err.message, exit_code: code, code: err.code }, null, 2)}
+`
+          );
+        }
+        capture("cli_command", {
+          command: commandPath,
+          ok: false,
+          error_class: "CommanderError",
+          duration_ms: Date.now() - startedAt
+        });
+      }
+      process.exitCode = code;
+    } else if (err instanceof CliError) {
+      const out = makeOutput({ json: process.argv.includes("--json") });
+      if (out.json) {
+        process.stdout.write(
+          `${JSON.stringify({ error: err.message, exit_code: err.exitCode, hint: err.hint }, null, 2)}
+`
+        );
+      } else {
+        process.stderr.write(`${fmt.red(out, "Error:")} ${err.message}
+`);
+        if (err.hint) process.stderr.write(`${fmt.dim(out, err.hint)}
+`);
+      }
+      process.exitCode = err.exitCode;
+      capture("cli_command", {
+        command: commandPath,
+        ok: false,
+        error_class: err.name,
+        duration_ms: Date.now() - startedAt
+      });
+    } else {
+      const out = makeOutput({ json: process.argv.includes("--json") });
+      const message = err?.message ?? String(err);
+      if (out.json) {
+        process.stdout.write(`${JSON.stringify({ error: message, exit_code: EXIT.ERROR }, null, 2)}
+`);
+      } else {
+        process.stderr.write(`${fmt.red(out, "Error:")} ${message}
+`);
+      }
+      process.exitCode = EXIT.ERROR;
+      capture("cli_command", {
+        command: commandPath,
+        ok: false,
+        error_class: err?.name ?? "Error",
+        duration_ms: Date.now() - startedAt
+      });
+    }
+  } finally {
+    await shutdown();
+  }
+}
+void main();