1import path from "node:path";
2import process from "node:process";
3import { homedir } from "node:os";
4import { fileURLToPath } from "node:url";
5import { access, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
6import type {
7  BatchFile,
8  BatchTaskInput,
9  CliArgs,
10  ExtendConfig,
11  OpenAIImageApiDialect,
12  Provider,
13} from "./types";
14 
15type ProviderModule = {
16  getDefaultModel: () => string;
17  generateImage: (prompt: string, model: string, args: CliArgs) => Promise<Uint8Array>;
18  validateArgs?: (model: string, args: CliArgs) => void;
19  getDefaultOutputExtension?: (model: string, args: CliArgs) => string;
20};
21 
22type PreparedTask = {
23  id: string;
24  prompt: string;
25  args: CliArgs;
26  provider: Provider;
27  model: string;
28  outputPath: string;
29  providerModule: ProviderModule;
30};
31 
32type TaskResult = {
33  id: string;
34  provider: Provider;
35  model: string;
36  outputPath: string;
37  success: boolean;
38  attempts: number;
39  error: string | null;
40};
41 
42type ProviderRateLimit = {
43  concurrency: number;
44  startIntervalMs: number;
45};
46 
47type LoadedBatchTasks = {
48  tasks: BatchTaskInput[];
49  jobs: number | null;
50  batchDir: string;
51};
52 
53const MAX_ATTEMPTS = 3;
54const DEFAULT_MAX_WORKERS = 10;
55const POLL_WAIT_MS = 250;
56const DEFAULT_PROVIDER_RATE_LIMITS: Record<Provider, ProviderRateLimit> = {
57  replicate: { concurrency: 5, startIntervalMs: 700 },
58  google: { concurrency: 3, startIntervalMs: 1100 },
59  openai: { concurrency: 3, startIntervalMs: 1100 },
60  openrouter: { concurrency: 3, startIntervalMs: 1100 },
61  dashscope: { concurrency: 3, startIntervalMs: 1100 },
62  zai: { concurrency: 3, startIntervalMs: 1100 },
63  minimax: { concurrency: 3, startIntervalMs: 1100 },
64  jimeng: { concurrency: 3, startIntervalMs: 1100 },
65  seedream: { concurrency: 3, startIntervalMs: 1100 },
66  azure: { concurrency: 3, startIntervalMs: 1100 },
67  "codex-cli": { concurrency: 1, startIntervalMs: 2000 },
68  agnes: { concurrency: 3, startIntervalMs: 1100 },
69};
70 
71function printUsage(): void {
72  console.log(`Usage:
73  npx -y bun scripts/main.ts --prompt "A cat" --image cat.png
74  npx -y bun scripts/main.ts --promptfiles system.md content.md --image out.png
75  npx -y bun scripts/main.ts --batchfile batch.json
76 
77Options:
78  -p, --prompt <text>       Prompt text
79  --promptfiles <files...>  Read prompt from files (concatenated)
80  --image <path>            Output image path (required in single-image mode)
81  --batchfile <path>        JSON batch file for multi-image generation
82  --jobs <count>            Worker count for batch mode (default: auto, max from config, built-in default 10)
83  --provider google|openai|openrouter|dashscope|zai|minimax|replicate|jimeng|seedream|azure|codex-cli|agnes  Force provider (auto-detect by default)
84  -m, --model <id>          Model ID
85  --ar <ratio>              Aspect ratio (e.g., 16:9, 1:1, 4:3)
86  --size <WxH>              Size (e.g., 1024x1024)
87  --quality normal|2k       Quality preset (default: 2k)
88  --imageSize 1K|2K|4K      Image size for Google/OpenRouter (default: from quality)
89  --imageApiDialect <id>    OpenAI-compatible image dialect: openai-native|ratio-metadata
90  --response-format file|url  Output mode: file (download image, default) or url (return URL text)
91  --ref <files...>          Reference images (Google, OpenAI, Azure, OpenRouter, Replicate supported families, MiniMax, Seedream 4.0/4.5/5.0, or DashScope wan2.7-image*)
92  --n <count>               Number of images for the current task (default: 1; Replicate currently requires 1)
93  --json                    JSON output
94  -h, --help                Show help
95 
96Batch file format:
97  {
98    "jobs": 4,
99    "tasks": [
100      {
101        "id": "hero",
102        "promptFiles": ["prompts/hero.md"],
103        "image": "out/hero.png",
104        "provider": "replicate",
105        "model": "google/nano-banana-2",
106        "ar": "16:9"
107      }
108    ]
109  }
110 
111Behavior:
112  - Batch mode automatically runs in parallel when pending tasks >= 2
113  - Each image retries automatically up to 3 attempts
114  - Batch summary reports success count, failure count, and per-image errors
115  - Replicate currently supports single-image save semantics only; --n must stay at 1
116 
117Environment variables:
118  OPENAI_API_KEY            OpenAI API key
119  OPENROUTER_API_KEY        OpenRouter API key
120  GOOGLE_API_KEY            Google API key
121  GEMINI_API_KEY            Gemini API key (alias for GOOGLE_API_KEY)
122  DASHSCOPE_API_KEY         DashScope API key
123  ZAI_API_KEY               Z.AI API key
124  BIGMODEL_API_KEY          Backward-compatible alias for Z.AI API key
125  MINIMAX_API_KEY           MiniMax API key
126  REPLICATE_API_TOKEN       Replicate API token
127  JIMENG_ACCESS_KEY_ID      Jimeng Access Key ID
128  JIMENG_SECRET_ACCESS_KEY  Jimeng Secret Access Key
129  ARK_API_KEY               Seedream/Ark API key
130  OPENAI_IMAGE_MODEL        Default OpenAI model (gpt-image-2)
131  OPENROUTER_IMAGE_MODEL    Default OpenRouter model (google/gemini-3.1-flash-image)
132  GOOGLE_IMAGE_MODEL        Default Google model (gemini-3-pro-image)
133  DASHSCOPE_IMAGE_MODEL     Default DashScope model (qwen-image-2.0-pro)
134  ZAI_IMAGE_MODEL           Default Z.AI model (glm-image)
135  BIGMODEL_IMAGE_MODEL      Backward-compatible alias for Z.AI model (glm-image)
136  MINIMAX_IMAGE_MODEL       Default MiniMax model (image-01)
137  REPLICATE_IMAGE_MODEL     Default Replicate model (google/nano-banana-2)
138  JIMENG_IMAGE_MODEL        Default Jimeng model (jimeng_t2i_v40)
139  SEEDREAM_IMAGE_MODEL      Default Seedream model (doubao-seedream-5-0-260128)
140  OPENAI_BASE_URL           Custom OpenAI endpoint
141  OPENAI_IMAGE_API_DIALECT  OpenAI-compatible image dialect (openai-native|ratio-metadata)
142  OPENAI_IMAGE_USE_CHAT     Use /chat/completions instead of /images/generations (true|false)
143  OPENROUTER_BASE_URL       Custom OpenRouter endpoint
144  OPENROUTER_HTTP_REFERER   Optional app URL for OpenRouter attribution
145  OPENROUTER_TITLE          Optional app name for OpenRouter attribution
146  GOOGLE_BASE_URL           Custom Google endpoint
147  DASHSCOPE_BASE_URL        Custom DashScope endpoint
148  ZAI_BASE_URL              Custom Z.AI endpoint
149  BIGMODEL_BASE_URL         Backward-compatible alias for Z.AI endpoint
150  MINIMAX_BASE_URL          Custom MiniMax endpoint
151  REPLICATE_BASE_URL        Custom Replicate endpoint
152  JIMENG_BASE_URL           Custom Jimeng endpoint
153  AZURE_OPENAI_API_KEY      Azure OpenAI API key
154  AZURE_OPENAI_BASE_URL     Azure OpenAI resource or deployment endpoint
155  AZURE_OPENAI_DEPLOYMENT   Default Azure deployment name
156  AZURE_API_VERSION         Azure API version (default: 2025-04-01-preview)
157  AZURE_OPENAI_IMAGE_MODEL  Backward-compatible Azure deployment/model alias (defaults to gpt-image-2)
158  SEEDREAM_BASE_URL         Custom Seedream endpoint
159  BAOYU_IMAGE_GEN_MAX_WORKERS  Override batch worker cap
160  BAOYU_IMAGE_GEN_<PROVIDER>_CONCURRENCY  Override provider concurrency (use underscores: BAOYU_IMAGE_GEN_CODEX_CLI_CONCURRENCY)
161  BAOYU_IMAGE_GEN_<PROVIDER>_START_INTERVAL_MS  Override provider start gap in ms
162  BAOYU_CODEX_IMAGEGEN_BIN  Path to codex-imagegen wrapper (default: bundled scripts/codex-imagegen/main.ts; accepts .ts or legacy .sh/binary)
163  BAOYU_CODEX_IMAGEGEN_CACHE_DIR  Enable idempotency cache for codex-cli provider (default: disabled)
164  BAOYU_CODEX_IMAGEGEN_TIMEOUT_MS  Per-attempt codex exec timeout for codex-cli provider (default: 300000)
165  BAOYU_CODEX_IMAGEGEN_RETRIES  Codex-side retry attempts on retryable errors (default: 2)
166  BAOYU_CODEX_IMAGEGEN_LOG_FILE  Append JSONL diagnostic log for codex-cli provider
167 
168Env file load order: CLI args > EXTEND.md > process.env > <cwd>/.baoyu-skills/.env > ~/.baoyu-skills/.env`);
169}
170 
171export function parseArgs(argv: string[]): CliArgs {
172  const out: CliArgs = {
173    prompt: null,
174    promptFiles: [],
175    imagePath: null,
176    provider: null,
177    model: null,
178    aspectRatio: null,
179    aspectRatioSource: null,
180    size: null,
181    quality: null,
182    imageSize: null,
183    imageSizeSource: null,
184    imageApiDialect: null,
185    responseFormat: null,
186    referenceImages: [],
187    n: 1,
188    batchFile: null,
189    jobs: null,
190    json: false,
191    help: false,
192  };
193 
194  const positional: string[] = [];
195 
196  const takeMany = (i: number): { items: string[]; next: number } => {
197    const items: string[] = [];
198    let j = i + 1;
199    while (j < argv.length) {
200      const v = argv[j]!;
201      if (v.startsWith("-")) break;
202      items.push(v);
203      j++;
204    }
205    return { items, next: j - 1 };
206  };
207 
208  for (let i = 0; i < argv.length; i++) {
209    const a = argv[i]!;
210 
211    if (a === "--help" || a === "-h") {
212      out.help = true;
213      continue;
214    }
215 
216    if (a === "--json") {
217      out.json = true;
218      continue;
219    }
220 
221    if (a === "--prompt" || a === "-p") {
222      const v = argv[++i];
223      if (!v) throw new Error(`Missing value for ${a}`);
224      out.prompt = v;
225      continue;
226    }
227 
228    if (a === "--promptfiles") {
229      const { items, next } = takeMany(i);
230      if (items.length === 0) throw new Error("Missing files for --promptfiles");
231      out.promptFiles.push(...items);
232      i = next;
233      continue;
234    }
235 
236    if (a === "--image") {
237      const v = argv[++i];
238      if (!v) throw new Error("Missing value for --image");
239      out.imagePath = v;
240      continue;
241    }
242 
243    if (a === "--batchfile") {
244      const v = argv[++i];
245      if (!v) throw new Error("Missing value for --batchfile");
246      out.batchFile = v;
247      continue;
248    }
249 
250    if (a === "--jobs") {
251      const v = argv[++i];
252      if (!v) throw new Error("Missing value for --jobs");
253      out.jobs = parseInt(v, 10);
254      if (isNaN(out.jobs) || out.jobs < 1) throw new Error(`Invalid worker count: ${v}`);
255      continue;
256    }
257 
258    if (a === "--provider") {
259      const v = argv[++i];
260      if (
261        v !== "google" &&
262        v !== "openai" &&
263        v !== "openrouter" &&
264        v !== "dashscope" &&
265        v !== "zai" &&
266        v !== "minimax" &&
267        v !== "replicate" &&
268        v !== "jimeng" &&
269        v !== "seedream" &&
270        v !== "azure" &&
271        v !== "codex-cli" &&
272        v !== "agnes"
273      ) {
274        throw new Error(`Invalid provider: ${v}`);
275      }
276      out.provider = v;
277      continue;
278    }
279 
280    if (a === "--model" || a === "-m") {
281      const v = argv[++i];
282      if (!v) throw new Error(`Missing value for ${a}`);
283      out.model = v;
284      continue;
285    }
286 
287    if (a === "--ar") {
288      const v = argv[++i];
289      if (!v) throw new Error("Missing value for --ar");
290      out.aspectRatio = v;
291      out.aspectRatioSource = "cli";
292      continue;
293    }
294 
295    if (a === "--size") {
296      const v = argv[++i];
297      if (!v) throw new Error("Missing value for --size");
298      out.size = v;
299      continue;
300    }
301 
302    if (a === "--quality") {
303      const v = argv[++i];
304      if (v !== "normal" && v !== "2k") throw new Error(`Invalid quality: ${v}`);
305      out.quality = v;
306      continue;
307    }
308 
309    if (a === "--imageSize") {
310      const v = argv[++i]?.toUpperCase();
311      if (v !== "1K" && v !== "2K" && v !== "4K") throw new Error(`Invalid imageSize: ${v}`);
312      out.imageSize = v;
313      out.imageSizeSource = "cli";
314      continue;
315    }
316 
317    if (a === "--imageApiDialect") {
318      const v = argv[++i];
319      if (v !== "openai-native" && v !== "ratio-metadata") {
320        throw new Error(`Invalid imageApiDialect: ${v}`);
321      }
322      out.imageApiDialect = v;
323      continue;
324    }
325 
326    if (a === "--response-format") {
327      const v = argv[++i];
328      if (v !== "file" && v !== "url") throw new Error(`Invalid response-format: ${v}`);
329      out.responseFormat = v;
330      continue;
331    }
332 
333    if (a === "--ref" || a === "--reference") {
334      const { items, next } = takeMany(i);
335      if (items.length === 0) throw new Error(`Missing files for ${a}`);
336      out.referenceImages.push(...items);
337      i = next;
338      continue;
339    }
340 
341    if (a === "--n") {
342      const v = argv[++i];
343      if (!v) throw new Error("Missing value for --n");
344      out.n = parseInt(v, 10);
345      if (isNaN(out.n) || out.n < 1) throw new Error(`Invalid count: ${v}`);
346      continue;
347    }
348 
349    if (a.startsWith("-")) {
350      throw new Error(`Unknown option: ${a}`);
351    }
352 
353    positional.push(a);
354  }
355 
356  if (!out.prompt && out.promptFiles.length === 0 && positional.length > 0) {
357    out.prompt = positional.join(" ");
358  }
359 
360  return out;
361}
362 
363async function loadEnvFile(p: string): Promise<Record<string, string>> {
364  try {
365    const content = await readFile(p, "utf8");
366    const env: Record<string, string> = {};
367    for (const line of content.split("\n")) {
368      const trimmed = line.trim();
369      if (!trimmed || trimmed.startsWith("#")) continue;
370      const idx = trimmed.indexOf("=");
371      if (idx === -1) continue;
372      const key = trimmed.slice(0, idx).trim();
373      let val = trimmed.slice(idx + 1).trim();
374      if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
375        val = val.slice(1, -1);
376      }
377      env[key] = val;
378    }
379    return env;
380  } catch {
381    return {};
382  }
383}
384 
385async function loadEnv(): Promise<void> {
386  const home = homedir();
387  const cwd = process.cwd();
388 
389  const homeEnv = await loadEnvFile(path.join(home, ".baoyu-skills", ".env"));
390  const cwdEnv = await loadEnvFile(path.join(cwd, ".baoyu-skills", ".env"));
391 
392  for (const [k, v] of Object.entries(homeEnv)) {
393    if (!process.env[k]) process.env[k] = v;
394  }
395  for (const [k, v] of Object.entries(cwdEnv)) {
396    if (!process.env[k]) process.env[k] = v;
397  }
398}
399 
400export function extractYamlFrontMatter(content: string): string | null {
401  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*$/m);
402  return match ? match[1] : null;
403}
404 
405export function parseSimpleYaml(yaml: string): Partial<ExtendConfig> {
406  const config: Partial<ExtendConfig> = {};
407  const lines = yaml.split("\n");
408  let currentKey: string | null = null;
409  let currentProvider: Provider | null = null;
410 
411  for (const line of lines) {
412    const trimmed = line.trim();
413    const indent = line.match(/^\s*/)?.[0].length ?? 0;
414    if (!trimmed || trimmed.startsWith("#")) continue;
415 
416    if (trimmed.includes(":") && !trimmed.startsWith("-")) {
417      const colonIdx = trimmed.indexOf(":");
418      const key = trimmed.slice(0, colonIdx).trim();
419      let value = trimmed.slice(colonIdx + 1).trim();
420 
421      if (value === "null" || value === "") {
422        value = "null";
423      }
424 
425      if (key === "version") {
426        config.version = value === "null" ? 1 : parseInt(value, 10);
427      } else if (key === "default_provider") {
428        config.default_provider = value === "null" ? null : (value as Provider);
429      } else if (key === "default_quality") {
430        config.default_quality = value === "null" ? null : value as "normal" | "2k";
431      } else if (key === "default_aspect_ratio") {
432        const cleaned = value.replace(/['"]/g, "");
433        config.default_aspect_ratio = cleaned === "null" ? null : cleaned;
434      } else if (key === "default_image_size") {
435        config.default_image_size = value === "null" ? null : value as "1K" | "2K" | "4K";
436      } else if (key === "default_image_api_dialect") {
437        config.default_image_api_dialect =
438          value === "null" ? null : parseOpenAIImageApiDialect(value);
439      } else if (key === "default_model") {
440        config.default_model = {
441          google: null,
442          openai: null,
443          openrouter: null,
444          dashscope: null,
445          zai: null,
446          minimax: null,
447          replicate: null,
448          jimeng: null,
449          seedream: null,
450          azure: null,
451          "codex-cli": null,
452          agnes: null,
453        };
454        currentKey = "default_model";
455        currentProvider = null;
456      } else if (key === "batch") {
457        config.batch = {};
458        currentKey = "batch";
459        currentProvider = null;
460      } else if (currentKey === "batch" && indent >= 2 && key === "max_workers") {
461        config.batch ??= {};
462        config.batch.max_workers = value === "null" ? null : parseInt(value, 10);
463      } else if (currentKey === "batch" && indent >= 2 && key === "provider_limits") {
464        config.batch ??= {};
465        config.batch.provider_limits ??= {};
466        currentKey = "provider_limits";
467        currentProvider = null;
468      } else if (
469        currentKey === "provider_limits" &&
470        indent >= 4 &&
471        (
472          key === "google" ||
473          key === "openai" ||
474          key === "openrouter" ||
475          key === "dashscope" ||
476          key === "zai" ||
477          key === "minimax" ||
478          key === "replicate" ||
479          key === "jimeng" ||
480          key === "seedream" ||
481          key === "azure" ||
482          key === "codex-cli" ||
483          key === "agnes"
484        )
485      ) {
486        config.batch ??= {};
487        config.batch.provider_limits ??= {};
488        config.batch.provider_limits[key] ??= {};
489        currentProvider = key;
490      } else if (
491        currentKey === "default_model" &&
492        (
493          key === "google" ||
494          key === "openai" ||
495          key === "openrouter" ||
496          key === "dashscope" ||
497          key === "zai" ||
498          key === "minimax" ||
499          key === "replicate" ||
500          key === "jimeng" ||
501          key === "seedream" ||
502          key === "azure" ||
503          key === "codex-cli" ||
504          key === "agnes"
505        )
506      ) {
507        const cleaned = value.replace(/['"]/g, "");
508        config.default_model![key] = cleaned === "null" ? null : cleaned;
509      } else if (
510        currentKey === "provider_limits" &&
511        currentProvider &&
512        indent >= 6 &&
513        (key === "concurrency" || key === "start_interval_ms")
514      ) {
515        config.batch ??= {};
516        config.batch.provider_limits ??= {};
517        const providerLimit = (config.batch.provider_limits[currentProvider] ??= {});
518        if (key === "concurrency") {
519          providerLimit.concurrency = value === "null" ? null : parseInt(value, 10);
520        } else {
521          providerLimit.start_interval_ms = value === "null" ? null : parseInt(value, 10);
522        }
523      }
524    }
525  }
526 
527  return config;
528}
529 
530export function parseOpenAIImageApiDialect(
531  value: string | undefined | null
532): OpenAIImageApiDialect | null {
533  if (!value) return null;
534  const normalized = value.replace(/['"]/g, "").trim();
535  if (normalized === "openai-native" || normalized === "ratio-metadata") return normalized;
536  throw new Error(`Invalid OpenAI image API dialect: ${value}`);
537}
538 
539type ExtendConfigPathPair = {
540  current: string;
541  legacy: string;
542};
543 
544function getExtendConfigPathPairs(cwd: string, home: string): ExtendConfigPathPair[] {
545  return [
546    {
547      current: path.join(cwd, ".baoyu-skills", "baoyu-image-gen", "EXTEND.md"),
548      legacy: path.join(cwd, ".baoyu-skills", "baoyu-imagine", "EXTEND.md"),
549    },
550    {
551      current: path.join(home, ".baoyu-skills", "baoyu-image-gen", "EXTEND.md"),
552      legacy: path.join(home, ".baoyu-skills", "baoyu-imagine", "EXTEND.md"),
553    },
554  ];
555}
556 
557async function exists(filePath: string): Promise<boolean> {
558  try {
559    await access(filePath);
560    return true;
561  } catch {
562    return false;
563  }
564}
565 
566export async function ensureDir(dir: string): Promise<void> {
567  try {
568    await mkdir(dir, { recursive: true });
569  } catch (err) {
570    // Bun on Windows incorrectly throws EEXIST for mkdir(dir, { recursive: true })
571    // when the directory already exists, contradicting Node's documented contract
572    // (mkdir with recursive: true resolves silently for an existing directory).
573    // Tolerate EEXIST only when the path really is a directory; rethrow otherwise
574    // (e.g. EEXIST raised because the path points at an existing file).
575    if ((err as { code?: string }).code !== "EEXIST") throw err;
576    if (!(await stat(dir)).isDirectory()) throw err;
577  }
578}
579 
580async function migrateLegacyExtendConfig(cwd: string, home: string): Promise<void> {
581  for (const { current, legacy } of getExtendConfigPathPairs(cwd, home)) {
582    const [hasCurrent, hasLegacy] = await Promise.all([exists(current), exists(legacy)]);
583    if (hasCurrent || !hasLegacy) continue;
584    await ensureDir(path.dirname(current));
585    await rename(legacy, current);
586  }
587}
588 
589export async function loadExtendConfig(
590  cwd = process.cwd(),
591  home = homedir(),
592): Promise<Partial<ExtendConfig>> {
593  await migrateLegacyExtendConfig(cwd, home);
594 
595  const paths = getExtendConfigPathPairs(cwd, home).map(({ current }) => current);
596 
597  for (const p of paths) {
598    try {
599      const content = await readFile(p, "utf8");
600      const yaml = extractYamlFrontMatter(content);
601      if (!yaml) continue;
602      return parseSimpleYaml(yaml);
603    } catch {
604      continue;
605    }
606  }
607 
608  return {};
609}
610 
611export function mergeConfig(args: CliArgs, extend: Partial<ExtendConfig>): CliArgs {
612  const aspectRatio = args.aspectRatio ?? extend.default_aspect_ratio ?? null;
613  const imageSize = args.imageSize ?? extend.default_image_size ?? null;
614  const imageApiDialect =
615    args.imageApiDialect ??
616    extend.default_image_api_dialect ??
617    parseOpenAIImageApiDialect(process.env.OPENAI_IMAGE_API_DIALECT);
618  return {
619    ...args,
620    provider: args.provider ?? extend.default_provider ?? null,
621    quality: args.quality ?? extend.default_quality ?? null,
622    aspectRatio,
623    aspectRatioSource:
624      args.aspectRatioSource ??
625      (args.aspectRatio !== null ? "cli" : (aspectRatio !== null ? "config" : null)),
626    imageSize,
627    imageSizeSource:
628      args.imageSizeSource ??
629      (args.imageSize !== null ? "cli" : (imageSize !== null ? "config" : null)),
630    imageApiDialect,
631  };
632}
633 
634export function parsePositiveInt(value: string | undefined): number | null {
635  if (!value) return null;
636  const parsed = parseInt(value, 10);
637  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
638}
639 
640export function parsePositiveBatchInt(value: unknown): number | null {
641  if (value === null || value === undefined) return null;
642  if (typeof value === "number") {
643    return Number.isInteger(value) && value > 0 ? value : null;
644  }
645  if (typeof value === "string") {
646    return parsePositiveInt(value);
647  }
648  return null;
649}
650 
651export function getConfiguredMaxWorkers(extendConfig: Partial<ExtendConfig>): number {
652  const envValue = parsePositiveInt(process.env.BAOYU_IMAGE_GEN_MAX_WORKERS);
653  const configValue = extendConfig.batch?.max_workers ?? null;
654  return Math.max(1, envValue ?? configValue ?? DEFAULT_MAX_WORKERS);
655}
656 
657export function getConfiguredProviderRateLimits(
658  extendConfig: Partial<ExtendConfig>
659): Record<Provider, ProviderRateLimit> {
660  const configured: Record<Provider, ProviderRateLimit> = {
661    replicate: { ...DEFAULT_PROVIDER_RATE_LIMITS.replicate },
662    google: { ...DEFAULT_PROVIDER_RATE_LIMITS.google },
663    openai: { ...DEFAULT_PROVIDER_RATE_LIMITS.openai },
664    openrouter: { ...DEFAULT_PROVIDER_RATE_LIMITS.openrouter },
665    dashscope: { ...DEFAULT_PROVIDER_RATE_LIMITS.dashscope },
666    zai: { ...DEFAULT_PROVIDER_RATE_LIMITS.zai },
667    minimax: { ...DEFAULT_PROVIDER_RATE_LIMITS.minimax },
668    jimeng: { ...DEFAULT_PROVIDER_RATE_LIMITS.jimeng },
669    seedream: { ...DEFAULT_PROVIDER_RATE_LIMITS.seedream },
670    azure: { ...DEFAULT_PROVIDER_RATE_LIMITS.azure },
671    "codex-cli": { ...DEFAULT_PROVIDER_RATE_LIMITS["codex-cli"] },
672    agnes: { ...DEFAULT_PROVIDER_RATE_LIMITS.agnes },
673  };
674 
675  for (const provider of ["replicate", "google", "openai", "openrouter", "dashscope", "zai", "minimax", "jimeng", "seedream", "azure", "codex-cli", "agnes"] as Provider[]) {
676    const envPrefix = `BAOYU_IMAGE_GEN_${provider.toUpperCase().replace(/-/g, "_")}`;
677    const extendLimit = extendConfig.batch?.provider_limits?.[provider];
678    configured[provider] = {
679      concurrency:
680        parsePositiveInt(process.env[`${envPrefix}_CONCURRENCY`]) ??
681        extendLimit?.concurrency ??
682        configured[provider].concurrency,
683      startIntervalMs:
684        parsePositiveInt(process.env[`${envPrefix}_START_INTERVAL_MS`]) ??
685        extendLimit?.start_interval_ms ??
686        configured[provider].startIntervalMs,
687    };
688  }
689 
690  return configured;
691}
692 
693async function readPromptFromFiles(files: string[]): Promise<string> {
694  const parts: string[] = [];
695  for (const f of files) {
696    parts.push(await readFile(f, "utf8"));
697  }
698  return parts.join("\n\n");
699}
700 
701async function readPromptFromStdin(): Promise<string | null> {
702  if (process.stdin.isTTY) return null;
703  try {
704    const chunks: Buffer[] = [];
705    for await (const chunk of process.stdin) {
706      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
707    }
708    const value = Buffer.concat(chunks).toString("utf8").trim();
709    return value.length > 0 ? value : null;
710  } catch {
711    return null;
712  }
713}
714 
715export function normalizeOutputImagePath(p: string, defaultExtension = ".png"): string {
716  const full = path.resolve(p);
717  const ext = path.extname(full);
718  if (ext) return full;
719  return `${full}${defaultExtension}`;
720}
721 
722function inferProviderFromModel(model: string | null): Provider | null {
723  if (!model) return null;
724  const normalized = model.trim();
725  if (normalized.includes("seedream") || normalized.includes("seededit")) return "seedream";
726  if (normalized === "image-01" || normalized === "image-01-live") return "minimax";
727  if (normalized === "glm-image" || normalized === "cogview-4-250304") return "zai";
728  if (normalized.includes("agnes-image")) return "agnes";
729  return null;
730}
731 
732export function detectProvider(args: CliArgs): Provider {
733  if (
734    args.referenceImages.length > 0 &&
735    args.provider &&
736    args.provider !== "google" &&
737    args.provider !== "openai" &&
738    args.provider !== "azure" &&
739    args.provider !== "openrouter" &&
740    args.provider !== "replicate" &&
741    args.provider !== "seedream" &&
742    args.provider !== "minimax" &&
743    args.provider !== "dashscope" &&
744    args.provider !== "codex-cli" &&
745    args.provider !== "agnes"
746  ) {
747    throw new Error(
748      "Reference images require a ref-capable provider. Use --provider google (Gemini multimodal), --provider openai (GPT Image edits), --provider azure (Azure OpenAI), --provider openrouter (OpenRouter multimodal), --provider replicate, --provider dashscope with a wan2.7 image model, --provider seedream for supported Seedream models, --provider minimax for MiniMax subject-reference workflows, --provider codex-cli (Codex image_gen with references), or --provider agnes (Agnes Image)."
749    );
750  }
751 
752  if (args.provider) return args.provider;
753 
754  const hasGoogle = !!(process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY);
755  const hasAzure = !!(process.env.AZURE_OPENAI_API_KEY && process.env.AZURE_OPENAI_BASE_URL);
756  const hasOpenai = !!process.env.OPENAI_API_KEY;
757  const hasOpenrouter = !!process.env.OPENROUTER_API_KEY;
758  const hasDashscope = !!process.env.DASHSCOPE_API_KEY;
759  const hasZai = !!(process.env.ZAI_API_KEY || process.env.BIGMODEL_API_KEY);
760  const hasMinimax = !!process.env.MINIMAX_API_KEY;
761  const hasReplicate = !!process.env.REPLICATE_API_TOKEN;
762  const hasJimeng = !!(process.env.JIMENG_ACCESS_KEY_ID && process.env.JIMENG_SECRET_ACCESS_KEY);
763  const hasSeedream = !!process.env.ARK_API_KEY;
764  const hasAgnes = !!process.env.AGNES_API_KEY;
765  const modelProvider = inferProviderFromModel(args.model);
766 
767  if (modelProvider === "seedream") {
768    if (!hasSeedream) {
769      throw new Error("Model looks like a Volcengine ARK image model, but ARK_API_KEY is not set.");
770    }
771    return "seedream";
772  }
773 
774  if (modelProvider === "minimax") {
775    if (!hasMinimax) {
776      throw new Error("Model looks like a MiniMax image model, but MINIMAX_API_KEY is not set.");
777    }
778    return "minimax";
779  }
780 
781  if (modelProvider === "zai") {
782    if (!hasZai) {
783      throw new Error("Model looks like a Z.AI image model, but ZAI_API_KEY is not set.");
784    }
785    return "zai";
786  }
787 
788  if (modelProvider === "agnes") {
789    if (!hasAgnes) {
790      throw new Error("Model looks like an Agnes image model, but AGNES_API_KEY is not set.");
791    }
792    return "agnes";
793  }
794 
795  if (args.referenceImages.length > 0) {
796    if (hasGoogle) return "google";
797    if (hasOpenai) return "openai";
798    if (hasAzure) return "azure";
799    if (hasOpenrouter) return "openrouter";
800    if (hasReplicate) return "replicate";
801    if (hasSeedream) return "seedream";
802    if (hasMinimax) return "minimax";
803    if (hasAgnes) return "agnes";
804    throw new Error(
805      "Reference images require Google, OpenAI, Azure, OpenRouter, Replicate, supported Seedream models, MiniMax, or Agnes. Set GOOGLE_API_KEY/GEMINI_API_KEY, OPENAI_API_KEY, AZURE_OPENAI_API_KEY+AZURE_OPENAI_BASE_URL, OPENROUTER_API_KEY, REPLICATE_API_TOKEN, ARK_API_KEY, MINIMAX_API_KEY, or AGNES_API_KEY, or remove --ref."
806    );
807  }
808 
809  const available = [
810    hasGoogle && "google",
811    hasOpenai && "openai",
812    hasAzure && "azure",
813    hasOpenrouter && "openrouter",
814    hasDashscope && "dashscope",
815    hasZai && "zai",
816    hasMinimax && "minimax",
817    hasReplicate && "replicate",
818    hasJimeng && "jimeng",
819    hasSeedream && "seedream",
820    hasAgnes && "agnes",
821  ].filter(Boolean) as Provider[];
822 
823  if (available.length === 1) return available[0]!;
824  if (available.length > 1) return available[0]!;
825 
826  throw new Error(
827    "No API key found. Set GOOGLE_API_KEY, GEMINI_API_KEY, OPENAI_API_KEY, AZURE_OPENAI_API_KEY+AZURE_OPENAI_BASE_URL, OPENROUTER_API_KEY, DASHSCOPE_API_KEY, ZAI_API_KEY, MINIMAX_API_KEY, REPLICATE_API_TOKEN, JIMENG keys, ARK_API_KEY, or AGNES_API_KEY.\n" +
828      "Create ~/.baoyu-skills/.env or <cwd>/.baoyu-skills/.env with your keys."
829  );
830}
831 
832export type ReferenceImageValidationOptions = {
833  allowRemoteUrls?: boolean;
834};
835 
836function isRemoteReferenceImage(refPath: string): boolean {
837  return /^https?:\/\//i.test(refPath);
838}
839 
840function shouldAllowRemoteReferenceImages(provider: Provider | null): boolean {
841  return provider === "dashscope" || provider === "agnes";
842}
843 
844export async function validateReferenceImages(
845  referenceImages: string[],
846  options: ReferenceImageValidationOptions = {},
847): Promise<void> {
848  for (const refPath of referenceImages) {
849    if (options.allowRemoteUrls && isRemoteReferenceImage(refPath)) continue;
850    const fullPath = path.resolve(refPath);
851    try {
852      await access(fullPath);
853    } catch {
854      throw new Error(`Reference image not found: ${fullPath}`);
855    }
856  }
857}
858 
859export function isRetryableGenerationError(error: unknown): boolean {
860  const msg = error instanceof Error ? error.message : String(error);
861  const nonRetryableMarkers = [
862    "Reference image",
863    "not supported",
864    "only supported",
865    "No API key found",
866    "is required",
867    "Invalid ",
868    "Unexpected ",
869    "API error (400)",
870    "API error (401)",
871    "API error (402)",
872    "API error (403)",
873    "API error (404)",
874    "temporarily disabled",
875    "supports saving exactly one image",
876    "supports only",
877    "support exactly one output image",
878    "support aspect ratios in",
879    "requires total pixels between",
880    "accept at most",
881  ];
882  return !nonRetryableMarkers.some((marker) => msg.includes(marker));
883}
884 
885async function loadProviderModule(provider: Provider): Promise<ProviderModule> {
886  if (provider === "google") return (await import("./providers/google")) as ProviderModule;
887  if (provider === "dashscope") return (await import("./providers/dashscope")) as ProviderModule;
888  if (provider === "zai") return (await import("./providers/zai")) as ProviderModule;
889  if (provider === "minimax") return (await import("./providers/minimax")) as ProviderModule;
890  if (provider === "replicate") return (await import("./providers/replicate")) as ProviderModule;
891  if (provider === "openrouter") return (await import("./providers/openrouter")) as ProviderModule;
892  if (provider === "jimeng") return (await import("./providers/jimeng")) as ProviderModule;
893  if (provider === "seedream") return (await import("./providers/seedream")) as ProviderModule;
894  if (provider === "azure") return (await import("./providers/azure")) as ProviderModule;
895  if (provider === "codex-cli") return (await import("./providers/codex-cli")) as ProviderModule;
896  if (provider === "agnes") return (await import("./providers/agnes")) as ProviderModule;
897  return (await import("./providers/openai")) as ProviderModule;
898}
899 
900async function loadPromptForArgs(args: CliArgs): Promise<string | null> {
901  let prompt: string | null = args.prompt;
902  if (!prompt && args.promptFiles.length > 0) {
903    prompt = await readPromptFromFiles(args.promptFiles);
904  }
905  return prompt;
906}
907 
908function getModelForProvider(
909  provider: Provider,
910  requestedModel: string | null,
911  extendConfig: Partial<ExtendConfig>,
912  providerModule: ProviderModule
913): string {
914  if (requestedModel) return requestedModel;
915  if (extendConfig.default_model) {
916    if (provider === "google" && extendConfig.default_model.google) return extendConfig.default_model.google;
917    if (provider === "openai" && extendConfig.default_model.openai) return extendConfig.default_model.openai;
918    if (provider === "openrouter" && extendConfig.default_model.openrouter) {
919      return extendConfig.default_model.openrouter;
920    }
921    if (provider === "dashscope" && extendConfig.default_model.dashscope) return extendConfig.default_model.dashscope;
922    if (provider === "zai" && extendConfig.default_model.zai) return extendConfig.default_model.zai;
923    if (provider === "minimax" && extendConfig.default_model.minimax) return extendConfig.default_model.minimax;
924    if (provider === "replicate" && extendConfig.default_model.replicate) return extendConfig.default_model.replicate;
925    if (provider === "jimeng" && extendConfig.default_model.jimeng) return extendConfig.default_model.jimeng;
926    if (provider === "seedream" && extendConfig.default_model.seedream) return extendConfig.default_model.seedream;
927    if (provider === "azure" && extendConfig.default_model.azure) return extendConfig.default_model.azure;
928    if (provider === "codex-cli" && extendConfig.default_model["codex-cli"]) return extendConfig.default_model["codex-cli"];
929    if (provider === "agnes" && extendConfig.default_model.agnes) return extendConfig.default_model.agnes;
930  }
931  return providerModule.getDefaultModel();
932}
933 
934async function prepareSingleTask(args: CliArgs, extendConfig: Partial<ExtendConfig>): Promise<PreparedTask> {
935  if (!args.quality) args.quality = "2k";
936 
937  const prompt = (await loadPromptForArgs(args)) ?? (await readPromptFromStdin());
938  if (!prompt) throw new Error("Prompt is required");
939  if (!args.imagePath) throw new Error("--image is required");
940  if (args.referenceImages.length > 0) {
941    await validateReferenceImages(args.referenceImages, {
942      allowRemoteUrls: shouldAllowRemoteReferenceImages(args.provider),
943    });
944  }
945 
946  const provider = detectProvider(args);
947  const providerModule = await loadProviderModule(provider);
948  const model = getModelForProvider(provider, args.model, extendConfig, providerModule);
949  providerModule.validateArgs?.(model, args);
950  const defaultOutputExtension = providerModule.getDefaultOutputExtension?.(model, args) ?? ".png";
951 
952  return {
953    id: "single",
954    prompt,
955    args,
956    provider,
957    model,
958    outputPath: normalizeOutputImagePath(args.imagePath, defaultOutputExtension),
959    providerModule,
960  };
961}
962 
963export async function loadBatchTasks(batchFilePath: string): Promise<LoadedBatchTasks> {
964  const resolvedBatchFilePath = path.resolve(batchFilePath);
965  const content = await readFile(resolvedBatchFilePath, "utf8");
966  const parsed = JSON.parse(content.replace(/^\uFEFF/, "")) as BatchFile;
967  const batchDir = path.dirname(resolvedBatchFilePath);
968  if (Array.isArray(parsed)) {
969    return {
970      tasks: parsed,
971      jobs: null,
972      batchDir,
973    };
974  }
975  if (parsed && typeof parsed === "object" && Array.isArray(parsed.tasks)) {
976    const jobs = parsePositiveBatchInt(parsed.jobs);
977    if (parsed.jobs !== undefined && parsed.jobs !== null && jobs === null) {
978      throw new Error("Invalid batch file. jobs must be a positive integer when provided.");
979    }
980    return {
981      tasks: parsed.tasks,
982      jobs,
983      batchDir,
984    };
985  }
986  throw new Error("Invalid batch file. Expected an array of tasks or an object with a tasks array.");
987}
988 
989export function resolveBatchPath(batchDir: string, filePath: string): string {
990  return path.isAbsolute(filePath) ? filePath : path.resolve(batchDir, filePath);
991}
992 
993function resolveBatchReferencePath(batchDir: string, filePath: string): string {
994  return isRemoteReferenceImage(filePath) ? filePath : resolveBatchPath(batchDir, filePath);
995}
996 
997export function createTaskArgs(baseArgs: CliArgs, task: BatchTaskInput, batchDir: string): CliArgs {
998  return {
999    ...baseArgs,
1000    prompt: task.prompt ?? null,
1001    promptFiles: task.promptFiles ? task.promptFiles.map((filePath) => resolveBatchPath(batchDir, filePath)) : [],
1002    imagePath: task.image ? resolveBatchPath(batchDir, task.image) : null,
1003    provider: task.provider ?? baseArgs.provider ?? null,
1004    model: task.model ?? baseArgs.model ?? null,
1005    aspectRatio: task.ar ?? baseArgs.aspectRatio ?? null,
1006    aspectRatioSource: task.ar != null ? "task" : (baseArgs.aspectRatioSource ?? null),
1007    size: task.size ?? baseArgs.size ?? null,
1008    quality: task.quality ?? baseArgs.quality ?? null,
1009    imageSize: task.imageSize ?? baseArgs.imageSize ?? null,
1010    imageSizeSource: task.imageSize != null ? "task" : (baseArgs.imageSizeSource ?? null),
1011    imageApiDialect: task.imageApiDialect ?? baseArgs.imageApiDialect ?? null,
1012    responseFormat: task.responseFormat ?? baseArgs.responseFormat ?? null,
1013    referenceImages: task.ref ? task.ref.map((filePath) => resolveBatchReferencePath(batchDir, filePath)) : [],
1014    n: task.n ?? baseArgs.n,
1015    batchFile: null,
1016    jobs: baseArgs.jobs,
1017    json: baseArgs.json,
1018    help: false,
1019  };
1020}
1021 
1022async function prepareBatchTasks(
1023  args: CliArgs,
1024  extendConfig: Partial<ExtendConfig>
1025): Promise<{ tasks: PreparedTask[]; jobs: number | null }> {
1026  if (!args.batchFile) throw new Error("--batchfile is required in batch mode");
1027  const { tasks: taskInputs, jobs: batchJobs, batchDir } = await loadBatchTasks(args.batchFile);
1028  if (taskInputs.length === 0) throw new Error("Batch file does not contain any tasks.");
1029 
1030  const prepared: PreparedTask[] = [];
1031  for (let i = 0; i < taskInputs.length; i++) {
1032    const task = taskInputs[i]!;
1033    const taskArgs = createTaskArgs(args, task, batchDir);
1034    const prompt = await loadPromptForArgs(taskArgs);
1035    if (!prompt) throw new Error(`Task ${i + 1} is missing prompt or promptFiles.`);
1036    if (!taskArgs.imagePath) throw new Error(`Task ${i + 1} is missing image output path.`);
1037    if (taskArgs.referenceImages.length > 0) {
1038      await validateReferenceImages(taskArgs.referenceImages, {
1039        allowRemoteUrls: shouldAllowRemoteReferenceImages(taskArgs.provider),
1040      });
1041    }
1042 
1043    const provider = detectProvider(taskArgs);
1044    const providerModule = await loadProviderModule(provider);
1045    const model = getModelForProvider(provider, taskArgs.model, extendConfig, providerModule);
1046    providerModule.validateArgs?.(model, taskArgs);
1047    const defaultOutputExtension = providerModule.getDefaultOutputExtension?.(model, taskArgs) ?? ".png";
1048    prepared.push({
1049      id: task.id || `task-${String(i + 1).padStart(2, "0")}`,
1050      prompt,
1051      args: taskArgs,
1052      provider,
1053      model,
1054      outputPath: normalizeOutputImagePath(taskArgs.imagePath, defaultOutputExtension),
1055      providerModule,
1056    });
1057  }
1058 
1059  return {
1060    tasks: prepared,
1061    jobs: args.jobs ?? batchJobs,
1062  };
1063}
1064 
1065async function writeImage(outputPath: string, imageData: Uint8Array): Promise<void> {
1066  await ensureDir(path.dirname(outputPath));
1067  await writeFile(outputPath, imageData);
1068}
1069 
1070async function generatePreparedTask(task: PreparedTask): Promise<TaskResult> {
1071  console.error(`Using ${task.provider} / ${task.model} for ${task.id}`);
1072  console.error(
1073    `Switch model: --model <id> | EXTEND.md default_model.${task.provider} | env ${task.provider.toUpperCase()}_IMAGE_MODEL`
1074  );
1075 
1076  let attempts = 0;
1077  while (attempts < MAX_ATTEMPTS) {
1078    attempts += 1;
1079    try {
1080      const imageData = await task.providerModule.generateImage(task.prompt, task.model, task.args);
1081      await writeImage(task.outputPath, imageData);
1082      return {
1083        id: task.id,
1084        provider: task.provider,
1085        model: task.model,
1086        outputPath: task.outputPath,
1087        success: true,
1088        attempts,
1089        error: null,
1090      };
1091    } catch (error) {
1092      const message = error instanceof Error ? error.message : String(error);
1093      const canRetry = attempts < MAX_ATTEMPTS && isRetryableGenerationError(error);
1094      if (canRetry) {
1095        console.error(`[${task.id}] Attempt ${attempts}/${MAX_ATTEMPTS} failed, retrying...`);
1096        continue;
1097      }
1098      return {
1099        id: task.id,
1100        provider: task.provider,
1101        model: task.model,
1102        outputPath: task.outputPath,
1103        success: false,
1104        attempts,
1105        error: message,
1106      };
1107    }
1108  }
1109 
1110  return {
1111    id: task.id,
1112    provider: task.provider,
1113    model: task.model,
1114    outputPath: task.outputPath,
1115    success: false,
1116    attempts: MAX_ATTEMPTS,
1117    error: "Unknown failure",
1118  };
1119}
1120 
1121function createProviderGate(providerRateLimits: Record<Provider, ProviderRateLimit>) {
1122  const state = new Map<Provider, { active: number; lastStartedAt: number }>();
1123 
1124  return async function acquire(provider: Provider): Promise<() => void> {
1125    const limit = providerRateLimits[provider];
1126    while (true) {
1127      const current = state.get(provider) ?? { active: 0, lastStartedAt: 0 };
1128      const now = Date.now();
1129      const enoughCapacity = current.active < limit.concurrency;
1130      const enoughGap = now - current.lastStartedAt >= limit.startIntervalMs;
1131      if (enoughCapacity && enoughGap) {
1132        state.set(provider, { active: current.active + 1, lastStartedAt: now });
1133        return () => {
1134          const latest = state.get(provider) ?? { active: 1, lastStartedAt: now };
1135          state.set(provider, {
1136            active: Math.max(0, latest.active - 1),
1137            lastStartedAt: latest.lastStartedAt,
1138          });
1139        };
1140      }
1141      await new Promise((resolve) => setTimeout(resolve, POLL_WAIT_MS));
1142    }
1143  };
1144}
1145 
1146export function getWorkerCount(taskCount: number, jobs: number | null, maxWorkers: number): number {
1147  const requested = jobs ?? Math.min(taskCount, maxWorkers);
1148  return Math.max(1, Math.min(requested, taskCount, maxWorkers));
1149}
1150 
1151async function runBatchTasks(
1152  tasks: PreparedTask[],
1153  jobs: number | null,
1154  extendConfig: Partial<ExtendConfig>
1155): Promise<TaskResult[]> {
1156  if (tasks.length === 1) {
1157    return [await generatePreparedTask(tasks[0]!)];
1158  }
1159 
1160  const maxWorkers = getConfiguredMaxWorkers(extendConfig);
1161  const providerRateLimits = getConfiguredProviderRateLimits(extendConfig);
1162  const acquireProvider = createProviderGate(providerRateLimits);
1163  const workerCount = getWorkerCount(tasks.length, jobs, maxWorkers);
1164  console.error(`Batch mode: ${tasks.length} tasks, ${workerCount} workers, parallel mode enabled.`);
1165  for (const provider of ["replicate", "google", "openai", "openrouter", "dashscope", "zai", "minimax", "jimeng", "seedream", "azure", "codex-cli", "agnes"] as Provider[]) {
1166    const limit = providerRateLimits[provider];
1167    console.error(`- ${provider}: concurrency=${limit.concurrency}, startIntervalMs=${limit.startIntervalMs}`);
1168  }
1169 
1170  let nextIndex = 0;
1171  const results: TaskResult[] = new Array(tasks.length);
1172 
1173  const worker = async (): Promise<void> => {
1174    while (true) {
1175      const currentIndex = nextIndex;
1176      nextIndex += 1;
1177      if (currentIndex >= tasks.length) return;
1178 
1179      const task = tasks[currentIndex]!;
1180      const release = await acquireProvider(task.provider);
1181      try {
1182        results[currentIndex] = await generatePreparedTask(task);
1183      } finally {
1184        release();
1185      }
1186    }
1187  };
1188 
1189  await Promise.all(Array.from({ length: workerCount }, () => worker()));
1190  return results;
1191}
1192 
1193function printBatchSummary(results: TaskResult[]): void {
1194  const successCount = results.filter((result) => result.success).length;
1195  const failureCount = results.length - successCount;
1196 
1197  console.error("");
1198  console.error("Batch generation summary:");
1199  console.error(`- Total: ${results.length}`);
1200  console.error(`- Succeeded: ${successCount}`);
1201  console.error(`- Failed: ${failureCount}`);
1202 
1203  if (failureCount > 0) {
1204    console.error("Failure reasons:");
1205    for (const result of results.filter((item) => !item.success)) {
1206      console.error(`- ${result.id}: ${result.error}`);
1207    }
1208  }
1209}
1210 
1211function emitJson(payload: unknown): void {
1212  console.log(JSON.stringify(payload, null, 2));
1213}
1214 
1215async function runSingleMode(args: CliArgs, extendConfig: Partial<ExtendConfig>): Promise<void> {
1216  const task = await prepareSingleTask(args, extendConfig);
1217  const result = await generatePreparedTask(task);
1218  if (!result.success) {
1219    throw new Error(result.error || "Generation failed");
1220  }
1221 
1222  if (args.json) {
1223    emitJson({
1224      savedImage: result.outputPath,
1225      provider: result.provider,
1226      model: result.model,
1227      attempts: result.attempts,
1228      prompt: task.prompt.slice(0, 200),
1229    });
1230    return;
1231  }
1232 
1233  console.log(result.outputPath);
1234}
1235 
1236async function runBatchMode(args: CliArgs, extendConfig: Partial<ExtendConfig>): Promise<void> {
1237  const { tasks, jobs } = await prepareBatchTasks(args, extendConfig);
1238  const results = await runBatchTasks(tasks, jobs, extendConfig);
1239  printBatchSummary(results);
1240 
1241  if (args.json) {
1242    emitJson({
1243      mode: "batch",
1244      total: results.length,
1245      succeeded: results.filter((item) => item.success).length,
1246      failed: results.filter((item) => !item.success).length,
1247      results,
1248    });
1249  }
1250 
1251  if (results.some((item) => !item.success)) {
1252    process.exitCode = 1;
1253  }
1254}
1255 
1256async function main(): Promise<void> {
1257  const args = parseArgs(process.argv.slice(2));
1258  if (args.help) {
1259    printUsage();
1260    return;
1261  }
1262 
1263  await loadEnv();
1264  const extendConfig = await loadExtendConfig();
1265  const mergedArgs = mergeConfig(args, extendConfig);
1266  if (!mergedArgs.quality) mergedArgs.quality = "2k";
1267 
1268  if (mergedArgs.batchFile) {
1269    await runBatchMode(mergedArgs, extendConfig);
1270    return;
1271  }
1272 
1273  await runSingleMode(mergedArgs, extendConfig);
1274}
1275 
1276function isDirectExecution(metaUrl: string): boolean {
1277  const entryPath = process.argv[1];
1278  if (!entryPath) return false;
1279 
1280  try {
1281    return path.resolve(entryPath) === fileURLToPath(metaUrl);
1282  } catch {
1283    return false;
1284  }
1285}
1286 
1287if (isDirectExecution(import.meta.url)) {
1288  main().catch((error) => {
1289    const message = error instanceof Error ? error.message : String(error);
1290    console.error(message);
1291    process.exit(1);
1292  });
1293}
1294