1import path from "node:path";
2import { readFile } from "node:fs/promises";
3import type { CliArgs, OpenAIImageApiDialect } from "../types";
4 
5export function getDefaultModel(): string {
6  return process.env.OPENAI_IMAGE_MODEL || "gpt-image-2";
7}
8 
9type OpenAIImageResponse = { data: Array<{ url?: string; b64_json?: string }> };
10 
11export function parseAspectRatio(ar: string): { width: number; height: number } | null {
12  const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
13  if (!match) return null;
14  const w = parseFloat(match[1]!);
15  const h = parseFloat(match[2]!);
16  if (w <= 0 || h <= 0) return null;
17  return { width: w, height: h };
18}
19 
20type SizeMapping = {
21  square: string;
22  landscape: string;
23  portrait: string;
24};
25 
26type OpenAIGenerationsBody = Record<string, unknown>;
27 
28function isGptImageModel(model: string): boolean {
29  return model.includes("gpt-image");
30}
31 
32function isGptImage2Model(model: string): boolean {
33  return model.includes("gpt-image-2");
34}
35 
36function roundToMultiple(value: number, multiple: number): number {
37  return Math.max(multiple, Math.round(value / multiple) * multiple);
38}
39 
40function buildGptImage2SizeFromAspectRatio(
41  ar: string | null,
42  quality: CliArgs["quality"],
43): string {
44  const parsed = ar ? parseAspectRatio(ar) : null;
45  const ratio = parsed ? parsed.width / parsed.height : 1;
46 
47  if (!parsed || Math.abs(ratio - 1) < 0.1) {
48    const edge = quality === "2k" ? 2048 : 1024;
49    return `${edge}x${edge}`;
50  }
51 
52  const targetLongEdge = quality === "2k" ? 2048 : 1024;
53  let width: number;
54  let height: number;
55 
56  if (ratio > 1) {
57    width = targetLongEdge;
58    height = roundToMultiple(width / ratio, 16);
59  } else {
60    height = targetLongEdge;
61    width = roundToMultiple(height * ratio, 16);
62  }
63 
64  while (width * height < 655_360) {
65    if (ratio > 1) {
66      width += 16;
67      height = roundToMultiple(width / ratio, 16);
68    } else {
69      height += 16;
70      width = roundToMultiple(height * ratio, 16);
71    }
72  }
73 
74  return `${width}x${height}`;
75}
76 
77export function getOpenAISize(
78  model: string,
79  ar: string | null,
80  quality: CliArgs["quality"]
81): string {
82  const isDalle3 = model.includes("dall-e-3");
83  const isDalle2 = model.includes("dall-e-2");
84 
85  if (isDalle2) {
86    return "1024x1024";
87  }
88 
89  if (isGptImage2Model(model)) {
90    return buildGptImage2SizeFromAspectRatio(ar, quality);
91  }
92 
93  const sizes: SizeMapping = isDalle3
94    ? {
95        square: "1024x1024",
96        landscape: "1792x1024",
97        portrait: "1024x1792",
98      }
99    : {
100        square: "1024x1024",
101        landscape: "1536x1024",
102        portrait: "1024x1536",
103      };
104 
105  if (!ar) return sizes.square;
106 
107  const parsed = parseAspectRatio(ar);
108  if (!parsed) return sizes.square;
109 
110  const ratio = parsed.width / parsed.height;
111 
112  if (Math.abs(ratio - 1) < 0.1) return sizes.square;
113  if (ratio > 1.5) return sizes.landscape;
114  if (ratio < 0.67) return sizes.portrait;
115  return sizes.square;
116}
117 
118function parsePixelSize(value: string): { width: number; height: number } | null {
119  const match = value.match(/^(\d+)\s*[xX]\s*(\d+)$/);
120  if (!match) return null;
121 
122  const width = parseInt(match[1]!, 10);
123  const height = parseInt(match[2]!, 10);
124  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
125    return null;
126  }
127 
128  return { width, height };
129}
130 
131function gcd(a: number, b: number): number {
132  let x = Math.abs(a);
133  let y = Math.abs(b);
134  while (y !== 0) {
135    const next = x % y;
136    x = y;
137    y = next;
138  }
139  return x || 1;
140}
141 
142export function getOpenAIImageApiDialect(args: Pick<CliArgs, "imageApiDialect">): OpenAIImageApiDialect {
143  return args.imageApiDialect ?? "openai-native";
144}
145 
146export function inferAspectRatioFromSize(size: string | null): string | null {
147  if (!size) return null;
148  const parsed = parsePixelSize(size);
149  if (!parsed) return null;
150 
151  const divisor = gcd(parsed.width, parsed.height);
152  return `${parsed.width / divisor}:${parsed.height / divisor}`;
153}
154 
155export function inferResolutionFromSize(size: string | null): "1K" | "2K" | "4K" | null {
156  if (!size) return null;
157  const parsed = parsePixelSize(size);
158  if (!parsed) return null;
159 
160  const longestEdge = Math.max(parsed.width, parsed.height);
161  if (longestEdge <= 1024) return "1K";
162  if (longestEdge <= 2048) return "2K";
163  return "4K";
164}
165 
166export function getOpenAIAspectRatio(args: Pick<CliArgs, "aspectRatio" | "size">): string {
167  return args.aspectRatio ?? inferAspectRatioFromSize(args.size) ?? "1:1";
168}
169 
170export function getOpenAIResolution(
171  args: Pick<CliArgs, "imageSize" | "size" | "quality">
172): "1K" | "2K" | "4K" {
173  if (args.imageSize === "1K" || args.imageSize === "2K" || args.imageSize === "4K") {
174    return args.imageSize;
175  }
176 
177  const inferred = inferResolutionFromSize(args.size);
178  if (inferred) return inferred;
179 
180  return args.quality === "normal" ? "1K" : "2K";
181}
182 
183function getOpenAIQuality(model: string, quality: CliArgs["quality"]): "standard" | "hd" | "medium" | "high" | null {
184  if (model.includes("dall-e-3")) {
185    return quality === "2k" ? "hd" : "standard";
186  }
187 
188  if (isGptImageModel(model)) {
189    return quality === "2k" ? "high" : "medium";
190  }
191 
192  return null;
193}
194 
195export function getOrientationFromAspectRatio(ar: string): "landscape" | "portrait" | null {
196  const parsed = parseAspectRatio(ar);
197  if (!parsed) return null;
198 
199  const ratio = parsed.width / parsed.height;
200  if (Math.abs(ratio - 1) < 0.1) return null;
201  return ratio > 1 ? "landscape" : "portrait";
202}
203 
204export function buildOpenAIGenerationsBody(
205  prompt: string,
206  model: string,
207  args: Pick<CliArgs, "aspectRatio" | "size" | "quality" | "imageSize" | "imageApiDialect">
208): OpenAIGenerationsBody {
209  if (getOpenAIImageApiDialect(args) === "ratio-metadata") {
210    const aspectRatio = getOpenAIAspectRatio(args);
211    const metadata: Record<string, string> = {
212      resolution: getOpenAIResolution(args),
213    };
214    const orientation = getOrientationFromAspectRatio(aspectRatio);
215    if (orientation) metadata.orientation = orientation;
216 
217    return {
218      model,
219      prompt,
220      size: aspectRatio,
221      metadata,
222    };
223  }
224 
225  const body: OpenAIGenerationsBody = {
226    model,
227    prompt,
228    size: args.size || getOpenAISize(model, args.aspectRatio, args.quality),
229  };
230 
231  const quality = getOpenAIQuality(model, args.quality);
232  if (quality) {
233    body.quality = quality;
234  }
235 
236  return body;
237}
238 
239export function validateArgs(model: string, args: CliArgs): void {
240  if (!isGptImage2Model(model)) return;
241 
242  if (args.aspectRatio && !args.size) {
243    const parsed = parseAspectRatio(args.aspectRatio);
244    if (!parsed) {
245      throw new Error(`Invalid gpt-image-2 aspect ratio: ${args.aspectRatio}`);
246    }
247    const ratio = parsed.width / parsed.height;
248    if (Math.max(ratio, 1 / ratio) > 3) {
249      throw new Error("gpt-image-2 aspect ratio must not exceed 3:1.");
250    }
251  }
252 
253  if (!args.size) return;
254 
255  const parsedSize = parsePixelSize(args.size);
256  if (!parsedSize) {
257    throw new Error(`Invalid gpt-image-2 --size: ${args.size}. Expected <width>x<height>.`);
258  }
259 
260  const { width, height } = parsedSize;
261  const totalPixels = width * height;
262  const ratio = Math.max(width, height) / Math.min(width, height);
263 
264  if (Math.max(width, height) > 3840) {
265    throw new Error("gpt-image-2 --size maximum edge length must be 3840px or less.");
266  }
267  if (width % 16 !== 0 || height % 16 !== 0) {
268    throw new Error("gpt-image-2 --size width and height must both be multiples of 16px.");
269  }
270  if (ratio > 3) {
271    throw new Error("gpt-image-2 --size long edge to short edge ratio must not exceed 3:1.");
272  }
273  if (totalPixels < 655_360 || totalPixels > 8_294_400) {
274    throw new Error("gpt-image-2 --size total pixels must be between 655,360 and 8,294,400.");
275  }
276}
277 
278export async function generateImage(
279  prompt: string,
280  model: string,
281  args: CliArgs
282): Promise<Uint8Array> {
283  const baseURL = process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
284  const apiKey = process.env.OPENAI_API_KEY;
285 
286  if (!apiKey) {
287    throw new Error(
288      "OPENAI_API_KEY is required. Codex/ChatGPT desktop login does not automatically grant OpenAI Images API access to this script."
289    );
290  }
291 
292  if (process.env.OPENAI_IMAGE_USE_CHAT === "true") {
293    return generateWithChatCompletions(baseURL, apiKey, prompt, model);
294  }
295 
296  const imageApiDialect = getOpenAIImageApiDialect(args);
297 
298  if (args.referenceImages.length > 0) {
299    if (imageApiDialect !== "openai-native") {
300      throw new Error(
301        "Reference images are not supported with the ratio-metadata OpenAI dialect yet. Use openai-native, Google, Azure, OpenRouter, MiniMax, Seedream, or Replicate for image-edit workflows."
302      );
303    }
304    if (model.includes("dall-e-2") || model.includes("dall-e-3")) {
305      throw new Error(
306        "Reference images with OpenAI in this skill require GPT Image models. Use --model gpt-image-2 (or another gpt-image model)."
307      );
308    }
309    const size = args.size || getOpenAISize(model, args.aspectRatio, args.quality);
310    return generateWithOpenAIEdits(baseURL, apiKey, prompt, model, size, args.referenceImages, args.quality);
311  }
312 
313  return generateWithOpenAIGenerations(
314    baseURL,
315    apiKey,
316    buildOpenAIGenerationsBody(prompt, model, args)
317  );
318}
319 
320async function generateWithChatCompletions(
321  baseURL: string,
322  apiKey: string,
323  prompt: string,
324  model: string
325): Promise<Uint8Array> {
326  const res = await fetch(`${baseURL}/chat/completions`, {
327    method: "POST",
328    headers: {
329      "Content-Type": "application/json",
330      Authorization: `Bearer ${apiKey}`,
331    },
332    body: JSON.stringify({
333      model,
334      messages: [{ role: "user", content: prompt }],
335    }),
336  });
337 
338  if (!res.ok) {
339    const err = await res.text();
340    throw new Error(`OpenAI API error: ${err}`);
341  }
342 
343  const result = (await res.json()) as { choices: Array<{ message: { content: string } }> };
344  const content = result.choices[0]?.message?.content ?? "";
345 
346  const match = content.match(/data:image\/[^;]+;base64,([A-Za-z0-9+/=]+)/);
347  if (match) {
348    return Uint8Array.from(Buffer.from(match[1]!, "base64"));
349  }
350 
351  throw new Error("No image found in chat completions response");
352}
353 
354async function generateWithOpenAIGenerations(
355  baseURL: string,
356  apiKey: string,
357  body: OpenAIGenerationsBody
358): Promise<Uint8Array> {
359  const res = await fetch(`${baseURL}/images/generations`, {
360    method: "POST",
361    headers: {
362      "Content-Type": "application/json",
363      Authorization: `Bearer ${apiKey}`,
364    },
365    body: JSON.stringify(body),
366  });
367 
368  if (!res.ok) {
369    const err = await res.text();
370    throw new Error(`OpenAI API error: ${err}`);
371  }
372 
373  const result = (await res.json()) as OpenAIImageResponse;
374  return extractImageFromResponse(result);
375}
376 
377async function generateWithOpenAIEdits(
378  baseURL: string,
379  apiKey: string,
380  prompt: string,
381  model: string,
382  size: string,
383  referenceImages: string[],
384  quality: CliArgs["quality"]
385): Promise<Uint8Array> {
386  const form = new FormData();
387  form.append("model", model);
388  form.append("prompt", prompt);
389  form.append("size", size);
390 
391  const openAIQuality = getOpenAIQuality(model, quality);
392  if (openAIQuality && openAIQuality !== "standard" && openAIQuality !== "hd") {
393    form.append("quality", openAIQuality);
394  }
395 
396  for (const refPath of referenceImages) {
397    const bytes = await readFile(refPath);
398    const filename = path.basename(refPath);
399    const mimeType = getMimeType(filename);
400    const blob = new Blob([bytes], { type: mimeType });
401    form.append("image[]", blob, filename);
402  }
403 
404  const res = await fetch(`${baseURL}/images/edits`, {
405    method: "POST",
406    headers: {
407      Authorization: `Bearer ${apiKey}`,
408    },
409    body: form,
410  });
411 
412  if (!res.ok) {
413    const err = await res.text();
414    throw new Error(`OpenAI edits API error: ${err}`);
415  }
416 
417  const result = (await res.json()) as OpenAIImageResponse;
418  return extractImageFromResponse(result);
419}
420 
421export function getMimeType(filename: string): string {
422  const ext = path.extname(filename).toLowerCase();
423  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
424  if (ext === ".webp") return "image/webp";
425  if (ext === ".gif") return "image/gif";
426  return "image/png";
427}
428 
429export async function extractImageFromResponse(result: OpenAIImageResponse): Promise<Uint8Array> {
430  const img = result.data[0];
431 
432  if (img?.b64_json) {
433    return Uint8Array.from(Buffer.from(img.b64_json, "base64"));
434  }
435 
436  if (img?.url) {
437    const imgRes = await fetch(img.url);
438    if (!imgRes.ok) throw new Error("Failed to download image");
439    const buf = await imgRes.arrayBuffer();
440    return new Uint8Array(buf);
441  }
442 
443  throw new Error("No image in response");
444}
445