1import path from "node:path";
2import { readFile } from "node:fs/promises";
3import type { CliArgs, Quality } from "../types";
4 
5type DashScopeModelFamily = "qwen2" | "qwenFixed" | "wan27" | "legacy";
6 
7type DashScopeModelSpec = {
8  family: DashScopeModelFamily;
9  defaultSize: string;
10};
11 
12const DEFAULT_MODEL = "qwen-image-2.0-pro";
13const MIN_QWEN_2_TOTAL_PIXELS = 512 * 512;
14const MAX_QWEN_2_TOTAL_PIXELS = 2048 * 2048;
15const SIZE_STEP = 16;
16const QWEN_NEGATIVE_PROMPT =
17  "低分辨率，低画质，肢体畸形，手指畸形，画面过饱和，蜡像感，人脸无细节，过度光滑，画面具有AI感，构图混乱，文字模糊，扭曲";
18 
19const QWEN_2_TARGET_PIXELS: Record<Quality, number> = {
20  normal: 1024 * 1024,
21  "2k": 1536 * 1536,
22};
23 
24const MIN_WAN27_TOTAL_PIXELS = 768 * 768;
25const MAX_WAN27_PRO_T2I_PIXELS = 4096 * 4096;
26const MAX_WAN27_GENERAL_PIXELS = 2048 * 2048;
27const WAN27_MAX_REFERENCE_IMAGES = 9;
28 
29const WAN27_TARGET_PIXELS: Record<Quality, number> = {
30  normal: 1024 * 1024,
31  "2k": 2048 * 2048,
32};
33 
34const QWEN_2_RECOMMENDED: Record<string, Record<Quality, string>> = {
35  "1:1": { normal: "1024*1024", "2k": "1536*1536" },
36  "2:3": { normal: "768*1152", "2k": "1024*1536" },
37  "3:2": { normal: "1152*768", "2k": "1536*1024" },
38  "3:4": { normal: "960*1280", "2k": "1080*1440" },
39  "4:3": { normal: "1280*960", "2k": "1440*1080" },
40  "9:16": { normal: "720*1280", "2k": "1080*1920" },
41  "16:9": { normal: "1280*720", "2k": "1920*1080" },
42  "21:9": { normal: "1344*576", "2k": "2048*872" },
43};
44 
45const QWEN_FIXED_SIZES_BY_RATIO: Record<string, string> = {
46  "16:9": "1664*928",
47  "4:3": "1472*1104",
48  "1:1": "1328*1328",
49  "3:4": "1104*1472",
50  "9:16": "928*1664",
51};
52 
53const QWEN_FIXED_SIZES = Object.values(QWEN_FIXED_SIZES_BY_RATIO);
54 
55const LEGACY_STANDARD_SIZES: [number, number][] = [
56  [1024, 1024],
57  [1280, 720],
58  [720, 1280],
59  [1024, 768],
60  [768, 1024],
61  [1536, 1024],
62  [1024, 1536],
63  [1536, 864],
64  [864, 1536],
65];
66 
67const LEGACY_STANDARD_SIZES_2K: [number, number][] = [
68  [1536, 1536],
69  [2048, 1152],
70  [1152, 2048],
71  [1536, 1024],
72  [1024, 1536],
73  [1536, 864],
74  [864, 1536],
75  [2048, 2048],
76];
77 
78const QWEN_2_SPEC: DashScopeModelSpec = {
79  family: "qwen2",
80  defaultSize: "1024*1024",
81};
82 
83const QWEN_FIXED_SPEC: DashScopeModelSpec = {
84  family: "qwenFixed",
85  defaultSize: QWEN_FIXED_SIZES_BY_RATIO["16:9"],
86};
87 
88const WAN27_SPEC: DashScopeModelSpec = {
89  family: "wan27",
90  defaultSize: "2048*2048",
91};
92 
93const LEGACY_SPEC: DashScopeModelSpec = {
94  family: "legacy",
95  defaultSize: "1536*1536",
96};
97 
98const MODEL_SPEC_ALIASES: Record<string, DashScopeModelSpec> = {
99  "qwen-image-2.0-pro": QWEN_2_SPEC,
100  "qwen-image-2.0-pro-2026-03-03": QWEN_2_SPEC,
101  "qwen-image-2.0": QWEN_2_SPEC,
102  "qwen-image-2.0-2026-03-03": QWEN_2_SPEC,
103  "qwen-image-max": QWEN_FIXED_SPEC,
104  "qwen-image-max-2025-12-30": QWEN_FIXED_SPEC,
105  "qwen-image-plus": QWEN_FIXED_SPEC,
106  "qwen-image-plus-2026-01-09": QWEN_FIXED_SPEC,
107  "qwen-image": QWEN_FIXED_SPEC,
108  "wan2.7-image-pro": WAN27_SPEC,
109  "wan2.7-image": WAN27_SPEC,
110};
111 
112export function getDefaultModel(): string {
113  return process.env.DASHSCOPE_IMAGE_MODEL || DEFAULT_MODEL;
114}
115 
116function getReferenceImageMime(filePath: string): string {
117  const ext = path.extname(filePath).toLowerCase();
118  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
119  if (ext === ".webp") return "image/webp";
120  if (ext === ".bmp") return "image/bmp";
121  return "image/png";
122}
123 
124async function loadReferenceImage(refPath: string): Promise<string> {
125  if (/^https?:\/\//i.test(refPath)) {
126    return refPath;
127  }
128  const fullPath = path.resolve(refPath);
129  const bytes = await readFile(fullPath);
130  return `data:${getReferenceImageMime(fullPath)};base64,${bytes.toString("base64")}`;
131}
132 
133function getApiKey(): string | null {
134  return process.env.DASHSCOPE_API_KEY || null;
135}
136 
137function getBaseUrl(): string {
138  const base = process.env.DASHSCOPE_BASE_URL || "https://dashscope.aliyuncs.com";
139  return base.replace(/\/+$/g, "");
140}
141 
142function getModelSpec(model: string): DashScopeModelSpec {
143  return MODEL_SPEC_ALIASES[model.trim().toLowerCase()] || LEGACY_SPEC;
144}
145 
146export function getModelFamily(model: string): DashScopeModelFamily {
147  return getModelSpec(model).family;
148}
149 
150function normalizeQuality(quality: CliArgs["quality"]): Quality {
151  return quality === "normal" ? "normal" : "2k";
152}
153 
154export function parseAspectRatio(ar: string): { width: number; height: number } | null {
155  const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
156  if (!match) return null;
157  const w = parseFloat(match[1]!);
158  const h = parseFloat(match[2]!);
159  if (w <= 0 || h <= 0) return null;
160  return { width: w, height: h };
161}
162 
163export function normalizeSize(size: string): string {
164  return size.replace("x", "*");
165}
166 
167export function parseSize(size: string): { width: number; height: number } | null {
168  const match = normalizeSize(size).match(/^(\d+)\*(\d+)$/);
169  if (!match) return null;
170  const width = Number(match[1]);
171  const height = Number(match[2]);
172  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
173    return null;
174  }
175  return { width, height };
176}
177 
178function formatSize(width: number, height: number): string {
179  return `${width}*${height}`;
180}
181 
182function getRatioValue(ar: string): number | null {
183  const parsed = parseAspectRatio(ar);
184  if (!parsed) return null;
185  return parsed.width / parsed.height;
186}
187 
188function findKnownRatioKey(ar: string, candidates: string[], tolerance = 0.02): string | null {
189  const targetRatio = getRatioValue(ar);
190  if (targetRatio == null) return null;
191 
192  let bestKey: string | null = null;
193  let bestDiff = Infinity;
194 
195  for (const candidate of candidates) {
196    const candidateRatio = getRatioValue(candidate);
197    if (candidateRatio == null) continue;
198    const diff = Math.abs(candidateRatio - targetRatio);
199    if (diff < bestDiff) {
200      bestDiff = diff;
201      bestKey = candidate;
202    }
203  }
204 
205  return bestDiff <= tolerance ? bestKey : null;
206}
207 
208function roundToStep(value: number): number {
209  return Math.max(SIZE_STEP, Math.round(value / SIZE_STEP) * SIZE_STEP);
210}
211 
212function floorToStep(value: number): number {
213  return Math.max(SIZE_STEP, Math.floor(value / SIZE_STEP) * SIZE_STEP);
214}
215 
216function fitToPixelBudget(
217  width: number,
218  height: number,
219  minPixels: number,
220  maxPixels: number,
221): { width: number; height: number } {
222  let nextWidth = width;
223  let nextHeight = height;
224  let pixels = nextWidth * nextHeight;
225 
226  if (pixels > maxPixels) {
227    const scale = Math.sqrt(maxPixels / pixels);
228    nextWidth *= scale;
229    nextHeight *= scale;
230  } else if (pixels < minPixels) {
231    const scale = Math.sqrt(minPixels / pixels);
232    nextWidth *= scale;
233    nextHeight *= scale;
234  }
235 
236  let roundedWidth = roundToStep(nextWidth);
237  let roundedHeight = roundToStep(nextHeight);
238  pixels = roundedWidth * roundedHeight;
239 
240  while (pixels > maxPixels && (roundedWidth > SIZE_STEP || roundedHeight > SIZE_STEP)) {
241    if (roundedWidth >= roundedHeight && roundedWidth > SIZE_STEP) {
242      roundedWidth -= SIZE_STEP;
243    } else if (roundedHeight > SIZE_STEP) {
244      roundedHeight -= SIZE_STEP;
245    } else {
246      break;
247    }
248    pixels = roundedWidth * roundedHeight;
249  }
250 
251  while (pixels < minPixels) {
252    if (roundedWidth <= roundedHeight) {
253      roundedWidth += SIZE_STEP;
254    } else {
255      roundedHeight += SIZE_STEP;
256    }
257    pixels = roundedWidth * roundedHeight;
258  }
259 
260  return { width: roundedWidth, height: roundedHeight };
261}
262 
263function clampWan27DerivedSizeToRatioBounds(
264  size: { width: number; height: number },
265): { width: number; height: number } {
266  let { width, height } = size;
267  const ratio = width / height;
268 
269  if (ratio > 8) {
270    width = floorToStep(height * 8);
271  } else if (ratio < 1 / 8) {
272    height = floorToStep(width * 8);
273  }
274 
275  return { width, height };
276}
277 
278export function getSizeFromAspectRatio(ar: string | null, quality: CliArgs["quality"]): string {
279  const normalizedQuality = normalizeQuality(quality);
280  const sizes = normalizedQuality === "2k" ? LEGACY_STANDARD_SIZES_2K : LEGACY_STANDARD_SIZES;
281  const defaultSize = normalizedQuality === "2k" ? "1536*1536" : "1024*1024";
282 
283  if (!ar) return defaultSize;
284 
285  const parsed = parseAspectRatio(ar);
286  if (!parsed) return defaultSize;
287 
288  const targetRatio = parsed.width / parsed.height;
289  let best = defaultSize;
290  let bestDiff = Infinity;
291 
292  for (const [width, height] of sizes) {
293    const diff = Math.abs(width / height - targetRatio);
294    if (diff < bestDiff) {
295      bestDiff = diff;
296      best = formatSize(width, height);
297    }
298  }
299 
300  return best;
301}
302 
303export function getQwen2SizeFromAspectRatio(ar: string | null, quality: CliArgs["quality"]): string {
304  const normalizedQuality = normalizeQuality(quality);
305 
306  if (!ar) {
307    return QWEN_2_RECOMMENDED["1:1"][normalizedQuality];
308  }
309 
310  const recommendedRatio = findKnownRatioKey(ar, Object.keys(QWEN_2_RECOMMENDED));
311  if (recommendedRatio) {
312    return QWEN_2_RECOMMENDED[recommendedRatio][normalizedQuality];
313  }
314 
315  const parsed = parseAspectRatio(ar);
316  if (!parsed) {
317    return QWEN_2_RECOMMENDED["1:1"][normalizedQuality];
318  }
319 
320  const targetRatio = parsed.width / parsed.height;
321  const targetPixels = QWEN_2_TARGET_PIXELS[normalizedQuality];
322  const rawWidth = Math.sqrt(targetPixels * targetRatio);
323  const rawHeight = Math.sqrt(targetPixels / targetRatio);
324  const fitted = fitToPixelBudget(
325    rawWidth,
326    rawHeight,
327    MIN_QWEN_2_TOTAL_PIXELS,
328    MAX_QWEN_2_TOTAL_PIXELS,
329  );
330 
331  return formatSize(fitted.width, fitted.height);
332}
333 
334function isWan27ProModel(model: string): boolean {
335  return model.trim().toLowerCase() === "wan2.7-image-pro";
336}
337 
338function getWan27MaxPixels(model: string, hasReferenceImages: boolean): number {
339  if (isWan27ProModel(model) && !hasReferenceImages) {
340    return MAX_WAN27_PRO_T2I_PIXELS;
341  }
342  return MAX_WAN27_GENERAL_PIXELS;
343}
344 
345export function getWan27SizeFromAspectRatio(
346  ar: string | null,
347  quality: CliArgs["quality"],
348  maxPixels: number,
349): string {
350  const normalizedQuality = normalizeQuality(quality);
351  const targetPixels = Math.min(WAN27_TARGET_PIXELS[normalizedQuality], maxPixels);
352 
353  if (!ar) {
354    const side = roundToStep(Math.sqrt(targetPixels));
355    return formatSize(side, side);
356  }
357 
358  const parsed = parseAspectRatio(ar);
359  if (!parsed) {
360    const side = roundToStep(Math.sqrt(targetPixels));
361    return formatSize(side, side);
362  }
363 
364  const ratio = parsed.width / parsed.height;
365  if (ratio < 1 / 8 || ratio > 8) {
366    throw new Error(
367      `DashScope wan2.7 image models support aspect ratios in [1:8, 8:1]. Received "${ar}".`
368    );
369  }
370 
371  const rawWidth = Math.sqrt(targetPixels * ratio);
372  const rawHeight = Math.sqrt(targetPixels / ratio);
373  const fitted = fitToPixelBudget(
374    rawWidth,
375    rawHeight,
376    MIN_WAN27_TOTAL_PIXELS,
377    maxPixels,
378  );
379  const bounded = clampWan27DerivedSizeToRatioBounds(fitted);
380 
381  return formatSize(bounded.width, bounded.height);
382}
383 
384function validateWan27Size(size: string, maxPixels: number, model: string): string {
385  const normalized = normalizeSize(size);
386  const parsed = validateSizeFormat(normalized);
387  const totalPixels = parsed.width * parsed.height;
388  if (totalPixels < MIN_WAN27_TOTAL_PIXELS || totalPixels > maxPixels) {
389    const limit = maxPixels === MAX_WAN27_PRO_T2I_PIXELS ? "4096*4096" : "2048*2048";
390    throw new Error(
391      `DashScope ${model} requires total pixels between 768*768 and ${limit} ` +
392      `for the current request. Received ${normalized} (${totalPixels} pixels).`
393    );
394  }
395  const ratio = parsed.width / parsed.height;
396  if (ratio < 1 / 8 || ratio > 8) {
397    throw new Error(
398      `DashScope wan2.7 image models support aspect ratios in [1:8, 8:1]. ` +
399      `Received ${normalized} (ratio ${ratio.toFixed(3)}).`
400    );
401  }
402  return normalized;
403}
404 
405function getQwenFixedSizeFromAspectRatio(ar: string | null, quality: CliArgs["quality"]): string {
406  if (quality === "normal") {
407    console.warn(
408      "DashScope qwen-image-max/plus/image models use fixed output sizes; --quality normal does not change the generated resolution."
409    );
410  }
411 
412  if (!ar) return QWEN_FIXED_SPEC.defaultSize;
413 
414  const ratioKey = findKnownRatioKey(ar, Object.keys(QWEN_FIXED_SIZES_BY_RATIO));
415  if (!ratioKey) {
416    throw new Error(
417      `DashScope model supports only fixed ratios ${Object.keys(QWEN_FIXED_SIZES_BY_RATIO).join(", ")}. ` +
418      `For custom ratios like "${ar}", use --model qwen-image-2.0-pro.`
419    );
420  }
421 
422  return QWEN_FIXED_SIZES_BY_RATIO[ratioKey]!;
423}
424 
425function validateSizeFormat(size: string): { width: number; height: number } {
426  const parsed = parseSize(size);
427  if (!parsed) {
428    throw new Error(`Invalid DashScope size "${size}". Expected <width>x<height> or <width>*<height>.`);
429  }
430  return parsed;
431}
432 
433function validateQwen2Size(size: string): string {
434  const normalized = normalizeSize(size);
435  const parsed = validateSizeFormat(normalized);
436  const totalPixels = parsed.width * parsed.height;
437  if (totalPixels < MIN_QWEN_2_TOTAL_PIXELS || totalPixels > MAX_QWEN_2_TOTAL_PIXELS) {
438    throw new Error(
439      `DashScope qwen-image-2.0* models require total pixels between ${MIN_QWEN_2_TOTAL_PIXELS} ` +
440      `and ${MAX_QWEN_2_TOTAL_PIXELS}. Received ${normalized} (${totalPixels} pixels).`
441    );
442  }
443  return normalized;
444}
445 
446function validateQwenFixedSize(size: string): string {
447  const normalized = normalizeSize(size);
448  validateSizeFormat(normalized);
449  if (!QWEN_FIXED_SIZES.includes(normalized)) {
450    throw new Error(
451      `DashScope qwen-image-max/plus/image models support only these sizes: ${QWEN_FIXED_SIZES.join(", ")}. ` +
452      `Received ${normalized}.`
453    );
454  }
455  return normalized;
456}
457 
458export function resolveSizeForModel(
459  model: string,
460  args: Pick<CliArgs, "size" | "aspectRatio" | "quality"> & { referenceImages?: string[] },
461): string {
462  const spec = getModelSpec(model);
463  const referenceCount = args.referenceImages?.length ?? 0;
464 
465  if (spec.family === "wan27") {
466    const maxPixels = getWan27MaxPixels(model, referenceCount > 0);
467    if (args.size) return validateWan27Size(args.size, maxPixels, model);
468    return getWan27SizeFromAspectRatio(args.aspectRatio, args.quality, maxPixels);
469  }
470 
471  if (args.size) {
472    if (spec.family === "qwen2") return validateQwen2Size(args.size);
473    if (spec.family === "qwenFixed") return validateQwenFixedSize(args.size);
474    validateSizeFormat(args.size);
475    return normalizeSize(args.size);
476  }
477 
478  if (spec.family === "qwen2") {
479    return getQwen2SizeFromAspectRatio(args.aspectRatio, args.quality);
480  }
481 
482  if (spec.family === "qwenFixed") {
483    return getQwenFixedSizeFromAspectRatio(args.aspectRatio, args.quality);
484  }
485 
486  return getSizeFromAspectRatio(args.aspectRatio, args.quality);
487}
488 
489function buildParameters(
490  family: DashScopeModelFamily,
491  size: string,
492): Record<string, unknown> {
493  if (family === "wan27") {
494    return {
495      size,
496      n: 1,
497      watermark: false,
498    };
499  }
500 
501  const parameters: Record<string, unknown> = {
502    prompt_extend: false,
503    size,
504  };
505 
506  if (family === "qwen2" || family === "qwenFixed") {
507    parameters.watermark = false;
508    parameters.negative_prompt = QWEN_NEGATIVE_PROMPT;
509  }
510 
511  return parameters;
512}
513 
514type DashScopeResponse = {
515  output?: {
516    result_image?: string;
517    choices?: Array<{
518      message?: {
519        content?: Array<{ image?: string }>;
520      };
521    }>;
522  };
523};
524 
525async function extractImageFromResponse(result: DashScopeResponse): Promise<Uint8Array> {
526  let imageData: string | null = null;
527 
528  if (result.output?.result_image) {
529    imageData = result.output.result_image;
530  } else if (result.output?.choices?.[0]?.message?.content) {
531    const content = result.output.choices[0].message.content;
532    for (const item of content) {
533      if (item.image) {
534        imageData = item.image;
535        break;
536      }
537    }
538  }
539 
540  if (!imageData) {
541    console.error("Response:", JSON.stringify(result, null, 2));
542    throw new Error("No image in response");
543  }
544 
545  if (imageData.startsWith("http://") || imageData.startsWith("https://")) {
546    const imgRes = await fetch(imageData);
547    if (!imgRes.ok) throw new Error("Failed to download image");
548    const buf = await imgRes.arrayBuffer();
549    return new Uint8Array(buf);
550  }
551 
552  return Uint8Array.from(Buffer.from(imageData, "base64"));
553}
554 
555export async function generateImage(
556  prompt: string,
557  model: string,
558  args: CliArgs
559): Promise<Uint8Array> {
560  const apiKey = getApiKey();
561  if (!apiKey) throw new Error("DASHSCOPE_API_KEY is required");
562 
563  const spec = getModelSpec(model);
564 
565  if (args.referenceImages.length > 0 && spec.family !== "wan27") {
566    throw new Error(
567      "Reference images are not supported with this DashScope model. Use a wan2.7 image model (--model wan2.7-image-pro or wan2.7-image), or switch to --provider google with a Gemini multimodal model."
568    );
569  }
570 
571  if (args.referenceImages.length > WAN27_MAX_REFERENCE_IMAGES) {
572    throw new Error(
573      `DashScope wan2.7 image models accept at most ${WAN27_MAX_REFERENCE_IMAGES} reference images. Received ${args.referenceImages.length}.`
574    );
575  }
576 
577  if (spec.family === "wan27" && args.n !== 1) {
578    throw new Error(
579      "DashScope wan2.7 image models in baoyu-image-gen support exactly one output image per request (extra images would be billed but discarded). Remove --n or use --n 1."
580    );
581  }
582 
583  const size = resolveSizeForModel(model, args);
584  const url = `${getBaseUrl()}/api/v1/services/aigc/multimodal-generation/generation`;
585 
586  const content: Array<Record<string, unknown>> = [];
587  if (spec.family === "wan27" && args.referenceImages.length > 0) {
588    for (const refPath of args.referenceImages) {
589      content.push({ image: await loadReferenceImage(refPath) });
590    }
591  }
592  content.push({ text: prompt });
593 
594  const body = {
595    model,
596    input: {
597      messages: [
598        {
599          role: "user",
600          content,
601        },
602      ],
603    },
604    parameters: buildParameters(spec.family, size),
605  };
606 
607  console.log(`Generating image with DashScope (${model})...`, { family: spec.family, size });
608 
609  const res = await fetch(url, {
610    method: "POST",
611    headers: {
612      "Content-Type": "application/json",
613      Authorization: `Bearer ${apiKey}`,
614    },
615    body: JSON.stringify(body),
616  });
617 
618  if (!res.ok) {
619    const err = await res.text();
620    throw new Error(`DashScope API error (${res.status}): ${err}`);
621  }
622 
623  const result = await res.json() as DashScopeResponse;
624  return extractImageFromResponse(result);
625}
626