jimeng-cli 0.2.0

package/dist/cli/index.js

@@ -0,0 +1,1664 @@
+#!/usr/bin/env node
+import {
+  buildRegionInfo,
+  config_default,
+  generateImageComposition,
+  generateImages,
+  generateVideo,
+  getCredit,
+  getLiveModels,
+  getTaskResponse,
+  getTokenLiveStatus,
+  logger_default,
+  parseRegionCode,
+  receiveCredit,
+  session_pool_default,
+  waitForTaskResponse
+} from "../chunk-JZY62VNI.js";
+
+// src/cli/app.ts
+import process2 from "process";
+
+// src/cli/token-commands.ts
+import { constants as fsConstants } from "fs";
+import path from "path";
+import { access, readFile } from "fs/promises";
+import minimist from "minimist";
+function maskToken(token) {
+  const n = token.length;
+  if (n <= 10) return "***";
+  return `${token.slice(0, 4)}...${token.slice(-4)}`;
+}
+function formatUnixMs(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return "-";
+  return new Date(value).toISOString();
+}
+function printTokenEntriesTable(items) {
+  if (items.length === 0) {
+    console.log("(empty)");
+    return;
+  }
+  console.log("token	region	enabled	live	lastCredit	lastCheckedAt	failures");
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+    const entry = item;
+    const token = typeof entry.token === "string" ? entry.token : "-";
+    const region = typeof entry.region === "string" ? entry.region : "-";
+    const enabled = typeof entry.enabled === "boolean" ? String(entry.enabled) : "-";
+    const live = typeof entry.live === "boolean" ? String(entry.live) : "-";
+    const lastCredit = typeof entry.lastCredit === "number" ? String(entry.lastCredit) : "-";
+    const lastCheckedAt = formatUnixMs(entry.lastCheckedAt);
+    const failures = typeof entry.consecutiveFailures === "number" ? String(entry.consecutiveFailures) : "-";
+    console.log(`${token}	${region}	${enabled}	${live}	${lastCredit}	${lastCheckedAt}	${failures}`);
+  }
+}
+function buildTokenPoolSnapshot() {
+  return {
+    summary: session_pool_default.getSummary(),
+    items: session_pool_default.getEntries(true)
+  };
+}
+async function pathExists(filePath) {
+  try {
+    await access(filePath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readTokensFromFile(filePathArg, deps) {
+  const filePath = path.resolve(filePathArg);
+  if (!await pathExists(filePath)) {
+    deps.fail(`Token file not found: ${filePath}`);
+  }
+  return (await readFile(filePath, "utf8")).split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+async function collectTokensFromArgs(args, usage, deps, required = false) {
+  const tokens = [...deps.toStringList(args.token)];
+  const tokenFile = deps.getSingleString(args, "token-file");
+  if (tokenFile) {
+    tokens.push(...await readTokensFromFile(tokenFile, deps));
+  }
+  const deduped = Array.from(new Set(tokens));
+  if (required && deduped.length === 0) {
+    deps.fail(`No tokens provided.
+
+${usage}`);
+  }
+  return deduped;
+}
+function createTokenSubcommands(deps) {
+  const handleTokenCheck = async (argv) => {
+    const args = minimist(argv, {
+      string: ["token", "token-file", "region"],
+      boolean: ["help", "json"]
+    });
+    const usage = deps.getUsage("check");
+    if (args.help) {
+      console.log(usage);
+      return;
+    }
+    const region = deps.getRegionWithDefault(args);
+    const regionCode = deps.parseRegionOrFail(region);
+    if (!regionCode) {
+      deps.fail("Missing region. Use --region cn/us/hk/jp/sg.");
+    }
+    const tokens = await collectTokensFromArgs(args, usage, deps, true);
+    if (!args.json) {
+      console.log(`Checking ${tokens.length} token(s)`);
+    }
+    await deps.ensureTokenPoolReady();
+    let invalid = 0;
+    let requestErrors = 0;
+    const results = [];
+    for (const token of tokens) {
+      const masked = maskToken(token);
+      try {
+        const live = await getTokenLiveStatus(token, buildRegionInfo(regionCode));
+        await session_pool_default.syncTokenCheckResult(token, live);
+        if (live === true) {
+          if (!args.json) console.log(`[OK]   ${masked} live=true`);
+        } else {
+          invalid += 1;
+          if (!args.json) console.log(`[FAIL] ${masked} live=false`);
+        }
+        results.push({ token_masked: masked, live: live === true });
+      } catch (error) {
+        requestErrors += 1;
+        const message = error instanceof Error ? error.message : String(error);
+        if (!args.json) console.log(`[ERROR] ${masked} ${message}`);
+        results.push({ token_masked: masked, error: message });
+      }
+    }
+    if (args.json) {
+      deps.printCommandJson("token.check", results, {
+        total: tokens.length,
+        invalid,
+        request_errors: requestErrors
+      });
+    } else {
+      console.log(`Summary: total=${tokens.length} invalid=${invalid} request_errors=${requestErrors}`);
+    }
+    if (requestErrors > 0) process.exit(3);
+    if (invalid > 0) process.exit(2);
+  };
+  const handleTokenList = async (argv) => {
+    const args = minimist(argv, {
+      boolean: ["help", "json"]
+    });
+    const usage = deps.getUsage("list");
+    if (args.help) {
+      console.log(usage);
+      return;
+    }
+    await deps.ensureTokenPoolReady();
+    const normalized = buildTokenPoolSnapshot();
+    if (args.json) {
+      deps.printCommandJson("token.list", normalized);
+      return;
+    }
+    const body = normalized && typeof normalized === "object" ? normalized : {};
+    const summary = body.summary;
+    if (summary && typeof summary === "object") {
+      console.log("Summary:");
+      deps.printJson(summary);
+    }
+    const items = Array.isArray(body.items) ? body.items : [];
+    console.log("Entries:");
+    printTokenEntriesTable(items);
+  };
+  const handleTokenPointsOrReceive = async (argv, action) => {
+    const args = minimist(argv, {
+      string: ["token", "token-file", "region"],
+      boolean: ["help", "json"]
+    });
+    const usage = deps.getUsage(action);
+    if (args.help) {
+      console.log(usage);
+      return;
+    }
+    const region = deps.getRegionWithDefault(args);
+    const regionCode = deps.parseRegionOrFail(region);
+    await deps.ensureTokenPoolReady();
+    const tokens = await collectTokensFromArgs(args, usage, deps, false);
+    const resolvedTokens = tokens.length > 0 ? tokens.map((token) => {
+      var _a;
+      const entryRegion = (_a = session_pool_default.getTokenEntry(token)) == null ? void 0 : _a.region;
+      const finalRegion = regionCode || entryRegion;
+      if (!finalRegion) {
+        deps.fail(`Missing region for token ${maskToken(token)}. Provide --region or register token region in token-pool.`);
+      }
+      return { token, region: finalRegion };
+    }) : session_pool_default.getEntries(false).filter((item) => item.enabled && item.live !== false && item.region).filter((item) => regionCode ? item.region === regionCode : true).map((item) => ({ token: item.token, region: item.region }));
+    if (resolvedTokens.length === 0) {
+      deps.fail("No token available. Provide --token or configure token-pool.");
+    }
+    const payload = action === "points" ? await Promise.all(
+      resolvedTokens.map(async (item) => ({
+        token: item.token,
+        points: await getCredit(item.token, buildRegionInfo(item.region))
+      }))
+    ) : await Promise.all(
+      resolvedTokens.map(async (item) => {
+        const currentCredit = await getCredit(item.token, buildRegionInfo(item.region));
+        if (currentCredit.totalCredit <= 0) {
+          try {
+            await receiveCredit(item.token, buildRegionInfo(item.region));
+            const updatedCredit = await getCredit(item.token, buildRegionInfo(item.region));
+            return { token: item.token, credits: updatedCredit, received: true };
+          } catch (error) {
+            return {
+              token: item.token,
+              credits: currentCredit,
+              received: false,
+              error: (error == null ? void 0 : error.message) || String(error)
+            };
+          }
+        }
+        return { token: item.token, credits: currentCredit, received: false };
+      })
+    );
+    if (args.json) {
+      deps.printCommandJson(`token.${action}`, payload);
+      return;
+    }
+    deps.printJson(payload);
+  };
+  const handleTokenAddOrRemove = async (argv, action) => {
+    const args = minimist(argv, {
+      string: ["token", "token-file", "region"],
+      boolean: ["help", "json"]
+    });
+    const usage = deps.getUsage(action);
+    if (args.help) {
+      console.log(usage);
+      return;
+    }
+    const region = deps.getRegionWithDefault(args);
+    await deps.ensureTokenPoolReady();
+    const tokens = await collectTokensFromArgs(args, usage, deps, true);
+    const regionCode = deps.parseRegionOrFail(region);
+    const payload = action === "add" ? {
+      ...await session_pool_default.addTokens(tokens, { defaultRegion: regionCode || void 0 }),
+      summary: session_pool_default.getSummary()
+    } : {
+      ...await session_pool_default.removeTokens(tokens),
+      summary: session_pool_default.getSummary()
+    };
+    if (args.json) {
+      deps.printCommandJson(`token.${action}`, deps.unwrapBody(payload), { region });
+      return;
+    }
+    deps.printJson(deps.unwrapBody(payload));
+  };
+  const handleTokenEnableOrDisable = async (argv, action) => {
+    const args = minimist(argv, {
+      string: ["token"],
+      boolean: ["help", "json"]
+    });
+    const usage = deps.getUsage(action);
+    if (args.help) {
+      console.log(usage);
+      return;
+    }
+    const token = deps.getSingleString(args, "token");
+    if (!token) {
+      deps.failWithUsage("Missing required --token.", usage);
+    }
+    await deps.ensureTokenPoolReady();
+    const payload = {
+      updated: await session_pool_default.setTokenEnabled(token, action === "enable"),
+      summary: session_pool_default.getSummary()
+    };
+    if (args.json) {
+      deps.printCommandJson(`token.${action}`, deps.unwrapBody(payload));
+      return;
+    }
+    deps.printJson(deps.unwrapBody(payload));
+  };
+  const handleTokenPool = async (argv) => {
+    const args = minimist(argv, {
+      boolean: ["help", "json"]
+    });
+    const usage = deps.getUsage("pool");
+    if (args.help) {
+      console.log(usage);
+      return;
+    }
+    await deps.ensureTokenPoolReady();
+    const normalized = buildTokenPoolSnapshot();
+    if (args.json) {
+      deps.printCommandJson("token.pool", normalized);
+      return;
+    }
+    const body = normalized && typeof normalized === "object" ? normalized : {};
+    console.log("Summary:");
+    deps.printJson(body.summary ?? {});
+    console.log("Entries:");
+    printTokenEntriesTable(Array.isArray(body.items) ? body.items : []);
+  };
+  const handleTokenPoolCheckOrReload = async (argv, action) => {
+    const args = minimist(argv, {
+      boolean: ["help", "json"]
+    });
+    const usage = deps.getUsage(action);
+    if (args.help) {
+      console.log(usage);
+      return;
+    }
+    await deps.ensureTokenPoolReady();
+    const payload = action === "pool-check" ? {
+      ...await session_pool_default.runHealthCheck(),
+      summary: session_pool_default.getSummary()
+    } : (await session_pool_default.reloadFromDisk(), {
+      reloaded: true,
+      summary: session_pool_default.getSummary(),
+      items: buildTokenPoolSnapshot().items
+    });
+    if (args.json) {
+      deps.printCommandJson(`token.${action}`, deps.unwrapBody(payload));
+      return;
+    }
+    deps.printJson(deps.unwrapBody(payload));
+  };
+  return [
+    {
+      name: "list",
+      description: "List token pool entries",
+      usageLine: "  jimeng token list [options]",
+      options: [deps.jsonOption, deps.helpOption],
+      handler: handleTokenList
+    },
+    {
+      name: "check",
+      description: "Validate tokens directly",
+      usageLine: "  jimeng token check --token <token> [--token <token> ...] [options]",
+      options: [
+        "  --token <token>          Token, can be repeated",
+        "  --token-file <path>      Read tokens from file (one per line, # for comments)",
+        "  --region <region>        X-Region, default cn (cn/us/hk/jp/sg)",
+        deps.jsonOption,
+        deps.helpOption
+      ],
+      handler: handleTokenCheck
+    },
+    {
+      name: "points",
+      description: "Query token points directly",
+      usageLine: "  jimeng token points [options]",
+      options: [
+        "  --token <token>          Token, can be repeated",
+        "  --token-file <path>      Read tokens from file (one per line, # for comments)",
+        "  --region <region>        Filter tokens by X-Region, default cn (cn/us/hk/jp/sg)",
+        deps.jsonOption,
+        deps.helpOption
+      ],
+      handler: async (argv) => handleTokenPointsOrReceive(argv, "points")
+    },
+    {
+      name: "receive",
+      description: "Receive token credits directly",
+      usageLine: "  jimeng token receive [options]",
+      options: [
+        "  --token <token>          Token, can be repeated",
+        "  --token-file <path>      Read tokens from file (one per line, # for comments)",
+        "  --region <region>        Filter tokens by X-Region, default cn (cn/us/hk/jp/sg)",
+        deps.jsonOption,
+        deps.helpOption
+      ],
+      handler: async (argv) => handleTokenPointsOrReceive(argv, "receive")
+    },
+    {
+      name: "add",
+      description: "Add token(s) into token-pool",
+      usageLine: "  jimeng token add --token <token> [--token <token> ...] [options]",
+      options: [
+        "  --token <token>          Token, can be repeated",
+        "  --token-file <path>      Read tokens from file (one per line, # for comments)",
+        "  --region <region>        Region for add, default cn (cn/us/hk/jp/sg)",
+        deps.jsonOption,
+        deps.helpOption
+      ],
+      handler: async (argv) => handleTokenAddOrRemove(argv, "add")
+    },
+    {
+      name: "remove",
+      description: "Remove token(s) from token-pool",
+      usageLine: "  jimeng token remove --token <token> [--token <token> ...] [options]",
+      options: [
+        "  --token <token>          Token, can be repeated",
+        "  --token-file <path>      Read tokens from file (one per line, # for comments)",
+        deps.jsonOption,
+        deps.helpOption
+      ],
+      handler: async (argv) => handleTokenAddOrRemove(argv, "remove")
+    },
+    {
+      name: "enable",
+      description: "Enable one token in token-pool",
+      usageLine: "  jimeng token enable --token <token> [options]",
+      options: ["  --token <token>          Required, a single token", deps.jsonOption, deps.helpOption],
+      handler: async (argv) => handleTokenEnableOrDisable(argv, "enable")
+    },
+    {
+      name: "disable",
+      description: "Disable one token in token-pool",
+      usageLine: "  jimeng token disable --token <token> [options]",
+      options: ["  --token <token>          Required, a single token", deps.jsonOption, deps.helpOption],
+      handler: async (argv) => handleTokenEnableOrDisable(argv, "disable")
+    },
+    {
+      name: "pool",
+      description: "Show token-pool summary and entries",
+      usageLine: "  jimeng token pool [options]",
+      options: [deps.jsonOption, deps.helpOption],
+      handler: handleTokenPool
+    },
+    {
+      name: "pool-check",
+      description: "Trigger token-pool health check",
+      usageLine: "  jimeng token pool-check [options]",
+      options: [deps.jsonOption, deps.helpOption],
+      handler: async (argv) => handleTokenPoolCheckOrReload(argv, "pool-check")
+    },
+    {
+      name: "pool-reload",
+      description: "Reload token-pool from disk",
+      usageLine: "  jimeng token pool-reload [options]",
+      options: [deps.jsonOption, deps.helpOption],
+      handler: async (argv) => handleTokenPoolCheckOrReload(argv, "pool-reload")
+    }
+  ];
+}
+
+// src/cli/query-commands.ts
+import minimist2 from "minimist";
+function parseTaskTypeOrFail(value, deps) {
+  if (!value) return void 0;
+  if (value === "image" || value === "video") return value;
+  deps.fail(`Invalid --type: ${value}. Use image or video.`);
+}
+function parseResponseFormatOrFail(value, deps) {
+  if (!value) return "url";
+  if (value === "url" || value === "b64_json") return value;
+  deps.fail(`Invalid --response-format: ${value}. Use url or b64_json.`);
+}
+function parsePositiveNumberOption(args, key, deps) {
+  const raw = deps.getSingleString(args, key);
+  if (!raw) return void 0;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    deps.fail(`Invalid --${key}: ${raw}`);
+  }
+  return parsed;
+}
+var TASK_STATUS_TEXT = {
+  10: "PENDING",
+  20: "PROCESSING",
+  40: "FAILED",
+  50: "COMPLETED"
+};
+function taskStatusText(status) {
+  return TASK_STATUS_TEXT[status] || "UNKNOWN";
+}
+function formatUnixSeconds(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return "-";
+  return `${value} (${new Date(value * 1e3).toISOString()})`;
+}
+function collectTaskInfo(payload, deps) {
+  const normalized = deps.unwrapBody(payload);
+  if (!normalized || typeof normalized !== "object") return null;
+  const obj = normalized;
+  if (typeof obj.task_id !== "string" || obj.task_id.length === 0) return null;
+  return {
+    task_id: obj.task_id,
+    type: typeof obj.type === "string" ? obj.type : void 0,
+    status: typeof obj.status === "number" ? obj.status : void 0,
+    fail_code: typeof obj.fail_code === "string" || obj.fail_code === null ? obj.fail_code : void 0,
+    created: typeof obj.created === "number" ? obj.created : void 0,
+    data: obj.data
+  };
+}
+function printTaskInfo(task, deps) {
+  console.log(`Task ID: ${task.task_id}`);
+  if (task.type) console.log(`Type: ${task.type}`);
+  if (typeof task.status === "number") {
+    console.log(`Status: ${task.status} (${taskStatusText(task.status)})`);
+  }
+  if (task.fail_code) console.log(`Fail Code: ${task.fail_code}`);
+  if (typeof task.created === "number") {
+    console.log(`Created: ${formatUnixSeconds(task.created)}`);
+  }
+  if (task.data != null) {
+    console.log("Data:");
+    deps.printJson(task.data);
+  }
+}
+function createQueryCommandHandlers(deps) {
+  const handleModelsList = async (argv) => {
+    const args = minimist2(argv, {
+      string: ["region", "token"],
+      boolean: ["help", "json", "verbose"]
+    });
+    if (args.help) {
+      console.log(deps.usageModelsList());
+      return;
+    }
+    const region = deps.getRegionWithDefault(args);
+    const parsedRegion = deps.parseRegionOrFail(region);
+    const token = deps.getSingleString(args, "token");
+    await deps.ensureTokenPoolReady();
+    const auth = token ? `Bearer ${token}` : void 0;
+    const direct = await getLiveModels(auth, parsedRegion || region);
+    const normalized = { object: "list", data: direct.data };
+    if (args.json) {
+      deps.printCommandJson("models.list", normalized, { region: region || null });
+      return;
+    }
+    const data = normalized && typeof normalized === "object" && Array.isArray(normalized.data) ? normalized.data : [];
+    if (data.length === 0) {
+      deps.fail(`No models found in response: ${JSON.stringify(normalized)}`);
+    }
+    if (args.verbose) {
+      console.log("id	type	desc	capabilities");
+      for (const item of data) {
+        if (!item || typeof item !== "object") continue;
+        const model = item;
+        const id = typeof model.id === "string" ? model.id : "";
+        if (!id) continue;
+        const modelType = typeof model.model_type === "string" ? model.model_type : "-";
+        const description = typeof model.description === "string" ? model.description : "-";
+        const capabilities = Array.isArray(model.capabilities) ? model.capabilities.filter((cap) => typeof cap === "string").join(",") : "-";
+        console.log(`${id}	type=${modelType}	desc=${description}	capabilities=${capabilities}`);
+      }
+      return;
+    }
+    for (const item of data) {
+      if (!item || typeof item !== "object") continue;
+      const id = item.id;
+      if (typeof id === "string" && id.length > 0) {
+        console.log(id);
+      }
+    }
+  };
+  const handleTaskGet = async (argv) => {
+    const args = minimist2(argv, {
+      string: ["token", "region", "task-id", "type", "response-format"],
+      boolean: ["help", "json"]
+    });
+    if (args.help) {
+      console.log(deps.usageTaskGet());
+      return;
+    }
+    const taskId = deps.getSingleString(args, "task-id");
+    if (!taskId) deps.fail(`Missing required --task-id.
+
+${deps.usageTaskGet()}`);
+    const type = parseTaskTypeOrFail(deps.getSingleString(args, "type"), deps);
+    const responseFormat = parseResponseFormatOrFail(deps.getSingleString(args, "response-format"), deps);
+    const token = deps.getSingleString(args, "token");
+    const region = deps.getRegionWithDefault(args);
+    const isJson = Boolean(args.json);
+    const pick = await deps.pickDirectTokenForTask(token, region);
+    const normalized = await getTaskResponse(
+      taskId,
+      pick.token,
+      buildRegionInfo(pick.region),
+      {
+        type,
+        responseFormat
+      }
+    );
+    const taskInfo = collectTaskInfo(normalized, deps);
+    if (!taskInfo) {
+      if (isJson) {
+        deps.printCommandJson("task.get", deps.unwrapBody(normalized));
+      } else {
+        deps.printJson(deps.unwrapBody(normalized));
+      }
+      return;
+    }
+    if (isJson) deps.printCommandJson("task.get", taskInfo);
+    else printTaskInfo(taskInfo, deps);
+  };
+  const handleTaskWait = async (argv) => {
+    const args = minimist2(argv, {
+      string: [
+        "token",
+        "region",
+        "task-id",
+        "type",
+        "response-format",
+        "wait-timeout-seconds",
+        "poll-interval-ms"
+      ],
+      boolean: ["help", "json"]
+    });
+    if (args.help) {
+      console.log(deps.usageTaskWait());
+      return;
+    }
+    const taskId = deps.getSingleString(args, "task-id");
+    if (!taskId) deps.fail(`Missing required --task-id.
+
+${deps.usageTaskWait()}`);
+    const token = deps.getSingleString(args, "token");
+    const region = deps.getRegionWithDefault(args);
+    const isJson = Boolean(args.json);
+    const body = {};
+    const type = parseTaskTypeOrFail(deps.getSingleString(args, "type"), deps);
+    const responseFormat = parseResponseFormatOrFail(deps.getSingleString(args, "response-format"), deps);
+    if (type) body.type = type;
+    body.response_format = responseFormat;
+    const waitTimeoutSeconds = parsePositiveNumberOption(args, "wait-timeout-seconds", deps);
+    if (waitTimeoutSeconds !== void 0) body.wait_timeout_seconds = waitTimeoutSeconds;
+    const pollIntervalMs = parsePositiveNumberOption(args, "poll-interval-ms", deps);
+    if (pollIntervalMs !== void 0) body.poll_interval_ms = pollIntervalMs;
+    const pick = await deps.pickDirectTokenForTask(token, region);
+    const normalized = await waitForTaskResponse(
+      taskId,
+      pick.token,
+      buildRegionInfo(pick.region),
+      {
+        type,
+        responseFormat,
+        waitTimeoutSeconds: typeof body.wait_timeout_seconds === "number" ? body.wait_timeout_seconds : void 0,
+        pollIntervalMs: typeof body.poll_interval_ms === "number" ? body.poll_interval_ms : void 0
+      }
+    );
+    const taskInfo = collectTaskInfo(normalized, deps);
+    if (!taskInfo) {
+      if (isJson) {
+        deps.printCommandJson("task.wait", deps.unwrapBody(normalized));
+      } else {
+        deps.printJson(deps.unwrapBody(normalized));
+      }
+      return;
+    }
+    if (isJson) deps.printCommandJson("task.wait", taskInfo);
+    else printTaskInfo(taskInfo, deps);
+  };
+  return {
+    handleModelsList,
+    handleTaskGet,
+    handleTaskWait,
+    printTaskInfo: (task) => {
+      const normalized = collectTaskInfo(task, deps);
+      if (!normalized) {
+        deps.printJson(task);
+        return;
+      }
+      printTaskInfo(normalized, deps);
+    }
+  };
+}
+
+// src/cli/media-commands.ts
+import { constants as fsConstants2 } from "fs";
+import { access as access2, mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import path3 from "path";
+import minimist3 from "minimist";
+
+// src/cli/video-input.ts
+import path2 from "path";
+var VIDEO_OMNI_IMAGE_SLOT_KEYS = Array.from({ length: 9 }, (_, i) => `image-file-${i + 1}`);
+var VIDEO_OMNI_VIDEO_SLOT_KEYS = Array.from({ length: 3 }, (_, i) => `video-file-${i + 1}`);
+var VIDEO_SUPPORTED_MODES = [
+  "text_to_video",
+  "image_to_video",
+  "first_last_frames",
+  "omni_reference"
+];
+var VIDEO_OMNI_SUPPORTED_MODELS = /* @__PURE__ */ new Set(["jimeng-video-seedance-2.0", "jimeng-video-seedance-2.0-fast"]);
+function parseVideoCliMode(args, usage, deps) {
+  const cliModeRaw = deps.getSingleString(args, "mode") || "text_to_video";
+  if (!VIDEO_SUPPORTED_MODES.includes(cliModeRaw)) {
+    deps.failWithUsage(
+      `Invalid --mode: ${cliModeRaw}. Use text_to_video, image_to_video, first_last_frames, or omni_reference.`,
+      usage
+    );
+  }
+  return cliModeRaw;
+}
+function collectVideoInputPlan(args, usage, deps) {
+  const repeatedImageInputs = deps.toStringList(args["image-file"]);
+  const repeatedVideoInputs = deps.toStringList(args["video-file"]);
+  const explicitImageSlots = VIDEO_OMNI_IMAGE_SLOT_KEYS.map((key, i) => ({ slot: i + 1, input: deps.getSingleString(args, key) })).filter((item) => Boolean(item.input));
+  const explicitVideoSlots = VIDEO_OMNI_VIDEO_SLOT_KEYS.map((key, i) => ({ slot: i + 1, input: deps.getSingleString(args, key) })).filter((item) => Boolean(item.input));
+  if (repeatedImageInputs.length > 0 && explicitImageSlots.length > 0) {
+    deps.failWithUsage(
+      "Do not mix repeated --image-file with explicit --image-file-N in one command.",
+      usage
+    );
+  }
+  if (repeatedVideoInputs.length > 0 && explicitVideoSlots.length > 0) {
+    deps.failWithUsage(
+      "Do not mix repeated --video-file with explicit --video-file-N in one command.",
+      usage
+    );
+  }
+  return {
+    repeatedImageInputs,
+    repeatedVideoInputs,
+    explicitImageSlots,
+    explicitVideoSlots,
+    totalImageInputs: repeatedImageInputs.length + explicitImageSlots.length,
+    totalVideoInputs: repeatedVideoInputs.length + explicitVideoSlots.length
+  };
+}
+function validateVideoModeAndModel(cliMode, model, plan, usage, deps) {
+  if (cliMode === "omni_reference" && !VIDEO_OMNI_SUPPORTED_MODELS.has(model)) {
+    deps.failWithUsage(
+      `omni_reference mode requires --model jimeng-video-seedance-2.0 or jimeng-video-seedance-2.0-fast (current: ${model}).`,
+      usage
+    );
+  }
+  if (cliMode === "text_to_video") {
+    if (plan.totalImageInputs + plan.totalVideoInputs > 0) {
+      deps.failWithUsage("text_to_video mode does not accept --image-file or --video-file inputs.", usage);
+    }
+    return;
+  }
+  if (cliMode === "image_to_video") {
+    if (plan.totalVideoInputs > 0) {
+      deps.failWithUsage("image_to_video mode does not accept --video-file.", usage);
+    }
+    if (plan.totalImageInputs !== 1) {
+      deps.failWithUsage("image_to_video mode requires exactly one --image-file input.", usage);
+    }
+    return;
+  }
+  if (cliMode === "first_last_frames") {
+    if (plan.totalVideoInputs > 0) {
+      deps.failWithUsage("first_last_frames mode does not accept --video-file.", usage);
+    }
+    if (plan.totalImageInputs === 0) {
+      deps.failWithUsage("first_last_frames mode requires at least one --image-file input.", usage);
+    }
+    if (plan.totalImageInputs > 2) {
+      deps.failWithUsage("first_last_frames mode supports at most 2 image inputs.", usage);
+    }
+    return;
+  }
+  if (plan.totalImageInputs + plan.totalVideoInputs === 0) {
+    deps.failWithUsage("omni_reference mode requires at least one --image-file or --video-file input.", usage);
+  }
+  if (plan.totalImageInputs > 9) {
+    deps.failWithUsage("omni_reference supports at most 9 image inputs.", usage);
+  }
+  if (plan.totalVideoInputs > 3) {
+    deps.failWithUsage("omni_reference supports at most 3 video inputs.", usage);
+  }
+}
+async function buildDirectVideoInputPayload(cliMode, plan, deps) {
+  const payload = {
+    filePaths: [],
+    files: {},
+    httpRequest: { body: {} }
+  };
+  const registerInput = async (fieldName, input, mediaType) => {
+    if (deps.isHttpUrl(input)) {
+      if (cliMode === "omni_reference") {
+        payload.httpRequest.body[fieldName] = input;
+      } else if (mediaType === "image") {
+        payload.filePaths.push(input);
+      } else {
+        deps.fail(`Mode ${cliMode} does not support video URL input.`);
+      }
+      return;
+    }
+    const filePath = path2.resolve(input);
+    if (!await deps.pathExists(filePath)) {
+      deps.fail(`Input file not found for ${fieldName}: ${filePath}`);
+    }
+    payload.files[fieldName] = {
+      filepath: filePath,
+      originalFilename: path2.basename(filePath)
+    };
+  };
+  if (cliMode === "omni_reference") {
+    for (let i = 0; i < plan.repeatedImageInputs.length; i += 1) {
+      await registerInput(`image_file_${i + 1}`, plan.repeatedImageInputs[i], "image");
+    }
+    for (let i = 0; i < plan.repeatedVideoInputs.length; i += 1) {
+      await registerInput(`video_file_${i + 1}`, plan.repeatedVideoInputs[i], "video");
+    }
+    for (const slot of plan.explicitImageSlots) {
+      await registerInput(`image_file_${slot.slot}`, slot.input, "image");
+    }
+    for (const slot of plan.explicitVideoSlots) {
+      await registerInput(`video_file_${slot.slot}`, slot.input, "video");
+    }
+    return payload;
+  }
+  const imageInputs = plan.repeatedImageInputs.length > 0 ? plan.repeatedImageInputs : plan.explicitImageSlots.sort((a, b) => a.slot - b.slot).map((item) => item.input);
+  for (let i = 0; i < imageInputs.length; i += 1) {
+    await registerInput(`image_file_${i + 1}`, imageInputs[i], "image");
+  }
+  return payload;
+}
+
+// src/cli/media-commands.ts
+function ensurePrompt(prompt, usage, deps) {
+  if (!prompt) {
+    deps.fail(`Missing required --prompt.
+
+${usage}`);
+  }
+  return prompt;
+}
+function isHttpUrl(input) {
+  return /^https?:\/\//i.test(input);
+}
+async function pathExists2(filePath) {
+  try {
+    await access2(filePath, fsConstants2.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectImageExtension(contentType) {
+  if (!contentType) return null;
+  if (contentType.includes("image/jpeg")) return "jpg";
+  if (contentType.includes("image/png")) return "png";
+  if (contentType.includes("image/webp")) return "webp";
+  if (contentType.includes("image/gif")) return "gif";
+  return null;
+}
+function detectImageExtensionFromUrl(fileUrl) {
+  try {
+    const pathname = new URL(fileUrl).pathname.toLowerCase();
+    if (pathname.endsWith(".jpg") || pathname.endsWith(".jpeg")) return "jpg";
+    if (pathname.endsWith(".png")) return "png";
+    if (pathname.endsWith(".webp")) return "webp";
+    if (pathname.endsWith(".gif")) return "gif";
+  } catch {
+    return null;
+  }
+  return null;
+}
+function detectImageExtensionFromBuffer(buffer) {
+  if (buffer.length >= 8) {
+    if (buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71 && buffer[4] === 13 && buffer[5] === 10 && buffer[6] === 26 && buffer[7] === 10) return "png";
+  }
+  if (buffer.length >= 3) {
+    if (buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) return "jpg";
+  }
+  if (buffer.length >= 12) {
+    if (buffer.toString("ascii", 0, 4) === "RIFF" && buffer.toString("ascii", 8, 12) === "WEBP") return "webp";
+  }
+  if (buffer.length >= 6) {
+    const sig = buffer.toString("ascii", 0, 6);
+    if (sig === "GIF87a" || sig === "GIF89a") return "gif";
+  }
+  return null;
+}
+function detectVideoExtension(contentType, fileUrl) {
+  if (contentType == null ? void 0 : contentType.includes("video/mp4")) return "mp4";
+  if (contentType == null ? void 0 : contentType.includes("video/webm")) return "webm";
+  const pathname = new URL(fileUrl).pathname.toLowerCase();
+  if (pathname.endsWith(".mp4")) return "mp4";
+  if (pathname.endsWith(".webm")) return "webm";
+  if (pathname.endsWith(".mov")) return "mov";
+  return "mp4";
+}
+function parsePositiveNumberOption2(args, key, deps) {
+  const raw = deps.getSingleString(args, key);
+  if (!raw) return void 0;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    deps.fail(`Invalid --${key}: ${raw}`);
+  }
+  return parsed;
+}
+function applyWaitOptionsToBody(body, args, deps, includeWaitFlag = true) {
+  const wait = Boolean(args.wait);
+  if (includeWaitFlag) body.wait = wait;
+  const waitTimeoutSeconds = parsePositiveNumberOption2(args, "wait-timeout-seconds", deps);
+  if (waitTimeoutSeconds !== void 0) body.wait_timeout_seconds = waitTimeoutSeconds;
+  const pollIntervalMs = parsePositiveNumberOption2(args, "poll-interval-ms", deps);
+  if (pollIntervalMs !== void 0) body.poll_interval_ms = pollIntervalMs;
+  return wait;
+}
+async function downloadBinary(url, deps) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    deps.fail(`Download failed (${response.status}): ${url}`);
+  }
+  return {
+    buffer: Buffer.from(await response.arrayBuffer()),
+    contentType: response.headers.get("content-type")
+  };
+}
+async function downloadImages(urls, outputDir, prefix, deps) {
+  const dir = path3.resolve(outputDir);
+  await mkdir(dir, { recursive: true });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "");
+  const saved = [];
+  for (let i = 0; i < urls.length; i += 1) {
+    const imageUrl = urls[i];
+    const { buffer, contentType } = await downloadBinary(imageUrl, deps);
+    const ext = detectImageExtension(contentType) ?? detectImageExtensionFromBuffer(buffer) ?? detectImageExtensionFromUrl(imageUrl) ?? "png";
+    const fileName = `${prefix}-${timestamp}-${String(i + 1).padStart(2, "0")}.${ext}`;
+    const filePath = path3.join(dir, fileName);
+    await writeFile(filePath, buffer);
+    saved.push(filePath);
+  }
+  return saved;
+}
+function createMediaCommandHandlers(deps) {
+  const handleImageGenerate = async (argv) => {
+    const args = minimist3(argv, {
+      string: [
+        "token",
+        "region",
+        "prompt",
+        "model",
+        "ratio",
+        "resolution",
+        "negative-prompt",
+        "sample-strength",
+        "output-dir",
+        "wait-timeout-seconds",
+        "poll-interval-ms"
+      ],
+      boolean: ["help", "intelligent-ratio", "wait", "json"],
+      default: { wait: true }
+    });
+    if (args.help) {
+      console.log(deps.usageImageGenerate());
+      return;
+    }
+    const token = deps.getSingleString(args, "token");
+    const region = deps.getRegionWithDefault(args);
+    const prompt = ensurePrompt(deps.getSingleString(args, "prompt"), deps.usageImageGenerate(), deps);
+    const outputDir = deps.getSingleString(args, "output-dir") || "./pic/cli-image-generate";
+    const body = {
+      prompt,
+      model: deps.getSingleString(args, "model") || "jimeng-4.5",
+      ratio: deps.getSingleString(args, "ratio") || "1:1",
+      resolution: deps.getSingleString(args, "resolution") || "2k"
+    };
+    const negativePrompt = deps.getSingleString(args, "negative-prompt");
+    if (negativePrompt) body.negative_prompt = negativePrompt;
+    if (args["intelligent-ratio"]) body.intelligent_ratio = true;
+    const wait = applyWaitOptionsToBody(body, args, deps);
+    const isJson = Boolean(args.json);
+    const sampleStrengthRaw = deps.getSingleString(args, "sample-strength");
+    if (sampleStrengthRaw) {
+      const parsed = Number(sampleStrengthRaw);
+      if (!Number.isFinite(parsed)) {
+        deps.fail(`Invalid --sample-strength: ${sampleStrengthRaw}`);
+      }
+      body.sample_strength = parsed;
+    }
+    const pick = await deps.pickDirectTokenForGeneration(
+      token,
+      region,
+      String(body.model || "jimeng-4.5"),
+      "image"
+    );
+    const result = await generateImages(
+      String(body.model || "jimeng-4.5"),
+      String(prompt),
+      {
+        ratio: String(body.ratio || "1:1"),
+        resolution: String(body.resolution || "2k"),
+        sampleStrength: typeof body.sample_strength === "number" ? body.sample_strength : void 0,
+        negativePrompt: typeof body.negative_prompt === "string" ? body.negative_prompt : void 0,
+        intelligentRatio: Boolean(body.intelligent_ratio),
+        wait,
+        waitTimeoutSeconds: typeof body.wait_timeout_seconds === "number" ? body.wait_timeout_seconds : void 0,
+        pollIntervalMs: typeof body.poll_interval_ms === "number" ? body.poll_interval_ms : void 0
+      },
+      pick.token,
+      buildRegionInfo(pick.region)
+    );
+    if (!Array.isArray(result)) {
+      if (isJson) deps.printCommandJson("image.generate", result, { wait });
+      else deps.printTaskInfo(result);
+      return;
+    }
+    const urls = result;
+    if (urls.length === 0) deps.fail("No image URL found in response.");
+    const savedFiles = await downloadImages(urls, outputDir, "jimeng-image-generate", deps);
+    if (isJson) {
+      deps.printCommandJson(
+        "image.generate",
+        { data: urls.map((url) => ({ url })), files: savedFiles },
+        { wait }
+      );
+    } else {
+      deps.printDownloadSummary("image", savedFiles);
+    }
+  };
+  const handleImageEdit = async (argv) => {
+    const args = minimist3(argv, {
+      string: [
+        "token",
+        "region",
+        "prompt",
+        "image",
+        "model",
+        "ratio",
+        "resolution",
+        "negative-prompt",
+        "sample-strength",
+        "output-dir",
+        "wait-timeout-seconds",
+        "poll-interval-ms"
+      ],
+      boolean: ["help", "intelligent-ratio", "wait", "json"],
+      default: { wait: true }
+    });
+    if (args.help) {
+      console.log(deps.usageImageEdit());
+      return;
+    }
+    const token = deps.getSingleString(args, "token");
+    const region = deps.getRegionWithDefault(args);
+    const prompt = ensurePrompt(deps.getSingleString(args, "prompt"), deps.usageImageEdit(), deps);
+    const sources = deps.toStringList(args.image);
+    if (sources.length === 0) deps.failWithUsage("Missing required --image.", deps.usageImageEdit());
+    if (sources.length > 10) deps.fail("At most 10 images are supported for image edit.");
+    const outputDir = deps.getSingleString(args, "output-dir") || "./pic/cli-image-edit";
+    const model = deps.getSingleString(args, "model") || "jimeng-4.5";
+    const ratio = deps.getSingleString(args, "ratio") || "1:1";
+    const resolution = deps.getSingleString(args, "resolution") || "2k";
+    const negativePrompt = deps.getSingleString(args, "negative-prompt");
+    const sampleStrengthRaw = deps.getSingleString(args, "sample-strength");
+    const intelligentRatio = Boolean(args["intelligent-ratio"]);
+    const wait = Boolean(args.wait);
+    const isJson = Boolean(args.json);
+    const allUrls = sources.every(isHttpUrl);
+    const allLocal = sources.every((item) => !isHttpUrl(item));
+    if (!allUrls && !allLocal) {
+      deps.fail("Mixed image sources are not supported. Use all URLs or all local files.");
+    }
+    const pick = await deps.pickDirectTokenForGeneration(token, region, model, "image");
+    const images = [];
+    if (allUrls) {
+      images.push(...sources);
+    } else {
+      for (const source of sources) {
+        const imagePath = path3.resolve(source);
+        if (!await pathExists2(imagePath)) deps.fail(`Image file not found: ${imagePath}`);
+        images.push(await readFile2(imagePath));
+      }
+    }
+    const sampleStrength = sampleStrengthRaw ? Number(sampleStrengthRaw) : void 0;
+    if (sampleStrengthRaw && !Number.isFinite(sampleStrength)) {
+      deps.fail(`Invalid --sample-strength: ${sampleStrengthRaw}`);
+    }
+    const result = await generateImageComposition(
+      model,
+      prompt,
+      images,
+      {
+        ratio,
+        resolution,
+        sampleStrength,
+        negativePrompt,
+        intelligentRatio,
+        wait,
+        waitTimeoutSeconds: parsePositiveNumberOption2(args, "wait-timeout-seconds", deps),
+        pollIntervalMs: parsePositiveNumberOption2(args, "poll-interval-ms", deps)
+      },
+      pick.token,
+      buildRegionInfo(pick.region)
+    );
+    if (!Array.isArray(result)) {
+      if (isJson) deps.printCommandJson("image.edit", result, { wait });
+      else deps.printTaskInfo(result);
+      return;
+    }
+    const urls = result;
+    if (urls.length === 0) deps.fail("No image URL found in response.");
+    const savedFiles = await downloadImages(urls, outputDir, "jimeng-image-edit", deps);
+    if (isJson) {
+      deps.printCommandJson(
+        "image.edit",
+        { data: urls.map((url) => ({ url })), files: savedFiles },
+        { wait }
+      );
+    } else {
+      deps.printDownloadSummary("image", savedFiles);
+    }
+  };
+  const handleVideoGenerate = async (argv) => {
+    const usage = deps.usageVideoGenerate();
+    const args = minimist3(argv, {
+      string: [
+        "token",
+        "region",
+        "prompt",
+        "mode",
+        "image-file",
+        "video-file",
+        ...VIDEO_OMNI_IMAGE_SLOT_KEYS,
+        ...VIDEO_OMNI_VIDEO_SLOT_KEYS,
+        "model",
+        "ratio",
+        "resolution",
+        "duration",
+        "output-dir",
+        "wait-timeout-seconds",
+        "poll-interval-ms"
+      ],
+      boolean: ["help", "wait", "json"],
+      default: { wait: true }
+    });
+    if (args.help) {
+      console.log(usage);
+      return;
+    }
+    const token = deps.getSingleString(args, "token");
+    const region = deps.getRegionWithDefault(args);
+    const prompt = ensurePrompt(deps.getSingleString(args, "prompt"), usage, deps);
+    const cliMode = parseVideoCliMode(args, usage, {
+      getSingleString: deps.getSingleString,
+      toStringList: deps.toStringList,
+      failWithUsage: deps.failWithUsage
+    });
+    const inputPlan = collectVideoInputPlan(args, usage, {
+      getSingleString: deps.getSingleString,
+      toStringList: deps.toStringList,
+      failWithUsage: deps.failWithUsage
+    });
+    const outputDir = deps.getSingleString(args, "output-dir") || "./pic/cli-video-generate";
+    const model = deps.getSingleString(args, "model") || (cliMode === "omni_reference" ? "jimeng-video-seedance-2.0-fast" : "jimeng-video-3.0");
+    validateVideoModeAndModel(cliMode, model, inputPlan, usage, { failWithUsage: deps.failWithUsage });
+    const functionMode = cliMode === "omni_reference" ? "omni_reference" : "first_last_frames";
+    const ratio = deps.getSingleString(args, "ratio") || "1:1";
+    const resolution = deps.getSingleString(args, "resolution") || "720p";
+    const durationRaw = deps.getSingleString(args, "duration") || "5";
+    const duration = Number(durationRaw);
+    if (!Number.isFinite(duration) || duration <= 0 || !Number.isInteger(duration)) {
+      deps.fail(`Invalid --duration: ${durationRaw}. Use a positive integer (seconds).`);
+    }
+    const wait = Boolean(args.wait);
+    const isJson = Boolean(args.json);
+    const requiredCapabilityTags = cliMode === "omni_reference" ? ["omni_reference"] : [];
+    const pick = await deps.pickDirectTokenForGeneration(token, region, model, "video", requiredCapabilityTags);
+    const directInputs = await buildDirectVideoInputPayload(cliMode, inputPlan, {
+      isHttpUrl,
+      pathExists: pathExists2,
+      fail: deps.fail
+    });
+    const result = await generateVideo(
+      model,
+      prompt,
+      {
+        ratio,
+        resolution,
+        duration,
+        filePaths: directInputs.filePaths,
+        files: directInputs.files,
+        httpRequest: directInputs.httpRequest,
+        functionMode,
+        wait,
+        waitTimeoutSeconds: parsePositiveNumberOption2(args, "wait-timeout-seconds", deps),
+        pollIntervalMs: parsePositiveNumberOption2(args, "poll-interval-ms", deps)
+      },
+      pick.token,
+      buildRegionInfo(pick.region)
+    );
+    if (typeof result !== "string") {
+      if (isJson) deps.printCommandJson("video.generate", result, { wait, mode: cliMode });
+      else deps.printTaskInfo(result);
+      return;
+    }
+    const videoUrl = result;
+    const { buffer, contentType } = await downloadBinary(videoUrl, deps);
+    const dir = path3.resolve(outputDir);
+    await mkdir(dir, { recursive: true });
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "");
+    const ext = detectVideoExtension(contentType, videoUrl);
+    const filePath = path3.join(dir, `jimeng-video-generate-${timestamp}.${ext}`);
+    await writeFile(filePath, buffer);
+    if (isJson) {
+      deps.printCommandJson(
+        "video.generate",
+        { data: [{ url: videoUrl }], files: [filePath] },
+        { wait, mode: cliMode }
+      );
+    } else {
+      deps.printDownloadSummary("video", [filePath]);
+    }
+  };
+  return {
+    handleImageGenerate,
+    handleImageEdit,
+    handleVideoGenerate
+  };
+}
+
+// src/cli/app.ts
+var JSON_OPTION = "  --json                   Output structured JSON";
+var HELP_OPTION = "  --help                   Show help";
+function buildUsageText(usageLine, options, sections) {
+  const lines = [
+    "Usage:",
+    usageLine,
+    "",
+    "Options:",
+    ...options
+  ];
+  if (sections && sections.length > 0) {
+    for (const section of sections) {
+      lines.push("", section.title, ...section.lines);
+    }
+  }
+  return lines.join("\n");
+}
+function usageRoot() {
+  const commandLines = ROOT_COMMAND_ENTRIES.map(
+    (entry) => `  ${entry.path.padEnd(32)}${entry.description}`
+  );
+  return [
+    "Usage:",
+    "  jimeng <command> [subcommand] [options]",
+    "",
+    "Commands:",
+    ...commandLines,
+    "",
+    ...ROOT_HELP_HINT_LINES
+  ].join("\n");
+}
+function usageModelsList() {
+  return buildUsageText("  jimeng models list [options]", [
+    "  --region <region>        X-Region header, default cn (cn/us/hk/jp/sg)",
+    "  --verbose                Print rich model fields",
+    "  --json                   Print full JSON response",
+    HELP_OPTION
+  ]);
+}
+function usageTokenSubcommand(name) {
+  const subcommand = TOKEN_SUBCOMMANDS_BY_NAME[name];
+  return buildUsageText(subcommand.usageLine, subcommand.options, subcommand.sections);
+}
+function usageTokenRoot() {
+  const subcommandLines = TOKEN_SUBCOMMANDS.map(
+    (subcommand) => `  ${subcommand.name.padEnd(24)}${subcommand.description}`
+  );
+  return [
+    "Usage:",
+    "  jimeng token <subcommand> [options]",
+    "",
+    "Subcommands:",
+    ...subcommandLines,
+    "",
+    "Run `jimeng token <subcommand> --help` for details."
+  ].join("\n");
+}
+function usageImageGenerate() {
+  return buildUsageText("  jimeng image generate --prompt <text> [options]", [
+    "  --token <token>          Optional, override token-pool selection",
+    "  --region <region>        X-Region header, default cn (cn/us/hk/jp/sg)",
+    "  --prompt <text>          Required",
+    "  --model <model>          Default jimeng-4.5",
+    "  --ratio <ratio>          Default 1:1",
+    "  --resolution <res>       Default 2k",
+    "  --negative-prompt <text> Optional",
+    "  --sample-strength <num>  Optional, 0-1",
+    "  --intelligent-ratio      Optional, enable intelligent ratio",
+    "  --wait / --no-wait       Default wait; --no-wait returns task only",
+    "  --wait-timeout-seconds   Optional wait timeout override",
+    "  --poll-interval-ms       Optional poll interval override",
+    JSON_OPTION,
+    "  --output-dir <dir>       Default ./pic/cli-image-generate",
+    HELP_OPTION
+  ]);
+}
+function usageImageEdit() {
+  return buildUsageText(
+    "  jimeng image edit --prompt <text> --image <path_or_url> [--image <path_or_url> ...] [options]",
+    [
+      "  --token <token>          Optional, override token-pool selection",
+      "  --region <region>        X-Region header, default cn (cn/us/hk/jp/sg)",
+      "  --prompt <text>          Required",
+      "  --image <path_or_url>    Required, can be repeated (1-10)",
+      "  --model <model>          Default jimeng-4.5",
+      "  --ratio <ratio>          Default 1:1",
+      "  --resolution <res>       Default 2k",
+      "  --negative-prompt <text> Optional",
+      "  --sample-strength <num>  Optional, 0-1",
+      "  --intelligent-ratio      Optional, enable intelligent ratio",
+      "  --wait / --no-wait       Default wait; --no-wait returns task only",
+      "  --wait-timeout-seconds   Optional wait timeout override",
+      "  --poll-interval-ms       Optional poll interval override",
+      JSON_OPTION,
+      "  --output-dir <dir>       Default ./pic/cli-image-edit",
+      HELP_OPTION
+    ],
+    [
+      {
+        title: "Notes:",
+        lines: ["  - Image sources must be all local files or all URLs in one command."]
+      }
+    ]
+  );
+}
+function usageVideoGenerate() {
+  return buildUsageText("  jimeng video generate --prompt <text> [options]", [
+    "  --token <token>          Optional, override token-pool selection",
+    "  --region <region>        X-Region header, default cn (cn/us/hk/jp/sg)",
+    "  --prompt <text>          Required",
+    "  --mode <mode>            Optional, text_to_video (default), image_to_video, first_last_frames, or omni_reference",
+    "  --image-file <input>     Image input, can be repeated (path or URL)",
+    "  --video-file <input>     Video input, can be repeated (path or URL, omni only)",
+    "  --image-file-1 <input>   Explicit image slot (1-9) for omni_reference",
+    "  --image-file-2 ... -9    More explicit image slots for omni_reference",
+    "  --video-file-1 <input>   Explicit video slot (1-3) for omni_reference",
+    "  --video-file-2 ... -3    More explicit video slots for omni_reference",
+    "  --model <model>          Default jimeng-video-3.0 (jimeng-video-seedance-2.0-fast in omni_reference)",
+    "  --ratio <ratio>          Default 1:1",
+    "  --resolution <res>       Default 720p",
+    "  --duration <seconds>     Default 5",
+    "  --wait / --no-wait       Default wait; --no-wait returns task only",
+    "  --wait-timeout-seconds   Optional wait timeout override",
+    "  --poll-interval-ms       Optional poll interval override",
+    JSON_OPTION,
+    "  --output-dir <dir>       Default ./pic/cli-video-generate",
+    HELP_OPTION
+  ], [
+    {
+      title: "Examples:",
+      lines: [
+        '  jimeng video generate --mode text_to_video --prompt "A fox runs in snow"',
+        '  jimeng video generate --mode image_to_video --prompt "Camera slowly pushes in" --image-file ./first.png',
+        '  jimeng video generate --mode first_last_frames --prompt "Transition day to night" --image-file ./first.png --image-file ./last.png',
+        '  jimeng video generate --mode omni_reference --model jimeng-video-seedance-2.0-fast --prompt "Use @image_file_1 for character and @video_file_1 for motion" --image-file ./character.png --video-file ./motion.mp4'
+      ]
+    },
+    {
+      title: "Notes:",
+      lines: [
+        "  - text_to_video: no image/video input allowed.",
+        "  - image_to_video: exactly 1 --image-file input, no --video-file.",
+        "  - first_last_frames: 1-2 --image-file inputs, no --video-file.",
+        "  - omni_reference: 1-9 images and 0-3 videos (at least one material).",
+        "  - omni_reference supports model jimeng-video-seedance-2.0 or jimeng-video-seedance-2.0-fast.",
+        "  - Use @image_file_N / @video_file_N in prompt for omni_reference."
+      ]
+    }
+  ]);
+}
+function usageTaskGet() {
+  return buildUsageText("  jimeng task get --task-id <id> [options]", [
+    "  --token <token>          Optional, override token-pool selection",
+    "  --region <region>        X-Region header, default cn (cn/us/hk/jp/sg)",
+    "  --task-id <id>           Required history/task id",
+    "  --type <type>            Optional image or video",
+    "  --response-format <fmt>  Optional url or b64_json",
+    JSON_OPTION,
+    HELP_OPTION
+  ]);
+}
+function usageTaskWait() {
+  return buildUsageText("  jimeng task wait --task-id <id> [options]", [
+    "  --token <token>          Optional, override token-pool selection",
+    "  --region <region>        X-Region header, default cn (cn/us/hk/jp/sg)",
+    "  --task-id <id>           Required history/task id",
+    "  --type <type>            Optional image or video",
+    "  --response-format <fmt>  Optional url or b64_json",
+    "  --wait-timeout-seconds   Optional wait timeout override",
+    "  --poll-interval-ms       Optional poll interval override",
+    JSON_OPTION,
+    HELP_OPTION
+  ]);
+}
+function configureCliLogging(command) {
+  if (process2.env.JIMENG_CLI_VERBOSE_LOGS === "true") {
+    process2.env.JIMENG_CLI_SILENT_LOGS = "false";
+    return;
+  }
+  process2.env.JIMENG_CLI_SILENT_LOGS = "true";
+  config_default.system.log_level = "fatal";
+  config_default.system.debug = false;
+  config_default.system.requestLog = false;
+  logger_default.info = () => void 0;
+  logger_default.debug = () => void 0;
+  logger_default.warn = () => void 0;
+  logger_default.error = () => void 0;
+  console.info = () => void 0;
+  console.debug = () => void 0;
+  console.warn = () => void 0;
+}
+function fail(message) {
+  throw new Error(message);
+}
+function failWithUsage(reason, usage) {
+  fail(`${reason}
+
+${usage}`);
+}
+function getSingleString(args, key) {
+  const raw = args[key];
+  if (typeof raw === "string" && raw.trim().length > 0) return raw.trim();
+  return void 0;
+}
+function getRegionWithDefault(args) {
+  return getSingleString(args, "region") || "cn";
+}
+function toStringList(raw) {
+  if (typeof raw === "string") return raw.split(",").map((item) => item.trim()).filter(Boolean);
+  if (Array.isArray(raw)) {
+    return raw.flatMap((item) => typeof item === "string" ? item.split(",") : []).map((item) => item.trim()).filter(Boolean);
+  }
+  return [];
+}
+var tokenPoolReady = false;
+async function ensureTokenPoolReady() {
+  if (tokenPoolReady) return;
+  await session_pool_default.init();
+  tokenPoolReady = true;
+}
+function parseRegionOrFail(region) {
+  if (!region) return void 0;
+  const parsed = parseRegionCode(region);
+  if (!parsed) fail("Invalid --region. Use cn/us/hk/jp/sg.");
+  return parsed;
+}
+async function pickDirectTokenForGeneration(token, region, requestedModel, taskType, requiredCapabilityTags = []) {
+  await ensureTokenPoolReady();
+  const tokenPick = session_pool_default.pickTokenForRequest({
+    authorization: token ? `Bearer ${token}` : void 0,
+    requestedModel,
+    taskType,
+    requiredCapabilityTags,
+    xRegion: region
+  });
+  if (!tokenPick.token || !tokenPick.region) {
+    fail(tokenPick.reason || "No direct token available. Provide --token and --region, or configure token-pool.");
+  }
+  return { token: tokenPick.token, region: tokenPick.region };
+}
+async function pickDirectTokenForTask(token, region) {
+  var _a;
+  await ensureTokenPoolReady();
+  const parsedRegion = parseRegionOrFail(region);
+  if (token) {
+    const fromPool = (_a = session_pool_default.getTokenEntry(token)) == null ? void 0 : _a.region;
+    const finalRegion = parsedRegion || fromPool;
+    if (!finalRegion) {
+      fail("Missing region for direct task mode. Provide --region or register token region in token-pool.");
+    }
+    return { token, region: finalRegion };
+  }
+  const candidates = session_pool_default.getEntries(false).filter((item) => item.enabled && item.live !== false && item.region).filter((item) => parsedRegion ? item.region === parsedRegion : true);
+  if (candidates.length === 0) {
+    fail("No token available for direct task mode. Provide --token --region or configure token-pool.");
+  }
+  return { token: candidates[0].token, region: candidates[0].region };
+}
+function unwrapBody(payload) {
+  if (!payload || typeof payload !== "object") return payload;
+  const body = payload;
+  if ("data" in body && ("code" in body || "message" in body)) {
+    return body.data;
+  }
+  return payload;
+}
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function printCommandJson(command, data, meta) {
+  const payload = {
+    object: "jimeng_cli_result",
+    command,
+    data
+  };
+  if (meta && Object.keys(meta).length > 0) {
+    payload.meta = meta;
+  }
+  printJson(payload);
+}
+function printDownloadSummary(kind, files) {
+  const label = kind === "image" ? "images" : "video";
+  console.log(`Downloaded ${files.length} ${label}.`);
+  for (const file of files) {
+    console.log(`- ${file}`);
+  }
+}
+function isHelpKeyword(value) {
+  return value === "--help" || value === "-h" || value === "help";
+}
+var TOKEN_SUBCOMMANDS = createTokenSubcommands({
+  getUsage: (name) => usageTokenSubcommand(name),
+  getSingleString,
+  getRegionWithDefault,
+  toStringList,
+  parseRegionOrFail,
+  ensureTokenPoolReady,
+  fail,
+  failWithUsage,
+  printJson,
+  printCommandJson,
+  unwrapBody,
+  jsonOption: JSON_OPTION,
+  helpOption: HELP_OPTION
+});
+var queryHandlers = createQueryCommandHandlers({
+  usageModelsList,
+  usageTaskGet,
+  usageTaskWait,
+  getSingleString,
+  getRegionWithDefault,
+  parseRegionOrFail,
+  ensureTokenPoolReady,
+  pickDirectTokenForTask,
+  fail,
+  printJson,
+  printCommandJson,
+  unwrapBody
+});
+var mediaHandlers = createMediaCommandHandlers({
+  usageImageGenerate,
+  usageImageEdit,
+  usageVideoGenerate,
+  getSingleString,
+  getRegionWithDefault,
+  toStringList,
+  fail,
+  failWithUsage,
+  pickDirectTokenForGeneration,
+  printCommandJson,
+  printDownloadSummary,
+  printTaskInfo: (task) => queryHandlers.printTaskInfo(task)
+});
+var TOKEN_SUBCOMMANDS_BY_NAME = Object.fromEntries(
+  TOKEN_SUBCOMMANDS.map((subcommand) => [subcommand.name, subcommand])
+);
+function buildHandlersMap(subcommands) {
+  return Object.fromEntries(subcommands.map((item) => [item.name, item.handler]));
+}
+var COMMAND_SPECS = [
+  {
+    name: "models",
+    description: "Model commands",
+    subcommands: [{ name: "list", description: "List available models", handler: queryHandlers.handleModelsList }],
+    usage: usageRoot
+  },
+  {
+    name: "image",
+    description: "Image commands",
+    subcommands: [
+      { name: "generate", description: "Generate image from text", handler: mediaHandlers.handleImageGenerate },
+      { name: "edit", description: "Edit image(s) with prompt", handler: mediaHandlers.handleImageEdit }
+    ],
+    usage: usageRoot
+  },
+  {
+    name: "video",
+    description: "Video commands",
+    subcommands: [
+      {
+        name: "generate",
+        description: "Generate video from multimodal references",
+        handler: mediaHandlers.handleVideoGenerate
+      }
+    ],
+    usage: usageRoot
+  },
+  {
+    name: "task",
+    description: "Task commands",
+    subcommands: [
+      { name: "get", description: "Get task status", handler: queryHandlers.handleTaskGet },
+      { name: "wait", description: "Wait until task completion", handler: queryHandlers.handleTaskWait }
+    ],
+    usage: usageRoot
+  },
+  {
+    name: "token",
+    description: "Token management commands",
+    subcommands: TOKEN_SUBCOMMANDS.map((subcommand) => ({
+      name: subcommand.name,
+      description: subcommand.description,
+      handler: subcommand.handler
+    })),
+    usage: usageTokenRoot,
+    showAsGrouped: true
+  }
+];
+var COMMAND_SPECS_BY_NAME = Object.fromEntries(
+  COMMAND_SPECS.map((spec) => [spec.name, spec])
+);
+var ROOT_COMMAND_ENTRIES = COMMAND_SPECS.flatMap((spec) => {
+  if (spec.handler) {
+    return [{ path: spec.name, description: spec.description }];
+  }
+  if (!spec.subcommands || spec.subcommands.length === 0) {
+    return [{ path: spec.name, description: spec.description }];
+  }
+  if (spec.showAsGrouped) {
+    return [{ path: `${spec.name} <subcommand>`, description: spec.description }];
+  }
+  return spec.subcommands.map((subcommand) => ({
+    path: `${spec.name} ${subcommand.name}`,
+    description: subcommand.description
+  }));
+});
+var ROOT_HELP_HINT_LINES = [
+  "Run `jimeng <command> --help` for command details.",
+  ...COMMAND_SPECS.filter((spec) => spec.showAsGrouped).map((spec) => `Run \`jimeng ${spec.name} --help\` for ${spec.name} subcommands.`)
+];
+async function dispatchSubcommand(subcommand, argv, handlers, usage, unknownLabel) {
+  if (!subcommand || isHelpKeyword(subcommand)) {
+    console.log(usage);
+    return true;
+  }
+  const handler = handlers[subcommand];
+  if (!handler) {
+    failWithUsage(`Unknown ${unknownLabel}: ${subcommand}`, usage);
+  }
+  await handler(argv);
+  return true;
+}
+async function run() {
+  const [command, subcommand, ...rest] = process2.argv.slice(2);
+  configureCliLogging(command);
+  if (!command || isHelpKeyword(command)) {
+    console.log(usageRoot());
+    return;
+  }
+  const spec = COMMAND_SPECS_BY_NAME[command];
+  if (!spec) {
+    failWithUsage(`Unknown command: ${[command, subcommand].filter(Boolean).join(" ")}`, usageRoot());
+  }
+  if (spec.handler) {
+    await spec.handler(rest);
+    return;
+  }
+  if (spec.subcommands) {
+    const handlers = buildHandlersMap(spec.subcommands);
+    if (await dispatchSubcommand(
+      subcommand,
+      process2.argv.slice(3),
+      handlers,
+      spec.usage ? spec.usage() : usageRoot(),
+      `${command} subcommand`
+    )) {
+      return;
+    }
+  }
+  failWithUsage(`Unknown command: ${[command, subcommand].filter(Boolean).join(" ")}`, usageRoot());
+}
+function runCli() {
+  run().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const isJson = process2.argv.includes("--json");
+    if (isJson) {
+      printCommandJson("error", { message });
+    } else {
+      console.error(`Error: ${message}`);
+    }
+    process2.exit(1);
+  });
+}
+
+// src/cli/index.ts
+runCli();
+//# sourceMappingURL=index.js.map