@yandy0725/mediagen-cli 0.0.0-stage → 0.1.1

package/dist/cli.js

@@ -0,0 +1,3306 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import fs6 from "fs";
+import readline from "readline";
+import { Writable } from "stream";
+import { fileURLToPath, pathToFileURL } from "url";
+import { Command, CommanderError } from "commander";
+import { parse as parseToml } from "smol-toml";
+
+// src/auth.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import fs3 from "fs";
+import path3 from "path";
+
+// src/config.ts
+import { randomUUID } from "crypto";
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+import { parse } from "smol-toml";
+
+// src/errors.ts
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+var UsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UsageError";
+  }
+};
+var NO_RESPONSE_STATUS = 0;
+var ApiError = class extends Error {
+  code;
+  /** The task this failure is about, when one exists: what `video status` resumes. */
+  taskId;
+  /** The HTTP status, or `NO_RESPONSE_STATUS` when the request got no response at all. */
+  status;
+  constructor(message, code, taskId, status) {
+    super(message);
+    this.name = "ApiError";
+    this.code = code;
+    this.taskId = taskId;
+    this.status = status;
+  }
+};
+function textOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function fieldsOf(error) {
+  return typeof error === "object" && error !== null ? error : void 0;
+}
+function parseLocator(error) {
+  const fields = fieldsOf(error);
+  const line = fields?.line;
+  const column = fields?.column;
+  if (typeof line === "number" && typeof column === "number") {
+    return ` (line ${line}, column ${column})`;
+  }
+  const position = /position (\d+)/.exec(textOf(error))?.[1];
+  return position === void 0 ? "" : ` (position ${position})`;
+}
+function malformedDocumentMessage(file, format, error) {
+  const remedy = format === "JSON" ? 'Repair it, or delete it and run "mediagen login --provider <name> --api-key ..." to write a fresh one.' : "Repair it by hand; mediagen reads these settings from no other file.";
+  return `invalid ${format} in ${file}${parseLocator(error)}: the parser message is suppressed because it quotes the document, which may hold an API key. ${remedy}`;
+}
+function unreadableFileMessage(file, error) {
+  const code = fieldsOf(error)?.code;
+  return `cannot read ${file} (${typeof code === "string" ? code : "unreadable"}): check that it is a readable file`;
+}
+function unwritableFileMessage(file, error) {
+  const code = fieldsOf(error)?.code;
+  return `cannot create ${file} (${typeof code === "string" ? code : "unwritable"}): point MEDIAGEN_CLI_CONFIG_DIR at a writable directory, or fix the permissions on the directory that holds this file`;
+}
+
+// src/providers.ts
+var SEED_CONFIG = `# mediagen configuration. Edit and save; the CLI re-reads it on every run.
+#
+# A provider is one account: one host (base_url) and one key. Each task it can
+# serve hangs off it by name \u2014 [providers.<name>.image], [providers.<name>.video]
+# \u2014 and declares its own protocol (api_type) plus the models you allow there. A
+# second model of the same vendor is one more entry in \`models\`, not another
+# provider. api_type may also sit on the provider table as the default for every
+# task under it.
+#
+# The protocols are "openai" (the OpenAI-compatible wire format), "dashscope"
+# (Alibaba's native input.messages/parameters form), "ark" (Volcengine's own API,
+# OpenAI-shaped for images but with its own parameters and per-item errors) and
+# "minimax" (MiniMax's video API). "qwen" still works as a deprecated alias of
+# "openai". dashscope serves images only: it has no video task.
+#
+# base_url is the origin. The version segment belongs to the endpoint, which the
+# dialect appends per task (/api/v3/images/generations, /compatible-mode/v1/...).
+
+default_provider = "volcengine"
+# output_dir = "./media-output"     # where generated files land; defaults to the cwd
+
+[providers.volcengine]
+base_url    = "https://ark.cn-beijing.volces.com"
+api_key_env = "ARK_API_KEY"   # which environment variable holds this provider's key
+
+[providers.volcengine.image]
+api_type = "ark"
+default  = "doubao-seedream-5-0-flash-260915"
+models   = ["doubao-seedream-5-0-flash-260915", "doubao-seedream-5-0-pro"]
+
+[providers.volcengine.video]
+api_type = "ark"
+default  = "doubao-seedance-1-0-pro-250528"
+models   = ["doubao-seedance-1-0-pro-250528"]   # ids are dated snapshots; add more here
+
+[providers.aliyun]
+# Bailian's native protocol is served on the public host, so this entry works as
+# written. For the OpenAI-compatible protocol use your workspace-scoped host
+# instead \u2014 https://{workspace-id}.cn-beijing.maas.aliyuncs.com \u2014 which is also
+# where Alibaba recommends sending native calls.
+base_url    = "https://dashscope.aliyuncs.com"
+api_key_env = "DASHSCOPE_API_KEY"
+
+[providers.aliyun.image]
+api_type = "dashscope"          # input.messages + parameters, output.choices[].image
+default  = "qwen-image-3.0"
+models   = ["qwen-image-3.0"]
+
+[providers.minimax]
+base_url    = "https://api.minimax.io"
+api_key_env = "MINIMAX_API_KEY"
+
+[providers.minimax.video]
+api_type = "minimax"
+default  = "MiniMax-H3"
+models   = ["MiniMax-H3", "MiniMax-H3-Max"]   # -Max: 480P/768P only, 5s minimum
+
+# A gateway that serves DashScope's native protocol on its own path:
+# [providers.my-gateway]
+# base_url    = "https://gateway.example.com"
+# api_key_env = "MY_GATEWAY_KEY"
+#
+# [providers.my-gateway.image]
+# api_type = "dashscope"          # input.messages + parameters, output.choices[].image
+# path     = "/v1/images/generations"
+# default  = "qwen-image-2.0-pro"
+# models   = ["qwen-image-2.0-pro"]
+
+# Your own entry, e.g. a proxy of the openai dialect:
+# [providers.my-proxy]
+# base_url    = "https://proxy.example.com/my-gateway"   # a gateway prefix is fine
+# api_key_env = "MY_PROXY_KEY"
+#
+# [providers.my-proxy.image]
+# api_type = "openai"
+# default  = "qwen-image-3.0"
+# models   = ["qwen-image-3.0"]
+`;
+
+// src/toml.ts
+function isBareTomlKey(value) {
+  return /^[A-Za-z0-9_-]+$/.test(value);
+}
+function tomlKey(name) {
+  return isBareTomlKey(name) ? name : tomlBasicString(name);
+}
+function tomlBasicString(value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  return `"${escaped}"`;
+}
+function shellArg(value) {
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+// src/util.ts
+import fs from "fs";
+import path from "path";
+var IMAGE_MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  ".gif": "image/gif",
+  ".heic": "image/heic",
+  ".heif": "image/heif"
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isUrl(value) {
+  return /^https?:\/\//i.test(value);
+}
+function normalizeHttpBaseUrl(value) {
+  const trimmed = value.trim();
+  if (/[?#]/.test(trimmed)) return void 0;
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    return void 0;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+  if (url.username !== "" || url.password !== "") return void 0;
+  return trimmed.replace(/\/+$/, "");
+}
+var SCHEME_URL = /^[a-z][a-z0-9+.-]*:\/\//i;
+function toImageInput(value) {
+  if (value.startsWith("data:")) return value;
+  if (isUrl(value)) return value;
+  if (SCHEME_URL.test(value)) return value;
+  const extension = path.extname(value).toLowerCase();
+  const mime = IMAGE_MIME_TYPES[extension];
+  if (mime === void 0) {
+    const supported = Object.keys(IMAGE_MIME_TYPES).join(", ");
+    throw new UsageError(
+      `unsupported image extension "${extension || "(none)"}" for ${value}; supported extensions: ${supported}`
+    );
+  }
+  let bytes;
+  try {
+    bytes = fs.readFileSync(value);
+  } catch (error) {
+    throw new UsageError(`cannot read image ${value}: ${errorMessage(error)}`);
+  }
+  return `data:${mime};base64,${bytes.toString("base64")}`;
+}
+function nowStamp(date = /* @__PURE__ */ new Date()) {
+  const pad = (value) => String(value).padStart(2, "0");
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hours = pad(date.getHours());
+  const minutes = pad(date.getMinutes());
+  const seconds = pad(date.getSeconds());
+  return `${year}${month}${day}-${hours}${minutes}${seconds}`;
+}
+function slugModel(model) {
+  return model.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// src/api/ark.ts
+var QWEN_ONLY_FIELDS = [
+  "negative_prompt",
+  "prompt_extend",
+  "prompt_extend_mode",
+  "enable_thinking"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function numberArray(value) {
+  if (!Array.isArray(value) || !value.every((entry) => typeof entry === "number")) {
+    return void 0;
+  }
+  return [...value];
+}
+function parseBoundingBox(value) {
+  if (!isRecord(value)) return void 0;
+  const absolute = numberArray(value.absolute);
+  const normalized = numberArray(value.normalized);
+  if (absolute === void 0 || normalized === void 0) return void 0;
+  return { absolute, normalized };
+}
+function buildArkRequest(req) {
+  for (const field of QWEN_ONLY_FIELDS) {
+    if (req[field] !== void 0) {
+      throw new UsageError(
+        `option "${field}" is openai-dialect only and is not supported by the ark dialect; remove it or set api_type = "openai" on this task`
+      );
+    }
+  }
+  const body = {
+    model: req.model,
+    prompt: req.prompt
+  };
+  if (req.images.length === 1) {
+    body.image = req.images[0];
+  } else if (req.images.length > 1) {
+    body.image = [...req.images];
+  }
+  if (req.size !== void 0) body.size = req.size;
+  if (req.seed !== void 0) body.seed = req.seed;
+  if (req.watermark !== void 0) body.watermark = req.watermark;
+  if (req.output_format !== void 0) body.output_format = req.output_format;
+  if (req.optimize_prompt_mode !== void 0) {
+    body.optimize_prompt_options = { mode: req.optimize_prompt_mode };
+  }
+  if (req.layer_decomposition !== void 0) body.layer_decomposition = req.layer_decomposition;
+  if (req.background !== void 0) body.background = req.background;
+  body.response_format = "url";
+  return body;
+}
+function parseArkFailure(value) {
+  const code = typeof value.code === "string" && value.code !== "" ? value.code : "UnknownError";
+  const message = typeof value.message === "string" && value.message.trim() !== "" ? value.message : "ark API image request failed";
+  return { code, message };
+}
+function parseArkResponse(json, requestId) {
+  if (!isRecord(json)) {
+    throw new ApiError("ark API returned a response that is not a JSON object");
+  }
+  if ("error" in json && json.error !== void 0 && json.error !== null) {
+    if (!isRecord(json.error)) {
+      throw new ApiError("ark API returned an unrecognized error body");
+    }
+    const code = typeof json.error.code === "string" ? json.error.code : void 0;
+    const message = typeof json.error.message === "string" && json.error.message.trim() !== "" ? json.error.message : "ark API request failed";
+    throw new ApiError(message, code);
+  }
+  if (!("data" in json) || json.data === void 0) {
+    throw new ApiError("ark API response is missing the data array");
+  }
+  if (!Array.isArray(json.data)) {
+    throw new ApiError("ark API response data is not an array");
+  }
+  const images = [];
+  const failures = [];
+  json.data.forEach((entry, index) => {
+    if (!isRecord(entry)) {
+      throw new ApiError(`ark API response item ${index + 1} is not a JSON object`);
+    }
+    if ("error" in entry && entry.error !== void 0 && entry.error !== null) {
+      if (!isRecord(entry.error)) {
+        throw new ApiError(`ark API response item ${index + 1} has an unrecognized error body`);
+      }
+      failures.push(parseArkFailure(entry.error));
+      return;
+    }
+    if (typeof entry.url !== "string" || entry.url === "") {
+      throw new ApiError(
+        `ark API response item ${index + 1} has neither a url nor an error`
+      );
+    }
+    const image = { url: entry.url };
+    if (typeof entry.size === "string") image.size = entry.size;
+    if (typeof entry.output_format === "string") image.outputFormat = entry.output_format;
+    if (typeof entry.z_index === "number") image.zIndex = entry.z_index;
+    const boundingBox = parseBoundingBox(entry.bounding_box);
+    if (boundingBox !== void 0) image.boundingBox = boundingBox;
+    if (typeof entry.name === "string") image.name = entry.name;
+    if (typeof entry.description === "string") image.description = entry.description;
+    images.push(image);
+  });
+  if (images.length === 0) {
+    if (failures.length > 0) {
+      const [first] = failures;
+      throw new ApiError(first.message, first.code);
+    }
+    throw new ApiError("ark API returned no images");
+  }
+  const parsed = { images, failures };
+  if (requestId !== void 0) parsed.requestId = requestId;
+  if (isRecord(json.usage)) parsed.usage = json.usage;
+  return parsed;
+}
+var ArkDialect = {
+  createPath: "/api/v3/images/generations",
+  buildRequest: buildArkRequest,
+  parseResponse: parseArkResponse
+};
+var ARK_VIDEO_TASKS_PATH = "/api/v3/contents/generations/tasks";
+function buildArkVideoRequest(req) {
+  const content = [{ type: "text", text: req.prompt }];
+  if (req.first_frame !== void 0) {
+    content.push({
+      type: "image_url",
+      image_url: { url: req.first_frame },
+      role: "first_frame"
+    });
+  }
+  const body = { model: req.model, content };
+  if (req.resolution !== void 0) body.resolution = req.resolution;
+  if (req.ratio !== void 0) body.ratio = req.ratio;
+  if (req.duration !== void 0) body.duration = req.duration;
+  if (req.seed !== void 0) body.seed = req.seed;
+  if (req.watermark !== void 0) body.watermark = req.watermark;
+  if (req.generate_audio !== void 0) body.generate_audio = req.generate_audio;
+  if (req.output_format !== void 0) body.output_format = req.output_format;
+  return body;
+}
+function taskIdFromArk(json) {
+  if (!isRecord(json) || typeof json.id !== "string" || json.id === "") {
+    throw new ApiError("ark create response is missing the task id");
+  }
+  return json.id;
+}
+function arkPollPath(id) {
+  return `${ARK_VIDEO_TASKS_PATH}/${encodeURIComponent(id)}`;
+}
+function arkVideoResult(json) {
+  const content = json.content;
+  if (!isRecord(content) || typeof content.video_url !== "string" || content.video_url === "") {
+    throw new ApiError("ark task succeeded without content.video_url");
+  }
+  const result = { url: content.video_url };
+  if (typeof json.model === "string") result.model = json.model;
+  if (typeof json.duration === "number") result.duration = json.duration;
+  if (typeof json.resolution === "string") result.resolution = json.resolution;
+  if (typeof json.ratio === "string") result.ratio = json.ratio;
+  if (typeof json.output_format === "string") result.format = json.output_format;
+  if (isRecord(json.usage)) result.usage = json.usage;
+  return result;
+}
+function arkVideoFailure(json, status) {
+  const error = json.error;
+  if (!isRecord(error)) {
+    return { message: `ark task ${status}` };
+  }
+  const failure = {
+    message: typeof error.message === "string" && error.message.trim() !== "" ? error.message : `ark task ${status}`
+  };
+  if (typeof error.code === "string" && error.code !== "") failure.code = error.code;
+  return failure;
+}
+function arkPollOutcome(json) {
+  if (!isRecord(json)) {
+    throw new ApiError("ark task response is not a JSON object");
+  }
+  const status = json.status;
+  if (status === "queued") return { state: "pending" };
+  if (status === "running") return { state: "running" };
+  if (status === "succeeded") return { state: "succeeded", result: arkVideoResult(json) };
+  if (status === "failed" || status === "cancelled" || status === "expired") {
+    return { state: status, failure: arkVideoFailure(json, status) };
+  }
+  throw new ApiError(`ark task reported the unknown status ${JSON.stringify(status)}`);
+}
+var ArkVideoDialect = {
+  dialect: "ark",
+  createPath: ARK_VIDEO_TASKS_PATH,
+  buildRequest: buildArkVideoRequest,
+  taskIdFrom: taskIdFromArk,
+  pollPath: arkPollPath,
+  pollOutcome: arkPollOutcome,
+  resolutions: ["480p", "720p", "1080p", "4k"],
+  exclusiveFields: ["generate_audio", "output_format", "watermark", "seed"]
+};
+
+// src/api/dashscope.ts
+var ARK_ONLY_FIELDS = [
+  "output_format",
+  "optimize_prompt_mode",
+  "layer_decomposition",
+  "background"
+];
+var OPENAI_ONLY_FIELDS = ["prompt_extend_mode", "enable_thinking"];
+var PIXEL_PAIR = /^(\d+)x(\d+)$/;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toDashscopeSize(size) {
+  const value = size.trim();
+  const pair = PIXEL_PAIR.exec(value);
+  if (pair === null || Number(pair[1]) <= 0 || Number(pair[2]) <= 0) {
+    throw new UsageError(
+      `invalid --size ${JSON.stringify(size)}: the dashscope dialect sends a WxH pixel pair as \u5BBD*\u9AD8, e.g. 2048x2048`
+    );
+  }
+  return `${pair[1]}*${pair[2]}`;
+}
+function buildDashscopeRequest(req) {
+  for (const field of ARK_ONLY_FIELDS) {
+    if (req[field] !== void 0) {
+      throw new UsageError(
+        `option "${field}" is ark-only and is not supported by the dashscope dialect; remove it or use an api_type = "ark" provider`
+      );
+    }
+  }
+  for (const field of OPENAI_ONLY_FIELDS) {
+    if (req[field] !== void 0) {
+      throw new UsageError(
+        `option "${field}" is openai dialect only and is not supported by the dashscope dialect; remove it or use an api_type = "openai" provider`
+      );
+    }
+  }
+  const content = req.images.map((image) => ({ image }));
+  content.push({ text: req.prompt });
+  const parameters = { n: req.n };
+  if (req.size !== void 0) parameters.size = toDashscopeSize(req.size);
+  if (req.negative_prompt !== void 0) parameters.negative_prompt = req.negative_prompt;
+  if (req.prompt_extend !== void 0) parameters.prompt_extend = req.prompt_extend;
+  if (req.watermark !== void 0) parameters.watermark = req.watermark;
+  if (req.seed !== void 0) parameters.seed = req.seed;
+  return {
+    model: req.model,
+    input: { messages: [{ role: "user", content }] },
+    parameters
+  };
+}
+var EXPECTED_SHAPE = "output.choices[].message.content[].image";
+function parseDashscopeResponse(json, requestId) {
+  if (!isRecord2(json)) {
+    throw new ApiError("dashscope API returned a response that is not a JSON object");
+  }
+  if (typeof json.code === "string" && json.code !== "") {
+    const message = typeof json.message === "string" && json.message.trim() !== "" ? json.message : "dashscope API request failed";
+    throw new ApiError(message, json.code);
+  }
+  if (!isRecord2(json.output) || !Array.isArray(json.output.choices)) {
+    throw new ApiError(`dashscope API response is missing ${EXPECTED_SHAPE}`);
+  }
+  const images = [];
+  for (const choice of json.output.choices) {
+    if (!isRecord2(choice) || !isRecord2(choice.message)) continue;
+    const content = choice.message.content;
+    if (!Array.isArray(content)) continue;
+    for (const item of content) {
+      if (isRecord2(item) && typeof item.image === "string" && item.image !== "") {
+        images.push({ url: item.image });
+      }
+    }
+  }
+  if (images.length === 0) {
+    throw new ApiError("dashscope API returned no images");
+  }
+  const parsed = { images, failures: [] };
+  const bodyRequestId = json.request_id;
+  if (requestId !== void 0) {
+    parsed.requestId = requestId;
+  } else if (typeof bodyRequestId === "string" && bodyRequestId !== "") {
+    parsed.requestId = bodyRequestId;
+  }
+  if (isRecord2(json.usage)) parsed.usage = json.usage;
+  return parsed;
+}
+function parseDashscopeError(json) {
+  if (!isRecord2(json)) return void 0;
+  const message = typeof json.message === "string" ? json.message.trim() : "";
+  if (message === "") return void 0;
+  const code = typeof json.code === "string" && json.code !== "" ? json.code : void 0;
+  return code === void 0 ? { message } : { code, message };
+}
+var DashscopeDialect = {
+  createPath: "/api/v1/services/aigc/multimodal-generation/generation",
+  buildRequest: buildDashscopeRequest,
+  parseResponse: parseDashscopeResponse,
+  parseErrorBody: parseDashscopeError
+};
+
+// src/api/minimax.ts
+var UNSUPPORTED_FIELDS = ["watermark", "generate_audio", "output_format", "seed"];
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var DEFAULT_RESOLUTION = "768p";
+var DEFAULT_DURATION_SECONDS = 5;
+function wireResolution(value) {
+  return value.toUpperCase();
+}
+function buildMinimaxVideoRequest(req) {
+  for (const field of UNSUPPORTED_FIELDS) {
+    if (req[field] !== void 0) {
+      throw new UsageError(
+        `option "${field}" is not supported by the minimax dialect; remove it`
+      );
+    }
+  }
+  const content = [{ type: "text", text: req.prompt }];
+  if (req.first_frame !== void 0) {
+    content.push({
+      type: "image_url",
+      image_url: { url: req.first_frame },
+      role: "first_frame"
+    });
+  }
+  return {
+    model: req.model,
+    content,
+    resolution: wireResolution(req.resolution ?? DEFAULT_RESOLUTION),
+    duration: req.duration ?? DEFAULT_DURATION_SECONDS,
+    ...req.ratio === void 0 ? {} : { ratio: req.ratio }
+  };
+}
+function taskIdFromMinimax(json) {
+  if (!isRecord3(json) || typeof json.task_id !== "string" || json.task_id === "") {
+    throw new ApiError("minimax create response is missing the task id");
+  }
+  return json.task_id;
+}
+function minimaxPollPath(id) {
+  return `/v2/query/video_generation/${encodeURIComponent(id)}`;
+}
+function minimaxFailure(error) {
+  const fallback = "minimax reported no message";
+  if (isRecord3(error)) {
+    const message = typeof error.message === "string" && error.message.trim() !== "" ? error.message : fallback;
+    const code = typeof error.type === "string" && error.type !== "" ? error.type : void 0;
+    return code === void 0 ? { message } : { code, message };
+  }
+  return { message: fallback };
+}
+function minimaxPollOutcome(json) {
+  if (!isRecord3(json) || !isRecord3(json.task)) {
+    throw new ApiError("minimax query response is missing the task object");
+  }
+  const task = json.task;
+  const status = task.status;
+  if (status === "queued") return { state: "pending" };
+  if (status === "running") return { state: "running" };
+  if (status === "succeeded") {
+    if (!isRecord3(task.content) || typeof task.content.url !== "string" || task.content.url === "") {
+      throw new ApiError("minimax task succeeded without content.url");
+    }
+    const result = { url: task.content.url };
+    if (typeof task.model === "string" && task.model !== "") result.model = task.model;
+    if (typeof task.duration === "number") result.duration = task.duration;
+    if (typeof task.resolution === "string") result.resolution = task.resolution;
+    if (typeof task.ratio === "string") result.ratio = task.ratio;
+    if (isRecord3(task.usage)) result.usage = task.usage;
+    return { state: "succeeded", result };
+  }
+  if (status === "failed") return { state: "failed", failure: minimaxFailure(task.error) };
+  if (status === "cancelled") return { state: "cancelled", failure: minimaxFailure(task.error) };
+  throw new ApiError(
+    `minimax task reported the unknown status ${JSON.stringify(status)}`
+  );
+}
+function parseMinimaxError(json) {
+  if (!isRecord3(json) || json.type !== "error" || !isRecord3(json.error)) return void 0;
+  const message = typeof json.error.message === "string" ? json.error.message.trim() : "";
+  if (message === "") return void 0;
+  const code = typeof json.error.type === "string" && json.error.type !== "" ? json.error.type : void 0;
+  return code === void 0 ? { message } : { code, message };
+}
+var MinimaxVideoDialect = {
+  dialect: "minimax",
+  createPath: "/v2/video_generation",
+  buildRequest: buildMinimaxVideoRequest,
+  taskIdFrom: taskIdFromMinimax,
+  pollPath: minimaxPollPath,
+  pollOutcome: minimaxPollOutcome,
+  parseErrorBody: parseMinimaxError,
+  resolutions: ["480p", "768p", "2k"],
+  // None of the dialect-specific optional fields: this API takes model, content,
+  // resolution, duration and ratio, and nothing else.
+  exclusiveFields: []
+};
+
+// src/api/qwen.ts
+var ARK_ONLY_FIELDS2 = [
+  "output_format",
+  "optimize_prompt_mode",
+  "layer_decomposition",
+  "background"
+];
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildQwenRequest(req) {
+  for (const field of ARK_ONLY_FIELDS2) {
+    if (req[field] !== void 0) {
+      throw new UsageError(
+        `option "${field}" is ark-only and is not supported by the openai dialect; remove it or set api_type = "ark" on this task`
+      );
+    }
+  }
+  if (req.prompt_extend_mode === "agent" && req.images.length > 0) {
+    throw new UsageError(
+      'prompt_extend_mode "agent" is only supported for text-to-image; image-to-image (\u56FE\u751F\u56FE) does not support it'
+    );
+  }
+  const body = {
+    model: req.model,
+    prompt: req.prompt
+  };
+  if (req.images.length === 1) {
+    body.image = req.images[0];
+  } else if (req.images.length > 1) {
+    body.image = [...req.images];
+  }
+  body.n = req.n;
+  if (req.size !== void 0) body.size = req.size;
+  if (req.negative_prompt !== void 0) body.negative_prompt = req.negative_prompt;
+  if (req.seed !== void 0) body.seed = req.seed;
+  if (req.prompt_extend !== void 0) body.prompt_extend = req.prompt_extend;
+  if (req.prompt_extend_mode !== void 0) body.prompt_extend_mode = req.prompt_extend_mode;
+  if (req.enable_thinking !== void 0) body.enable_thinking = req.enable_thinking;
+  if (req.watermark !== void 0) body.watermark = req.watermark;
+  return body;
+}
+function parseQwenResponse(json, requestId) {
+  if (!isRecord4(json)) {
+    throw new ApiError("openai API returned a response that is not a JSON object");
+  }
+  if ("error" in json && json.error !== void 0 && json.error !== null) {
+    if (!isRecord4(json.error)) {
+      throw new ApiError("openai API returned an unrecognized error body");
+    }
+    const code = typeof json.error.code === "string" ? json.error.code : void 0;
+    const message = typeof json.error.message === "string" && json.error.message.trim() !== "" ? json.error.message : "openai API request failed";
+    throw new ApiError(message, code);
+  }
+  if (!("data" in json) || json.data === void 0) {
+    throw new ApiError("openai API response is missing the data array");
+  }
+  if (!Array.isArray(json.data)) {
+    throw new ApiError("openai API response data is not an array");
+  }
+  if (json.data.length === 0) {
+    throw new ApiError("openai API returned no images");
+  }
+  const images = json.data.map((entry, index) => {
+    if (!isRecord4(entry) || typeof entry.url !== "string" || entry.url === "") {
+      throw new ApiError(`openai API response image ${index + 1} is missing a url`);
+    }
+    return { url: entry.url };
+  });
+  const parsed = { images, failures: [] };
+  if (requestId !== void 0) parsed.requestId = requestId;
+  if (isRecord4(json.usage)) parsed.usage = json.usage;
+  return parsed;
+}
+var QwenDialect = {
+  createPath: "/compatible-mode/v1/images/generations",
+  buildRequest: buildQwenRequest,
+  parseResponse: parseQwenResponse
+};
+
+// src/api/index.ts
+var DIALECTS = {
+  openai: { image: QwenDialect },
+  // The native DashScope protocol serves images only: its video task was
+  // dropped, because its wire shape shares nothing with the async video dialects.
+  dashscope: { image: DashscopeDialect },
+  ark: { image: ArkDialect, video: ArkVideoDialect },
+  // A video-only service: nothing in this dialect serves an image today, and the
+  // registry says so rather than pretending.
+  minimax: { video: MinimaxVideoDialect }
+};
+function adapterPath(apiType, task) {
+  if (!Object.hasOwn(DIALECTS, apiType)) return void 0;
+  return DIALECTS[apiType][task]?.createPath;
+}
+function getAdapter(apiType, task) {
+  if (!Object.hasOwn(DIALECTS, apiType)) {
+    const allowed = Object.keys(DIALECTS).join(", ");
+    throw new ConfigError(
+      `unknown api_type "${String(apiType)}"; expected one of: ${allowed}`
+    );
+  }
+  const adapters = DIALECTS[apiType];
+  const adapter = adapters[task];
+  if (adapter === void 0) {
+    throw new ConfigError(
+      `the "${apiType}" dialect has no "${task}" adapter; implemented tasks: ${Object.keys(adapters).join(", ")}`
+    );
+  }
+  return adapter;
+}
+
+// src/config.ts
+function configDir() {
+  const override = process.env.MEDIAGEN_CLI_CONFIG_DIR;
+  if (override) return override;
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+  if (xdgConfigHome) return path2.join(xdgConfigHome, "mediagen-cli");
+  return path2.join(os.homedir(), ".config", "mediagen-cli");
+}
+function stateDir() {
+  const override = process.env.MEDIAGEN_CLI_STATE_DIR;
+  if (override) return override;
+  const xdgStateHome = process.env.XDG_STATE_HOME;
+  if (xdgStateHome) return path2.join(xdgStateHome, "mediagen-cli");
+  return path2.join(os.homedir(), ".local", "state", "mediagen-cli");
+}
+function configPath() {
+  return path2.join(configDir(), "config.toml");
+}
+function noProviderSelectedMessage(file = configPath()) {
+  return `no provider selected: set "default_provider" in ${file} or pass --provider <name>`;
+}
+function writeConfigFile(text) {
+  const file = configPath();
+  const dir = path2.dirname(file);
+  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+  const tmp = path2.join(dir, `.config.toml.${process.pid}.${randomUUID()}.tmp`);
+  try {
+    fs2.writeFileSync(tmp, text);
+    fs2.renameSync(tmp, file);
+  } catch (error) {
+    try {
+      fs2.unlinkSync(tmp);
+    } catch {
+    }
+    throw error;
+  }
+  return file;
+}
+function ensureConfigFile() {
+  const file = configPath();
+  if (fs2.existsSync(file)) return;
+  try {
+    fs2.mkdirSync(configDir(), { recursive: true, mode: 448 });
+    fs2.writeFileSync(file, SEED_CONFIG, { flag: "wx" });
+  } catch (error) {
+    const code = error?.code;
+    if (code === "EEXIST" && fs2.existsSync(file)) return;
+    try {
+      fs2.unlinkSync(file);
+    } catch {
+    }
+    throw new ConfigError(unwritableFileMessage(file, error));
+  }
+}
+function prepareConfigFile() {
+  ensureConfigFile();
+  loadConfig();
+}
+function resolveBaseUrl(name, apiType, file, value) {
+  const normalized = normalizeHttpBaseUrl(value);
+  if (normalized !== void 0) return normalized;
+  const table = `[providers.${tomlKey(name)}] in ${file}`;
+  if (value.includes("<")) {
+    throw new ConfigError(
+      `base_url under ${table} still contains the placeholder ${JSON.stringify(value)}: replace <workspace-id> with your Bailian workspace id, e.g. "https://abc123.cn-beijing.maas.aliyuncs.com"`
+    );
+  }
+  const example = apiType === "ark" ? "https://ark.cn-beijing.volces.com" : apiType === "openai" || apiType === "dashscope" ? "https://abc123.cn-beijing.maas.aliyuncs.com" : "https://gateway.example.com";
+  throw new ConfigError(
+    `provider "${name}" has invalid base_url ${JSON.stringify(value)} under ${table}: expected an absolute http(s) origin \u2014 a gateway prefix is allowed, a version segment is not \u2014 without credentials, query or fragment, e.g. ${example}`
+  );
+}
+function readOptionalString(table, key, file) {
+  const value = table[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    throw new ConfigError(`"${key}" in ${file} must be a string`);
+  }
+  return value;
+}
+function vendorPathIssue(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return void 0;
+  }
+  if (!isVendorHost(url.hostname)) return void 0;
+  if (url.pathname === "" || url.pathname === "/") return void 0;
+  return { prefix: url.pathname, origin: `${url.protocol}//${url.host}` };
+}
+function pathAfterVendorRoot(createPath) {
+  if (createPath === void 0) return void 0;
+  const segments = createPath.split("/");
+  const rootSegments = segments.length >= 5 ? 3 : segments.length >= 3 ? 2 : 0;
+  if (rootSegments === 0) return void 0;
+  return `/${segments.slice(rootSegments).join("/")}`;
+}
+function isVendorHost(hostname) {
+  const host = hostname.toLowerCase();
+  return host === "ark.cn-beijing.volces.com" || host === "dashscope.aliyuncs.com" || host === "dashscope-intl.aliyuncs.com" || host === "api.minimax.io" || host.endsWith(".maas.aliyuncs.com");
+}
+function readDialect(value) {
+  if (value === "openai" || value === "dashscope" || value === "ark" || value === "minimax") {
+    return { dialect: value, deprecated: false };
+  }
+  if (value === "qwen") return { dialect: "openai", deprecated: true };
+  return void 0;
+}
+var DIALECT_CHOICES = 'expected "openai", "dashscope", "ark" or "minimax" ("qwen" is accepted as a deprecated alias of "openai")';
+function isTable(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var KNOWN_TASKS = ["image", "video"];
+var DEFAULT_TIMEOUT_SECONDS = { image: 300, video: 1800 };
+var MAX_TIMEOUT_SECONDS = 86400;
+var PROVIDER_ENTRY_FIELDS = ["api_type", "base_url", "api_key_env"];
+var TASK_BLOCK_FIELDS = ["default", "models", "timeout_seconds", "path", "api_type"];
+function loadConfig() {
+  const file = configPath();
+  if (!fs2.existsSync(file)) {
+    return { default_provider: "", output_dir: process.cwd(), providers: {} };
+  }
+  let source;
+  try {
+    source = fs2.readFileSync(file, "utf8");
+  } catch (error) {
+    throw new ConfigError(unreadableFileMessage(file, error));
+  }
+  let parsed;
+  try {
+    parsed = parse(source);
+  } catch (error) {
+    throw new ConfigError(malformedDocumentMessage(file, "TOML", error));
+  }
+  const providers = /* @__PURE__ */ Object.create(null);
+  const rawProviders = parsed.providers;
+  if (rawProviders !== void 0) {
+    if (!isTable(rawProviders)) {
+      throw new ConfigError(`"providers" in ${file} must be a table`);
+    }
+    for (const [name, rawEntry] of Object.entries(rawProviders)) {
+      if (!isTable(rawEntry)) {
+        throw new ConfigError(`provider "${name}" in ${file} must be a table`);
+      }
+      providers[name] = readProviderEntry(name, file, rawEntry);
+    }
+  }
+  return {
+    default_provider: readOptionalString(parsed, "default_provider", file) ?? "",
+    output_dir: readOptionalString(parsed, "output_dir", file) ?? process.cwd(),
+    providers
+  };
+}
+function readProviderEntry(name, file, table) {
+  const entry = { tasks: {} };
+  for (const [key, value] of Object.entries(table)) {
+    if (key === "api_type") {
+      const parsed = readDialect(value);
+      if (parsed === void 0) {
+        throw new ConfigError(
+          `provider "${name}" in ${file} has invalid api_type ${JSON.stringify(value)}; ${DIALECT_CHOICES}`
+        );
+      }
+      entry.api_type = parsed.dialect;
+      if (parsed.deprecated) entry.api_type_alias = true;
+      continue;
+    }
+    if (key === "base_url" || key === "api_key_env") {
+      if (typeof value !== "string") {
+        throw new ConfigError(
+          `provider "${name}" in ${file} has invalid ${key}: expected a string`
+        );
+      }
+      entry[key] = value;
+      continue;
+    }
+    if (isTask(key)) {
+      if (!isTable(value)) {
+        throw new ConfigError(
+          `provider "${name}" in ${file} has invalid [providers.${tomlKey(name)}.${key}]: expected a table`
+        );
+      }
+      entry.tasks[key] = readTaskBlock(name, key, file, value);
+      continue;
+    }
+    const singular = key.endsWith("s") ? key.slice(0, -1) : void 0;
+    if (singular !== void 0 && isTask(singular)) {
+      throw new ConfigError(
+        `unknown task "${key}" under [providers.${tomlKey(name)}]; expected ${KNOWN_TASKS.join(", ")}`
+      );
+    }
+    throw new ConfigError(
+      `unknown key "${key}" under [providers.${tomlKey(name)}]; expected ${[...PROVIDER_ENTRY_FIELDS, ...KNOWN_TASKS].join(", ")}`
+    );
+  }
+  return entry;
+}
+function readTaskBlock(name, task, file, table) {
+  const block = {};
+  const where = `[providers.${tomlKey(name)}.${task}]`;
+  for (const [key, value] of Object.entries(table)) {
+    if (key === "api_type") {
+      const parsed = readDialect(value);
+      if (parsed === void 0) {
+        throw new ConfigError(
+          `api_type under ${where} is invalid: ${JSON.stringify(value)}; ${DIALECT_CHOICES}`
+        );
+      }
+      block.api_type = parsed.dialect;
+      if (parsed.deprecated) block.api_type_alias = true;
+      continue;
+    }
+    if (key === "default") {
+      if (typeof value !== "string") {
+        throw new ConfigError(`default under ${where} must be a string (${file})`);
+      }
+      block.default = value;
+      continue;
+    }
+    if (key === "models") {
+      if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        throw new ConfigError(
+          `models under ${where} must be an array of strings (${file})`
+        );
+      }
+      block.models = value;
+      continue;
+    }
+    if (key === "path") {
+      if (typeof value !== "string" || !value.startsWith("/") || /[?#]/.test(value)) {
+        throw new ConfigError(
+          `path under ${where} must start with "/" and carry no query or fragment (${file})`
+        );
+      }
+      block.path = value.replace(/\/+$/, "") || "/";
+      continue;
+    }
+    if (key === "timeout_seconds") {
+      if (typeof value !== "number") {
+        throw new ConfigError(`timeout_seconds under ${where} must be a number (${file})`);
+      }
+      block.timeout_seconds = value;
+      continue;
+    }
+    throw new ConfigError(
+      `unknown key "${key}" under ${where}; expected ${TASK_BLOCK_FIELDS.join(", ")}`
+    );
+  }
+  return block;
+}
+function validateProviderShape(name, config) {
+  const file = configPath();
+  if (name === "") throw new ConfigError(noProviderSelectedMessage(file));
+  const entry = config.providers[name];
+  if (entry === void 0) {
+    throw new ConfigError(
+      `unknown provider "${name}": no [providers.${tomlKey(name)}] table in ${file}; add one by hand, or run "mediagen config add ${shellArg(name)} --api-type <openai|dashscope|ark|minimax> --base-url <origin> --model <id>"`
+    );
+  }
+  const declared = taskNames(entry);
+  const missing = [];
+  const hasDialect = entry.api_type !== void 0 || KNOWN_TASKS.some((task) => entry.tasks[task]?.api_type !== void 0);
+  if (!hasDialect) missing.push("api_type");
+  if (entry.base_url === void 0) missing.push("base_url");
+  if (missing.length > 0) {
+    const where = missing.includes("api_type") && declared.length > 0 ? `; api_type may live on the provider or on a task table, e.g. ${declared.map((task) => `[providers.${tomlKey(name)}.${task}]`).join(" or ")}` : "";
+    throw new ConfigError(
+      `provider "${name}" is missing required field(s): ${missing.join(", ")}; fix [providers.${tomlKey(name)}] in ${file}${where}`
+    );
+  }
+  if (declared.length === 0) {
+    throw new ConfigError(
+      `provider "${name}" declares no task tables; expected ${KNOWN_TASKS.join(", ")}`
+    );
+  }
+  const baseUrl = entry.base_url;
+  const provider = {
+    name,
+    base_url: resolveBaseUrl(name, entry.api_type, file, baseUrl)
+  };
+  if (entry.api_type !== void 0) provider.api_type = entry.api_type;
+  if (entry.api_key_env !== void 0) provider.api_key_env = entry.api_key_env;
+  return provider;
+}
+function resolveSelection(request, config) {
+  const name = selectProviderName(request, config);
+  const entry = config.providers[name];
+  const where = `[providers.${tomlKey(name)}.${request.task}]`;
+  if (entry === void 0) {
+    validateProviderShape(name, config);
+  }
+  const block = entry?.tasks[request.task];
+  if (block === void 0) {
+    const declared = entry === void 0 ? [] : taskNames(entry);
+    throw new ConfigError(
+      `provider "${name}" declares no "${request.task}" models; declared tasks: ${declared.length === 0 ? "(none)" : declared.join(", ")}`
+    );
+  }
+  const provider = validateProviderShape(name, config);
+  const dialect = block.api_type ?? entry?.api_type;
+  if (dialect === void 0) {
+    throw new ConfigError(
+      `${where} declares no api_type and [providers.${tomlKey(name)}] sets no default; add api_type = "openai" | "dashscope" | "ark" under ${where} in ${configPath()}`
+    );
+  }
+  if (block.path === void 0) {
+    const issue = vendorPathIssue(provider.base_url);
+    if (issue !== void 0) {
+      const defaultPath = adapterPath(dialect, request.task);
+      throw new ConfigError(
+        `provider "${name}" has base_url ${JSON.stringify(provider.base_url)} in ${configPath()}: it points at the sub-path "${issue.prefix}", and the ${dialect} dialect appends its own path to base_url. Set base_url to the origin (e.g. "${issue.origin}"), or keep the prefix and declare path = ${JSON.stringify(pathAfterVendorRoot(defaultPath) ?? "/<path from the prefix>")} under ${where}`
+      );
+    }
+  }
+  const models = block.models;
+  if (models === void 0) {
+    throw new ConfigError(`${where} is missing required field(s): models`);
+  }
+  if (models.length === 0) {
+    throw new ConfigError(`models must not be empty under ${where}`);
+  }
+  const model = request.model ?? block.default;
+  if (model === void 0) {
+    throw new ConfigError(
+      `${where} sets no default model; pass --model <id> or add default = "<id>"`
+    );
+  }
+  if (!models.includes(model)) {
+    const otherTask = KNOWN_TASKS.find(
+      (task) => task !== request.task && entry?.tasks[task]?.models?.includes(model) === true
+    );
+    if (otherTask !== void 0) {
+      throw new ConfigError(
+        `model "${model}" is declared for task "${otherTask}", not "${request.task}"; run the command that matches its task, or add it under ${where}`
+      );
+    }
+    if (block.default === model) {
+      throw new ConfigError(`default "${model}" is not listed in models under ${where}`);
+    }
+    throw new ConfigError(
+      `unknown model "${model}" for provider "${name}" (task ${request.task}) in ${configPath()}; add it to models = [...] under ${where}`
+    );
+  }
+  getAdapter(dialect, request.task);
+  const seconds = block.timeout_seconds ?? DEFAULT_TIMEOUT_SECONDS[request.task];
+  if (!Number.isInteger(seconds) || seconds < 1 || seconds > MAX_TIMEOUT_SECONDS) {
+    throw new ConfigError(
+      `timeout_seconds must be an integer in 1..${MAX_TIMEOUT_SECONDS} under ${where}, got ${Number.isNaN(seconds) ? "NaN" : String(seconds)}`
+    );
+  }
+  const binding = {
+    provider,
+    task: request.task,
+    model,
+    timeout_ms: seconds * 1e3,
+    dialect
+  };
+  if (block.path !== void 0) binding.path = block.path;
+  return binding;
+}
+function selectProviderName(request, config) {
+  if (request.provider !== void 0) return request.provider;
+  if (request.model !== void 0) {
+    const hits = Object.entries(config.providers).filter(([, entry]) => entry.tasks[request.task]?.models?.includes(request.model)).map(([name]) => name);
+    if (hits.length === 1) return hits[0];
+    if (hits.length > 1) {
+      throw new ConfigError(
+        `model "${request.model}" is declared by providers ${hits.map((name) => `"${name}"`).join(", ")}; pass --provider`
+      );
+    }
+    const otherTask = KNOWN_TASKS.find(
+      (task) => task !== request.task && knownModels(task, config).includes(request.model)
+    );
+    if (otherTask !== void 0) {
+      throw new ConfigError(
+        `model "${request.model}" is declared for task "${otherTask}", not "${request.task}"; run the command that matches its task`
+      );
+    }
+    const known = knownModels(request.task, config);
+    throw new ConfigError(
+      `unknown model "${request.model}": no provider declares it for task "${request.task}"; known models for task "${request.task}": ${known.length === 0 ? "(none)" : known.join(", ")}`
+    );
+  }
+  return config.default_provider;
+}
+function knownModels(task, config) {
+  const seen = [];
+  for (const entry of Object.values(config.providers)) {
+    for (const model of entry.tasks[task]?.models ?? []) {
+      if (!seen.includes(model)) seen.push(model);
+    }
+  }
+  return seen;
+}
+function taskNames(entry) {
+  return KNOWN_TASKS.filter((task) => entry.tasks[task] !== void 0);
+}
+function isTask(value) {
+  return KNOWN_TASKS.includes(value);
+}
+
+// src/auth.ts
+function authPath() {
+  return path3.join(stateDir(), "auth.json");
+}
+function loadAuth() {
+  const file = authPath();
+  let source;
+  try {
+    source = fs3.readFileSync(file, "utf8");
+  } catch (error) {
+    if (isNotFound(error)) return { providers: {} };
+    throw new ConfigError(unreadableFileMessage(file, error));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (error) {
+    throw new ConfigError(malformedDocumentMessage(file, "JSON", error));
+  }
+  return normalizeAuth(parsed, file);
+}
+function saveApiKey(providerName, apiKey) {
+  const auth = loadAuth();
+  auth.providers[providerName] = { api_key: apiKey };
+  writeAuth(auth);
+}
+function removeApiKey(providerName) {
+  const auth = loadAuth();
+  if (!Object.prototype.hasOwnProperty.call(auth.providers, providerName)) return false;
+  delete auth.providers[providerName];
+  writeAuth(auth);
+  return true;
+}
+function maskKey(key) {
+  if (key.length < 12) return "***";
+  return `${key.slice(0, 4)}\u2026${key.slice(-4)}`;
+}
+function resolveApiKey(provider, flagKey, env = process.env) {
+  if (flagKey) return { key: flagKey, source: "flag" };
+  const configuredEnv = provider.api_key_env;
+  if (configuredEnv) {
+    const value = env[configuredEnv];
+    if (value) return { key: value, source: "env" };
+  }
+  const stored = loadAuth().providers[provider.name]?.api_key;
+  if (stored) return { key: stored, source: "auth" };
+  return null;
+}
+function writeAuth(auth) {
+  const file = authPath();
+  const dir = path3.dirname(file);
+  fs3.mkdirSync(dir, { recursive: true, mode: 448 });
+  const tmp = path3.join(dir, `.auth.json.${process.pid}.${randomUUID2()}.tmp`);
+  try {
+    fs3.writeFileSync(tmp, `${JSON.stringify(auth, null, 2)}
+`, { mode: 384 });
+    fs3.renameSync(tmp, file);
+  } catch (error) {
+    try {
+      fs3.unlinkSync(tmp);
+    } catch {
+    }
+    throw error;
+  }
+  fs3.chmodSync(file, 384);
+}
+function normalizeAuth(parsed, file) {
+  if (!isRecord5(parsed)) {
+    throw new ConfigError(`auth file ${file} must contain a JSON object`);
+  }
+  const rawProviders = parsed.providers;
+  if (rawProviders === void 0) return { providers: {} };
+  if (!isRecord5(rawProviders)) {
+    throw new ConfigError(`"providers" in ${file} must be an object`);
+  }
+  const providers = {};
+  for (const [name, entry] of Object.entries(rawProviders)) {
+    if (!isRecord5(entry) || typeof entry.api_key !== "string") {
+      throw new ConfigError(`provider "${name}" in ${file} must have a string "api_key"`);
+    }
+    providers[name] = { api_key: entry.api_key };
+  }
+  return { providers };
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNotFound(error) {
+  return isRecord5(error) && error.code === "ENOENT";
+}
+
+// src/generate.ts
+import fs5 from "fs";
+import os2 from "os";
+import path5 from "path";
+
+// src/download.ts
+import fs4 from "fs";
+import path4 from "path";
+var DOWNLOAD_TIMEOUT_MS = 12e4;
+var VIDEO_DOWNLOAD_TIMEOUT_MS = 6e5;
+var SAFE_EXTENSION = /^[a-z0-9]+$/;
+var KNOWN_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "webp",
+  "bmp",
+  "tif",
+  "tiff",
+  "gif",
+  "heic",
+  "heif"
+]);
+var KNOWN_VIDEO_EXTENSIONS = /* @__PURE__ */ new Set(["mp4", "mov", "webm", "mkv"]);
+var IMAGE_CONTENT_TYPE_EXTENSIONS = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp",
+  "image/bmp": "bmp",
+  "image/tiff": "tiff",
+  "image/gif": "gif",
+  "image/heic": "heic",
+  "image/heif": "heif"
+};
+var VIDEO_CONTENT_TYPE_EXTENSIONS = {
+  "video/mp4": "mp4",
+  "video/quicktime": "mov",
+  "video/webm": "webm",
+  "video/x-matroska": "mkv"
+};
+function buildFilename(params) {
+  return `${params.provider}-${slugModel(params.model)}-${params.stamp}-${params.index}.${params.ext}`;
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isTimeoutError(error) {
+  return error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+}
+function downloadFailure(url, error, timeoutMs) {
+  if (isTimeoutError(error)) {
+    return new ApiError(`download timeout after ${timeoutMs / 1e3}s for ${url}`);
+  }
+  return new ApiError(`failed to download ${url}: ${errorMessage2(error)}`);
+}
+function extensionFromUrl(url, knownExtensions) {
+  const pathname = url.split(/[?#]/)[0] ?? "";
+  const extension = path4.extname(pathname).toLowerCase().replace(/^\./, "");
+  return knownExtensions.has(extension) ? extension : void 0;
+}
+function extensionFromContentType(contentType, knownExtensions) {
+  const mime = contentType.split(";")[0]?.trim().toLowerCase();
+  return mime === void 0 ? void 0 : knownExtensions[mime];
+}
+function inferExtension(result, contentType, kind = "image") {
+  if (kind === "video") {
+    const declared = "format" in result ? result.format?.trim().toLowerCase() : void 0;
+    if (declared !== void 0 && SAFE_EXTENSION.test(declared) && KNOWN_VIDEO_EXTENSIONS.has(declared)) {
+      return declared;
+    }
+    const fromVideoUrl = extensionFromUrl(result.url, KNOWN_VIDEO_EXTENSIONS);
+    if (fromVideoUrl !== void 0) return fromVideoUrl;
+    if (contentType !== void 0) {
+      const fromContentType = extensionFromContentType(contentType, VIDEO_CONTENT_TYPE_EXTENSIONS);
+      if (fromContentType !== void 0) return fromContentType;
+    }
+    return "mp4";
+  }
+  const outputFormat = "outputFormat" in result ? result.outputFormat?.trim().toLowerCase() : void 0;
+  if (outputFormat !== void 0 && SAFE_EXTENSION.test(outputFormat)) {
+    return outputFormat === "jpeg" ? "jpg" : outputFormat;
+  }
+  const fromUrl = extensionFromUrl(result.url, KNOWN_IMAGE_EXTENSIONS);
+  if (fromUrl !== void 0) return fromUrl;
+  if (contentType !== void 0) {
+    const fromContentType = extensionFromContentType(contentType, IMAGE_CONTENT_TYPE_EXTENSIONS);
+    if (fromContentType !== void 0) return fromContentType;
+  }
+  return "png";
+}
+function uniquePath(filePath) {
+  if (!fs4.existsSync(filePath)) return filePath;
+  const dir = path4.dirname(filePath);
+  const ext = path4.extname(filePath);
+  const base = path4.basename(filePath, ext);
+  for (let suffix = 2; ; suffix += 1) {
+    const candidate = path4.join(dir, `${base}-${suffix}${ext}`);
+    if (!fs4.existsSync(candidate)) return candidate;
+  }
+}
+async function downloadMedia(result, opts) {
+  const timeoutMs = opts.kind === "video" ? VIDEO_DOWNLOAD_TIMEOUT_MS : DOWNLOAD_TIMEOUT_MS;
+  fs4.mkdirSync(opts.outDir, { recursive: true });
+  let response;
+  try {
+    response = await fetch(result.url, { signal: AbortSignal.timeout(timeoutMs) });
+  } catch (error) {
+    throw downloadFailure(result.url, error, timeoutMs);
+  }
+  if (!response.ok) {
+    throw new ApiError(`download failed with status ${response.status} for ${result.url}`);
+  }
+  let bytes;
+  try {
+    bytes = Buffer.from(await response.arrayBuffer());
+  } catch (error) {
+    throw downloadFailure(result.url, error, timeoutMs);
+  }
+  const ext = inferExtension(result, response.headers.get("content-type") ?? void 0, opts.kind);
+  const name = buildFilename({
+    provider: opts.provider,
+    model: opts.model,
+    stamp: opts.stamp,
+    index: opts.index,
+    ext
+  });
+  const target = uniquePath(path4.resolve(opts.outDir, name));
+  fs4.writeFileSync(target, bytes);
+  return { path: target, url: result.url, index: opts.index, meta: result };
+}
+async function downloadImage(result, opts) {
+  return downloadMedia(result, { ...opts, kind: "image" });
+}
+
+// src/http.ts
+var BODY_EXCERPT_LIMIT = 200;
+var QWEN_WORKSPACE_BASE_URL = "https://<workspace-id>.cn-beijing.maas.aliyuncs.com";
+var REQUEST_TIMEOUT_MS = 6e4;
+function errorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isTimeoutError2(error) {
+  return error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function redactorFor(apiKey) {
+  if (apiKey === "") return (text) => text;
+  return (text) => text.split(apiKey).join("[redacted]");
+}
+var ANSI_ESCAPE_SEQUENCE = /\u001b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\u0007\u001b]*(?:\u0007|\u001b\\))/g;
+var CONTROL_BYTE = /[\u0000-\u001f\u007f-\u009f]/g;
+function oneLine(text) {
+  return text.replace(ANSI_ESCAPE_SEQUENCE, "").replace(CONTROL_BYTE, " ").replace(/\s+/g, " ").trim();
+}
+function capLength(line) {
+  return line.length > BODY_EXCERPT_LIMIT ? `${line.slice(0, BODY_EXCERPT_LIMIT)}...` : line;
+}
+function bodyExcerpt(text) {
+  const line = oneLine(text);
+  return line === "" ? "empty body" : capLength(line);
+}
+function safeLine(text) {
+  return capLength(oneLine(text));
+}
+function httpError(message, status, code) {
+  return new ApiError(message, code, void 0, status);
+}
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+function vendorError(json) {
+  if (!isRecord6(json) || !isRecord6(json.error)) return void 0;
+  const message = typeof json.error.message === "string" ? json.error.message.trim() : "";
+  if (message === "") return void 0;
+  const code = vendorCode(json.error.code);
+  return code === void 0 ? { message } : { code, message };
+}
+function vendorCode(code) {
+  if (typeof code === "string") return code === "" ? void 0 : code;
+  if (typeof code === "number" && Number.isFinite(code)) return String(code);
+  return void 0;
+}
+function parseJson(text, status, redact) {
+  if (text.trim() === "") {
+    throw httpError(`API response with status ${status} has an empty body`, status);
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw httpError(
+      `API response with status ${status} is not valid JSON: ${redact(bodyExcerpt(text))}`,
+      status
+    );
+  }
+}
+function missingQwenEndpointMessage(provider, status, redact) {
+  const host = redact(hostOf(provider.base_url));
+  return [
+    `${provider.name} API request failed with status ${status}: this endpoint does not exist on ${host}.`,
+    `The OpenAI-compatible images API is served only on your workspace-scoped Bailian host, ${QWEN_WORKSPACE_BASE_URL}.`,
+    `Fix it by setting base_url = "${QWEN_WORKSPACE_BASE_URL}" under [providers.${tomlKey(provider.name)}] in config.toml \u2014 base_url is the origin, and the dialect appends the endpoint path, version segment included \u2014 then run the command again.`
+  ].join("\n");
+}
+function errorForStatus(text, status, provider, dialect, adapter, redact) {
+  if (status === 404 && text.trim() === "" && dialect === "openai") {
+    return httpError(missingQwenEndpointMessage(provider, status, redact), status);
+  }
+  let json;
+  try {
+    json = text.trim() === "" ? void 0 : JSON.parse(text);
+  } catch {
+    json = void 0;
+  }
+  const vendor = adapter.parseErrorBody?.(json) ?? vendorError(json);
+  if (vendor !== void 0) {
+    const code = vendor.code === void 0 ? void 0 : redact(vendor.code);
+    const codeSuffix = code === void 0 ? "" : ` (code: ${code})`;
+    return httpError(
+      `${provider.name} API request failed with status ${status}: ${redact(vendor.message)}${codeSuffix}`,
+      status,
+      code
+    );
+  }
+  return httpError(
+    `${provider.name} API request failed with status ${status}: ${redact(bodyExcerpt(text))}`,
+    status
+  );
+}
+async function readResponseText(response, url, redact, timeoutSeconds, timeoutMessage) {
+  try {
+    return await response.text();
+  } catch (error) {
+    if (isTimeoutError2(error)) {
+      throw httpError(
+        redact(
+          timeoutMessage ?? `API request timeout after ${timeoutSeconds}s while reading the response from ${redact(hostOf(url))}`
+        ),
+        NO_RESPONSE_STATUS
+      );
+    }
+    throw httpError(
+      `failed to read the API response from ${redact(hostOf(url))}: ${redact(errorMessage3(error))}`,
+      NO_RESPONSE_STATUS
+    );
+  }
+}
+function isImageAdapter(adapter) {
+  return "parseResponse" in adapter;
+}
+async function callApi(params) {
+  const { binding, apiKey, request } = params;
+  const provider = binding.provider;
+  const timeoutSeconds = binding.timeout_ms / 1e3;
+  const adapter = getAdapter(binding.dialect, binding.task);
+  if (!isImageAdapter(adapter)) {
+    throw new ApiError(
+      `this request is for the image task; the binding is for the "${binding.task}" task`
+    );
+  }
+  const body = adapter.buildRequest(request);
+  const payload = JSON.stringify(body);
+  const redact = redactorFor(apiKey);
+  const url = `${provider.base_url}${binding.path ?? adapter.createPath}`;
+  const signal = AbortSignal.timeout(binding.timeout_ms);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: payload,
+      signal
+    });
+  } catch (error) {
+    if (isTimeoutError2(error)) {
+      throw httpError(
+        `${provider.name} API request timeout after ${timeoutSeconds}s (${redact(url)})`,
+        NO_RESPONSE_STATUS
+      );
+    }
+    throw httpError(
+      `${provider.name} API request to ${redact(hostOf(url))} failed: ${redact(errorMessage3(error))}`,
+      NO_RESPONSE_STATUS
+    );
+  }
+  const text = await readResponseText(response, url, redact, timeoutSeconds);
+  if (!response.ok) {
+    throw errorForStatus(text, response.status, provider, binding.dialect, adapter, redact);
+  }
+  const json = parseJson(text, response.status, redact);
+  const requestId = requestIdOf(response);
+  const parsed = adapter.parseResponse(json, requestId);
+  if (parsed.requestId === void 0 && requestId !== void 0) {
+    parsed.requestId = requestId;
+  }
+  return parsed;
+}
+var UNRESOLVED_CREATE_NOTE = "the task may already have been created and paid for. No task id came back, so check your provider's console or usage page for a recent task before submitting again.";
+function createTimeoutMessage(provider) {
+  return `${provider.name} create request timed out after ${REQUEST_TIMEOUT_MS / 1e3}s: ` + UNRESOLVED_CREATE_NOTE;
+}
+function unresolvedSuffix(note) {
+  return note === void 0 ? "" : ` ${note}`;
+}
+function withNote(error, note) {
+  if (note === void 0) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  if (error instanceof ApiError) {
+    return new ApiError(`${message} ${note}`, error.code, error.taskId, error.status);
+  }
+  return new ApiError(`${message} ${note}`);
+}
+function unknownTaskMessage(provider, taskId, host) {
+  return (bodyText) => {
+    const lines = [
+      // The id is echoed back, so it is treated like any other untrusted text and
+      // bounded like a body: pasting tens of KB must not flood the terminal.
+      `${provider.name} API request failed with status 404: no task "${safeLine(taskId)}" exists on ${host}.`,
+      "That is not a failed task: a task id is readable only on the provider that created it, so check --provider and that the id is complete."
+    ];
+    if (oneLine(bodyText) !== "") lines.push(`The response said: ${bodyExcerpt(bodyText)}`);
+    return lines.join("\n");
+  };
+}
+function requestIdOf(response) {
+  const header = response.headers.get("x-request-id");
+  return header === null || header === "" ? void 0 : header;
+}
+async function sendVideoRequest(params) {
+  const { binding, adapter, apiKey, method, url, body, timeoutMessage, notFoundMessage, unresolvedNote } = params;
+  const provider = binding.provider;
+  const redact = redactorFor(apiKey);
+  const timeoutSeconds = REQUEST_TIMEOUT_MS / 1e3;
+  const headers = { Authorization: `Bearer ${apiKey}` };
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      body,
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+  } catch (error) {
+    if (isTimeoutError2(error)) {
+      throw httpError(
+        redact(
+          timeoutMessage ?? `${provider.name} API request timeout after ${timeoutSeconds}s (${url})`
+        ),
+        NO_RESPONSE_STATUS
+      );
+    }
+    throw httpError(
+      `${provider.name} API request to ${redact(hostOf(url))} failed: ${redact(errorMessage3(error))}${unresolvedSuffix(unresolvedNote)}`,
+      NO_RESPONSE_STATUS
+    );
+  }
+  let text;
+  try {
+    text = await readResponseText(
+      response,
+      url,
+      redact,
+      timeoutSeconds,
+      // A create whose body could not be read may already be accepted and paid
+      // for, so the dangerous wording has to survive a read timeout too.
+      timeoutMessage
+    );
+  } catch (error) {
+    throw withNote(error, timeoutMessage === void 0 ? unresolvedNote : void 0);
+  }
+  if (!response.ok) {
+    if (response.status === 404 && notFoundMessage !== void 0) {
+      throw httpError(redact(notFoundMessage(text)), response.status);
+    }
+    const note = response.status >= 500 ? unresolvedNote : void 0;
+    throw withNote(
+      errorForStatus(text, response.status, provider, binding.dialect, adapter, redact),
+      note
+    );
+  }
+  let json;
+  try {
+    json = parseJson(text, response.status, redact);
+  } catch (error) {
+    throw withNote(error, unresolvedNote);
+  }
+  return {
+    json,
+    requestId: requestIdOf(response)
+  };
+}
+function redactedApiError(error, redact) {
+  if (!(error instanceof ApiError)) return error;
+  const message = redact(error.message);
+  const code = error.code === void 0 ? void 0 : redact(error.code);
+  if (message === error.message && code === error.code) return error;
+  return new ApiError(message, code, error.taskId, error.status);
+}
+function redacting(action, redact) {
+  try {
+    return action();
+  } catch (error) {
+    throw redactedApiError(error, redact);
+  }
+}
+async function createTask(params) {
+  const { binding, apiKey, request } = params;
+  const redact = redactorFor(apiKey);
+  const adapter = getAdapter(binding.dialect, "video");
+  const payload = redacting(() => JSON.stringify(adapter.buildRequest(request)), redact);
+  const url = `${binding.provider.base_url}${binding.path ?? adapter.createPath}`;
+  const { json, requestId } = await sendVideoRequest({
+    binding,
+    adapter,
+    apiKey,
+    method: "POST",
+    url,
+    body: payload,
+    timeoutMessage: createTimeoutMessage(binding.provider),
+    unresolvedNote: UNRESOLVED_CREATE_NOTE
+  });
+  let taskId;
+  try {
+    taskId = safeLine(redacting(() => adapter.taskIdFrom(json), redact));
+  } catch (error) {
+    throw withNote(error, UNRESOLVED_CREATE_NOTE);
+  }
+  return requestId === void 0 ? { taskId } : { taskId, requestId };
+}
+function redactedOutcome(outcome, redact) {
+  switch (outcome.state) {
+    case "failed":
+    case "cancelled":
+    case "expired": {
+      const failure = {
+        message: redact(outcome.failure.message)
+      };
+      if (outcome.failure.code !== void 0) failure.code = redact(outcome.failure.code);
+      return { state: outcome.state, failure };
+    }
+    default:
+      return outcome;
+  }
+}
+async function pollTask(params) {
+  const { binding, apiKey, taskId } = params;
+  const provider = binding.provider;
+  const adapter = getAdapter(binding.dialect, "video");
+  const url = binding.path === void 0 ? `${provider.base_url}${adapter.pollPath(taskId)}` : `${provider.base_url}${binding.path}/${encodeURIComponent(taskId)}`;
+  const { json, requestId } = await sendVideoRequest({
+    binding,
+    adapter,
+    apiKey,
+    method: "GET",
+    url,
+    notFoundMessage: unknownTaskMessage(provider, taskId, hostOf(url))
+  });
+  const redact = redactorFor(apiKey);
+  const outcome = redactedOutcome(redacting(() => adapter.pollOutcome(json), redact), redact);
+  return requestId === void 0 ? outcome : { ...outcome, requestId };
+}
+
+// src/generate.ts
+var SIZE_TIERS = ["1K", "1.5K", "2K", "3K", "4K"];
+var PIXEL_PAIR2 = /^(\d+)x(\d+)$/;
+var N_LIMIT = 6;
+function validateSize(size, dialect) {
+  const value = size.trim();
+  if (dialect === "dashscope") {
+    const native = PIXEL_PAIR2.exec(value);
+    if (native !== null && Number(native[1]) > 0 && Number(native[2]) > 0) return;
+    throw new UsageError(
+      `invalid --size ${JSON.stringify(size)}: the dashscope dialect accepts only a WxH pixel pair like --size 2048x2048; size tiers and "auto" belong to the openai dialect`
+    );
+  }
+  if (SIZE_TIERS.includes(value.toUpperCase())) return;
+  const pair = PIXEL_PAIR2.exec(value);
+  if (pair !== null && Number(pair[1]) > 0 && Number(pair[2]) > 0) return;
+  if (dialect === "openai" && value.toLowerCase() === "auto") return;
+  const accepted = dialect === "openai" ? `a tier (${SIZE_TIERS.join(", ")}), a WxH pixel pair of positive integers using a lowercase "x" (e.g. 1024x1024), or "auto"` : `a tier (${SIZE_TIERS.join(", ")}) or a WxH pixel pair of positive integers using a lowercase "x" (e.g. 1024x1024); "auto" is openai-only`;
+  throw new UsageError(`invalid --size ${JSON.stringify(size)}: expected ${accepted}`);
+}
+function resolveOutDir(outDir, configOutDir, cwd = process.cwd(), home = os2.homedir()) {
+  return path5.resolve(cwd, expandHome(outDir ?? configOutDir ?? cwd, home));
+}
+function expandHome(value, home) {
+  if (value === "~") return home;
+  if (value.startsWith("~/") || value.startsWith("~\\")) return path5.join(home, value.slice(2));
+  return value;
+}
+function normalizeBaseUrl(value) {
+  const normalized = normalizeHttpBaseUrl(value);
+  if (normalized === void 0) {
+    throw new UsageError(
+      `invalid --base-url ${JSON.stringify(value)}: expected an absolute http(s) origin without credentials, query or fragment`
+    );
+  }
+  const issue = vendorPathIssue(normalized);
+  if (issue !== void 0) {
+    throw new UsageError(
+      `invalid --base-url ${JSON.stringify(value)}: it points at the sub-path "${issue.prefix}", and the dialect appends its own path; set base_url to the origin, e.g. "${issue.origin}"`
+    );
+  }
+  return normalized;
+}
+function validateN(value) {
+  const n = value ?? 1;
+  if (!Number.isInteger(n) || n < 1) {
+    throw new UsageError(
+      `invalid --n ${JSON.stringify(value)}: expected an integer in the accepted range 1-${N_LIMIT}`
+    );
+  }
+  if (n > N_LIMIT) {
+    throw new UsageError(
+      `invalid --n ${n}: the limit is ${N_LIMIT} images per run; the accepted range is 1-${N_LIMIT}`
+    );
+  }
+  return n;
+}
+function validateSeed(value) {
+  if (value !== void 0 && !Number.isInteger(value)) {
+    throw new UsageError(`invalid --seed ${JSON.stringify(value)}: expected an integer`);
+  }
+  return value;
+}
+function ensureOutDir(dir) {
+  try {
+    fs5.mkdirSync(dir, { recursive: true });
+  } catch (error) {
+    const cause = error instanceof Error ? error.message : String(error);
+    throw new UsageError(
+      `cannot create the output directory ${dir}: ${cause}; check --out-dir (or output_dir in config.toml)`
+    );
+  }
+}
+function missingKeyError(provider) {
+  const hints = [`run "mediagen login --provider ${shellArg(provider.name)}"`];
+  if (provider.api_key_env) hints.push(`set ${provider.api_key_env}`);
+  hints.push("pass --api-key");
+  return new ConfigError(
+    `no API key found for provider "${provider.name}": ${hints.join(", ")}`
+  );
+}
+function buildImageRequest(prompt, opts, model, images, n, seed) {
+  const request = { model, prompt, images, n };
+  if (seed !== void 0) request.seed = seed;
+  if (opts.size !== void 0) request.size = opts.size;
+  if (opts.watermark !== void 0) request.watermark = opts.watermark;
+  if (opts.negativePrompt !== void 0) request.negative_prompt = opts.negativePrompt;
+  if (opts.promptExtend !== void 0) request.prompt_extend = opts.promptExtend;
+  if (opts.promptExtendMode !== void 0) request.prompt_extend_mode = opts.promptExtendMode;
+  if (opts.enableThinking !== void 0) request.enable_thinking = opts.enableThinking;
+  if (opts.outputFormat !== void 0) request.output_format = opts.outputFormat;
+  if (opts.optimizePrompt !== void 0) request.optimize_prompt_mode = opts.optimizePrompt;
+  if (opts.layerDecomposition !== void 0) request.layer_decomposition = opts.layerDecomposition;
+  if (opts.background !== void 0) request.background = opts.background;
+  return request;
+}
+function fanOut(request, count, seed) {
+  return Array.from({ length: count }, (_unused, index) => {
+    const sub = { ...request, n: 1 };
+    if (seed !== void 0) sub.seed = seed + index;
+    return sub;
+  });
+}
+function failedResponse(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const code = error instanceof ApiError && error.code !== void 0 ? error.code : "RequestFailed";
+  return { images: [], failures: [{ code, message }] };
+}
+function mergeResponses(responses) {
+  const merged = { images: [], failures: [] };
+  for (const response of responses) {
+    merged.images.push(...response.images);
+    merged.failures.push(...response.failures);
+    if (merged.usage === void 0) merged.usage = response.usage;
+    if (merged.requestId === void 0) merged.requestId = response.requestId;
+  }
+  return merged;
+}
+function noImagesError(providerName, failures) {
+  const [first] = failures;
+  if (first === void 0) {
+    return new ApiError(`${providerName} API returned no images`);
+  }
+  const detail = failures.map((failure) => `${failure.code}: ${failure.message}`).join("; ");
+  return new ApiError(
+    `${providerName} API returned no images; ${failures.length} request(s) failed: ${detail}`,
+    first.code
+  );
+}
+function downloadFailure2(index, image, error) {
+  const cause = error instanceof Error ? error.message : String(error);
+  return { code: "DownloadError", message: `image ${index} (${image.url}): ${cause}` };
+}
+function nothingSavedError(providerName, failures) {
+  const detail = failures.map((failure) => `${failure.code}: ${failure.message}`).join("; ");
+  const code = failures[0]?.code;
+  return new ApiError(
+    `${providerName} API returned images but none could be saved; ${failures.length} failure(s): ${detail}`,
+    code === void 0 || code === "" ? "DownloadError" : code
+  );
+}
+async function runGenerate(prompt, opts, env = process.env) {
+  if (opts.edit && opts.images.length === 0) {
+    throw new UsageError("edit requires at least one --image");
+  }
+  const n = validateN(opts.n);
+  const seed = validateSeed(opts.seed);
+  const baseUrl = opts.baseUrl === void 0 ? void 0 : normalizeBaseUrl(opts.baseUrl);
+  const config = loadConfig();
+  const binding = resolveSelection(
+    { provider: opts.provider, model: opts.model, task: "image" },
+    config
+  );
+  const provider = baseUrl === void 0 ? binding.provider : { ...binding.provider, base_url: baseUrl };
+  const resolved = { ...binding, provider };
+  const adapter = getAdapter(binding.dialect, "image");
+  if (opts.size !== void 0) validateSize(opts.size, binding.dialect);
+  const model = resolved.model;
+  const draft = buildImageRequest(prompt, opts, model, opts.images, n, seed);
+  adapter.buildRequest(draft);
+  const request = { ...draft, images: draft.images.map(toImageInput) };
+  const auth = resolveApiKey(provider, opts.apiKey, env);
+  if (auth === null) throw missingKeyError(provider);
+  const outDir = resolveOutDir(opts.outDir, config.output_dir);
+  ensureOutDir(outDir);
+  const fanOutRequests = binding.dialect === "ark" && n > 1 ? fanOut(request, n, seed) : [request];
+  const responses = fanOutRequests.length === 1 ? [await callApi({ binding: resolved, apiKey: auth.key, request: fanOutRequests[0] })] : await Promise.all(
+    fanOutRequests.map(
+      (sub) => callApi({ binding: resolved, apiKey: auth.key, request: sub }).catch(failedResponse)
+    )
+  );
+  const response = mergeResponses(responses);
+  if (response.images.length === 0) throw noImagesError(provider.name, response.failures);
+  const stamp = nowStamp();
+  const outcomes = await Promise.allSettled(
+    response.images.map(
+      (image, index) => downloadImage(image, { outDir, provider: provider.name, model, stamp, index })
+    )
+  );
+  const saved = [];
+  response.images.forEach((image, index) => {
+    const outcome = outcomes[index];
+    if (outcome.status === "fulfilled") {
+      saved.push(outcome.value);
+    } else {
+      response.failures.push(downloadFailure2(index, image, outcome.reason));
+    }
+  });
+  if (saved.length === 0) throw nothingSavedError(provider.name, response.failures);
+  return { saved, response, provider };
+}
+
+// src/video.ts
+var RATIOS = ["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "adaptive"];
+function validateResolution(value, adapter) {
+  const tier = value.trim().toLowerCase();
+  if (!adapter.resolutions.includes(tier)) {
+    throw new UsageError(
+      `invalid --resolution ${JSON.stringify(value)}: the ${adapter.dialect} dialect accepts ${adapter.resolutions.join(", ")}; whether a model supports a tier is checked by the vendor`
+    );
+  }
+  return tier;
+}
+function validateDuration(value) {
+  if (value === void 0) return void 0;
+  if (!Number.isInteger(value) || value < 1) {
+    throw new UsageError(
+      `invalid --duration ${JSON.stringify(value)}: expected a positive integer of seconds, e.g. --duration 5; the range a model allows is checked by the vendor`
+    );
+  }
+  return value;
+}
+function validateSeed2(value) {
+  if (value === void 0) return void 0;
+  if (!Number.isInteger(value) || value < 0) {
+    throw new UsageError(`invalid --seed ${JSON.stringify(value)}: expected a non-negative integer`);
+  }
+  return value;
+}
+function validateRatio(value) {
+  if (value === void 0) return void 0;
+  const ratio = value.trim();
+  if (!RATIOS.includes(ratio)) {
+    throw new UsageError(
+      `invalid --ratio ${JSON.stringify(value)}: expected one of ${RATIOS.join(", ")}`
+    );
+  }
+  return ratio;
+}
+function validatePrompt(prompt) {
+  const text = prompt.trim();
+  if (text === "") {
+    throw new UsageError("a video prompt is required: pass the clip's description as the first argument");
+  }
+  return text;
+}
+function firstFrame(images) {
+  if (images.length > 1) {
+    throw new UsageError(
+      `only one --image is supported, the clip's first frame; the second --image ${JSON.stringify(images[1])} would be a last frame (last_frame), and first/last-frame mode is not implemented yet`
+    );
+  }
+  return images[0];
+}
+var DIALECT_SPECIFIC_FIELDS = [
+  { option: "generateAudio", field: "generate_audio", flag: "--generate-audio" },
+  { option: "outputFormat", field: "output_format", flag: "--output-format" },
+  { option: "watermark", field: "watermark", flag: "--watermark" },
+  { option: "seed", field: "seed", flag: "--seed" }
+];
+function rejectUndeclaredFlags(opts, adapter) {
+  const declared = adapter.exclusiveFields ?? [];
+  for (const { option, field, flag } of DIALECT_SPECIFIC_FIELDS) {
+    if (opts[option] !== void 0 && !declared.includes(field)) {
+      throw undeclaredFlag(flag, field, adapter);
+    }
+  }
+}
+function undeclaredFlag(flag, field, adapter) {
+  return new UsageError(
+    `option "${field}" (${flag}) is not supported by the ${adapter.dialect} dialect; remove ${flag}, or select a provider whose dialect accepts it`
+  );
+}
+function buildVideoRequest(prompt, opts, model, adapter) {
+  const text = validatePrompt(prompt);
+  const duration = validateDuration(opts.duration);
+  const seed = validateSeed2(opts.seed);
+  const ratio = validateRatio(opts.ratio);
+  const frame = firstFrame(opts.image ?? []);
+  rejectUndeclaredFlags(opts, adapter);
+  const resolution = opts.resolution === void 0 ? void 0 : validateResolution(opts.resolution, adapter);
+  const request = { model, prompt: text };
+  if (resolution !== void 0) request.resolution = resolution;
+  if (ratio !== void 0) request.ratio = ratio;
+  if (duration !== void 0) request.duration = duration;
+  if (seed !== void 0) request.seed = seed;
+  if (opts.watermark !== void 0) request.watermark = opts.watermark;
+  if (opts.generateAudio !== void 0) request.generate_audio = opts.generateAudio;
+  if (opts.outputFormat !== void 0) request.output_format = opts.outputFormat;
+  if (frame !== void 0) request.first_frame = readFrame(frame);
+  return request;
+}
+function readFrame(value) {
+  try {
+    return toImageInput(value);
+  } catch (error) {
+    if (!(error instanceof UsageError)) throw error;
+    throw new UsageError(`invalid --image ${JSON.stringify(value)}: ${error.message}`);
+  }
+}
+var POLL_INITIAL_MS = 2e3;
+var POLL_FACTOR = 1.5;
+var POLL_MAX_MS = 1e4;
+var POLL_MAX_CONSECUTIVE_FAILURES = 5;
+var REAL_DEPS = {
+  sleep: (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  }),
+  now: () => Date.now()
+};
+function nextDelay(delay) {
+  return Math.min(Math.round(delay * POLL_FACTOR), POLL_MAX_MS);
+}
+async function runVideoGenerate(prompt, opts, deps = REAL_DEPS, env = process.env) {
+  const baseUrl = opts.baseUrl === void 0 ? void 0 : normalizeBaseUrl(opts.baseUrl);
+  const config = loadConfig();
+  const selection = resolveSelection(
+    { provider: opts.provider, model: opts.model, task: "video" },
+    config
+  );
+  const binding = baseUrl === void 0 ? selection : { ...selection, provider: { ...selection.provider, base_url: baseUrl } };
+  const adapter = getAdapter(binding.dialect, "video");
+  const request = buildVideoRequest(prompt, opts, binding.model, adapter);
+  const auth = resolveApiKey(binding.provider, opts.apiKey, env);
+  if (auth === null) throw missingKeyError(binding.provider);
+  const outDir = resolveOutDir(opts.outDir, config.output_dir);
+  ensureOutDir(outDir);
+  const created = await createTask({ binding, apiKey: auth.key, request });
+  noteTaskCreated(created.taskId, opts.noWait);
+  if (opts.noWait) {
+    const pending = {
+      saved: [],
+      taskId: created.taskId,
+      status: "pending",
+      response: void 0
+    };
+    if (created.requestId !== void 0) pending.requestId = created.requestId;
+    return pending;
+  }
+  const waited = await waitForTask(binding, auth.key, created.taskId, deps);
+  const media = waited.result;
+  const saved = await saveVideo(media, {
+    outDir,
+    provider: binding.provider.name,
+    // The model the server echoed, not the one we asked for: `video status` builds
+    // a binding from the default model, and naming a 2.5 clip after 1.0 would be a
+    // false statement about its contents.
+    model: media.model ?? binding.model,
+    taskId: created.taskId
+  });
+  const result = {
+    saved: [saved],
+    taskId: created.taskId,
+    status: "succeeded",
+    response: media
+  };
+  if (media.usage !== void 0) result.usage = media.usage;
+  const requestId = created.requestId ?? waited.requestId;
+  if (requestId !== void 0) result.requestId = requestId;
+  return result;
+}
+function withTaskId(cause, taskId) {
+  if (cause instanceof ApiError && cause.taskId !== void 0) return cause;
+  const reason = cause instanceof Error ? cause.message : String(cause);
+  const code = cause instanceof ApiError ? cause.code : void 0;
+  const alreadyNamed = reason.includes(safeLine(taskId));
+  return new ApiError(
+    alreadyNamed ? reason : `${reason} (task ${safeLine(taskId)})`,
+    code,
+    taskId,
+    causeStatus(cause)
+  );
+}
+async function runVideoStatus(taskId, opts, env = process.env) {
+  const id = taskId.trim();
+  if (id === "") {
+    throw new UsageError("a task id is required: pass the id a previous run printed");
+  }
+  const baseUrl = opts.baseUrl === void 0 ? void 0 : normalizeBaseUrl(opts.baseUrl);
+  const config = loadConfig();
+  const selection = resolveSelection(
+    { provider: opts.provider, model: opts.model, task: "video" },
+    config
+  );
+  const binding = baseUrl === void 0 ? selection : { ...selection, provider: { ...selection.provider, base_url: baseUrl } };
+  const auth = resolveApiKey(binding.provider, opts.apiKey, env);
+  if (auth === null) throw missingKeyError(binding.provider);
+  let outcome;
+  try {
+    outcome = await pollTask({ binding, apiKey: auth.key, taskId: id });
+  } catch (error) {
+    throw withTaskId(error, id);
+  }
+  if (outcome.state === "failed" || outcome.state === "cancelled" || outcome.state === "expired") {
+    throw taskEndedError(binding, id, outcome);
+  }
+  if (outcome.state !== "succeeded") {
+    const unfinished = {
+      saved: [],
+      taskId: id,
+      status: outcome.state,
+      response: void 0
+    };
+    if (outcome.requestId !== void 0) unfinished.requestId = outcome.requestId;
+    return unfinished;
+  }
+  const outDir = resolveOutDir(opts.outDir, config.output_dir);
+  ensureOutDir(outDir);
+  const media = outcome.result;
+  const saved = await saveVideo(media, {
+    outDir,
+    provider: binding.provider.name,
+    model: media.model ?? binding.model,
+    taskId: id
+  });
+  const result = {
+    saved: [saved],
+    taskId: id,
+    status: "succeeded",
+    response: media
+  };
+  if (media.usage !== void 0) result.usage = media.usage;
+  if (outcome.requestId !== void 0) result.requestId = outcome.requestId;
+  return result;
+}
+function noteTaskCreated(taskId, noWait) {
+  const id = safeLine(taskId);
+  const remedy = noWait ? `fetch it later with "mediagen video status ${id}"` : `if this process is interrupted, resume with "mediagen video status ${id}"`;
+  process.stderr.write(`note: task ${id} was created and paid for; ${remedy}
+`);
+}
+async function waitForTask(binding, apiKey, taskId, deps) {
+  const deadline = deps.now() + binding.timeout_ms;
+  let delay = POLL_INITIAL_MS;
+  let failures = 0;
+  for (; ; ) {
+    await deps.sleep(delay);
+    let polled;
+    try {
+      polled = await pollTask({ binding, apiKey, taskId });
+    } catch (error) {
+      if (!isTransientPollFailure(error)) throw stoppedPollingError(taskId, error);
+      failures += 1;
+      if (failures >= POLL_MAX_CONSECUTIVE_FAILURES) throw gaveUpPollingError(binding, taskId, error);
+      if (deps.now() >= deadline) throw notFinishedError(binding, taskId);
+      delay = nextDelay(delay);
+      continue;
+    }
+    failures = 0;
+    const outcome = polled;
+    switch (outcome.state) {
+      case "succeeded":
+        return polled.requestId === void 0 ? { result: outcome.result } : { result: outcome.result, requestId: polled.requestId };
+      case "pending":
+      case "running":
+        break;
+      default:
+        throw taskEndedError(binding, taskId, outcome);
+    }
+    if (deps.now() >= deadline) throw notFinishedError(binding, taskId);
+    delay = nextDelay(delay);
+  }
+}
+function isTransientPollFailure(error) {
+  if (!(error instanceof ApiError)) return false;
+  const status = error.status;
+  if (status === void 0) return false;
+  return status === NO_RESPONSE_STATUS || status === 429 || status >= 500;
+}
+function resumeHint(id) {
+  return `The task was created and paid for, so do not resubmit it: run "mediagen video status ${id}", which checks it and downloads the clip once it is ready.`;
+}
+function causeStatus(cause) {
+  return cause instanceof ApiError ? cause.status : void 0;
+}
+function notFinishedError(binding, taskId) {
+  const id = safeLine(taskId);
+  return new ApiError(
+    `task ${id} has not finished after the ${binding.timeout_ms / 1e3}s poll budget (raise timeout_seconds on this provider's video task to wait longer). ` + resumeHint(id),
+    "TaskNotFinished",
+    taskId
+  );
+}
+function gaveUpPollingError(binding, taskId, cause) {
+  const id = safeLine(taskId);
+  const reason = safeLine(cause instanceof Error ? cause.message : String(cause));
+  const code = cause instanceof ApiError && cause.code !== void 0 ? cause.code : "PollFailed";
+  return new ApiError(
+    `polling task ${id} gave up after ${POLL_MAX_CONSECUTIVE_FAILURES} failures in a row: ${reason}. ${resumeHint(id)}`,
+    code,
+    taskId,
+    causeStatus(cause)
+  );
+}
+function stoppedPollingError(taskId, cause) {
+  const id = safeLine(taskId);
+  const reason = safeLine(cause instanceof Error ? cause.message : String(cause));
+  const code = cause instanceof ApiError && cause.code !== void 0 ? cause.code : "PollFailed";
+  return new ApiError(
+    `polling task ${id} stopped before its state was known: ${reason}. ${resumeHint(id)}`,
+    code,
+    taskId,
+    causeStatus(cause)
+  );
+}
+function taskEndedError(binding, taskId, outcome) {
+  const id = safeLine(taskId);
+  return new ApiError(
+    `${binding.provider.name} video task ${id} ${outcome.state}: ${safeLine(outcome.failure.message)}`,
+    outcome.failure.code,
+    taskId
+  );
+}
+async function saveVideo(media, params) {
+  try {
+    return await downloadMedia(media, {
+      kind: "video",
+      outDir: params.outDir,
+      provider: params.provider,
+      model: params.model,
+      stamp: nowStamp(),
+      index: 0
+    });
+  } catch (error) {
+    const cause = safeLine(error instanceof Error ? error.message : String(error));
+    const id = safeLine(params.taskId);
+    const code = error instanceof ApiError && error.code !== void 0 ? error.code : "DownloadError";
+    throw new ApiError(
+      `task ${id} succeeded but its video could not be saved: ${cause}. The task is paid for, so do not generate it again: "mediagen video status ${id}" downloads the clip without paying twice.`,
+      code,
+      params.taskId
+    );
+  }
+}
+
+// src/output.ts
+function renderHuman(saved, res) {
+  const lines = res.failures.map((failure) => `warning: ${failure.code}: ${failure.message}`);
+  if (saved.length > 0 && res.failures.length > 0) {
+    lines.push(
+      `note: ${saved.length} file(s) written, ${res.failures.length} failed; files are already on disk, do not retry the whole request.`
+    );
+  }
+  return {
+    stdout: saved.map((file) => file.path).join("\n"),
+    stderr: lines.join("\n")
+  };
+}
+function imageSize(meta) {
+  return meta !== void 0 && "size" in meta ? meta.size : void 0;
+}
+function renderJson(saved, res) {
+  const payload = {
+    ok: saved.length > 0,
+    partial: saved.length > 0 && res.failures.length > 0,
+    files: saved.map((file) => {
+      const size = imageSize(file.meta);
+      return {
+        path: file.path,
+        index: file.index,
+        ...size !== void 0 ? { size } : {},
+        url: file.url
+      };
+    }),
+    errors: res.failures.map((failure) => ({
+      code: failure.code,
+      message: failure.message
+    }))
+  };
+  if (res.usage !== void 0) {
+    payload.usage = res.usage;
+  }
+  if (res.requestId !== void 0) {
+    payload.request_id = res.requestId;
+  }
+  return JSON.stringify(payload);
+}
+function videoExtras(meta) {
+  const extras = {};
+  if (meta === void 0) return extras;
+  if ("duration" in meta && typeof meta.duration === "number") extras.duration = meta.duration;
+  if ("resolution" in meta && typeof meta.resolution === "string") {
+    extras.resolution = meta.resolution;
+  }
+  return extras;
+}
+function renderVideoJson(result) {
+  const payload = {
+    ok: true,
+    task_id: result.taskId,
+    status: result.status,
+    files: result.saved.map((file) => {
+      const extras = videoExtras(file.meta);
+      return {
+        path: file.path,
+        index: file.index,
+        url: file.url,
+        ...extras.duration === void 0 ? {} : { duration: extras.duration },
+        ...extras.resolution === void 0 ? {} : { resolution: extras.resolution }
+      };
+    }),
+    errors: []
+  };
+  if (result.usage !== void 0) payload.usage = result.usage;
+  if (result.requestId !== void 0) payload.request_id = result.requestId;
+  return JSON.stringify(payload);
+}
+function renderVideoHuman(result) {
+  const lines = result.saved.length > 0 ? result.saved.map((file) => file.path) : [result.taskId];
+  return { stdout: lines.join("\n"), stderr: "" };
+}
+function renderError(err, json) {
+  const message = describeError(err);
+  const exitCode = err instanceof UsageError ? 2 : 1;
+  if (json) {
+    const error = { message };
+    if (err instanceof ApiError && err.code !== void 0) {
+      error.code = err.code;
+    }
+    if (err instanceof ApiError && err.taskId !== void 0) {
+      error.task_id = err.taskId;
+    }
+    return { stdout: JSON.stringify({ error }), stderr: "", exitCode };
+  }
+  return { stdout: "", stderr: message, exitCode };
+}
+function describeError(err) {
+  if (err instanceof Error) {
+    return err.message.trim() ? err.message : err.name || "unknown error";
+  }
+  if (typeof err === "string") {
+    return err.trim() ? err : "unknown error";
+  }
+  if (typeof err === "object" && err !== null) {
+    const message = err.message;
+    if (typeof message === "string" && message.trim()) {
+      return message;
+    }
+    return "unknown error";
+  }
+  if (typeof err === "number" || typeof err === "bigint" || typeof err === "boolean") {
+    return String(err);
+  }
+  return "unknown error";
+}
+
+// src/cli.ts
+var ROOT_HELP = `
+Built for AI agents: explicit flags, no interactive prompts, machine-readable output.
+
+Quickstart:
+  mediagen config show                                    # any command creates config.toml on first use
+  mediagen config add my-proxy --api-type openai --base-url https://proxy.example.com --model qwen-image-3.0
+  mediagen login --provider my-proxy --api-key sk-...      # store a key in auth.json
+  mediagen image generate "a red fox in fresh snow" --provider my-proxy --out-dir ./out
+  mediagen image edit "make the sky sunset orange" --image ./photo.jpg
+  mediagen image generate "..." --json               # {"ok":..,"files":[..],"errors":[..]}
+  mediagen video generate "a fox running through deep snow" --provider volcengine
+  mediagen video generate "..." --no-wait --json     # returns the task id immediately
+  mediagen video status <task-id>                    # check a task you already paid for
+
+Subcommands:
+  login / logout    store or remove a provider's API key in auth.json; provider
+                    definitions live in config.toml
+  auth status       which key each provider would use and where it came from (masked)
+  config show       the resolved configuration, with a source note for each value
+  config path       where config.toml lives
+  config add        create a provider in config.toml (edit the file for anything else)
+  video generate    create and pay for a video task, then save the result
+  video status      look at one task once, and save its video if it finished
+
+Exit codes: 0 success \u2014 including a partial image success that saved at least one
+file, a video task that was created and is still running, or a video task that was
+merely read; 1 an API/config/runtime failure, 2 a usage error.
+
+Run "mediagen image generate --help" or "mediagen video generate --help" for the flag
+list, the model table and examples.`;
+var LOGIN_HELP = `
+A key belongs to a provider entry in config.toml, and every task of that entry uses it:
+--api-key on any command, else the entry's api_key_env variable, else auth.json. There is no
+protocol-level default variable, so two entries that speak the same protocol can hold
+different keys. Stored keys are only ever printed masked.`;
+function imageHelpText(command) {
+  const intro = command === "edit" ? 'Edit images: identical to "mediagen image generate" except that at least one --image is required.' : "Generate an image from a prompt. Add --image to switch to image-to-image editing.";
+  const examples = command === "edit" ? `  # edit a local file (local paths are read and sent as base64 data URLs)
+  mediagen image edit "make the sky sunset orange, keep the composition" --image ./photo.jpg --provider aliyun
+
+  # combine several references
+  mediagen image edit "put the character from the first image into the scene from the second" --image ./character.png --image ./scene.jpg --provider aliyun
+
+  # ark layer decomposition: one paid request, several files back (base + layers)
+  mediagen image edit "separate the sticker from its background" --image ./sticker.png --provider volcengine --layer-decomposition true --json
+
+  # a third-party proxy declared as [providers.my-proxy] in config.toml
+  mediagen image edit "remove the timestamp" --image ./shot.png --provider my-proxy --out-dir ./out` : `  # text to image
+  mediagen image generate "a red fox in fresh snow, soft morning light" --provider aliyun --size 1024x1024 --out-dir ./out
+
+  # image to image; "mediagen image edit" is the same command with --image required
+  mediagen image generate "make the sky sunset orange, keep the composition" --image ./photo.jpg --provider aliyun
+
+  # several references at once
+  mediagen image generate "the character from the first image wearing the jacket from the second" --image ./character.png --image ./jacket.png --provider aliyun
+
+  # four ark variants as JSON, for an agent to parse
+  mediagen image generate "minimalist logo for a coffee roastery" --provider volcengine --model doubao-seedream-5-0-pro --n 4 --seed 42 --json
+
+  # a third-party proxy declared as [providers.my-proxy] in config.toml
+  mediagen image generate "product photo on a white background" --provider my-proxy --out-dir ./shots
+
+  # a one-off test against a proxy, without touching config.toml
+  mediagen image generate "colour test card" --provider aliyun --base-url https://proxy.example.com --api-key sk-...`;
+  return `
+${intro}
+
+Models (--provider picks the account, --model the exact id; config.toml decides what is allowed):
+  qwen-image-3.0              aliyun      best text rendering (CJK + Latin) and image editing
+  doubao-seedream-5-0-flash   volcengine  fastest; use it for drafts and iteration
+  doubao-seedream-5-0-pro     volcengine  highest quality; slower and more expensive
+  A model must be listed in models = [...] under [providers.<name>.image]; the provider
+  names above are what the first run writes into config.toml, and a second model of the
+  same vendor is one more entry there, not another provider.
+
+Protocols (api_type, declared per task in config.toml):
+  openai     the OpenAI-compatible wire format; "qwen" still works as an alias
+  dashscope  Alibaba's native form: input.messages + parameters, output.choices[].image
+  ark        Volcengine's own API (image + video)
+
+Sizes (--size, passed through to the vendor; omit it for the vendor default):
+  tiers    1K | 1.5K | 2K | 3K | 4K     ark and openai take these (ark defaults to 2K)
+  pixels   WxH with a lowercase x, e.g. 2048x2048, 1536x2048, 1024x1024
+  auto     openai only; omitting --size lets the model choose from the prompt
+  dashscope takes pixels only; it sends \u5BBD*\u9AD8 and rejects tiers and auto.
+
+Images and count:
+  --image <path-or-url>  repeatable; a local file becomes a data:<mime>;base64 URL
+  --n <count>            1-6 images. ark fans out into one paid request per image
+                         (seeds seed, seed+1, ...); openai and dashscope send a single request.
+
+Output:
+  Files are written to --out-dir (default: config output_dir, else the current
+  directory) as <provider>-<model>-<yyyyMMdd-HHmmss>-<index>.<ext>. Human mode prints
+  one absolute path per line on stdout and warnings on stderr; --json prints a single
+  object with ok, partial, files[], errors[], usage and request_id. Partial success
+  exits 0 and lists each failure: the images on disk were already paid for, so do not
+  retry the whole request.
+
+Protocol-specific flags:
+  openai only  --prompt-extend-mode --enable-thinking
+  openai and dashscope  --negative-prompt --prompt-extend
+  ark only  --output-format --optimize-prompt --layer-decomposition --background
+  A flag the selected dialect does not accept fails before any paid request is sent.
+  Boolean flags take an explicit value: --watermark false, not --no-watermark.
+
+Examples:
+${examples}`;
+}
+var IMAGE_OPTION_HELP = {
+  provider: "provider name declared in config.toml (default: config default_provider)",
+  model: "model id, must be listed in the task's models (default: the task's default)",
+  image: "reference image, repeatable; local files are sent as data URLs",
+  size: "1K|1.5K|2K|3K|4K, WxH pixels, or auto (openai only; dashscope takes pixels)",
+  n: "how many images, 1-6 (ark sends one paid request per image)",
+  seed: "random seed; ark fan-out uses seed, seed+1, ...",
+  watermark: "true|false (default: the vendor default, false on openai and dashscope)",
+  negativePrompt: "openai and dashscope: what the image must not contain",
+  promptExtend: "openai and dashscope: true|false prompt rewriting",
+  promptExtendMode: "openai only: agent mode is text-to-image only",
+  enableThinking: "openai only: true|false",
+  outputFormat: "ark only (default: the vendor default, jpeg)",
+  optimizePrompt: "ark only; flash models accept standard only",
+  layerDecomposition: "ark only: true|false, needs --image, returns several files",
+  background: "ark only: transparent needs one input with an alpha channel",
+  outDir: "where to write files (default: config output_dir, else cwd)",
+  json: "print one JSON object instead of file paths",
+  apiKey: "one-off API key; overrides env and auth.json",
+  baseUrl: "one-off provider origin, e.g. https://ark.cn-beijing.volces.com (a proxy prefix is allowed)"
+};
+function addImageOptions(command) {
+  return command.option("--provider <name>", IMAGE_OPTION_HELP.provider).option("--model <id>", IMAGE_OPTION_HELP.model).option("--image <path-or-url>", IMAGE_OPTION_HELP.image, collectImage).option("--size <size>", IMAGE_OPTION_HELP.size).option("--n <count>", IMAGE_OPTION_HELP.n).option("--seed <seed>", IMAGE_OPTION_HELP.seed).option("--watermark <bool>", IMAGE_OPTION_HELP.watermark).option("--negative-prompt <text>", IMAGE_OPTION_HELP.negativePrompt).option("--prompt-extend <bool>", IMAGE_OPTION_HELP.promptExtend).option("--prompt-extend-mode <direct|agent>", IMAGE_OPTION_HELP.promptExtendMode).option("--enable-thinking <bool>", IMAGE_OPTION_HELP.enableThinking).option("--output-format <png|jpeg>", IMAGE_OPTION_HELP.outputFormat).option("--optimize-prompt <standard|fast>", IMAGE_OPTION_HELP.optimizePrompt).option("--layer-decomposition <bool>", IMAGE_OPTION_HELP.layerDecomposition).option("--background <transparent|opaque>", IMAGE_OPTION_HELP.background).option("--out-dir <dir>", IMAGE_OPTION_HELP.outDir).option("--json", IMAGE_OPTION_HELP.json).option("--api-key <key>", IMAGE_OPTION_HELP.apiKey).option("--base-url <url>", IMAGE_OPTION_HELP.baseUrl);
+}
+function collectImage(value, previous) {
+  return previous === void 0 ? [value] : [...previous, value];
+}
+var VIDEO_OPTION_HELP = {
+  provider: "provider name declared in config.toml (default: config default_provider)",
+  model: "model id, must be listed in the task's models (default: the task's default)",
+  image: "first frame, one per request; local files are sent as data URLs",
+  resolution: "a resolution tier the dialect accepts, case-insensitive (e.g. 480p, 720p; which tiers a model supports is the vendor's call)",
+  ratio: `one of ${RATIOS.join(", ")}`,
+  duration: "seconds, a positive integer (the range is the model's)",
+  seed: "non-negative integer",
+  watermark: "true|false (default: the vendor default)",
+  generateAudio: "true|false, where the model supports it (2.0/2.5)",
+  outputFormat: "mp4|mov, where the model supports it (2.5)",
+  outDir: "where to write files (default: config output_dir, else cwd)",
+  json: "print one JSON object instead of the file path",
+  apiKey: "one-off API key; overrides env and auth.json",
+  baseUrl: "one-off provider origin, e.g. https://ark.cn-beijing.volces.com",
+  noWait: "create the task and print its id instead of waiting for the video"
+};
+function videoHelpText() {
+  return `
+Generate a video from a prompt. Unlike an image, a video is an asynchronous task:
+creating it is what gets billed, and the file appears one to five minutes later.
+
+Models (--provider picks the account, --model the exact id; config.toml decides what is allowed):
+  doubao-seedance-1-0-pro-250528   volcengine  text to video, or from one first frame
+  MiniMax-H3                       minimax     text to video, or from one first frame
+  A model must be listed in models = [...] under [providers.<name>.video].
+
+Cost and interruption:
+  The task is paid for when it is created. If this process is interrupted, do not
+  submit again: the task keeps running for a while, and "mediagen video status <id>"
+  fetches it later. --no-wait prints that id immediately for exactly this reason, and
+  the id is also written to stderr right after the task is created.
+
+One video per request:
+  --n belongs to image; here it is not an option at all. For a second variant, run the
+  command again (add a different --seed on the ark dialect if you want it to differ).
+
+Flags the vendor checks, not this CLI:
+  --resolution --duration are passed through; whether a given model supports a tier or
+  a range is validated by the vendor when the task is created, before anything is billed.
+
+Ark-only flags, rejected locally by any other dialect:
+  --seed --generate-audio --output-format --watermark. The minimax API takes only the
+  model, the content, the resolution, the duration and the ratio.
+
+Output:
+  Files are written to --out-dir (default: config output_dir, else the current
+  directory) as <provider>-<model>-<yyyyMMdd-HHmmss>-<index>.<ext>. With --json the
+  envelope carries task_id and status: "pending" or "running" with files: [] means the
+  task exists and was paid for \u2014 not that the command failed.
+
+Examples:
+  # text to video, then find the file on stdout
+  mediagen video generate "a red fox running through deep snow, golden hour" --provider volcengine
+
+  # animate the first frame of a still image
+  mediagen video generate "the same fox, now shaking the snow off" --image ./fox.png --provider volcengine
+
+  # do not wait: hand the task id to a later step (an agent usually wants this)
+  mediagen video generate "a slow pan over a frozen lake" --provider volcengine --no-wait --json
+
+  # collect it afterwards, without paying again
+  mediagen video status cgt-20261028-abcd --provider volcengine --out-dir ./clips`;
+}
+function videoStatusHelpText() {
+  return `
+Look at one video task once, by the id a previous run printed. Nothing is created and
+nothing is billed: this is the way back into a task whose run was interrupted.
+
+It asks once. A task that is still pending or running is a success (exit 0) with its id
+and no files, so a caller can poll this command on its own schedule. Of the commands that
+talk to a provider, this is the only one that cannot spend money. A task that has
+finished is downloaded to --out-dir. A task that failed, was cancelled or expired exits 1
+with the vendor's own message.
+
+Flags not passed here are taken from config.toml: the provider from default_provider, the
+model from that provider's video table. The provider picks the account and the endpoint;
+--model is checked against config.toml and is not sent, because the task id decides
+everything else (it is only a fallback for the file name if the server reports no model).
+
+Examples:
+  mediagen video status cgt-20261028-abcd --provider volcengine
+  mediagen video status cgt-20261028-abcd --provider volcengine --json
+  mediagen video status cgt-20261028-abcd --provider volcengine --out-dir ./clips`;
+}
+function addVideoOptions(command) {
+  return command.option("--provider <name>", VIDEO_OPTION_HELP.provider).option("--model <id>", VIDEO_OPTION_HELP.model).option("--image <path-or-url>", VIDEO_OPTION_HELP.image, collectImage).option("--resolution <tier>", VIDEO_OPTION_HELP.resolution).option("--ratio <ratio>", VIDEO_OPTION_HELP.ratio).option("--duration <seconds>", VIDEO_OPTION_HELP.duration).option("--seed <seed>", VIDEO_OPTION_HELP.seed).option("--watermark <bool>", VIDEO_OPTION_HELP.watermark).option("--generate-audio <bool>", VIDEO_OPTION_HELP.generateAudio).option("--output-format <format>", VIDEO_OPTION_HELP.outputFormat).option("--out-dir <dir>", VIDEO_OPTION_HELP.outDir).option("--no-wait", VIDEO_OPTION_HELP.noWait).option("--json", VIDEO_OPTION_HELP.json).option("--api-key <key>", VIDEO_OPTION_HELP.apiKey).option("--base-url <url>", VIDEO_OPTION_HELP.baseUrl);
+}
+function packageVersion() {
+  try {
+    const raw = fs6.readFileSync(new URL("../package.json", import.meta.url), "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.version === "string" ? parsed.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function createProgram(options = {}) {
+  const deps = options.deps ?? {};
+  const program = new Command("mediagen");
+  const version = packageVersion();
+  if (version !== void 0) {
+    program.version(version, "-V, --version", "print the packaged version and exit");
+  }
+  program.description(
+    "Generate and edit images (Bailian qwen, Volcengine Ark doubao/seedream) and generate video (Ark seedance, MiniMax H3)."
+  ).exitOverride().configureOutput({
+    writeOut: options.writeOut ?? ((text) => process.stdout.write(text)),
+    writeErr: options.writeErr ?? ((text) => process.stderr.write(text))
+  }).addHelpText("after", ROOT_HELP);
+  program.command("login").description("Store an API key for a provider in auth.json (mode 600)").option("--provider <name>", "provider name (default: config default_provider)").option("--api-key <key>", "the key; omit to be prompted (needs a TTY)").option("--json", "print a JSON result").addHelpText("after", LOGIN_HELP).action(async (flags) => {
+    await runLogin(flags, deps);
+  });
+  program.command("logout").description("Remove the stored API key for a provider").option("--provider <name>", "provider name (default: config default_provider)").option("--json", "print a JSON result").action(async (flags) => {
+    runLogout(flags);
+  });
+  const auth = program.command("auth").description("Inspect stored credentials");
+  auth.command("status").description("Show which API key each provider would use, and where it came from").option("--json", "print a JSON result").action(async (flags) => {
+    runAuthStatus(flags);
+  });
+  const config = program.command("config").description("Inspect the resolved configuration");
+  config.command("show").description("Print the effective configuration with a source note for each value").option("--json", "print a JSON result").action(async (flags) => {
+    runConfigShow(flags);
+  });
+  config.command("path").description("Print the path of config.toml").option("--json", "print a JSON result").action(async (flags) => {
+    runConfigPath(flags);
+  });
+  config.command("add <name>").description("Create a [providers.<name>] table in config.toml").option("--api-type <dialect>", "protocol dialect: openai, dashscope, ark or minimax").option("--base-url <url>", "the provider's origin, e.g. https://ark.cn-beijing.volces.com").option("--task <image|video>", "which task table to create (default: image)").option("--model <id>", "the model id this task defaults to").option("--api-key-env <VAR>", "environment variable holding this provider's key").option("--json", "print a JSON result").action(async (name, flags) => {
+    runConfigAdd(name, flags);
+  });
+  const image = program.command("image").description("Generate and edit images");
+  const generate = image.command("generate").description("Generate an image from a prompt; add --image to edit").argument("<prompt>", "what to draw; quote it and describe the subject, style and text");
+  addImageOptions(generate).addHelpText("after", imageHelpText("generate"));
+  generate.action(async (prompt, flags) => {
+    await runImage(prompt, flags, false);
+  });
+  const edit = image.command("edit").description("Edit images: like generate, but --image is required").argument("<prompt>", "the edit to perform; quote it and name what must stay unchanged");
+  addImageOptions(edit).addHelpText("after", imageHelpText("edit"));
+  edit.action(async (prompt, flags) => {
+    await runImage(prompt, flags, true);
+  });
+  const video = program.command("video").description("Generate video from a prompt; the task is asynchronous and billed on create");
+  const videoGenerate = video.command("generate").description("Create a video task and save the result; add --image for a first frame").argument("<prompt>", "what to film; quote it and describe the subject, motion and camera");
+  addVideoOptions(videoGenerate).addHelpText("after", videoHelpText());
+  videoGenerate.action(async (prompt, flags) => {
+    await runVideo(prompt, flags);
+  });
+  const videoStatus = video.command("status").description("Look at one video task once, and save its video if it finished").argument("<task-id>", "the id a previous run printed");
+  videoStatus.option("--provider <name>", VIDEO_OPTION_HELP.provider).option("--model <id>", VIDEO_OPTION_HELP.model).option("--out-dir <dir>", VIDEO_OPTION_HELP.outDir).option("--json", VIDEO_OPTION_HELP.json).option("--api-key <key>", VIDEO_OPTION_HELP.apiKey).option("--base-url <url>", VIDEO_OPTION_HELP.baseUrl).addHelpText("after", videoStatusHelpText());
+  videoStatus.action(async (taskId, flags) => {
+    await runVideoStatusCommand(taskId, flags);
+  });
+  return program;
+}
+function requestsHelpOrVersion(argv) {
+  if (argv[0] === "help") return true;
+  for (const arg of argv) {
+    if (arg === "--") return false;
+    if (arg === "-h" || arg === "--help" || arg === "-V" || arg === "--version") return true;
+  }
+  return false;
+}
+async function main(argv, deps = {}) {
+  const buffer = [];
+  try {
+    if (!requestsHelpOrVersion(argv)) prepareConfigFile();
+    const program = createProgram({
+      deps,
+      writeOut: (text) => buffer.push(text),
+      writeErr: (text) => buffer.push(text)
+    });
+    await program.parseAsync(argv, { from: "user" });
+    return 0;
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      return reportCommanderError(error, buffer.join(""), argv.includes("--json"));
+    }
+    return reportError(error, argv.includes("--json"));
+  }
+}
+function emit(rendered) {
+  if (rendered.stdout !== "") process.stdout.write(`${rendered.stdout}
+`);
+  if (rendered.stderr !== "") process.stderr.write(`${rendered.stderr}
+`);
+}
+function writeLine(text) {
+  process.stdout.write(`${text}
+`);
+}
+function writeErrLine(text) {
+  process.stderr.write(`${text}
+`);
+}
+function reportError(error, jsonMode) {
+  const rendered = renderError(error, jsonMode);
+  emit(rendered);
+  return rendered.exitCode;
+}
+function reportCommanderError(error, text, jsonMode) {
+  if (error.exitCode === 0) {
+    if (text !== "") process.stdout.write(text);
+    return 0;
+  }
+  if (error.code === "commander.help") {
+    if (!jsonMode) {
+      if (text !== "") process.stdout.write(text);
+      return 2;
+    }
+    return reportError(
+      new UsageError('missing command; run "mediagen --help" to list the commands'),
+      true
+    );
+  }
+  const message = error.message.replace(/^error:\s*/, "").trim();
+  if (jsonMode) return reportError(new UsageError(message), true);
+  process.stderr.write(text.trim() === "" ? `${message}
+` : text);
+  return 2;
+}
+async function runImage(prompt, flags, edit) {
+  const options = toGenerateOptions(flags, edit);
+  const result = await runGenerate(prompt, options);
+  if (flags.json === true) {
+    writeLine(renderJson(result.saved, result.response));
+    return;
+  }
+  emit(renderHuman(result.saved, result.response));
+}
+async function runVideo(prompt, flags) {
+  const result = await runVideoGenerate(prompt, toVideoOptions(flags));
+  if (flags.json === true) {
+    writeLine(renderVideoJson(result));
+    return;
+  }
+  emit(renderVideoHuman(result));
+}
+async function runVideoStatusCommand(taskId, flags) {
+  const options = {
+    provider: flags.provider,
+    model: flags.model,
+    outDir: flags.outDir,
+    apiKey: flags.apiKey,
+    baseUrl: flags.baseUrl
+  };
+  const result = await runVideoStatus(taskId, options);
+  if (flags.json === true) {
+    writeLine(renderVideoJson(result));
+    return;
+  }
+  emit(renderVideoHuman(result));
+}
+function toVideoOptions(flags) {
+  return {
+    provider: flags.provider,
+    model: flags.model,
+    image: flags.image ?? [],
+    resolution: flags.resolution,
+    ratio: parseChoice(flags.ratio, RATIOS, "--ratio"),
+    duration: parseInteger(flags.duration, "--duration"),
+    seed: parseInteger(flags.seed, "--seed"),
+    watermark: parseBool(flags.watermark, "--watermark"),
+    generateAudio: parseBool(flags.generateAudio, "--generate-audio"),
+    outputFormat: parseChoice(flags.outputFormat, ["mp4", "mov"], "--output-format"),
+    outDir: flags.outDir,
+    apiKey: flags.apiKey,
+    baseUrl: flags.baseUrl,
+    noWait: flags.wait === false
+  };
+}
+function toGenerateOptions(flags, edit) {
+  return {
+    provider: flags.provider,
+    model: flags.model,
+    images: flags.image ?? [],
+    size: flags.size,
+    n: parseInteger(flags.n, "--n"),
+    seed: parseInteger(flags.seed, "--seed"),
+    watermark: parseBool(flags.watermark, "--watermark"),
+    negativePrompt: flags.negativePrompt,
+    promptExtend: parseBool(flags.promptExtend, "--prompt-extend"),
+    promptExtendMode: parseChoice(flags.promptExtendMode, ["direct", "agent"], "--prompt-extend-mode"),
+    enableThinking: parseBool(flags.enableThinking, "--enable-thinking"),
+    outputFormat: parseChoice(flags.outputFormat, ["png", "jpeg"], "--output-format"),
+    optimizePrompt: parseChoice(flags.optimizePrompt, ["standard", "fast"], "--optimize-prompt"),
+    layerDecomposition: parseBool(flags.layerDecomposition, "--layer-decomposition"),
+    background: parseChoice(flags.background, ["transparent", "opaque"], "--background"),
+    outDir: flags.outDir,
+    apiKey: flags.apiKey,
+    baseUrl: flags.baseUrl,
+    edit
+  };
+}
+function parseBool(value, flag) {
+  if (value === void 0) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true") return true;
+  if (normalized === "false") return false;
+  throw new UsageError(`invalid ${flag} ${JSON.stringify(value)}: expected true or false`);
+}
+var INTEGER_PATTERN = /^[+-]?\d+$/;
+function parseInteger(value, flag) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (!INTEGER_PATTERN.test(trimmed)) {
+    throw new UsageError(`invalid ${flag} ${JSON.stringify(value)}: expected an integer`);
+  }
+  return Number(trimmed);
+}
+function parseChoice(value, allowed, flag) {
+  if (value === void 0) return void 0;
+  const normalized = value.trim().toLowerCase();
+  const match = allowed.find((entry) => entry === normalized);
+  if (match === void 0) {
+    throw new UsageError(
+      `invalid ${flag} ${JSON.stringify(value)}: expected one of ${allowed.join(", ")}`
+    );
+  }
+  return match;
+}
+async function runLogin(flags, deps) {
+  const config = loadConfig();
+  const name = flags.provider ?? config.default_provider;
+  assertKnownProvider(name, config);
+  const key = await resolveLoginKey(name, flags.apiKey, deps);
+  saveApiKey(name, key);
+  const masked = maskKey(key);
+  if (flags.json === true) {
+    writeLine(
+      JSON.stringify({
+        ok: true,
+        provider: name,
+        masked_key: masked,
+        auth_file: authPath()
+      })
+    );
+    return;
+  }
+  writeLine(`saved API key ${masked} for provider "${name}" to ${authPath()}`);
+}
+function assertKnownProvider(name, config) {
+  if (name === "") throw new UsageError(noProviderSelectedMessage());
+  if (!Object.hasOwn(config.providers, name)) {
+    throw new UsageError(
+      `unknown provider "${name}": login stores API keys but never creates providers; add a [providers.${tomlKey(name)}] table to ${configPath()} first (or run "mediagen config add ${shellArg(name)} ...")`
+    );
+  }
+  try {
+    validateProviderShape(name, config);
+  } catch (error) {
+    throw new UsageError(error instanceof Error ? error.message : String(error));
+  }
+}
+async function resolveLoginKey(provider, flagKey, deps) {
+  const fromFlag = flagKey?.trim();
+  if (fromFlag !== void 0 && fromFlag !== "") return fromFlag;
+  const isTTY = deps.isTTY ?? (() => Boolean(process.stdin.isTTY));
+  if (!isTTY()) {
+    throw new UsageError(
+      `no API key for provider "${provider}": pass --api-key <key>; reading the key interactively needs a TTY on stdin`
+    );
+  }
+  const readSecret = deps.readSecret ?? readSecretFromTerminal;
+  const key = (await readSecret(`API key for provider "${provider}" (input is hidden): `)).trim();
+  if (key === "") throw new UsageError("the API key was empty; nothing was saved");
+  return key;
+}
+function readSecretFromTerminal(promptText) {
+  return new Promise((resolve, reject) => {
+    process.stderr.write(promptText);
+    const muted = new Writable({
+      write(_chunk, _encoding, callback) {
+        callback();
+      }
+    });
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: muted,
+      terminal: true
+    });
+    const finish = (action) => {
+      rl.close();
+      process.stderr.write("\n");
+      action();
+    };
+    rl.on("SIGINT", () => {
+      finish(() => reject(new UsageError("login cancelled")));
+    });
+    rl.question("", (answer) => {
+      finish(() => resolve(answer));
+    });
+  });
+}
+function runLogout(flags) {
+  const config = loadConfig();
+  const name = flags.provider ?? config.default_provider;
+  if (name === "") throw new UsageError(noProviderSelectedMessage());
+  const removed = removeApiKey(name);
+  if (flags.json === true) {
+    writeLine(JSON.stringify({ ok: true, provider: name, removed }));
+    return;
+  }
+  writeLine(
+    removed ? `removed the API key for provider "${name}" from ${authPath()}` : `no API key stored for provider "${name}"; nothing to do`
+  );
+}
+function runAuthStatus(flags) {
+  const config = loadConfig();
+  const entries = [];
+  const details = [];
+  for (const [name, override] of Object.entries(config.providers)) {
+    const apiKeyEnv = override.api_key_env;
+    const resolved = resolveApiKey({ name, api_key_env: apiKeyEnv }, void 0, process.env);
+    const entry = {
+      name,
+      configured: resolved !== null,
+      source: resolved?.source ?? "none"
+    };
+    if (resolved !== null) {
+      entry.masked_key = maskKey(resolved.key);
+      details.push(`${entry.masked_key} (${describeKeySource(apiKeyEnv, resolved.source)})`);
+    } else {
+      details.push(`not configured (${missingKeyHint(name, apiKeyEnv)})`);
+    }
+    entries.push(entry);
+  }
+  if (flags.json === true) {
+    writeLine(JSON.stringify({ providers: entries }));
+    return;
+  }
+  const width = entries.reduce((max, entry) => Math.max(max, entry.name.length), 0);
+  const lines = entries.map((entry, index) => `${entry.name.padEnd(width)}  ${details[index]}`);
+  lines.push(`auth file: ${authPath()}`);
+  writeLine(lines.join("\n"));
+}
+function describeKeySource(apiKeyEnv, source) {
+  if (source === "env") return `env ${apiKeyEnv ?? "environment variable"}`;
+  return `auth.json: ${authPath()}`;
+}
+function missingKeyHint(name, apiKeyEnv) {
+  const hints = [`run "mediagen login --provider ${shellArg(name)}"`];
+  if (apiKeyEnv !== void 0) hints.push(`set ${apiKeyEnv}`);
+  hints.push("pass --api-key");
+  return hints.join(", ");
+}
+function runConfigPath(flags) {
+  if (flags.json === true) {
+    writeLine(JSON.stringify({ config_path: configPath(), auth_path: authPath() }));
+    return;
+  }
+  writeLine(configPath());
+}
+function runConfigAdd(name, flags) {
+  const provider = name.trim();
+  if (provider === "") throw new UsageError("a provider name is required");
+  const apiType = parseChoice(
+    flags.apiType,
+    ["openai", "dashscope", "ark", "minimax", "qwen"],
+    "--api-type"
+  );
+  if (apiType === void 0) {
+    throw new UsageError(
+      '--api-type is required: "openai", "dashscope", "ark" or "minimax" ("qwen" still works as a deprecated alias of "openai")'
+    );
+  }
+  if (flags.baseUrl === void 0) throw new UsageError("--base-url is required");
+  const task = parseChoice(flags.task, ["image", "video"], "--task") ?? "image";
+  const model = (flags.model ?? "").trim();
+  if (model === "") throw new UsageError("--model is required");
+  const apiKeyEnv = flags.apiKeyEnv?.trim();
+  if (flags.apiKeyEnv !== void 0 && apiKeyEnv === "") {
+    throw new UsageError("--api-key-env must not be empty");
+  }
+  const file = configPath();
+  const config = loadConfig();
+  if (Object.hasOwn(config.providers, provider)) {
+    throw new UsageError(
+      `a [providers.${tomlKey(provider)}] section already exists in ${file}; add a model with one more entry in models = [...] under [providers.${tomlKey(provider)}.${task}], or edit the table by hand`
+    );
+  }
+  const dialect = apiType === "qwen" ? "openai" : apiType;
+  const fields = {
+    base_url: originBaseUrl(flags.baseUrl)
+  };
+  if (apiKeyEnv !== void 0) fields.api_key_env = apiKeyEnv;
+  const before = fs6.existsSync(file) ? fs6.readFileSync(file, "utf8") : "";
+  const beforeTable = before.trim() === "" ? void 0 : parseToml(before);
+  if (apiType === "qwen") {
+    writeErrLine('note: api_type "qwen" is a deprecated alias; writing api_type = "openai"');
+  }
+  const after = appendProviderTable(before, provider, fields, task, model, dialect);
+  assertFaithfulRewrite(beforeTable, after, provider, fields, task, model, dialect, file);
+  try {
+    writeConfigFile(after);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new ConfigError(`cannot write ${file}: ${reason}`);
+  }
+  if (flags.json === true) {
+    writeLine(
+      JSON.stringify({
+        ok: true,
+        provider,
+        task,
+        model,
+        config_file: file,
+        fields: { ...fields, api_type: dialect }
+      })
+    );
+    return;
+  }
+  const loginHint = `mediagen login --provider ${shellArg(provider)} --api-key ...`;
+  const keyRoute = apiKeyEnv === void 0 ? `run "${loginHint}" to store its key` : `set ${shellArg(apiKeyEnv)}, or run "${loginHint}"`;
+  if (adapterPath(dialect, task) === void 0) {
+    writeErrLine(
+      `note: the "${dialect}" dialect has no "${task}" task; the table is stored, and "config show" will say the same`
+    );
+  }
+  writeLine(
+    [
+      `added provider "${provider}" to ${file} with an ${task} table defaulting to "${model}"`,
+      `another model of the same provider is one more entry in models = [...] under [providers.${tomlKey(provider)}.${task}]`,
+      keyRoute
+    ].join("\n")
+  );
+}
+function runConfigShow(flags) {
+  const config = loadConfig();
+  const file = configPath();
+  const exists = fs6.existsSync(file);
+  const declared = exists ? parseToml(fs6.readFileSync(file, "utf8")) : {};
+  const defaultProvider = configuredValue(
+    config.default_provider,
+    declared.default_provider
+  );
+  const outputDir = configuredValue(config.output_dir, declared.output_dir);
+  const views = Object.entries(config.providers).map(([name, entry]) => ({
+    name,
+    apiKeyEnv: entry.api_key_env,
+    view: buildProviderView(name, entry)
+  }));
+  if (flags.json === true) {
+    writeLine(
+      JSON.stringify({
+        config_file: { path: file, exists },
+        default_provider: defaultProvider,
+        output_dir: outputDir,
+        providers: views.map(({ view }) => view)
+      })
+    );
+    return;
+  }
+  const lines = [
+    `config file: ${file} (loaded)`,
+    `default_provider: ${defaultProvider.value === "" ? `(not set) (${defaultProvider.source})` : show(defaultProvider)}`,
+    `output_dir: ${outputDir.value} (${outputDir.source === "default" ? "default: current directory" : outputDir.source})`,
+    "",
+    "providers:"
+  ];
+  if (views.length === 0) {
+    lines.push(
+      '  (none; run "mediagen config add <name> --api-type <openai|dashscope|ark|minimax> --base-url <origin> --model <id>")'
+    );
+  }
+  for (const { name, apiKeyEnv, view } of views) {
+    lines.push(
+      `  ${view.name} (dialect ${view.api_type?.value ?? (view.tasks?.some((task) => task.api_type !== void 0) === true ? "per task" : "unknown")})`
+    );
+    for (const field of ["api_type", "base_url", "api_key_env"]) {
+      const value = view[field];
+      if (value !== void 0) lines.push(`    ${field}: ${show(value)}${noteSuffix(value)}`);
+    }
+    if (view.missing !== void 0 && view.missing.length > 0) {
+      lines.push(`    missing: ${view.missing.join(", ")} (required in ${file})`);
+    }
+    lines.push(
+      view.api_key.configured && view.api_key.source !== "none" ? `    api_key: ${view.api_key.masked_key} (${describeKeySource(apiKeyEnv, view.api_key.source)})` : `    api_key: not set (${missingKeyHint(name, apiKeyEnv)})`
+    );
+    for (const taskView of view.tasks ?? []) {
+      lines.push(`    ${taskView.task}:`);
+      if (taskView.api_type !== void 0) {
+        lines.push(`      api_type: ${show(taskView.api_type)}${noteSuffix(taskView.api_type)}`);
+      }
+      if (taskView.default !== void 0) lines.push(`      default: ${show(taskView.default)}`);
+      if (taskView.models !== void 0) {
+        lines.push(`      models: ${taskView.models.join(", ")}`);
+      }
+      if (taskView.path !== void 0) {
+        lines.push(`      path: ${show(taskView.path)}`);
+      }
+      if (taskView.timeout_seconds !== void 0) {
+        lines.push(
+          `      timeout_seconds: ${taskView.timeout_seconds}` + (taskView.timeout_seconds_default === true ? " (default)" : "")
+        );
+      }
+      if (taskView.endpoint !== void 0) {
+        lines.push(`      endpoint: ${taskView.endpoint} (computed)`);
+      } else {
+        lines.push(`      endpoint: (${taskView.endpoint_note ?? "no endpoint"})`);
+      }
+    }
+  }
+  writeLine(lines.join("\n"));
+}
+function show(value) {
+  return `${value.value} (${value.source})`;
+}
+function noteSuffix(value) {
+  return value.note === void 0 ? "" : `; ${value.note}`;
+}
+function configuredValue(value, declared) {
+  return declared === void 0 ? { value, source: "default" } : { value, source: "config.toml" };
+}
+function buildProviderView(name, entry) {
+  const missing = [];
+  const fields = {};
+  for (const key of ["api_type", "base_url", "api_key_env"]) {
+    const value = entry[key];
+    if (value === void 0) {
+      if (key === "base_url") missing.push(key);
+      continue;
+    }
+    fields[key] = { value, source: "config.toml" };
+    if (key === "api_type" && entry.api_type_alias === true) {
+      fields[key] = {
+        value,
+        source: "config.toml",
+        note: 'declared as the deprecated alias "qwen"'
+      };
+    }
+  }
+  const declaresProtocol = entry.api_type !== void 0 || KNOWN_TASKS.some((task) => entry.tasks[task]?.api_type !== void 0);
+  if (!declaresProtocol) missing.push("api_type");
+  const view = {
+    name,
+    ...fields,
+    api_key: keyStatus(name, entry.api_key_env)
+  };
+  const base = fields.base_url === void 0 ? void 0 : normalizeHttpBaseUrl(fields.base_url.value);
+  const tasks = KNOWN_TASKS.filter((task) => entry.tasks[task] !== void 0).map(
+    (task) => {
+      const block = entry.tasks[task] ?? {};
+      const taskView = { task };
+      const ownDialect = block.api_type;
+      const effectiveDialect = ownDialect ?? entry.api_type;
+      if (ownDialect !== void 0) {
+        taskView.api_type = {
+          value: ownDialect,
+          source: "config.toml",
+          ...block.api_type_alias === true ? { note: 'declared as the deprecated alias "qwen"' } : {}
+        };
+      } else if (effectiveDialect !== void 0) {
+        taskView.api_type = {
+          value: effectiveDialect,
+          source: "default",
+          note: "provider default"
+        };
+      }
+      if (block.default !== void 0) {
+        taskView.default = { value: block.default, source: "config.toml" };
+      }
+      if (block.models !== void 0) taskView.models = block.models;
+      taskView.timeout_seconds = block.timeout_seconds ?? DEFAULT_TIMEOUT_SECONDS[task];
+      taskView.timeout_seconds_default = block.timeout_seconds === void 0;
+      if (block.path !== void 0) {
+        taskView.path = { value: block.path, source: "config.toml" };
+      }
+      const path6 = block.path ?? (effectiveDialect === void 0 ? void 0 : adapterPath(effectiveDialect, task));
+      if (effectiveDialect === void 0) {
+        taskView.endpoint_note = "api_type is not set";
+      } else if (path6 === void 0) {
+        taskView.endpoint_note = `the ${effectiveDialect} dialect has no ${task} task`;
+      } else if (base === void 0) {
+        taskView.endpoint_note = "base_url is not a URL yet";
+      } else if (block.path === void 0 && vendorPathIssue(base) !== void 0) {
+        taskView.endpoint_note = "base_url carries a path; declare path = ... or use the origin";
+      } else {
+        taskView.endpoint = `${base}${path6}`;
+      }
+      return taskView;
+    }
+  );
+  if (tasks.length > 0) view.tasks = tasks;
+  if (viewsTaskCount(entry) === 0) missing.push("image or video task table");
+  if (missing.length > 0) view.missing = missing;
+  return view;
+}
+function viewsTaskCount(entry) {
+  return KNOWN_TASKS.filter((task) => entry.tasks[task] !== void 0).length;
+}
+function keyStatus(name, apiKeyEnv) {
+  const resolved = resolveApiKey({ name, api_key_env: apiKeyEnv }, void 0, process.env);
+  if (resolved === null) return { configured: false, source: "none" };
+  return { configured: true, source: resolved.source, masked_key: maskKey(resolved.key) };
+}
+function originBaseUrl(value) {
+  const normalized = normalizeBaseUrl2(value);
+  const issue = vendorPathIssue(normalized);
+  if (issue !== void 0) {
+    throw new UsageError(
+      `invalid --base-url ${JSON.stringify(value)}: it points at the sub-path "${issue.prefix}", and the dialect appends its own path; set base_url to the origin, e.g. "${issue.origin}", or declare path = "<path from there>" on the task table by hand`
+    );
+  }
+  return normalized;
+}
+function normalizeBaseUrl2(value) {
+  const normalized = normalizeHttpBaseUrl(value);
+  if (normalized === void 0) {
+    throw new UsageError(
+      `invalid --base-url ${JSON.stringify(value)}: expected an absolute http(s) URL without credentials, query or fragment`
+    );
+  }
+  return normalized;
+}
+function appendProviderTable(text, name, fields, task, model, dialect) {
+  const lines = [`[providers.${tomlKey(name)}]`];
+  for (const [key, value] of Object.entries(fields)) {
+    lines.push(`${key} = ${tomlBasicString(value)}`);
+  }
+  lines.push("", `[providers.${tomlKey(name)}.${task}]`);
+  lines.push(`api_type = ${tomlBasicString(dialect)}`);
+  lines.push(`default = ${tomlBasicString(model)}`);
+  lines.push(`models = [${tomlBasicString(model)}]`);
+  const base = text.trim() === "" ? "" : text.endsWith("\n") ? `${text}
+` : `${text}
+
+`;
+  return `${base}${lines.join("\n")}
+`;
+}
+function assertFaithfulRewrite(before, after, name, expected, task, model, apiType, file) {
+  function fail() {
+    throw new UsageError(
+      `cannot safely rewrite ${file} for provider "${name}"; edit ${file} by hand instead`
+    );
+  }
+  let parsed;
+  try {
+    parsed = parseToml(after);
+  } catch {
+    fail();
+  }
+  const table = tableAt(parsed, ["providers", name]);
+  for (const [key, value] of Object.entries(expected)) {
+    if (table?.[key] !== value) fail();
+  }
+  const taskTable = tableAt(parsed, ["providers", name, task]);
+  if (taskTable?.api_type !== apiType) fail();
+  if (taskTable?.default !== model) fail();
+  const models = taskTable?.models;
+  if (!Array.isArray(models) || models.length !== 1 || models[0] !== model) fail();
+  if (before !== void 0 && !isPreserved(before, parsed, [])) fail();
+}
+function tableAt(table, keys) {
+  let current = table;
+  for (const key of keys) {
+    if (!isRecord7(current)) return void 0;
+    current = current[key];
+  }
+  return isRecord7(current) ? current : void 0;
+}
+function isPreserved(before, after, exempt) {
+  if (before instanceof Date || after instanceof Date) {
+    return sameInstant(before, after);
+  }
+  if (isRecord7(before)) {
+    if (!isRecord7(after)) return false;
+    for (const [key, value] of Object.entries(before)) {
+      if (exempt.length === 1 && exempt[0] === key) continue;
+      if (!(key in after)) return false;
+      const nested = exempt.length > 1 && exempt[0] === key ? exempt.slice(1) : [];
+      if (!isPreserved(value, after[key], nested)) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(before)) {
+    if (!Array.isArray(after) || after.length !== before.length) return false;
+    return before.every((entry, index) => isPreserved(entry, after[index], []));
+  }
+  return before === after;
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sameInstant(before, after) {
+  if (!(before instanceof Date) || !(after instanceof Date)) return false;
+  const left = before.getTime();
+  const right = after.getTime();
+  return Number.isNaN(left) ? Number.isNaN(right) : left === right;
+}
+function realHref(modulePath) {
+  if (modulePath === void 0) return void 0;
+  try {
+    return pathToFileURL(fs6.realpathSync(modulePath)).href;
+  } catch {
+    return void 0;
+  }
+}
+function selfHref(moduleUrl) {
+  try {
+    return realHref(fileURLToPath(moduleUrl));
+  } catch {
+    return void 0;
+  }
+}
+var thisModule = selfHref(import.meta.url);
+var invokedAsScript = thisModule !== void 0 && thisModule === realHref(process.argv[1]);
+if (invokedAsScript) {
+  process.exit(await main(process.argv.slice(2)));
+}
+export {
+  createProgram,
+  main,
+  requestsHelpOrVersion
+};