1import path from "node:path";
2import { readFile } from "node:fs/promises";
3 
4import type { CliArgs } from "../types";
5 
6const DEFAULT_MODEL = "image-01";
7const MAX_REFERENCE_IMAGE_BYTES = 10 * 1024 * 1024;
8const SUPPORTED_ASPECT_RATIOS = new Set(["1:1", "16:9", "4:3", "3:2", "2:3", "3:4", "9:16", "21:9"]);
9 
10type MinimaxSubjectReference = {
11  type: "character";
12  image_file: string;
13};
14 
15type MinimaxRequestBody = {
16  model: string;
17  prompt: string;
18  response_format: "base64";
19  aspect_ratio?: string;
20  width?: number;
21  height?: number;
22  n?: number;
23  subject_reference?: MinimaxSubjectReference[];
24};
25 
26type MinimaxResponse = {
27  id?: string;
28  data?: {
29    image_urls?: string[];
30    image_base64?: string[];
31  };
32  base_resp?: {
33    status_code?: number;
34    status_msg?: string;
35  };
36};
37 
38export function getDefaultModel(): string {
39  return process.env.MINIMAX_IMAGE_MODEL || DEFAULT_MODEL;
40}
41 
42function getApiKey(): string | null {
43  return process.env.MINIMAX_API_KEY || null;
44}
45 
46export function buildMinimaxUrl(): string {
47  const base = (process.env.MINIMAX_BASE_URL || "https://api.minimax.io").replace(/\/+$/g, "");
48  return base.endsWith("/v1") ? `${base}/image_generation` : `${base}/v1/image_generation`;
49}
50 
51function getMimeType(filename: string): "image/jpeg" | "image/png" {
52  const ext = path.extname(filename).toLowerCase();
53  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
54  if (ext === ".png") return "image/png";
55  throw new Error(
56    `MiniMax subject_reference only supports JPG, JPEG, or PNG files: ${filename}`
57  );
58}
59 
60export function parsePixelSize(size: string): { width: number; height: number } | null {
61  const match = size.trim().match(/^(\d+)\s*[xX*]\s*(\d+)$/);
62  if (!match) return null;
63 
64  const width = parseInt(match[1]!, 10);
65  const height = parseInt(match[2]!, 10);
66  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
67    return null;
68  }
69 
70  return { width, height };
71}
72 
73function validatePixelSize(width: number, height: number): void {
74  if (width < 512 || width > 2048 || height < 512 || height > 2048) {
75    throw new Error("MiniMax custom size must keep width and height between 512 and 2048.");
76  }
77  if (width % 8 !== 0 || height % 8 !== 0) {
78    throw new Error("MiniMax custom size requires width and height divisible by 8.");
79  }
80}
81 
82export function validateArgs(model: string, args: CliArgs): void {
83  if (args.n > 9) {
84    throw new Error("MiniMax supports at most 9 images per request.");
85  }
86 
87  if (args.aspectRatio && !SUPPORTED_ASPECT_RATIOS.has(args.aspectRatio)) {
88    throw new Error(
89      `MiniMax aspect_ratio must be one of: ${Array.from(SUPPORTED_ASPECT_RATIOS).join(", ")}.`
90    );
91  }
92 
93  if (args.size && !args.aspectRatio) {
94    if (model !== "image-01") {
95      throw new Error("MiniMax custom --size is only supported with model image-01. Use --model image-01 or pass --ar instead.");
96    }
97    const parsed = parsePixelSize(args.size);
98    if (!parsed) {
99      throw new Error("MiniMax --size must be in WxH format, for example 1536x1024.");
100    }
101    validatePixelSize(parsed.width, parsed.height);
102  }
103}
104 
105export async function buildSubjectReference(
106  referenceImages: string[],
107): Promise<MinimaxSubjectReference[] | undefined> {
108  if (referenceImages.length === 0) return undefined;
109 
110  const subjectReference: MinimaxSubjectReference[] = [];
111  for (const refPath of referenceImages) {
112    const bytes = await readFile(refPath);
113    if (bytes.length > MAX_REFERENCE_IMAGE_BYTES) {
114      throw new Error(`MiniMax subject_reference images must be smaller than 10MB: ${refPath}`);
115    }
116 
117    subjectReference.push({
118      type: "character",
119      image_file: `data:${getMimeType(refPath)};base64,${bytes.toString("base64")}`,
120    });
121  }
122 
123  return subjectReference;
124}
125 
126export async function buildRequestBody(
127  prompt: string,
128  model: string,
129  args: CliArgs,
130): Promise<MinimaxRequestBody> {
131  validateArgs(model, args);
132 
133  const body: MinimaxRequestBody = {
134    model,
135    prompt,
136    response_format: "base64",
137  };
138 
139  if (args.aspectRatio) {
140    body.aspect_ratio = args.aspectRatio;
141  } else if (args.size) {
142    const parsed = parsePixelSize(args.size);
143    if (!parsed) {
144      throw new Error("MiniMax --size must be in WxH format, for example 1536x1024.");
145    }
146    body.width = parsed.width;
147    body.height = parsed.height;
148  }
149 
150  if (args.n > 1) {
151    body.n = args.n;
152  }
153 
154  const subjectReference = await buildSubjectReference(args.referenceImages);
155  if (subjectReference) {
156    body.subject_reference = subjectReference;
157  }
158 
159  return body;
160}
161 
162async function downloadImage(url: string): Promise<Uint8Array> {
163  const response = await fetch(url);
164  if (!response.ok) {
165    throw new Error(`Failed to download image from MiniMax: ${response.status}`);
166  }
167  return new Uint8Array(await response.arrayBuffer());
168}
169 
170export async function extractImageFromResponse(result: MinimaxResponse): Promise<Uint8Array> {
171  const baseResp = result.base_resp;
172  if (baseResp && baseResp.status_code !== undefined && baseResp.status_code !== 0) {
173    throw new Error(baseResp.status_msg || `MiniMax API returned status_code=${baseResp.status_code}`);
174  }
175 
176  const base64Image = result.data?.image_base64?.[0];
177  if (base64Image) {
178    return Uint8Array.from(Buffer.from(base64Image, "base64"));
179  }
180 
181  const url = result.data?.image_urls?.[0];
182  if (url) {
183    return downloadImage(url);
184  }
185 
186  throw new Error("No image data in MiniMax response");
187}
188 
189export function getDefaultOutputExtension(): ".jpg" {
190  return ".jpg";
191}
192 
193export async function generateImage(
194  prompt: string,
195  model: string,
196  args: CliArgs
197): Promise<Uint8Array> {
198  const apiKey = getApiKey();
199  if (!apiKey) {
200    throw new Error("MINIMAX_API_KEY is required. Get one from https://platform.minimax.io/");
201  }
202 
203  const body = await buildRequestBody(prompt, model, args);
204  const response = await fetch(buildMinimaxUrl(), {
205    method: "POST",
206    headers: {
207      "Content-Type": "application/json",
208      Authorization: `Bearer ${apiKey}`,
209    },
210    body: JSON.stringify(body),
211  });
212 
213  if (!response.ok) {
214    const err = await response.text();
215    throw new Error(`MiniMax API error (${response.status}): ${err}`);
216  }
217 
218  const result = (await response.json()) as MinimaxResponse;
219  return extractImageFromResponse(result);
220}
221